DreamLake

New Project requests use streaming

This admission contract applies after the matching API release is deployed; capabilities advertise the streaming-only admission floor.

New Project transfers require mode: "stream" and an explicitly supported streamVersion (1 or 2). Request GET /namespaces/:namespace/ownership/resources/project/:id/transfer-plan?mode=stream, then preview and submit that streaming policy without a fixed manifest. A legacy Project preview or new legacy create returns 422 PROJECT_STREAM_REQUIRED. The legacy read-only plan remains available for inspection, marked deprecated: true, replacementMode: "stream", and executable: false. Never silently fall back to the older RTC checkpoint/room-rotation path when streaming reports an access or resource blocker. Individual resource transfers keep their existing contracts.

Existing fixed-manifest operations remain inspectable and may be accepted, cancelled, rejected, or recovered through their original operation IDs. Replaying an existing create with its exact actor/idempotency key and request remains supported; deprecation does not invalidate accepted work or recovery receipts. Keep the configured legacy executor/RTC recovery dependencies enabled while those operations remain; disabling their rollout flags would strand recovery.

Streaming retains the Memo RTC binding and moves metadata when its access proof is eligible. Artifact and Infrastructure support depends on the advertised adapter/runtime readiness; unsupported resource or audience policies remain explicit blockers, not permission to change access.

Whole Project and owned resources transfer

The following acceptance record describes the older restrictive path, retained for existing operation inspection and recovery rather than new requests.

Backend production acceptance — October 15, 2026 (Asia/Shanghai). The running API release was 8d9e79254157ebc78e4eb160d22196e33e10a8f0, verified by the exact-main checks, deployment guard, retained-task drain and health revision. Later repository commits are not implied to be deployed. Verified release and fixture evidence records both original and continuation results.

Two real-storage fixtures completed ownership cutover:

FixtureObserved result
Capacity25 native Memos and 205 ordinary file/image/video Nodes; 20/20 checks passed, including unchanged IDs/keys and content, old-room/write denial, exact replay and active/history lists. All 233 fixture records were cleaned up through existing deletion paths.
Mixed resourcesProject, Memo, ordinary files, Artifact and Env; 22/22 functionality checks passed, including canonical content/history reads, new-owner append, old-owner registration denial, external-placement removal, share revocation and old-name storage isolation. All nine fixture records were cleaned up.

The mixed fixture's original run stopped during cleanup: soft-deleting an Artifact deliberately left its Project mount, so the next plan correctly blocked the unavailable resource. That STOP receipt was retained. A separately reviewed continuation detached the four exact fixture mounts using the normal API, verified both plans recovered, then finished cleanup. This is not recorded as an uninterrupted original PASS. Catalog objects retain existing Trash policy; ordinary-file physical cleanup uses the existing durable queue.

These fixtures used one actor owning both namespaces. They do not establish a distinct-recipient matrix, every NoteFile/provider-isolation path or a historical off-box writer census. Backend acceptance is separate from published CLI/SDK and Web consumer acceptance. Artifact/Env plans require CLI 0.64.0+ or Python SDK 0.31.0+, plus current server readiness; installing a client alone does not prove the deployment is ready. Standalone Memo metadata transfer is a separate contract; Project streaming does not establish readiness of other standalone resource types.

Published-client acceptance — October 15, 2026. CLI 0.64.0 and Python SDK 0.31.0 were published through GitHub Actions, with public artifact bytes verified against their reviewed sources. A fresh installed-client fixture passed 23/23 production checks on the API release above. The SDK performed the real read-only preview; the CLI issued exactly one create and one accept command, completed owner cutover and exact replay, and all nine fixture records were cleaned up. This does not claim SDK create/accept execution or a distinct-recipient matrix. Installed-client evidence.

The Web production rollout was read back at ac47aa11fc6688d479444028b754be396c44214f: namespace Projects/Transfers routes returned 200 and the production JavaScript matched the release marker and all 14 expected feature markers. This verifies the served bundle; authenticated production UI transfer clicks were not exercised. Web release readback. Local headless interaction tests and the real backend/client fixture are separate evidence, not a claim of that UI production click coverage.

Memo body writers during metadata cutover

A standalone metadata move preserves the Memo ID, RTC room and storage identity. An authenticated body writer using the previous namespace can follow a completed, accepted metadata-only ownership chain, then must pass the current owner’s live write policy. The old namespace is an identity alias, never an access grant. Revoked retained grants and removed organization membership still deny the edit. Legacy RTC ownership cutovers cannot use this rebind path.

Database admission and binding recheck each retry fresh transaction snapshots for at most two seconds and twelve attempts, with jitter. Each phase includes transaction acquisition and execution in its remaining budget; this is not an overall deadline for the separate RTC/S3 request. This handles a short cutover conflicting with the same Note/actor authority parents. Rebinding requires the exact accepted Memo epoch and unchanged RTC/storage/projection binding. Room or storage changes and unproved epoch changes fail closed. RTC initialization and native edits stay outside the retry boundary; an unknown acknowledgement never causes the server to replay provider IO or the edit.

Streaming catalog closure v2

