<!-- source: https://docs.dreamlake.ai/dev/notes/project-note-transfer @ 0.1.192 b2f973b1 -->
## 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`](https://github.com/dreamlake-ai/dreamlake-workspace/commit/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](https://github.com/dreamlake-ai/dreamlake-workspace/pull/1146#issuecomment-6174057997)
records both original and continuation results.

Two real-storage fixtures completed ownership cutover:

| Fixture | Observed result |
|---|---|
| Capacity | 25 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 resources | Project, 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](https://github.com/dreamlake-ai/dreamlake-cli/pull/268#issuecomment-6174872626).

The Web production rollout was read back at
[`ac47aa11fc6688d479444028b754be396c44214f`](https://github.com/dreamlake-ai/dreamlake-ai/commit/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](https://github.com/dreamlake-ai/dreamlake-ai/pull/971#issuecomment-6175022079).
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

| Mechanism | Race it prevents |
|---|---|
| Stable-ID baseline pages of 64 plus a durable Mongo change cursor opened before scanning | A 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 barrier | A 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 fences | After 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 transaction | New 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 transaction | A 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 evidence | A 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](https://github.com/dreamlake-ai/dreamlake-workspace/pull/1170), 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.

| Choice | Default | Effect |
|---|---|---|
| Project and moved resource visibility | Private | General visitors do not gain access; independent destination namespace membership rules still apply. Republish is unsupported. |
| Preserve existing access | Off | Revoke 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 filings | Off | Remove 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](/api/external-mounts/) 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](#artifact-and-env-storage-and-access).
  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.

| API | Purpose |
|---|---|
| `GET /namespaces/:slug/ownership/resources/project/:id/transfer-plan` | Owner-only complete manifest, current version, names and execution status. |
| `POST /namespaces/:slug/ownership/transfers/preview` | Bind scope, policy, destination authority and collision choices to a preview hash. |
| `POST /namespaces/:slug/ownership/transfers` | Create or replay the exact idempotent request. |
| `GET /namespaces/:slug/ownership/transfers` | Owner-authorized incoming/outgoing requests; optional canonical resource filter and bounded active-only listing. |
| `GET /namespaces/:slug/ownership/transfers/:id` | Redacted status, ownerCommitted and recovery direction. |
| `POST .../transfers/:id/accept` or `/reject` | Destination owner decision. |
| `POST .../transfers/:id/cancel` | Source 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](/dev/notes/ownership-rollout/)
remains the broader infrastructure evidence contract.
