DreamLake

Project and Source ownership preflight

The whole-Project and owned-Notes 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 was strictly verified at 07:01:03 UTC on October 9, 2026 in run 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 was strictly verified at 2026-10-09T22:43:30.582522+00:00 in run 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.

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 } }:

CodeHTTPRecovery
PROJECT_BINDR_OWNERSHIP_BUSY409Refresh transfer status. Retry the same filing intent after ownership is writable; do not clear a lease or change namespace IDs.
PROJECT_BINDR_LOST_AUTHORITY403Refresh 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:

CodeHTTPRecovery
WRITER_FENCE_REQUIRED / STALE_EPOCH409Refresh ownership status; retry the same intent only once the resource is writable. Never clear a lease.
OPERATION_CONFLICT409Transaction retries were exhausted. Refresh and retry with bounded backoff.
LOST_AUTHORITY403Refresh 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. 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. 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.

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.