streamVersion: 2 uses a distinct project-stream-v2 executor. It adds private, owned Env/Scene and Annotation attachments to the existing Note/Artifact closure. Their IDs, content/version data, share tokens, Project audiences and frozen S3 bucket/prefix remain unchanged. Source names are durably reserved so old URLs keep selecting the original resource; every read still checks current access. External catalog filings, unsupported storage operations and unsupported access profiles fail explicitly rather than detaching resources. Infrastructure continues to follow the stable Project ID through its independently verified adapter. Source/Dataset/Episode closures are not added by this version.

V2 scans bounded stable-ID pages, consumes changes from before the scan, then rechecks the complete live closure in the final Mongo transaction. Existing Project/catalog writer parents serialize only the final authority decision with concurrent creation, edits and grant changes. Content/RTC edits are not copied, checkpointed or held behind a long RTC fence. Final Memo publication proofs load only immutable scalar identity/hash/state metadata, never publication bodies or history payloads. The accepted receipt binds those proofs and catalog epochs.

OWNERSHIP_PROJECT_STREAMING_CATALOG_V2_ENABLED defaults to false and also requires existing streaming/Infrastructure/Chat readiness. Before enabling, deploy compatible readers/workers everywhere, drain older API readers, and provision the catalog historical alias indexes through the existing reviewed index workflow. The additive Artifact index is {artifactId: 1, "ownershipHistory.sourceNamespaceId": 1}; Env/Annotation use {name: 1, "ownershipHistory.sourceNamespaceId": 1}. Startup verifies exact normal index keys; no request runs DDL. Artifact standalone admission requires its index too.

Capabilities advertise streamVersions and defaultStreamVersion. The default plan remains v1 while v2 is disabled, and becomes v2 only after activation; clients must echo the exact reviewed version and never downgrade a request. Explicit v1 plans remain available. Pending v2 acceptance is admission-gated; accepted recovery, inspection and exact idempotent replay remain available after admission closes. Stored v1 requests, executor identities and receipt validation retain their original behavior. Recovery fairly pages both generations with the existing bounded worker pool.

Unreleased: metadata-only streaming v1

Source implementation, not production acceptance. This section describes the separate project-stream-v1 executor. Its API capability and compatible CLI are unreleased; the production fixture results above exercise the existing fixed-manifest protocol. Enabling OWNERSHIP_PROJECT_STREAMING_ENABLED=true requires the reviewed streaming indexes and a compatible, fully drained reader and executor fleet. An installed CLI or a progress counter does not prove readiness.

Configured external dependencies are additional admission boundaries. New stream preview, creation and pending acceptance require all configured adapters to have actual runtime evidence. Infrastructure requires the built current-Project owner adapter and its verified Project identity index bound to the exact runtime SQL secret selector. Chat requires the built stable-identity transport adapter, three verified historical identity indexes on the runtime Mongo database, and a fresh signed service capability for identity version 1 and transport version 1. The service URL/secret and SQL selector bind that evidence; changing them or letting the Chat evidence expire closes admission again. There is no environment bypass for dependency readiness.

Until each configured dependency is ready, its blocker is PROJECT_STREAM_INFRASTRUCTURE_UNSUPPORTED or PROJECT_STREAM_CHAT_UNSUPPORTED. The capability reports disabled and the plan is nonexecutable even when the streaming flag is true. A zero-resource preview cannot replace this compatibility floor. Previously accepted operations retain status, recovery, cancellation, cleanup and authorized same-key replay. The guard does not copy SQL registrations, Terraform state or Chat history. The streaming flag still defaults off; rollout requires the compatible fleet and the actual service/schema verification above.

Transfer diagnostics

Project structural validation checks Bindr members against the complete live Project tree, including incoming foreign-owned Memo filings. Those incoming filings are excluded from the ownership manifest and still require their own external-mount disposition. Their presence is not a corrupt-tree error and does not authorize detachment. Missing references, invalid parent chains and malformed paths return error.details.blockers with the exact item ID and repair reason. Preview does not change the tree, memberships, grants or ownership.

A singleton Memo transfer blocked by a service-account grant reports the source Project ID/name, grant ID and service-account ID. Principal identities from a foreign Project are not disclosed through that error. Project ADMINs can inspect serviceAccountGrants on GET /namespaces/:namespace/projects/:project/grants; this field contains IDs and roles, never credentials. Preserving transfers remain controlled by noteTransfer.preservingTransfer.enabled; neither these diagnostics nor a CLI update enables them. Do not remove grants to force a transfer.

Eligibility preserves access without moving content

The initial scope requires a private Project in a personal source namespace, an active source owner, private source-owned Memos, and a retained explicit direct user ADMIN Project grant for that owner. Every Memo mount and its live folder chain must belong to the Project. The server binds the complete supported grant, accepted Note-share and external-filing inventory; share-token values are hashed in proof rather than copied into diagnostic output. Unsupported principals, service-account Project grants, public visibility, restrictive policies and unprovable access fail closed. Dataset, SourceBinding, embedding and Track ownership are not inferred from Project affiliation; unsupported managed rows block this first version explicitly.

