<!-- source: https://docs.dreamlake.ai/dev/notes/project-source-ownership @ 0.1.192 b2f973b1 -->
# Project and Source ownership preflight

The [whole-Project and owned-Notes transfer](/dev/notes/project-note-transfer/)
is a separate bounded execution adapter, not a release of general Source or
standalone Memo transfer. Its bounded Project adapter is production-accepted;
see that contract for the live scope and remaining validation limits. The released
Project-sharing contract still applies;
references can confer explicit Project-derived content access, never ownership.

Updated October 9, 2026. Project/Source inspection and preview-only adapters
integrate the version 1 ownership contract and scoped Vault foundation. Access
management and preview were available in that release; cross-namespace execution
was disabled. Current whole-Project execution is documented separately above. The
project/source reference fences and selected-Note inventory,
Memo metadata/filing safeguards, and activation/acknowledgement safeguards below
have earlier verified runtime acceptance. That acceptance does not establish
readiness of later writer activations or resolve a current
Memo-read failure.

October 9 release status: catalog readers and attachment compatibility (946/957),
transactional attachment sharing (961), and atomic move/trash (962) are included
in the strictly verified API release `0e0fa830` (task definition 212). Their race
and failure behavior was validated in isolated tests, not by destructive
production mutations. A bounded service-task observation at the compatible
`f3406928` release supplements the image/digest receipts; it is neither an atomic
snapshot nor proof of historical or future writer exclusion. All intervening
verified releases preserve compatibility. The separate immutable-upload release
(958) now has exact running image/digest acceptance with
`NOTE_FILE_IMMUTABLE_WRITES` enabled. Release
[`f4d9d4917b57e5cb8452e41fee9f5c7af62786f9`](https://github.com/dreamlake-ai/dreamlake-workspace/commit/f4d9d4917b57e5cb8452e41fee9f5c7af62786f9)
was strictly verified at 07:01:03 UTC on October 9, 2026 in
[run 37895028852](https://github.com/dreamlake-ai/dreamlake-workspace/actions/runs/37895028852),
with task definition 214 and the running image bound to the exact pushed digest
`sha256:2bff87c0d2de849fa480c3cb47b0121aa1c4ebc54a5c4a295f46d63ae08651d7`. Its 184 isolated tests cover races and failure
paths; production attachment-write and user acceptance remain separate and are
not established by the runtime receipt.
The copy (975) and default catalog-writer (997) successor
[`27896dc87e38fa09c43e0cf25f5ac8c0319721b8`](https://github.com/dreamlake-ai/dreamlake-workspace/commit/27896dc87e38fa09c43e0cf25f5ac8c0319721b8)
was strictly verified at 2026-10-09T22:43:30.582522+00:00 in
[run 37999348930](https://github.com/dreamlake-ai/dreamlake-workspace/actions/runs/37999348930),
with task definition 224 and exact pushed digest
`sha256:bed6bf78bcd873a1bc9eef4e0df406d3f6cf95e8620a87524da4e5890aae3a6b`. Authenticated attachment metadata and version-list GETs returned HTTP 200; the version response advertised catalog readers (`1`), the catalog writer (`catalog`) and `no-store`. These two requests completed at 2026-10-09T22:44:40.841234+00:00. Individual requests were not attributed to a serving task; the strict fleet receipt is separate.
These observations do not establish a production attachment-copy or version-save
mutation; no such write was performed for release acceptance.
`NOTE_VERSION_CATALOG_WRITES` is enabled; `NOTE_FILE_DURABLE_PURGE` remains false.
No transfer gate is enabled; Memo-read availability remains a separate concern.

Authenticated resource inspection is available at
`GET /namespaces/:namespace/ownership/resources/:type/:id` for project/source.
It returns current owner, resource-specific capabilities, lifecycle limitations
and an owner-only expected version. Project ADMIN retains existing grant and
delete management; Source EDIT cannot transfer or manage credentials. Authorship
and project affiliation never confer transfer authority.

The `/manifest` subroute requires current namespace ownership and returns bounded
structure/filing inventory, grant/editor IDs and active mutating operations. The
existing A `/transfers/preview` route now supports C's preview-only adapters.
Explicit selections determine ownership; excluded resources keep their owners.
Cross-owner filings require explicit detach choices. Existing BindrMember and
ProjectSourceBinding remain affiliations, never ownership transfers. Released
Project grants can confer content access through those relations. No provider paths, memo bodies,
private Connection config, credentials or internal storage bindings are returned.

A source-only owner cannot discover destination Connections or name occupancy.
The preflight blocks until destination authority can validate these dependencies.
With both authorities, C validates destination namespace, active lifecycle,
connector compatibility, settings and credential revisions; it does not rewrite
or export the old Connection. A bounded destination scope probe and managed
storage staging/verification/recovery remain mandatory gates. B's current contract
supports named capabilities, authorization epochs, serialized final release, and
explicit source-retaining credential copies with destination reseal and recovery.
Credential moves still require complete consumer inventory; customer-KMS
policy-aware destination reseal remains gated. Destination-supplied Connections
are independently authorized. C never performs an implicit credential copy.

The owner panel appears in project editing and Source settings. It previews
explicit selections/detachments and uses server capabilities. Source settings
now exposes existing disable/enable and Source editor management; requests reuse
an exact idempotency key on explicit retry. Source deletion keeps the existing
terminal worker contract; no external buckets or shared Connections are deleted.
Project deletion keeps existing resource-preserving semantics. The `/restore`
subroute reports unsupported while safe current authority can be established:
`PROJECT_SNAPSHOT_REQUIRED` or `SOURCE_DELETE_TERMINAL`; deleted/missing resources
can return `NOT_FOUND`. The proposed 30-day project snapshot recovery is not
implemented. Separate archive is unsupported.

## Filing concurrency and recovery

Selected-Note inventory is being changed to bounded bulk reads inside the same
ownership transaction. The batch first validates every selected Memo's live
source ownership and project filing, then hashes the same per-Note metadata and
ledgers in deterministic order. It refuses an aggregate inventory over 10,000
rows with `MANIFEST_TOO_LARGE`; existing per-Note limits still apply. Destination
name checks remain conditional on destination authority. This implementation
does not extend the transaction timeout, split an atomic manifest, enable an
adapter, or approve detaching excluded resources and reverse filings.

The existing Source filing endpoints keep their permission requirements:
project WRITE (the route's create/delete permission), plus namespace Source USE
for PUT. DELETE does not require Source access, so stale references remain
removable. A filing does not change ownership. Under released Project sharing, explicit
Project grants can contribute Source USE/EDIT; creating a new Source reference
also requires independent Source sharing-management authority.

```text
PUT    /namespaces/:namespace/projects/:project/sources/:sourceId
DELETE /namespaces/:namespace/projects/:project/sources/:sourceId
PUT    /namespaces/:namespace/projects/:project/bindrs/:bindr/sources/:sourceId
DELETE /namespaces/:namespace/projects/:project/bindrs/:bindr/sources/:sourceId
```

Each mutation rechecks authority and writes the Source/Project ownership leases
and reference parents within its database transaction. A concurrent authority
change or transfer cannot commit between that check and the filing write. A
refusal rolls back both the filing change and the fence writes. Missing-Source
cleanup remains supported. Existing PUT/DELETE no-ops still succeed without any
write, including while a transfer lease is busy.

The response keeps `{ error: { code, message, retryable, requestId } }`:

| Code | HTTP | Recovery |
| --- | --- | --- |
| `PROJECT_BINDR_OWNERSHIP_BUSY` | 409 | Refresh transfer status. Retry the same filing intent after ownership is writable; do not clear a lease or change namespace IDs. |
| `PROJECT_BINDR_LOST_AUTHORITY` | 403 | Refresh access and stop the write. Regain the required permission before retrying. |

Fresh permission failures retain their existing forbidden/not-found codes;
`PROJECT_BINDR_LOST_AUTHORITY` specifically reports an actor, organization or
namespace fence refusal.

These are four specific reference writers. They do not establish complete tree,
Bindr, content, upload, background-job or Memo writer coverage, and do not enable
an ownership adapter. Organization baseline access remains unchanged.

## Memo metadata and generic filing writers

This metadata and generic-filing writer slice has earlier verified runtime
acceptance. It does not change any adapter readiness flag or establish acceptance
of later catalog or attachment writer activations.

The Memo metadata PATCH reauthorizes title, summary and visibility changes using
the existing namespace-owner or creator-current-member policy. A project-tree
rename uses that same policy: project WRITE and departed authorship are not
sufficient. Metadata changes and all mounted-title updates commit together.
Share-link PUT/DELETE (including accepted-record revocation), accepted-share
removal, comment POST/PATCH, and share-acceptance record creation/role or last-seen
updates use the same transaction-local Memo authority/lease fence. A fresh
accepted-share read requiring no record update remains a no-op.

Each covered write fences the active actor, organization when present, namespace,
Memo ownership lease and common Memo parent. A title change also fences affected
mounted projects. Memo deletion checks admission and fences its final database
soft-delete/grant cleanup/unmount transaction; its preceding RTC/storage side
effects are not protected by a durable external-phase lock. This is not complete
Memo deletion or collaboration-revocation proof.

Explicit metadata/share/comment mutation routes use their existing flat
`{ error: code }` response shape. Read/activate callers that persist share
acceptance use the existing Fastify error mapping, for example
`{ error: "Conflict", message: "WRITER_FENCE_REQUIRED" }` with HTTP 409.
The best-effort namespace-slug backfill in `GET /me/notes/shared` is also fenced;
a refusal skips that write without failing the otherwise-correct list.

Mutation recovery codes:

| Code | HTTP | Recovery |
| --- | --- | --- |
| `WRITER_FENCE_REQUIRED` / `STALE_EPOCH` | 409 | Refresh ownership status; retry the same intent only once the resource is writable. Never clear a lease. |
| `OPERATION_CONFLICT` | 409 | Transaction retries were exhausted. Refresh and retry with bounded backoff. |
| `LOST_AUTHORITY` | 403 | Refresh current identity/access and stop until the required authority is restored. |

Fresh forbidden/not-found policy responses and comment revision conflicts keep
their existing behavior. A `comment_changed` conflict must preserve the draft
while the client reconciles current text/revision.

Generic Memo filing coverage includes mount/unmount, deletion cleanup,
Bindr tag/untag/create-with-tag/delete/legacy removal, tree PATCH/subtree delete,
Project soft-delete and Bindr PATCH/reparent with all affected Memos. Each covered
writer rechecks current authority and fences the resource and filing parents. Generic project-node PATCH now requires the same ADMIN `project:update` permission as the dedicated project API; Project WRITE alone is insufficient. Memo mounts and tags validate the actual parent path as well as its project identity, so an inconsistent folder cannot acquire a Memo filing. Note-containing tree
moves across project roots or into an unfiled root refuse
`409 NOTE_FILING_RECONCILIATION_REQUIRED`: path rewrites alone cannot preserve
`projectNodeId` and Bindr tags. The original subtree remains intact. Same-project
tree moves and supported additive Memo filing remain available. This refusal
must not be bypassed with namespace relabeling, copy/delete or silent detachment.

Organization baseline access and body editing via accepted write shares are
unchanged. Activation, body/native-operation sync, files/uploads, saved versions,
media and issued download capabilities still need independent writer/storage/RTC
evidence. All transfer gates remain closed.

## Preservation access inventory (implementation, not yet deployed)

The source-owner manifest enumerates existing project grants and accepted shares
for every live, source-owned Memo filed in the project, including Memos not
selected for relocation. A filing never establishes ownership of a foreign Memo.
Grant identity, direct-user versus team scope, recipient availability, cached
share owner, stored role and current link role are distinct facts. Link tokens,
private bodies and storage bindings remain absent from the response. Disabled
links and unavailable or unresolved recipients remain visible, not silently
removed. Membership may confer stronger access than an accepted share.

Source versions bind the complete bounded inventory, Memo sharing policy and
recipient availability. Last-seen activity is not a permission change; creation
provenance and cached owner changes are bound. Truncated parent or aggregate
inventories refuse rather than return an apparently complete preservation list.
The preview records the caller's `ownership.accept` result in the same snapshot;
only authorized destination evidence reads and hashes its authority parents.
This observation is not durable destination acceptance or a reservation.

Existing direct project grants permit active users outside the owning namespace;
team grants require separate organization eligibility. Accepted Memo shares
depend on current sharing policy, not just their stored roles. None are approved
for retention by this inventory: `RETAINED_GRANT_POLICY_UNSUPPORTED` and all
execution gates remain. Cross-owner filing readers, effective destination
membership changes and old links need a separately reviewed contract before
cutover. No grant, filing, ownership or bearer capability is mutated here.

## External filing evidence (implementation, not yet deployed)

The owner-only project snapshot now binds a complete, separately bounded set of
external Memo filings, project parents, Bindr affiliations and project grants.
Only live Memos owned by the source namespace are selected; a foreign Memo
mounted in the root does not authorize discovery of its other placements.
Private rows are never serialized. Date-bearing provenance is normalized before
hashing, and deterministic ordering makes repeated unchanged snapshots stable.

The manifest and preview expose each filing's original opaque identities plus
independent current project-read and Memo-read observations. Project namespace,
path/name and Bindr membership IDs are redacted when project read is denied.
Source ownership establishes current Memo authority independently of project
roles. Only selected Memos carry a proposed destination owner in previews.
All records require separately reviewed cross-owner support; current source
access never establishes destination access. Normal destination organization
baseline access remains a separate effect, not an identical-access guarantee.

Missing/deleted/mismatched project or Bindr parents and unresolved namespaces
refuse the complete inventory. The aggregate 10,000-row cap includes Memo
identities and all enumerated child/parent/grant records. Existing per-Note
bounds remain. No cross-owner reader, grant/tag authority inheritance, detach
approval, artifact adapter or readiness flag changes in this slice.

## Bindr writers without Memo members (deployed; acceptance verified)

The #1093 release passed disposable empty-Bindr create/list/delete/list and
verified-empty project cleanup in production. Bindr creation, deletion and tag changes must recheck current project write
authority and fence the project ownership lease in the same transaction even
when the label is empty or contains only non-Note nodes. Memo members additionally
retain their existing Memo fences. An occupied project lease returns
`409 WRITER_FENCE_REQUIRED`; lost project access refuses the mutation and rolls
back its parent writes. Duplicate tags and absent-tag removals remain read-only
no-ops. This closes one writer gap; it does not enable transfer execution or
establish artifact ownership, retained-grant policy, storage or RTC readiness.

## Activation binding and acknowledged body writes

This activation and acknowledgement slice has earlier verified runtime
acceptance. It does not establish acceptance of the later catalog and attachment
writer activations, or diagnose a current Memo-read failure. It does not enable a transfer adapter.

RTC activation rechecks current read or body-edit permission, the live namespace
and organization, the Memo ownership lease, and the exact storage/room binding
inside database transactions. Signed-in public-Note readers and accepted read-share readers retain
their existing implicit initialization behavior; this does not grant content-edit
permission or enable anonymous API endpoints. The admitted namespace, storage binding, room and ownership epoch
are server-only state, never a new client capability.

RTC initialization and S3 reads occur outside transaction retries. Completion
revalidates the admitted identity and current authority before returning the
room. Failed initialization may roll back only its own unchanged claim; it must
not clear a binding finalized by another initializer. Creation compensation must
also refuse to delete a Memo whose admitted identity or authority has changed.

After an acknowledged native edit, resetting the idle-sync marker uses the
captured ownership epoch and binding plus current body-edit permission. A stale
or refused marker update preserves the successful native acknowledgement; clients
must not resend that edit merely because its projection update failed. The
acknowledged revision can precede successful baseline retention; clients must
read current state and reconcile when that retained baseline is unavailable.
A conditional commit acknowledgement remains distinct from a later snapshot;
failed readback must not discard the acknowledgement or fabricate a checkpoint.

These database boundaries do not durably exclude ownership changes during
external initialization, native commits or retained baseline/revision/timeline
writes. A lease may still be acquired between checks. Saved-version publication,
files, issued capabilities, RTC revocation and crash recovery require separate
operation-bound protection and acceptance before transfer gates can open.

## Attachment preview capability mutations

The file preview mint/revoke implementation is included in the verified API
release. Isolated tests cover its race and refusal behavior; production acceptance
did not create or revoke real public links. Both mutations use the same ownership transaction and current Memo writer fence
as other metadata writers. Mint keeps the existing `share` permission requirement;
revoke retains `updateContent`, including an accepted write-share reader. A read
permission alone cannot mint or revoke a capability. Session-only preview remains
a read and does not issue a public token.

The transaction checks exact file ID, Memo and namespace, live state and absence
of purge intent before changing a token. Concurrent mint requests return the same
committed token; mint/revoke serialize without replaying a stale preflight token.
Existing public preview tokens remain stable until an authorized revoke. No S3
operation, new schema/index, ownership adapter or execution gate is introduced.
Public capability reads still resolve the live file by token; this change does
not fence previously issued capability reads against Memo ownership cutover.
Storage copying, those read capabilities, remaining attachment metadata writers
and RTC revocation still require their separate completeness work.

## Saved-version publication rollout

The **catalog-reader and default catalog-writer releases are verified**; transfer
adapters remain disabled. The serving release uses the publication catalog for
new saves and retains catalog-aware readers and legacy S3 history at the existing
Memos version, history and body APIs. Version publication has its own strict
runtime receipt above; the earlier immutable-upload release alone did not enable it.
Do not enable version writers during a mixed legacy-reader deployment.
Rollback after activation must retain catalog-aware readers.

The verified catalog-default release sets `NOTE_VERSION_CATALOG_WRITES` to true
for normal route registration. Real production save acceptance remains separate.
It changes no endpoint, DTO, schema or index. Authorized responses report
`x-note-version-publication: catalog`, which describes one responding instance,
not a verified whole fleet. Existing no-key saves remain distinct operations;
current edit authority, organization baseline access and accepted write-share
behavior remain unchanged. Read-only shares cannot read or reconcile versions.
Catalog publication is independent of attachment copy, durable purge and transfer gates.

A `NotePublication` records the admitted Memo identity, actor, ownership epoch,
namespace, storage/room binding, request digest, stable version ID and object
manifest. The publication transaction rechecks current edit access and exact
binding against the ownership lease. S3 writes happen outside retryable Mongo
transactions and use operation-specific immutable keys. Size and SHA-256 are
verified even after conditional-write conflicts or lost storage responses.
Only a published catalog row makes these staged objects visible to product
readers. Executor expiry permits a later identical request to claim recovery; it does not
schedule a background worker and is not an expiring ownership fence. A stale executor cannot publish after another claim generation.

Readers receive the authorized Memo ID explicitly: `s3Key` is not unique and
must never identify another Memo's catalog. Published and legacy version IDs
are merged before cursor pagination; labels, ancestry, IDs and historical
snapshots remain intact. The existing S3 compare-and-swap number allocator
continues through rollout so legacy and new writers cannot allocate the same
number. Gaps after failed saves remain valid. No legacy history is imported,
deleted or reassigned by this slice.

On the verified writer release, a caller may send an `Idempotency-Key`
(16–128 ASCII letters, digits, underscores or hyphens) with a version save.
Retry against the same server and Memo as the **same authenticated actor**,
with the **identical** normalized tag, summary, hash, parent and retained revision.
The unique key is scoped to Note/actor/operation; another editor reusing the
string creates a separate operation, not recovery or deduplication. A completed operation returns its original receipt after current
edit authorization. Reusing the key for different input returns
`IDEMPOTENCY_CONFLICT`. Recovery verifies the original staged objects; it never
reads today's draft as a replacement. If an incomplete upload is proven missing,
its publication can be aborted under the current executor generation. Late bytes
stay invisible; the caller must inspect history and deliberately begin a new save.
Storage/network errors alone are not proof of missing bytes or non-publication.

Only after the catalog-reader release is verified, while its writer remains
disabled, does a keyed save return `503 version_publication_unavailable` without
saving. Older APIs may ignore `Idempotency-Key` and create an ordinary version;
never issue a mutating POST as a readiness probe. Read-only capability responses
can describe one responding instance, but cannot establish a compatible serving
fleet or enable the writer. Adopt keyed saves only after the separately verified
writer release. The serving implementation maps generic transport/database failures during
same-key reconciliation to `503 version_save_unconfirmed`, as it already does
for an interrupted initial save. An identical same-actor retry reconciles before
reading RTC, allocating another version or staging bytes. A published or fully
staged matching operation returns its original 201 version; an active executor
returns `409 RECOVERY_IN_PROGRESS`, changed input `409 IDEMPOTENCY_CONFLICT`, and
verified missing staged bytes `409 PUBLICATION_ABORTED`. Corrupt bytes return
`503 PUBLICATION_OBJECT_MISMATCH` and remain pending; network errors never prove
absence. Current authority and ownership checks still apply to an existing receipt.
Without a key, inspect history before another save; with one, preserve the exact
request and key for reconciliation after verified activation. No automatic replay
or background publication of unrelated pending saves is introduced.

The six reviewed publication indexes have been provisioned separately through
the additive index reconciler. This completes the index prerequisite, not reader
or writer fleet acceptance. The production deploy guard still refuses newly
proposed indexes; normal deployment is not index-creation authorization. Startup
verifies the two unique Note/actor/operation and Note/version indexes, three
published-history lookup indexes and one executor-scheduling index. Partial,
sparse, hidden or TTL substitutes remain refused.
Unresolved publication rows and staged bytes are not automatically purged.
Selected-Note previews bind published, staging and aborted publication metadata
to an opaque dependency digest. Staging publications count as active operations
and block transfer; an oversized inventory fails closed. Object keys, room tokens,
version bodies and labels are not returned in that dependency. This catalog
inventory does not verify storage bytes or establish transfer readiness.
General body/baseline/timeline retention, files, media, RTC revocation and storage
transfer recovery remain separate gaps. All transfer execution gates stay false.

## Atomic attachment move and recoverable trash

The metadata-writer implementation is included in the verified API release.
Isolated tests cover its races and rollback behavior; production verification
did not perform destructive attachment mutations. Existing PATCH move/rename
and non-purge DELETE route their writes through a single
ownership transaction. It fences current actor/organization/namespace/Note edit
authority and the ownership lease, then reads the exact Note/namespace/file and
checks current content `If-Match` and purge state. Even same-path or already-trashed
no-ops must pass current authority checks.

Overwrite-move trashes a colliding destination and updates the source path in one
transaction. A failure rolls both back; the destination remains recoverable on
success. File identity, storage keys/retained lineage, creator and preview token
are preserved. This operation has no object-storage side effect. A conflict after
route preflight cannot bypass the transaction's current ETag or lifecycle checks.
Copy publication has separate coverage below. Issued-capability reads, object
recovery and full transfer/RTC revocation still require separate coverage; all
execution gates remain false.

## Attachment copy publication

The existing copy route is unchanged. The verified copy implementation admits current Memo
edit authority, ownership epoch/binding and exact source/destination observations;
it reads and stages independent bytes outside retryable transactions. Publication
rechecks those observations, conditionally fences the source row, and commits
destination trash and the new file identity together. It requires the existing
`NOTE_FILE_IMMUTABLE_WRITES` flag and refuses a started purge. New copies do not
inherit public tokens or retained-key lineage. Unknown commit outcomes retain
staged bytes; callers must inspect the destination rather than automatically
resend. Durable orphan reconciliation remains separate. This copy implementation
has passed strict runtime release verification, not a production copy mutation
acceptance. It changes no transfer gate, version writer or durable-purge activation.

## Known-byte publication journal and cancellation

**Enabled API release verified October 10, 2026:** `5d64f024` passed strict
running-image/digest verification in [release run 38012963285](https://github.com/dreamlake-ai/dreamlake-workspace/actions/runs/38012963285).
The bounded old-writer drain preceded this activation; the journal's exact three
indexes were provisioned separately. Selected status acceptance performed two
GETs: anonymous 401 and authorized 404, both `no-store`. It performed no attachment
write, body read, RTC call or provider-failure recovery. This is runtime and
refusal-boundary evidence, not production-write or user acceptance.
CLI 0.48.2 source `996e2f20` completed [production publication](https://github.com/dreamlake-ai/dreamlake-cli/actions/runs/38012872453).
All nine npm packages, eight native binaries and latest/stable pointers were
verified, with real isolated npm/native Linux installs and 55-file skill readback,
idempotence and customization preservation. Other seven OS targets were
byte-verified, not runtime-tested. This does not establish an attachment write.
Public instructions and API examples are in
[the Memos journal workflow](/notes/files/#recover-a-text-or-copy-publication).

The enabled text POST and same-Note copy POST admit
every operation, including unkeyed requests. The optional actor+Note-scoped
`Idempotency-Key` identifies a normalized request; changing action, destination,
overwrite, text checksum/content type or copy source ID conflicts. A repeated
unkeyed call creates a new identity. Recovery of an existing key precedes any
source GET or PUT. Existing DTOs, 200/201, content preconditions and current
`updateContent` authorization remain. The returned `Note-File-Operation-Id` is
exposed through CORS and retained on typed post-admission refusals; unknown
acknowledgements are sanitized `503 file_publication_unconfirmed` outcomes.
Do not use a mutating request to discover readiness: older code may ignore the
key, while the compatible disabled journal rejects it before storage.

A private admission pins original authority/lease/binding, request and reserved
object/result identities. It stores checksums and selected metadata, not uploaded
text/attachment bodies or credentials. The original executor must durably win
`admitted` → `write-started` before a single conditional PUT. The known-byte
transport does not retry PUT. Reconciliation reads and verifies the original
staged bytes; it performs no PUT, replacement source GET or speculative cleanup.
Current authority/CAS checks, destination trash/new copy or text pointer update,
and the published journal receipt commit in one transaction. A lost database
acknowledgement does not authorize another upload.

Selected status, reconcile and abort require the original actor with current
Memo `updateContent`. They expose only the selected state and a whitelisted
historical File receipt; storage locators, ownership epochs, RTC bindings and
sharing tokens remain private. Published history is not current liveness and
cannot replay after trash/purge. Unresolved or mismatched storage observations
retain the operation rather than creating another object.

Abort changes only `admitted` with null content/result/status to
`aborted-before-write`, under the original lease/binding and current authority.
That transaction races the executor's write-authorization transaction: exactly
one wins. A started or published operation returns
`409 file_publication_abort_not_allowed`. A lost abort acknowledgement is
resolved through selected status or a deliberate repeated abort, never a new
upload. Terminal cancellation retains the original key and private inventory;
same-key write/reconcile returns `409 file_publication_aborted`.
Only a validated terminal row ceases to count as an active pre-upload operation;
its full retained record still contributes to the preview dependency digest.
Malformed terminal rows, unknown states and `write-started` remain blockers.

Local Mongo transaction, registered-route and provider-fault fixtures validate
these failure contracts; strict runtime and the two GETs above do not establish
production-write or provider-failure recovery acceptance. They do not cover raw
streaming/multipart uploads, pre-existing unjournaled orphans, late external
writers, whole-Note deletion, capability expiry or RTC revocation. Object 404,
elapsed time and lease expiry do not prove external-write quiescence. Durable
purge and all transfer adapters were disabled in that release. Current
whole-Project transfer is documented separately above.
Raw-upload inventory PR 1022 is a separate merged, disabled source candidate,
not part of this runtime receipt. There is no new activation, schema change or
index-provisioning permission in this documentation release. Matching docs and
skills are published separately; no new product GUI is claimed here.

## Attachment object publication and purge protocol

The separate immutable-upload activation has exact running image/digest
verification with `NOTE_FILE_IMMUTABLE_WRITES` enabled. Compatible readers and
rejection behavior are retained on the serving fleet. The 184 isolated tests
cover publication races and failure paths; neither those tests nor the runtime
receipt establish production attachment-write or user acceptance. Durable purge
remains disabled; the separate default saved-version publication release is verified above. A bounded service-task
observation remains separate evidence, not proof of historical or future writer
exclusion. Source, index provisioning and a health response alone do not establish
activation. Deployment has three separately verified steps; the first two are
verified and the third remains disabled:

1. Deploy compatible readers, restore checks and fenced legacy writers to every
   API task. Legacy writers reject the new object-key format or retained lineage;
   their metadata CAS cannot repoint a newer publication. Legacy purge also rejects
   those rows and conditionally removes only its admitted row after storage deletion.
2. Enable immutable uploads in a separate release, leaving durable purge disabled.
   Older compatibility tasks refuse new-format uploads/purges rather than changing
   their objects. An already admitted legacy upload can still finish against its old
   key, so retired keys are cleanup inventory, **not immutable version history**.
3. Only after strict exact image/digest proof that all mutable-writer tasks are gone,
   enable durable purge. This prevents a late legacy upload from recreating bytes
   after permanent cleanup. Rollback cannot restore a legacy writer once new-format
   rows exist; retain the compatible code and disable new admission if necessary.

A merge, health check or one upgraded task is insufficient fleet evidence. No
transfer readiness flag changes in any of these steps.

When immutable mode is enabled, POST text and PUT raw upload admit the actor, Memo,
namespace and ownership lease in a database transaction, upload to a fresh private
object key outside transaction retries, and recheck current authority, lease epoch
and exact Memo storage/RTC binding before publishing the pointer. Overwrites compare
the admitted file identity, path, key, checksum and update timestamp. New files
recheck path availability and the file limit in the publication transaction.
Concurrent changes return a conflict; a stale supplied `If-Match` returns 412.
No failed publication may modify the previously visible object's bytes. Unknown
commit outcomes must not trigger speculative object deletion or automatic replay.

Successful overwrites retain prior object keys in the same metadata transaction.
The bounded retained-key inventory refuses further replacements once full; this
is not a new public file-version API. Existing rows without the additive fields
remain readable. No new collection or index is needed.

When durable purge is enabled, explicit file purge records a durable intent and the complete known object inventory
before external deletion. Failed deletion keeps that intent and its keys; it must
not return `purged: true` or erase the database row. An authorized retry resumes
cleanup, and final row removal rechecks the authority, ownership epoch and exact
intent. Restore and content publication refuse a started purge. Purge is irreversible;
retained keys are cleanup records, not a promise that a partially purged file can
be restored. Storage operations remain outside database transaction retries.

This slice does **not** establish a complete storage transfer adapter. Interrupted
unpublished uploads still require a durable staging journal and orphan reconciliation;
there is no automatic cleanup worker here. Uncovered mutation paths, anonymous
media provenance, issued download capability expiry, durable RTC revocation and
checkpoint/recovery remain separate requirements. Preview hashes include retained
keys and purge intent without exposing them, and unfinished purge blocks transfer.
All ownership execution gates remain false; the FortyFive project move is not done.

Public-skill impact: existing CLI command syntax is unchanged. The canonical Memos
guide and attachment action distinguish the verified immutable-upload release from
the still-disabled purge and separately verified version writer, with conditional replacement and
conflict recovery guidance. Synchronize the public Memos skill from the committed
source; docs publication and installed-skill readback require separate receipts.

## Preview selected Memos

Select Memos explicitly when previewing a project. Each selected Memo must be
live, owned by the source namespace, and already filed in that project. Foreign,
deleted or absent Memos return `NOT_FOUND`; a source-owned Memo not filed in the
project returns `NOTE_NOT_FILED_IN_PROJECT`. No Memo is selected automatically.

Preview now counts reverse project filings and binds Memo sharing, Bindr tags,
comment revisions, identity and live/trashed attachment metadata to the preview
hash. Storage and RTC binding changes also invalidate the hash; room keys,
share tokens, storage locations, Memo bodies and comment text are not returned.
Destination Note-name collisions are checked only when the caller has destination
authority. Oversized inventories block instead of silently omitting dependencies.

A Memo shared with another project can require an explicit detachment choice;
preview does not remove that filing. Metadata inventory is not proof of retained
bytes, history, native baselines or RTC eviction. The response continues to report
`NOTE_ADAPTER_REQUIRED`, `NOTE_WRITER_FENCE_REQUIRED`,
`NOTE_STORAGE_VERIFICATION_REQUIRED`, `NOTE_RTC_REVOCATION_REQUIRED` and
`NOTE_MEDIA_OWNERSHIP_REQUIRED`. Inconsistent filing/file ownership is also a
blocker. All execution readiness flags stay false, and transfer creation remains
refused until the complete adapter and recovery gates are satisfied.

## Remaining implementation gates

- **C writer/atomic cutover:** all project/node/bindr/grant/source mutations,
  delete workers, uploads, run admission and emitted storage capabilities must
  consult A's durable per-resource lease in the same transaction. Parent fences
  must cover grants, affiliations, destination names/quota and structure. No
  atomic owner/structure/grant cutover is enabled by this draft.
- **C storage/recovery:** operation-keyed copy/count/digest verification, staged
  destination bindings, pre-CAS abort cleanup, post-CAS roll-forward, old-data
  retention/GC and cursor/cache/index invalidation need implementation. Byte and
  lineage preservation is unverified; synthetic planning tests are not proof.
- **A runtime:** crashed executors retain claims; quiescence proof and exact-token
  CAS clearing are required. Automatic crash takeover and mixed-version writer
  fleet verification are not available. Readiness flags stay false.
- **B:** explicit credential copy preview/commit/status/cancel/recovery and
  serialized final-release authority are integrated. Credential move consumer
  inventory (`VAULT_CONSUMER_INVENTORY_REQUIRED`) and customer-KMS destination
  reseal (`VAULT_DESTINATION_KMS_RESEAL_UNSUPPORTED`) remain gated. C uses
  destination-supplied Connections and never silently copies vault entries.
- **D:** local durable old-room/socket revocation passes at RTC `0caa3cd6`,
  integrated through D `97a57434`. Selected memo manifests remain blocked by
  unfinished memo mutation/upload/media/download-capability fencing, actual
  adapter and recovery, filing/grant and lifecycle proof.

- **C lifecycle/client completion:** retained project deletion snapshots,
  tombstone-authority restore and grant revalidation; project manage-access UI;
  complete project lifecycle SDK/CLI and destination Connection-picker UI remain.
  Existing Source delete controls/CLI remain in place; SDK management is added.

Unsupported owned tree kinds such as episodes/files and Dataset dependencies are
named blockers. Oversized inventories are rejected, never split into a misleading
atomic operation. Source-only independent multi-source batches are unsupported;
use individual requests or a future validated coordinated project manifest.

Public skill impact: this development page is an internal generated reference.
The companion canonical Memos guide and summary/move action guides correct
creator membership, unavailable cross-workspace transfer, and recovery guidance;
regenerate and synchronize the public Memos skill after committing those sources.
CLI command syntax and its existing fail-closed transfer procedures are unchanged.
No CLI binary rebuild is required for this server-only writer slice. Released
skills must continue to refuse unsupported cross-namespace transfer or restore.

## Current filing admission — implementation candidate

The following writer changes require their own deployment and disposable runtime acceptance; earlier reader acceptance does not establish their release.

Mounting or tagging a Memo requires current project write permission and independent current Memo read permission, including requests that find an existing filing or tag. Project membership does not grant Memo access. Additive filing remains limited to Memos owned by the project namespace; independently readable foreign Memos are refused.

Authorized duplicates and absent tag cleanup do not update project activity timestamps. Live filing paths and the complete Bindr parent chain must match the project before duplicate success or insertion. Corrupt, deleted, missing, foreign or cyclic ancestors require reconciliation; requests do not repair or adopt them. Mutating admission and activity bookkeeping commit together, with existing shared authority and ownership fences and whole-transaction retries. Mutation response counts reuse independent reader eligibility and conceal other unreadable Memo affiliations. A read-only duplicate is a snapshot decision, not a lasting capability.

This writer slice does not certify retained foreign filings or enable transfers. Cleanup retains its independent project delete policy without requiring Memo read. Storage, RTC, outstanding credentials and the real-project cutover remain under their separate contracts and authorization gates.

Public skill procedures are unchanged in this slice: the documented source-owner login already supplies independent Memo authority, and CLI move syntax/recovery guidance is unchanged. The new checks close server-side duplicate and tagging bypasses; they do not introduce a new client task or authorize foreign filing. No generated public skill source is changed.

## Metadata edits during Source cutover

A Source metadata edit (name/description with settings-revision CAS) may use an
accepted historical namespace URL. Inside a fresh short transaction, the server
verifies the completed metadata-transfer receipt and unchanged storage identity,
then checks current active-user and destination SourceADMIN authority. Only this
Mongo decision is retried on a real write conflict (at most 12 attempts within a
two-second acquisition-plus-execution budget). Provider I/O is never repeated.
The command key, actor, original request namespace and payload hash remain the
original idempotency identity; a lost-response replay returns the same receipt
only after current SourceADMIN authorization. Revoked membership or invalid
transfer provenance denies both new edits and replay. Other mutating Source
commands still require their canonical current namespace and preserve their
existing provider-effect recovery contracts.

## Standalone managed Source metadata transfer — implementation candidate

This new protocol is a staged, default-off candidate, distinct from the older
preview-only Source adapter above. `OWNERSHIP_SOURCE_METADATA_TRANSFER_ENABLED`
must remain false until its compatible Source readers are deployed everywhere
and older readers have drained. Recovery/inspection and exact accepted-request
replay do not depend on new admission remaining enabled.

The first `source-metadata-v1` profile moves one active or disabled, personal-owned
Source with only its internal `s3-compatible` layer. The original owner must still
have Source ADMIN at the destination; ordinary organization membership grants
USE, so it alone cannot preserve the previous owner's settings/delete authority.
Any active destination organization member may accept an eligible request.
External layers (including orphan reverse rows), Project filings, Editor rows,
non-succeeded physical operations, inconsistent bindings and disallowed bucket
placement remain explicit blockers. Destination credentials are never guessed,
provider authority is not broadened, and no objects are copied or enumerated.

The normal ownership capability response adds
`sourceTransfer: {apiVersion: 1, enabled, metadataOnly: true}`. The plan is
`GET /namespaces/:source/ownership/resources/source/:id/transfer-plan`;
its `resourceName`, singleton manifest and `transferMode: "metadata"` feed the
existing ownership preview/create/accept endpoints. The accepted policy requires
private access, `preserveAccess: true` and `preserveExternalFilings: true`.
Unsupported filings fail rather than being detached. A pending request does not
freeze content. Recipient acceptance revalidates authority and completes the
Source owner change, bounded history hop, historical-name reservation and durable
receipt in one Mongo transaction. A crash rolls everything back; exact retry or
lost-ack replay returns the same operation and stable resource ID.

`InternalSourceStorageBinding`, its actual S3 bucket/root, file bytes, settings
revisions, share token/role, all share admissions, completed physical-operation
history and command idempotency receipts stay unchanged. Share-admission namespace
labels remain creation provenance: current authorization and shared listings use
the stable Source ID and the live Source owner/token. No recipient census or
per-admission rewrite is needed. Revoking the live link or destination membership
still takes effect through the existing authorization rules. Preissued storage
capabilities retain their existing TTL; transfer does not claim instantaneous
revocation of already-issued S3 URLs.

Old ID/name GET URLs resolve only through exact completed receipt/history proof,
then reauthorize in the current namespace. Historical directory-operation reads
also check the live Source parent. Canonical names reserved by accepted transfers
cannot be reused by a different Source. A deterministic per-namespace/name write
parent serializes acceptance against a same-name creator or rename; unrelated
names do not contend on a namespace-wide creation counter. Ordinary renames retain
their existing no-redirect behavior unless a name was reserved by a transfer.

Provider-effect commands are not retargeted: namespace-scoped idempotency must
not miss an old successful receipt and repeat physical deletion against newly
written data. Metadata name/description edits follow the separately documented
receipt-bound path above and keep the original command key and namespace. Other
writes use the current canonical owner returned by detail/read APIs and retain
the existing Source writer/lease fence.

This standalone profile does not add Sources to Project streaming v1/v2. Project
closure additionally needs retained in-Project binding/reference IDs, a proof for
all source audiences and original Source ADMIN capability, current-Source history
readers, and an explicit decision for outside filings. Existing Project v4's
revoke/detach policy is not equivalent to the new preserve policy. External
connections require a separately reviewed destination-authorized binding and
service-grant protocol; they never inherit ambient credentials as a fallback.
