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.
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.
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:
- 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.
- 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.
- 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 D97a57434. 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.