The retained Project grant gives the former namespace owner Memo content read and write access through existing authorization, even without destination organization membership. It does not promise every former namespace-owner management privilege. Accepted share identities, token roles and approved external filings remain bound to their original IDs. Access proof must still match at commit; changing a grant, token, visibility or filing invalidates the decision. Reader lastSeenAt heartbeats and unrelated authorization-fence increments are not semantic access changes.

For this proven same-or-superset content audience, the executor leaves RTC room and document IDs, storage keys, bodies, search projections and revision payloads in place. There is no RTC freeze or rekey: no previously authorized content reader or writer is being revoked. This is not a general bypass for restrictive transfers, and it does not make ordinary RTC writer claims automatically recoverable. Task and TaskEvent moves change only their namespace field, preserving task state, event IDs, payloads and timestamps.

Each coordination step closes a specific race

MechanismRace it prevents
Stable-ID baseline pages of 64 plus a durable Mongo change cursor opened before scanningA resource inserted behind the scan cursor, or committed after its page was read, would otherwise be missed. The feed projects IDs and collection/operation metadata, never Memo content.
Persist progress and resume token together; catch up through an operation barrierA crash must not acknowledge a change without saving its progress. The barrier supplies a finite watermark, rather than treating a quiet poll as proof of completeness.
Short executor token CAS, expiry and transaction fencesAfter an interrupted worker is reclaimed, the previous worker cannot commit or release its successor's claim. Expiry alone is not permission for an unfenced writer to continue.
Fresh complete closure and access proof in one final Mongo transactionNew resources, deletions, changed grants or Note-name collisions cannot escape the reviewed whole-Project ownership decision. Source content remains usable during preparation; ownership is not exposed Memo by Memo.
Project and external Project parent fences in that transactionA grant, folder or external-filing writer must conflict with the exact access decision, including writers acting through another Project. No database transaction waits for RTC or object-store network I/O.
Exact saved request and idempotency key, plus immutable completion evidenceA lost response or repeated request must return the same operation, not create a second transfer or append a second access-history entry.

Discovery is paged; final validation and ownership cutover are deliberately one bounded metadata transaction. Limits remain 512 manifest resources, 4,096 tree Nodes and 5,000 aggregate inventory rows, with the existing execution and operation byte budgets. This is not an unbounded transfer engine or a claim of strict lock freedom. Content edits do not require copying or replaying bodies; membership and access changes are captured and revalidated. Unknown or excessive closure stops instead of silently dropping resources.

Recovery and permanent evidence

The worker can reclaim an expired streaming executor claim and continue the same operation from persisted progress. Token-fenced transactions reject a stale executor. This is distinct from legacy RTC claims: the manual quiescence guidance later on this page still applies to those unfenced writers.

If change-stream history is no longer available, the operation enters rescan-required; it must not guess a cursor or assume no changes occurred. An authorized explicit resume starts a new discovery generation and captures a new change cursor. Pending requests still require destination acceptance. Progress reads and admitted-operation recovery remain separate from new-admission readiness.

The completed proof also retains the exact source Project identity {id, namespaceId, name, kind, path, visibility} whose digest matches the reviewed root version, plus its committed Project lease epoch and live Bindr IDs with their Project relation. The monotonic epoch orders verified ownership hops even when failed claims consume intermediate epochs. These bounded, server-authored fields allow compatible historical-link readers to verify an old Project slug or Bindr identity after temporary progress cleanup. Identity evidence never grants access: readers must authorize the current owner and audience.

The unreleased read-only locator GET /namespaces/:namespace/projects/:project/canonical-location returns {apiVersion: 1, projectId, namespace, projectSlug} only after current Project READ authorization. A current Project at the original slug wins, including a private replacement the caller cannot read. Unknown or invalid history does not reveal a destination. Historical scopes remain invalid for mutation endpoints. The compatible Web Project browser resolves this location before mounting its child readers or controls, then replaces the URL's namespace and Project slug while preserving query parameters and the fragment, including Memo, Bindr and Artifact selections. Deploy the locator API before this Web change: the browser does not reinterpret an authorization 404 as permission to use a legacy fallback. This source behavior still requires API/Web deployment and live old-link acceptance.

After terminal retention of seven days, eligible cleanup may remove temporary member and barrier progress rows. The completed ownership journal retains its final manifest, access/decision binding and final watermark. Historical Artifact aliases and external Memo filing authority must continue to validate that permanent evidence after progress cleanup; they cannot depend on a temporary scan row or its count. Cleanup requires no active executor or resource leases.

Compatible CLI and disposable gold loop

Use a source-built compatible CLI and a server explicitly advertising projectTransferStream: { apiVersion: 1, enabled: true }. There is no automatic fallback to fixed-manifest mode. Replace the example slugs only for a disposable Project whose complete access inventory you can review:

bash
dl project move stream-fixture --namespace personal --to team --stream --dry-run --preserve-access --preserve-external-filings --out stream-review.json
dl project move stream-fixture --namespace personal --to team --stream --confirm --request-file stream-review.json --accept-if-owner --wait
dl ownership progress OPERATION_ID --namespace personal
dl ownership resume OPERATION_ID --namespace personal --confirm

The review file pins Project/source/destination identities, policy, preview hash and a stable request key; the server discovers the dynamic resource closure. Resume is a recovery action for that existing operation, not a command to create or accept another. Bounded --wait timeout is neither cancellation nor success; retain the operation ID and exact review after an ambiguous response.

A repeatable disposable gold loop should:

  1. Create a private fixture with the required retained owner ADMIN grant, more than 64 supported members, a private shared Memo, an approved external filing, an Artifact with history, and a Task with immutable events. Record IDs, content/version hashes, share roles and filing IDs without exporting tokens.
  2. Review and accept one streaming request. While preparation is pending, edit Memo content and add a resource behind the baseline cursor. Verify the final closure includes the addition and keeps the latest content. In a separate interrupted-worker fixture, expire the fenced executor and verify recovery resumes the same operation while a stale executor is refused.
  3. Require completed owner state, zero pending work and a final watermark. Read the same IDs through the destination, retained source-owner grant, historical Artifact alias and external filing; compare content, history and TaskEvent payload hashes. Reconcile the same operation again and verify no duplicate resource or history entry.
  4. Exercise a separate retention-gap fixture: require explicit rescan, then verify completion. After eligible progress cleanup, repeat historical-link and filing reads against permanent evidence. Remove only disposable fixture resources through their normal deletion paths and retain cleanup receipts.

Local Mongo, HTTP and helper regressions exercise these invariants; exact test counts belong to the source PR's validation receipt. A production streaming gold loop, released-client compatibility and real user-Project cutover remain pending until separately recorded. The steps above are an acceptance recipe, not a claim that those live interactions have already passed.

Complete scope, never a partial move

The common-resource adapter moves one Project, its direct ordinary files, images and videos, and all its live, source-owned Memo, Artifact and Env attachments together. Artifact/Env support requires the matching backend release and CLI 0.64.0+ or Python SDK 0.31.0+; the earlier CLI/SDK versions support the Memo-only manifest. Check the installed version and server plan rather than assuming a source checkout is deployed. The manifest includes the Project exactly once and every included owned resource exactly once. It does not accept a hand-picked subset or treat a filing as ownership. The larger-capacity backend permits 512 manifest resources in total (the Project plus at most 511 Memos when no Artifact/Env slots are used), 4,096 Project tree nodes, 5,000 aggregate inventory rows, an 8 MiB private execution ledger and a 12 MiB total operation. The old independent 20-Note limit is removed. These are joint budgets: a large body, retained revision history, comments or NoteFile inventory can exhaust a byte, object or inventory budget before the resource count is reached. Over-limit responses distinguish resource, tree, inventory and byte capacity; a smaller count is not a promise that arbitrary content fits. Check the server plan's advertised limits; older deployments still return 20 Memos and 200 tree nodes. An oversized or inconsistent inventory is blocked, not truncated. Existing ownership history is bounded too; invalid or exhausted history refuses another transfer.

Project folder/resource/file/image/video Nodes and Bindrs retain their IDs and relationships. Project paths and namespace ownership change in the atomic cutover. Memo IDs, authorship and S3 roots remain stable; destination slugs may be explicitly renamed to avoid collisions. NoteFile owner namespaces change in the same atomic database cutover. Historical content, file bytes and immutable publication rows are not rewritten to look as though they were created by the destination. Current and retained Note/NoteFile storage objects must pass actual byte/checksum verification first; direct Project files retain their existing storage metadata without an object check. Memo collaboration retains its snapshot-recovery and room-cutover flow; it can write projection/revision/transfer-baseline data under the existing prefix. Ordinary Project media and Artifact/Env storage objects are not moved; this does not mean the entire operation performs no S3 writes.

The following block the entire operation: Source bindings or Bindr Source references; Annotation or Workflow mounts; foreign/missing owned resources; Project episode nodes, Tracks, Tasks/events, Datasets, embedding-job records (including historical jobs) or service-account Project grants.

Unreleased — not in the verified production scope above. A reviewed but unmerged/undeployed change (project-resources-v4) moves Tasks, Task events and legacy Datasets with the whole Project instead of blocking on them: Task/TaskEvent owner labels change in the same atomic cutover, Dataset documents are untouched because their stable projectNodeId already follows the Project, Bindr/Dataset links and Task Memo references keep their stable IDs, and no file payload moves. Task and Dataset writers consult the Project ownership lease inside their write transactions and answer 409 while a transfer holds it. Deployed workers reject the new execution key before claiming; pending project/project-files-v1/project-files-v2/ project-resources-v3 operations keep their original closure.

The same unreleased project-resources-v4 closure also admits two new member types. Owned Annotation catalog mounts move as manifest members: cutover pins each row's existing bucket/prefix (legacy rows resolve their original namespace/name prefix with no backfill), and a same-name annotation recreated in the old namespace receives a fresh catalog-ID-isolated prefix, so it can never address the moved bytes. Annotation reads/presigns, upload-credential minting, registration/revive/update/delete and purge re-admit inside their write transaction against the current owner and the ownership lease; revive preserves the pinned binding. Pure-managed Sources — no external layer, live lifecycle, a valid stable internal storage binding — move with the Project: the Source ID and internal binding stay byte-identical, no payload is relocated and no per-file enumeration occurs, so file volume is irrelevant. The Project's own ProjectSourceBinding and Bindr Source reference rows are retained with their IDs and only their namespace labels move; Source bindings and references outside the moved Project are explicitly previewed and detached. Preserving access is unsupported while old Source authority exists (share link, admissions or editors): transfer revokes them by default. Succeeded physical-operation history stays recorded under its old-namespace tenure rather than being relabeled without bound, and current-scope retry admission denies a moved Source. An uncertain or failed one-object-delete marker is a specific blocker that requires operator recovery — a new same-path delete never clears it; detach that Source to move the rest of the Project. External, deleting, invalid-binding, pending-operation and destination-placement-restricted Sources remain specific blockers (FOREIGN_OR_MISSING_RESOURCE, SOURCE_DELETING, SOURCE_EXTERNAL_TRANSFER_UNSUPPORTED, SOURCE_STORAGE_BINDING_RECONCILIATION_REQUIRED, SOURCE_STORAGE_STATE_UNSUPPORTED, SOURCE_OPERATION_PENDING, SOURCE_REFERENCE_RECONCILIATION_REQUIRED, SOURCE_STORAGE_PLACEMENT_UNSUPPORTED, plus the existing RESOURCE_* destination collision/preservation codes), and already-issued signed read/upload capabilities keep their existing TTLs.

Until that change ships, the deployed service behaves exactly as this memo describes: Tasks/events, Datasets, Source bindings/references and Annotation mounts still block the entire operation. Pending publication, purge/deletion work, invalid paths or RTC bindings also block. Memo attachments represented by NoteFile are supported, as are ordinary Project file/image/video Nodes; episode content remains unsupported. Other byte-backed leaves, such as JSON or audio, qualify when their existing metadata identifies a valid stored key or BSS ID; unknown Nodes without a storage binding do not. There is no copy/delete or partial fallback. Source continues using ProjectSourceBinding; no new attachment table or Source relationship migration is introduced, including by the unreleased v4 scope above, which only relabels the retained rows' namespace labels. In the deployed release, Source, Workflow, Annotation and structural content remain unsupported; the unreleased v4 closure covers Annotation mounts and the eligible pure-managed Source subset only. External Sources still need destination Connection handling, an uncertain managed-file deletion marker still requires operator recovery, and Workflow transfer needs active-run and history handling. These remain separate follow-ups; unsupported members are never silently omitted from a Project move. Embedding-job status is a free-form string; this release has no verified immutable terminal-state contract. Completing or cancelling a job therefore does not remove its blocker. Use a Project without embedding-job records; the blocked plan leaves the original records unchanged.

A blocked plan returns owner-only error.details.blockers, with each item identified by its safe ID, name, path and kind. The application lists the affected item and its reason so the owner can identify what needs attention. Inspect the full list before retrying; resolving one item does not authorize a partial transfer. Unsupported content, missing Memo storage proof, incomplete inventory and active writer/deletion work must continue to stop the entire operation. Blocker responses never include object-store credentials, signed URLs or private execution-ledger contents.

A soft-deleted or unavailable mounted resource can produce FOREIGN_OR_MISSING_RESOURCE; soft deletion does not detach it. Inspect the owner-only blocker and verify the exact resource/Project relationship. If the resource should no longer belong to the Project, use the normal detach action for that known mount, then obtain a fresh complete plan. Do not purge the resource, silently discard manifest entries or treat a missing resource as an empty plan.

The application adds no new resource-relationship collection. The first production RTC rollout initialized the empty RoomAuthority coordination collection already defined in the upstream RTC schema, with only MongoDB's implicit _id index. This RTC coordination setup is separate from application resource relationships; it requires no Memo or Source-binding data migration.

Direct Project files and existing storage capabilities

Direct ordinary files, images and videos move by changing database namespace ownership and Project paths atomically. Their storage metadata stays unchanged, including existing s3Key and bssId references. Transfer does not copy media, resolve or migrate BSS records, inspect physical objects, or change bucket configuration. It adds no network file preflight or media byte-size cap.

Ordinary file/image/video Nodes do not need a resolvable physical object to change ownership. A file that was missing before transfer remains missing afterwards; transfer does not repair its storage. Other byte-backed leaves, such as JSON or audio, are recognized through their existing valid stored-key/BSS metadata. Structural tree checks still apply and episode content remains unsupported. Note/NoteFile storage proof and its existing 512 MiB verification limit are unchanged and separate from these direct Project file references.

Existing BSS raw references retain the existing BSS access behavior. Transfer does not add BSS caller authorization or invalidate the stored BSS ID. This is a source-verified compatibility boundary, separate from signed S3 URL expiry; it is not a new production BSS authorization test.

New API requests use the current database owner for authorization. Read and upload URLs issued before transfer retain their existing expiry: an unexpired upload URL can still write the same underlying object, and an unexpired read URL can still read it. Transfer does not revoke these already-issued storage capabilities or freeze bytes against such writes. Stronger immediate revocation is outside this transfer contract; do not present owner cutover as immediate invalidation of old signed URLs.

Artifact and Env storage and access

Artifact and Env IDs, canonical names, versions and existing physical storage locations remain stable. The atomic database cutover changes their namespace owner and pins the original bucket/prefix; no objects are copied or moved and no backfill or bucket versioning is needed. Content clients use the returned backendUrl and ref, never a path guessed from the new namespace. Recreating a name in the old namespace allocates a different storage prefix.

These resources become private. The accepted older release above blocks Artifact/Env link retention. Artifact preservation additionally requires the compatible catalog/token/proxy API and ownership executors introduced by PR1170, with old readers drained and ARTIFACT_TRANSFER_SHARING_ENABLED=true. This admission flag defaults off independently of S3 snapshot admission; an installed client or a repository merge alone does not establish the running API floor. The deployment also needs the reviewed additive ArtifactCatalog_artifactId_idx index through the existing target-fingerprinted, plan-hash-pinned index workflow.

With that floor and the reviewed Keep direct shares choice, current Artifact share tokens and exact existing share-visit IDs/timestamps move with the Artifact. Visits still depend on its live token and never become independent grants. Verified old-namespace read aliases authorize the current owner; they grant no old-member access, never serve writes, and yield to a resource recreated under the old name. Revoking/changing sharing still governs alias reads. Env share links remain unsupported. Older/disabled deployments and incompatible requests retain preview blockers; do not bypass them or copy/delete resources. The Keep Memos in other Projects choice applies only to Memos. Artifact/Env placements in outside Projects and their Bindr memberships are always removed; the preview reports their removed count separately. The resources themselves move with their contents. Canonical resource names cannot be renamed inside this transfer; resolve destination name collisions before proceeding.

Active or uncertain apply/purge/thumbnail work blocks transfer. New API writes and credential mints verify the current database owner and ownership lease. Credentials and signed URLs issued earlier keep their original finite lifetime; this release does not promise immediate revocation of an existing S3 capability.

Uploads spanning the server upgrade can receive 409 UPLOAD_RESERVATION_REQUIRED when their first registration has no upload reservation. Obtain fresh upload credentials, reupload to the returned target, then register. Retrying the same registration alone cannot select a safe storage location. Normal current clients already obtain credentials before uploading.

Owners and access choices

The source namespace owner creates the request; the destination namespace owner accepts. Project ADMIN, resource authorship and inherited content WRITE do not confer ownership authority. One actor owning both namespaces can explicitly accept only when the server verifies destination ownership. Preview authority is an observation, not durable acceptance.

ChoiceDefaultEffect
Project and moved resource visibilityPrivateGeneral visitors do not gain access; independent destination namespace membership rules still apply. Republish is unsupported.
Preserve existing accessOffRevoke moved Project grants, Memo accepted shares/share links and NoteFile preview links. Opt-in preservation is reviewed and accepted as part of the exact request.
Preserve external Project filingsOffRemove other-Project mounts and their Bindr tags. Explicit opt-in keeps them only with destination-owner approval of their live audience.

Defaults above describe the UI/CLI/SDK. Low-level API callers should set both booleans explicitly and inspect the preview's effective policy. If external filings exist, omitting the preserve/remove choice blocks preview with EXTERNAL_FILING_POLICY_REQUIRED; the server does not silently detach them. Preservation refuses unavailable recipients or team grants outside the destination organization rather than silently retaining an invalid permission.

Removing an external filing ends access inherited through that filing. It does not delete the Memo or its content: the whole Project and its owned Memos move together with stable resource IDs and data. Independent grants/share links follow the separate preserve-access choice, which also defaults off; independent current namespace permissions continue to apply.

These are separate decisions. Opting in to keep an external filing can keep old audience access even with preserveAccess off. An old Project owner can retain inherited WRITE/ADMIN content access through that Project. Direct/team grants and the existing Project namespace's ordinary organization-member READ baseline can retain reads; this is the Project's live audience, not just a frozen user list. A public Project's implicit READ still does not open a private Memo. The destination must review this audience before acceptance. Inherited content access never grants independent sharing management, deletion or another transfer.

Legacy retained foreign-namespace filings qualify only through server-authored, completed transfer history and the private journal's approval evidence. A failed later transfer requires its exact source-restoration proof before those readings can resume. They keep this behavior and are never converted automatically.

New cross-namespace mounts use owner-issued external mount grants for Memos, Artifacts, Scenes, Annotations and Workflows. A request carrying policy.externalMounts disposes of every grant and incoming mount explicitly, and a retained filing then becomes a grant with an approved audience and maxRole instead of a legacy marker. A new request that preserves external filings without it is refused with EXTERNAL_MOUNT_POLICY_REQUIRED, and any grant or incoming mount requires dispositions (EXTERNAL_MOUNT_DISPOSITION_REQUIRED). Only operations stored before this rule keep the marker contract above when they are accepted or recovered.

Web review and namespace Transfers

The Web transfer dialog uses two independent switches, both off by default. The Project and its included resources become private with either setting:

  • Keep direct shares preserves eligible existing Project people/team grants, Memo direct grants and Memo share links. Off revokes those grants and links; on adds no recipients and does not preserve public visibility. Existing Artifact share tokens/visits can additionally be retained only with the compatible API floor and enabled admission. Env links and older/disabled Artifact implementations still block retention.
  • Keep Memos in other Projects preserves existing external Memo mounts and the access inherited from those Projects, even when direct shares are off. Off removes those placements and their contribution to access without deleting Memos. This refers to Memo placements, not files attached inside a Memo.

Neither switch authorizes arbitrary new cross-namespace mounts. Changing either choice requires another reviewed preview.

The Web client submits destination acceptance automatically after creation only when the reviewed preview explicitly allows this actor's matching destination accept action and namespace, destination acceptance capability is allowed and the destination Project adapter is ready. Role labels or a guessed account relationship do not establish authority; the server checks acceptance again. Otherwise the request remains pending for the destination namespace owner. CLI still requires explicit --accept-if-owner, SDK requires accept_if_owner=True, and direct API callers use the separate accept endpoint. The Web behavior does not change those client contracts.

Project transfer requests have a dedicated namespace page at /:namespace/transfers?direction=incoming or direction=outgoing. Settings links to this page instead of embedding the long transfer list. It defaults to active Project requests. Show recent history switches to the most recent 100 requests, including active and terminal states; this is not complete history. The Projects page shows an active incoming/outgoing Project-transfer banner only for directions allowed by the actor's current server capabilities. A capped response displays 100+ instead of claiming an exact total or pending count; failed reads are shown as errors rather than zero requests. The banner opens that namespace's Transfers page.

A completed, owner-committed result closes the dialog and opens the destination Project only after its canonical namespace and slug are safely resolved. If that read is unavailable, it opens recent history (history=recent) in destination incoming Transfers when the actor can manage acceptance there; otherwise it opens source outgoing Transfers. A pending request closes the dialog and opens source outgoing Transfers with a notice that the destination namespace owner must approve it. Preparing work also opens Transfers and is not reported as completed ownership.

Review, request, accept and observe

These examples require the minimum client versions above and an enabled, accepted backend/RTC deployment. Check installed help and server readiness first; stop on unsupported capability or a blocked preview.

bash
# Save one complete review artifact, including the stable request/key/hash.
dl project move research --namespace source --to destination \
  --dry-run --out reviewed.json
# After reviewing scope, names, audience and access policy, replay that artifact.
dl project move research --namespace source --to destination \
  --confirm --request-file reviewed.json

The review file is created exclusively with private permissions. Do not replace it with a new plan after an ambiguous response. The sender's request can return pending acceptance, not completed ownership. The target owner uses the returned operation ID with ownership accept; source cancellation and destination rejection remain distinct. --accept-if-owner requests explicit same-actor acceptance; it never bypasses server ownership checks. Optional bounded waiting observes status, rather than issuing a second mutation.

--preserve-access opts in to existing access. External filings are removed by default; --preserve-external-filings explicitly opts in to retaining Memo placements and their reviewed live audience. Artifact/Env outside placements are always removed. SDK callers use preserve_external_filings=True for the same opt-in; the default is false. Use --name and repeat --rename-note NOTE_ID=NAME for reviewed destination collisions. All choices must be in the artifact that was previewed and confirmed.

The SDK provides projects.transfer_plan(namespace, project) and projects.move(...); retain the returned review dictionary and use reviewed=original_review, dry_run=False, confirm=True for exact replay. SDK operations have the same independent destination acceptance and bounded-wait rules. See the owning CLI Projects and SDK Projects guides for complete arguments.

APIPurpose
GET /namespaces/:slug/ownership/resources/project/:id/transfer-planOwner-only complete manifest, current version, names and execution status.
POST /namespaces/:slug/ownership/transfers/previewBind scope, policy, destination authority and collision choices to a preview hash.
POST /namespaces/:slug/ownership/transfersCreate or replay the exact idempotent request.
GET /namespaces/:slug/ownership/transfersOwner-authorized incoming/outgoing requests; optional canonical resource filter and bounded active-only listing.
GET /namespaces/:slug/ownership/transfers/:idRedacted status, ownerCommitted and recovery direction.
POST .../transfers/:id/accept or /rejectDestination owner decision.
POST .../transfers/:id/cancelSource owner cancellation, before the irreversible owner-commit boundary.

STALE_PREVIEW requires fresh review before a new request. A lost create response requires replay of the same request, preview hash and idempotency key, even if the old source Project lookup now returns 404. If the operation ID is known, inspect its status instead. Do not infer failure from timeout, rebuild its manifest automatically, remove leases or recreate resources.

Content and old-address behavior

RTC-backed Memos revoke the old room permanently and capture a lossless native snapshot/journal. The new room has a fresh generation and remains quarantined until database ownership commits. Completion activates only that committed binding. A pre-commit abort needs a durable restoration/cancellation proof; not-admitted, an expired request or a successful HTTP response alone is not proof that external work stopped. Old rooms never become ordinary writable rooms again.

A historical Note/NoteFile namespace URL is only a read alias, after verification of a completed owner chain. The server resolves current ownership and checks the requester's permissions there. An old URL is not an access grant; writes use the current canonical namespace. Resource navigation uses the resource's owner namespace while the Project backlink keeps the filing Project's namespace. Historical Memo bodies/attachments are never rewritten for the alias. Direct Project file URLs use the moved Project's current namespace and path; the Memo history alias does not extend to old Project file paths. Already-issued download URLs retain their existing finite lifetime; revoking independent share links does not retroactively cancel those storage capabilities.

Within a retained foreign-Project Memo pane, creating/extracting a new Memo uses the current Note-owner namespace and does not automatically attach it to that foreign Project. Creating from a Project column uses the Project's actual namespace. Normal creation authority still applies; inherited content permission does not become namespace-wide creation authority.

Deletion can continue at the new owner using verified historical publication receipts. A current namespace owner may take over a stopped durable deletion operation, keeping its original actor and fixed target and recording recovery actor identity. That does not let a stale executor publish results or turn a content grantee into a deletion administrator.

Activation and operator recovery

PROJECT_NOTE_TRANSFER_ENABLED defaults to false. Configuration alone is not acceptance. For a new deployment, before enabling it, release compatible RTC, configure the authenticated bridge, verify required ownership indexes and the exact server release, drain every old writer, and execute cross-service and real-storage acceptance. Isolated composition uses real RTC and MongoDB with injected physical storage. The separate production acceptance above verifies native Memo storage, ordinary media and Artifact/Env content through the stated fixtures; it does not establish every provider or attachment isolation path.

The managed ECS drain observes retained service tasks; it is not a census of production-database-connected local servers. Update those local servers to the latest compatible main before using their write APIs. Old catalog upload issuers cannot be retrofitted by draining ECS, and already-issued credentials keep their original lifetime. The accepted public production API is the verified release above; a newer local repository commit is not evidence of a deployed API.

The bridge uses RTC_API_URL and RTC_REVOCATION_TOKEN. Keep the shared token in the existing encrypted GitHub/RTC deployment secret paths; never include its value in docs, review artifacts, command examples, PRs or logs. Verify matching deployed configuration without printing or copying the credential. A missing token or unsupported RTC release must leave execution disabled.

Public status redacts private ledgers and executor tokens. There is no client reconcile command. The configured server reconciler resumes unclaimed operations.

Larger-capacity Note/file Project transfers use the internal execution key project-files-v2. Common-resource transfers use project-resources-v3 in the same existing operation record. Public Project root references and writer leases remain project; members use canonical note, artifact or env references. The unreleased project-resources-v4 key additionally accepts canonical annotation and source members. annotation members are denied under every pre-v4 persisted key, and source members are denied under the project-resources-v3 catalog key, including through an edited persisted request; the legacy project/project-files-v1/project-files-v2 accepted request shapes are preserved unchanged (they could always carry source-shaped members), and their adapters continue to fail closed on Sources at preview/fence. Artifact/Env gain optional storage-binding/operation fields; there is no association-table or stored-object migration. Compatible workers also resume existing project, project-files-v1 and project-files-v2 operations with their original adapter and snapshot shape. Older workers do not recognize the new key and reject it before claiming the operation, so they cannot apply an older content whitelist or capacity limit and abort an otherwise valid transfer. Keep a compatible worker available until these operations finish; rolling back to an older worker pauses them rather than providing recovery. Legacy status endpoints may display the internal execution key as the resource type; it is a version identifier, not a credential. Use a compatible server to inspect or manage those operations. Current servers omit unknown execution versions from lists and refuse unsupported single-operation actions before changing state. This is an internal worker compatibility change, with no new public command or public-skill procedure.

For a crashed executor, use this controlled operator sequence:

  1. Read public operation status and the private journal through the authorized operations channel; record operation identity, state and ownerCommitted. Keep the exact observed claim token inside that channel only.
  2. Prove the old executor is stopped and all its external work is quiescent. A timeout, elapsed lease period, changed owner or apparently terminal state does not establish this. Do not clear a live executor claim.
  3. In a controlled database operation, compare-and-clear only the executor claim matching that operation and exact observed token, with the observed state/ownerCommitted preconditions. Require one matched row; zero matches means reread and stop. Never clear ownership leases, rewrite ownership, alter accepted policy, or mark the operation completed manually.
  4. Let the configured reconciler acquire a fresh claim. Before owner commit it must prove source staging abort; after ownerCommitted it must roll forward. Require the adapter's durable RTC/storage proof and final status, not merely a successful retry. A later transfer's abort must preserve the previously approved filing history through its recorded recovery proof.
  5. Confirm current owner, canonical read/write behavior, old-room denial, new-room activation, retained audience policy and lease release. Keep an audited recovery receipt without credentials or private content.

After ownerCommitted, finishing an already accepted operation does not depend on the original accepting actor still being active or namespace owner. The adapter fences the current stored owner tuple of the live destination namespace (and its active organization when organization-owned), then verifies the exact committed Note/RTC bindings before roll-forward. Original acceptance provenance is retained; no new grant or ownership change is implied. If the destination namespace is missing or deleted, retain recovery-required with DESTINATION_NAMESPACE_UNAVAILABLE for operator attention, rather than activate into that namespace. Pre-commit authority loss still cannot commit ownership.

There is no TTL claim takeover or automatic owner rollback. If the old executor cannot be proven quiescent or proof is incomplete, retain the claim/gate and the explicit recovery blocker. Ownership rollout remains the broader infrastructure evidence contract.