@pellux/goodvibes-sdk 1.0.0 → 1.2.0

package/dist/platform/control-plane/method-catalog-control-companion.js

@@ -117,6 +117,49 @@ export const builtinGatewayControlCompanionMethodDescriptors = [
         inputSchema: objectSchema({ sessionId: STRING_SCHEMA }, ['sessionId']),
         outputSchema: COMPANION_CHAT_MESSAGES_LIST_SCHEMA,
     }),
+    methodDescriptor({
+        id: 'companion.chat.messages.retry',
+        title: 'Regenerate Companion Chat Response',
+        description: 'Regenerate an assistant response. Optional `messageId` targets a specific assistant message; omitted, the latest assistant response is re-run. The prior response (and any turns after it) is SUPERSEDED — kept in the message list and on disk, flagged as retained history — never deleted, then a fresh turn re-runs from the preceding user message. Returns the superseded message ids so the caller can render the honest lineage. Rejected on a closed session (409 SESSION_CLOSED) or unknown session (404 SESSION_NOT_FOUND), and with an honest machine code (409 NO_ASSISTANT_MESSAGE) when there is nothing to regenerate.',
+        category: 'companion',
+        scopes: ['write:sessions'],
+        http: { method: 'POST', path: '/api/companion/chat/sessions/{sessionId}/messages/retry' },
+        inputSchema: bodyEnvelopeSchema({
+            messageId: STRING_SCHEMA,
+        }, []),
+        outputSchema: objectSchema({
+            sessionId: STRING_SCHEMA,
+            regeneratedFrom: STRING_SCHEMA,
+            supersededMessageIds: arraySchema(STRING_SCHEMA),
+            turnStarted: BOOLEAN_SCHEMA,
+        }, ['sessionId', 'regeneratedFrom', 'supersededMessageIds', 'turnStarted']),
+    }),
+    methodDescriptor({
+        id: 'companion.chat.messages.edit',
+        title: 'Edit Companion Chat Message And Branch',
+        description: 'Edit a user message and branch the conversation from it. `messageId` (required) is the user message to edit; the edited text is passed as `body` or `content` (as message create accepts), with optional `attachments` referencing artifacts. The original message and everything after it are SUPERSEDED — retained as history, never deleted — a new user message carrying `revisionOf` back to the original is appended, and a fresh turn answers it. Returns the new message id and the superseded ids for honest lineage. Same closed/unknown-session refusals as companion.chat.messages.retry.',
+        category: 'companion',
+        scopes: ['write:sessions'],
+        http: { method: 'POST', path: '/api/companion/chat/sessions/{sessionId}/messages/edit' },
+        inputSchema: bodyEnvelopeSchema({
+            messageId: STRING_SCHEMA,
+            body: STRING_SCHEMA,
+            content: STRING_SCHEMA,
+            attachments: arraySchema(objectSchema({
+                artifactId: STRING_SCHEMA,
+                label: STRING_SCHEMA,
+                metadata: objectSchema({}, []),
+            }, ['artifactId'])),
+            metadata: objectSchema({}, []),
+        }, []),
+        outputSchema: objectSchema({
+            sessionId: STRING_SCHEMA,
+            editedFrom: STRING_SCHEMA,
+            messageId: STRING_SCHEMA,
+            supersededMessageIds: arraySchema(STRING_SCHEMA),
+            turnStarted: BOOLEAN_SCHEMA,
+        }, ['sessionId', 'editedFrom', 'messageId', 'supersededMessageIds', 'turnStarted']),
+    }),
     methodDescriptor({
         id: 'companion.chat.events.stream',
         title: 'Stream Companion Chat Events',

package/dist/platform/control-plane/method-catalog-control-core.js

@@ -467,9 +467,9 @@ export const builtinGatewayControlCoreMethodDescriptors = [
         }, ['sessionId', 'inputId']),
         outputSchema: entityOutputSchema('input', SHARED_SESSION_INPUT_RECORD_SCHEMA),
     }),
-    // ── W3-S2: sessions.search ──────────────────────────────────────────────
+    // ── sessions.search (see CHANGELOG 1.0.0) ────────────────────────────────
     // Paginated/filtered query over the home-scoped session store, extending
-    // the Wave-1 list-filter shape (project/kind/includeClosed) with free-text
+    // the session-spine list-filter shape (project/kind/includeClosed) with free-text
     // `query`, `surfaceKind`, `status`, and opaque cursor pagination. Handler:
     // routes/session-search.ts (registered directly on the catalog with no
     // `http` REST binding — see the transport note below).
@@ -561,7 +561,7 @@ export const builtinGatewayControlCoreMethodDescriptors = [
         outputSchema: TASK_STATUS_OUTPUT_SCHEMA,
     }),
     // fleet.* + checkpoints.* descriptors moved to method-catalog-fleet.ts
-    // (W3-S2) — this file was already at the 800-line cap; see that file's
+    // (see CHANGELOG 1.0.0) — this file was already at the 800-line cap; see that file's
     // header comment for the full design rationale, merged in by
     // method-catalog-control.ts alongside method-catalog-control-automation.ts.
     methodDescriptor({

package/dist/platform/control-plane/method-catalog-email.d.ts

@@ -5,7 +5,7 @@ import type { GatewayMethodDescriptor } from './method-catalog-shared.js';
  * connector actions in addition to the direct-socket path. Daemon-backed; the SDK
  * publishes the typed contract surface (no internal handler).
  *
- * W4-A3 (capability-advertisement honesty): none of these four http paths are
+ * Capability-advertisement honesty: none of these four http paths are
  * currently served by the daemon router — there is no /api/email surface at
  * any prefix (confirmed by reading router.ts and every dispatch chain it
  * delegates to; see method-catalog-route-reconcile.ts). The daemon's own 404

package/dist/platform/control-plane/method-catalog-email.js

@@ -29,7 +29,7 @@ const EMAIL_MESSAGE_DETAIL_SCHEMA = objectSchema({
  * connector actions in addition to the direct-socket path. Daemon-backed; the SDK
  * publishes the typed contract surface (no internal handler).
  *
- * W4-A3 (capability-advertisement honesty): none of these four http paths are
+ * Capability-advertisement honesty: none of these four http paths are
  * currently served by the daemon router — there is no /api/email surface at
  * any prefix (confirmed by reading router.ts and every dispatch chain it
  * delegates to; see method-catalog-route-reconcile.ts). The daemon's own 404

package/dist/platform/control-plane/method-catalog-fleet.d.ts

@@ -1,7 +1,7 @@
 /**
  * method-catalog-fleet.ts
  *
- * W3-S2 — fleet.* + checkpoints.* method descriptors. Split out of
+ * (see CHANGELOG 1.0.0) — fleet.* + checkpoints.* method descriptors. Split out of
  * method-catalog-control-core.ts (which was already at the 800-line
  * source-file cap) rather than grown into it, mirroring how
  * method-catalog-control-automation.ts is a sibling split of the same file

package/dist/platform/control-plane/method-catalog-push.d.ts

@@ -0,0 +1,30 @@
+/**
+ * method-catalog-push.ts
+ *
+ * Browser-push (Web Push) verb descriptors: the VAPID public-key read, and the
+ * subscription lifecycle (register / list / delete / verify) a PWA uses to
+ * receive approvals and completions as notifications.
+ *
+ * These are pure descriptors so `buildOperatorContract` / the generated catalog
+ * / api docs see them; the handlers are attached at RuntimeServices construction
+ * time in routes/push.ts (the same `catalog.register(descriptor, handler)`
+ * pattern fleet.* uses), reached over HTTP through the generic
+ * `/api/control-plane/methods/{id}/invoke` endpoint.
+ *
+ * Verb tails follow docs/decisions/2026-07-06-core-verb-spec.md: register is
+ * `create`, unregister is `delete`, the collection read is `list`, the public
+ * key read is `get`. `verify` (send a live test push to prove the round trip)
+ * is not a generic CRUD word — it is documented in the `push-delivery` exempt
+ * category in packages/contracts/src/core-verbs.ts.
+ *
+ * Like the other handler-registered verb groups (fleet.*, checkpoints.*,
+ * sessions.search) these declare `transport: ['ws']` and carry NO dedicated
+ * REST `http` binding: they are served by the registered in-process handler
+ * through the generic `/api/control-plane/methods/{id}/invoke` endpoint, not by
+ * a path route in the external daemon-sdk package. Advertising an `http` path
+ * that no route serves would trip the capability-advertisement honesty gate
+ * (method-catalog-route-reconcile.ts), so it is deliberately omitted.
+ */
+import type { GatewayMethodDescriptor } from './method-catalog-shared.js';
+export declare const builtinGatewayPushMethodDescriptors: readonly GatewayMethodDescriptor[];
+//# sourceMappingURL=method-catalog-push.d.ts.map

package/dist/platform/control-plane/method-catalog-push.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-catalog-push.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/method-catalog-push.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAkC1E,eAAO,MAAM,mCAAmC,EAAE,SAAS,uBAAuB,EAyDjF,CAAC"}

package/dist/platform/control-plane/method-catalog-push.js

@@ -0,0 +1,80 @@
+import { BOOLEAN_SCHEMA, NUMBER_SCHEMA, STRING_SCHEMA, arraySchema, methodDescriptor, objectSchema, } from './method-catalog-shared.js';
+const PUSH_SUBSCRIPTION_KEYS_SCHEMA = objectSchema({
+    p256dh: STRING_SCHEMA,
+    auth: STRING_SCHEMA,
+}, ['p256dh', 'auth']);
+/** The wire-safe (redacted) subscription view — no capability URL, no key material. */
+const PUBLIC_PUSH_SUBSCRIPTION_SCHEMA = objectSchema({
+    id: STRING_SCHEMA,
+    principalId: STRING_SCHEMA,
+    endpointOrigin: STRING_SCHEMA,
+    endpointHash: STRING_SCHEMA,
+    createdAt: NUMBER_SCHEMA,
+    lastDeliveryAt: NUMBER_SCHEMA,
+    lastOutcome: STRING_SCHEMA,
+}, ['id', 'principalId', 'endpointOrigin', 'endpointHash', 'createdAt']);
+const PUSH_DELIVERY_RECEIPT_SCHEMA = objectSchema({
+    subscriptionId: STRING_SCHEMA,
+    endpointOrigin: STRING_SCHEMA,
+    outcome: STRING_SCHEMA,
+    httpStatus: NUMBER_SCHEMA,
+    detail: STRING_SCHEMA,
+}, ['subscriptionId', 'endpointOrigin', 'outcome']);
+export const builtinGatewayPushMethodDescriptors = [
+    methodDescriptor({
+        id: 'push.vapid.get',
+        title: 'Get Web Push Public Key',
+        description: 'Return the daemon\'s public VAPID key (base64url application-server key) that a browser client passes to pushManager.subscribe(). The matching private key never leaves the daemon and is never returned by any verb.',
+        category: 'push',
+        scopes: ['read:push'],
+        transport: ['ws'],
+        outputSchema: objectSchema({ publicKey: STRING_SCHEMA }, ['publicKey']),
+    }),
+    methodDescriptor({
+        id: 'push.subscriptions.create',
+        title: 'Register Web Push Subscription',
+        description: 'Store a browser Push subscription (endpoint capability URL + p256dh/auth keys) for the authenticated operator so the daemon can deliver notifications to that device. Re-registering the same endpoint updates its keys in place rather than duplicating it. The stored endpoint and keys are never returned over the wire; the response is the redacted subscription view.',
+        category: 'push',
+        scopes: ['write:push'],
+        transport: ['ws'],
+        inputSchema: objectSchema({
+            endpoint: STRING_SCHEMA,
+            keys: PUSH_SUBSCRIPTION_KEYS_SCHEMA,
+        }, ['endpoint', 'keys']),
+        outputSchema: objectSchema({ subscription: PUBLIC_PUSH_SUBSCRIPTION_SCHEMA }, ['subscription']),
+    }),
+    methodDescriptor({
+        id: 'push.subscriptions.list',
+        title: 'List Web Push Subscriptions',
+        description: 'List the authenticated operator\'s registered push devices as redacted subscription views (id, endpoint origin + hash, timestamps, last delivery outcome). The capability URL and key material are never included.',
+        category: 'push',
+        scopes: ['read:push'],
+        transport: ['ws'],
+        outputSchema: objectSchema({
+            subscriptions: arraySchema(PUBLIC_PUSH_SUBSCRIPTION_SCHEMA),
+        }, ['subscriptions']),
+    }),
+    methodDescriptor({
+        id: 'push.subscriptions.delete',
+        title: 'Delete Web Push Subscription',
+        description: 'Permanently remove one of the authenticated operator\'s push subscriptions: the stored record (endpoint + keys) is dropped and cannot be listed afterward. An unknown id, or one owned by another principal, is a 404 SUBSCRIPTION_NOT_FOUND, never a 200-noop.',
+        category: 'push',
+        scopes: ['write:push'],
+        transport: ['ws'],
+        inputSchema: objectSchema({ subscriptionId: STRING_SCHEMA }, ['subscriptionId']),
+        outputSchema: objectSchema({
+            subscriptionId: STRING_SCHEMA,
+            deleted: BOOLEAN_SCHEMA,
+        }, ['subscriptionId', 'deleted']),
+    }),
+    methodDescriptor({
+        id: 'push.subscriptions.verify',
+        title: 'Send Test Web Push',
+        description: 'Send a live test notification to one of the authenticated operator\'s subscriptions and return an honest delivery receipt (delivered / pruned / failed). A subscription whose endpoint reports 404/410 gone is pruned as part of the attempt and the receipt says so. An unknown id, or one owned by another principal, is a 404 SUBSCRIPTION_NOT_FOUND.',
+        category: 'push',
+        scopes: ['write:push'],
+        transport: ['ws'],
+        inputSchema: objectSchema({ subscriptionId: STRING_SCHEMA }, ['subscriptionId']),
+        outputSchema: objectSchema({ receipt: PUSH_DELIVERY_RECEIPT_SCHEMA }, ['receipt']),
+    }),
+];

package/dist/platform/control-plane/method-catalog-route-reconcile.d.ts

@@ -1,6 +1,6 @@
 import type { GatewayMethodDescriptor } from './method-catalog-shared.js';
 /**
- * method-catalog-route-reconcile.ts (W4-A3)
+ * method-catalog-route-reconcile.ts
  *
  * Advertisement-vs-route reconciliation. Every method descriptor that
  * carries an `http` binding is a promise to a caller: "this daemon actually

package/dist/platform/control-plane/method-catalog-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"method-catalog-runtime.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/method-catalog-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAqH1E,eAAO,MAAM,sCAAsC,EAAE,SAAS,uBAAuB,EAyXpF,CAAC"}
+{"version":3,"file":"method-catalog-runtime.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/method-catalog-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAkJ1E,eAAO,MAAM,sCAAsC,EAAE,SAAS,uBAAuB,EA2hBpF,CAAC"}

package/dist/platform/control-plane/method-catalog-runtime.js

@@ -1,6 +1,6 @@
 import { EMPTY_OBJECT_SCHEMA, BOOLEAN_SCHEMA, STRING_SCHEMA, NUMBER_SCHEMA, objectSchema, listOutputSchema, entityOutputSchema, bodyEnvelopeSchema, methodDescriptor, runtimeEventId, arraySchema, } from './method-catalog-shared.js';
 import { enumSchema, nullableSchema } from './operator-contract-schemas-shared.js';
-import { CONTINUITY_SNAPSHOT_SCHEMA, DISTRIBUTED_NODE_HOST_CONTRACT_SCHEMA, HEALTH_SNAPSHOT_SCHEMA, INTELLIGENCE_SNAPSHOT_SCHEMA, MEMORY_DOCTOR_REPORT_SCHEMA, MEMORY_VECTOR_STATS_SCHEMA, PROVIDER_ACCOUNT_SNAPSHOT_SCHEMA, PROVIDER_RUNTIME_SNAPSHOT_SCHEMA, PROVIDER_USAGE_SNAPSHOT_SCHEMA, REMOTE_PAIR_APPROVAL_OUTPUT_SCHEMA, REMOTE_PAIR_REQUEST_OUTPUT_SCHEMA, REMOTE_PAIR_REQUESTS_OUTPUT_SCHEMA, REMOTE_PEERS_OUTPUT_SCHEMA, REMOTE_PAIR_REQUEST_ACTION_INPUT_SCHEMA, REMOTE_PEER_DISCONNECT_INPUT_SCHEMA, REMOTE_PEER_INVOKE_INPUT_SCHEMA, REMOTE_PEER_INVOKE_OUTPUT_SCHEMA, REMOTE_PEER_OUTPUT_SCHEMA, REMOTE_PEER_TOKEN_REVOKE_INPUT_SCHEMA, REMOTE_PEER_TOKEN_ROTATE_INPUT_SCHEMA, REMOTE_PEER_TOKEN_ROTATE_OUTPUT_SCHEMA, REMOTE_SNAPSHOT_SCHEMA, REMOTE_WORK_LIST_OUTPUT_SCHEMA, REMOTE_WORK_CANCEL_INPUT_SCHEMA, REMOTE_WORK_OUTPUT_SCHEMA, SECURITY_SETTINGS_REPORT_SCHEMA, SETTINGS_SNAPSHOT_SCHEMA, WORKTREE_SNAPSHOT_SCHEMA, } from './operator-contract-schemas.js';
+import { CONTINUITY_SNAPSHOT_SCHEMA, DISTRIBUTED_NODE_HOST_CONTRACT_SCHEMA, HEALTH_SNAPSHOT_SCHEMA, INTELLIGENCE_SNAPSHOT_SCHEMA, MEMORY_DOCTOR_REPORT_SCHEMA, MEMORY_VECTOR_STATS_SCHEMA, MEMORY_CLASS_SCHEMA, MEMORY_SCOPE_SCHEMA, MEMORY_REVIEW_STATE_SCHEMA, MEMORY_PROVENANCE_KIND_SCHEMA, MEMORY_PROVENANCE_LINK_SCHEMA, MEMORY_RECORD_SCHEMA, MEMORY_RECORD_SEARCH_OUTPUT_SCHEMA, MEMORY_RECORD_DELETE_OUTPUT_SCHEMA, MEMORY_LINK_SCHEMA, MEMORY_BUNDLE_SCHEMA, MEMORY_IMPORT_RESULT_SCHEMA, MEMORY_RECORD_LIST_OUTPUT_SCHEMA, MEMORY_RECORD_SEMANTIC_OUTPUT_SCHEMA, MEMORY_RECORD_LINKS_OUTPUT_SCHEMA, PROVIDER_ACCOUNT_SNAPSHOT_SCHEMA, PROVIDER_RUNTIME_SNAPSHOT_SCHEMA, PROVIDER_USAGE_SNAPSHOT_SCHEMA, REMOTE_PAIR_APPROVAL_OUTPUT_SCHEMA, REMOTE_PAIR_REQUEST_OUTPUT_SCHEMA, REMOTE_PAIR_REQUESTS_OUTPUT_SCHEMA, REMOTE_PEERS_OUTPUT_SCHEMA, REMOTE_PAIR_REQUEST_ACTION_INPUT_SCHEMA, REMOTE_PEER_DISCONNECT_INPUT_SCHEMA, REMOTE_PEER_INVOKE_INPUT_SCHEMA, REMOTE_PEER_INVOKE_OUTPUT_SCHEMA, REMOTE_PEER_OUTPUT_SCHEMA, REMOTE_PEER_TOKEN_REVOKE_INPUT_SCHEMA, REMOTE_PEER_TOKEN_ROTATE_INPUT_SCHEMA, REMOTE_PEER_TOKEN_ROTATE_OUTPUT_SCHEMA, REMOTE_SNAPSHOT_SCHEMA, REMOTE_WORK_LIST_OUTPUT_SCHEMA, REMOTE_WORK_CANCEL_INPUT_SCHEMA, REMOTE_WORK_OUTPUT_SCHEMA, SECURITY_SETTINGS_REPORT_SCHEMA, SETTINGS_SNAPSHOT_SCHEMA, WORKTREE_SNAPSHOT_SCHEMA, } from './operator-contract-schemas.js';
 const MCP_SCOPE_SCHEMA = enumSchema(['project', 'global']);
 const MCP_SERVER_CONFIG_SCHEMA = objectSchema({
     name: STRING_SCHEMA,
@@ -71,6 +71,20 @@ const MCP_TOOL_SCHEMA = objectSchema({
 const MCP_TOOLS_RESPONSE_SCHEMA = objectSchema({
     tools: arraySchema(MCP_TOOL_SCHEMA),
 }, ['tools']);
+/** The shared memory search-filter fields (no `recall` — that is search-only). Reused by list / search-semantic / export. */
+const MEMORY_SEARCH_FILTER_FIELDS = {
+    scope: MEMORY_SCOPE_SCHEMA,
+    cls: MEMORY_CLASS_SCHEMA,
+    tags: arraySchema(STRING_SCHEMA),
+    query: STRING_SCHEMA,
+    semantic: BOOLEAN_SCHEMA,
+    since: NUMBER_SCHEMA,
+    reviewState: arraySchema(MEMORY_REVIEW_STATE_SCHEMA),
+    minConfidence: NUMBER_SCHEMA,
+    provenanceKinds: arraySchema(MEMORY_PROVENANCE_KIND_SCHEMA),
+    staleOnly: BOOLEAN_SCHEMA,
+    limit: NUMBER_SCHEMA,
+};
 export const builtinGatewayRuntimeMethodDescriptors = [
     methodDescriptor({
         id: 'mcp.config.get',
@@ -433,6 +447,168 @@ export const builtinGatewayRuntimeMethodDescriptors = [
         }),
         outputSchema: objectSchema({ records: arraySchema(objectSchema({}, [], { additionalProperties: true })) }, ['records']),
     }),
+    methodDescriptor({
+        id: 'memory.records.add',
+        title: 'Add Memory Record',
+        description: 'Add a memory record to the daemon-owned canonical store. The daemon is the single writer for its store; a client surface routes its writes here instead of opening the store file, so two processes never write the same sql.js file. New records default to confidence 60 (the recall floor) and reviewState fresh unless the review block overrides them.',
+        category: 'memory',
+        scopes: ['write:memory'],
+        http: { method: 'POST', path: '/api/memory/records' },
+        inputSchema: bodyEnvelopeSchema({
+            cls: MEMORY_CLASS_SCHEMA,
+            summary: STRING_SCHEMA,
+            scope: MEMORY_SCOPE_SCHEMA,
+            detail: STRING_SCHEMA,
+            tags: arraySchema(STRING_SCHEMA),
+            provenance: arraySchema(MEMORY_PROVENANCE_LINK_SCHEMA),
+            review: objectSchema({
+                state: MEMORY_REVIEW_STATE_SCHEMA,
+                confidence: NUMBER_SCHEMA,
+                reviewedBy: STRING_SCHEMA,
+                staleReason: STRING_SCHEMA,
+            }),
+        }, ['cls', 'summary']),
+        outputSchema: entityOutputSchema('record', MEMORY_RECORD_SCHEMA),
+    }),
+    methodDescriptor({
+        id: 'memory.records.search',
+        title: 'Search Memory Records',
+        description: 'Search the canonical store, literal or semantic. When semantic is requested but the semantic index cannot be consulted, the search falls back to a literal scan and states the reason in indexUnavailableReason rather than returning a silent empty result that reads as "nothing was ever stored". With recall=true the cross-surface recall-honesty contract is applied: flagged (stale/contradicted) records are excluded outright and records below the 60% confidence floor are dropped, each exclusion counted honestly.',
+        category: 'memory',
+        scopes: ['read:memory'],
+        http: { method: 'POST', path: '/api/memory/records/search' },
+        inputSchema: bodyEnvelopeSchema({
+            scope: MEMORY_SCOPE_SCHEMA,
+            cls: MEMORY_CLASS_SCHEMA,
+            tags: arraySchema(STRING_SCHEMA),
+            query: STRING_SCHEMA,
+            semantic: BOOLEAN_SCHEMA,
+            since: NUMBER_SCHEMA,
+            reviewState: arraySchema(MEMORY_REVIEW_STATE_SCHEMA),
+            minConfidence: NUMBER_SCHEMA,
+            provenanceKinds: arraySchema(MEMORY_PROVENANCE_KIND_SCHEMA),
+            staleOnly: BOOLEAN_SCHEMA,
+            limit: NUMBER_SCHEMA,
+            recall: BOOLEAN_SCHEMA,
+        }),
+        outputSchema: MEMORY_RECORD_SEARCH_OUTPUT_SCHEMA,
+    }),
+    methodDescriptor({
+        id: 'memory.records.get',
+        title: 'Get Memory Record',
+        description: 'Return a single memory record by id from the canonical store, or 404 when no record with that id exists.',
+        category: 'memory',
+        scopes: ['read:memory'],
+        http: { method: 'GET', path: '/api/memory/records/{id}' },
+        inputSchema: objectSchema({ id: STRING_SCHEMA }, ['id']),
+        outputSchema: entityOutputSchema('record', MEMORY_RECORD_SCHEMA),
+    }),
+    methodDescriptor({
+        id: 'memory.records.update-review',
+        title: 'Update Memory Record Review',
+        description: 'Update a record\'s review signal (reviewState, confidence, reviewer, staleReason) in the canonical store. Marking a record stale or contradicted flags it so the recall-honesty contract will never inject it into a prompt again regardless of confidence. Returns 404 when no record with that id exists.',
+        category: 'memory',
+        scopes: ['write:memory'],
+        http: { method: 'POST', path: '/api/memory/records/{id}/review' },
+        inputSchema: bodyEnvelopeSchema({
+            id: STRING_SCHEMA,
+            state: MEMORY_REVIEW_STATE_SCHEMA,
+            confidence: NUMBER_SCHEMA,
+            reviewedBy: STRING_SCHEMA,
+            staleReason: STRING_SCHEMA,
+        }, ['id']),
+        outputSchema: entityOutputSchema('record', MEMORY_RECORD_SCHEMA),
+    }),
+    methodDescriptor({
+        id: 'memory.records.delete',
+        title: 'Delete Memory Record',
+        description: 'Permanently delete a memory record and its links from the canonical store. Delete means delete: the record is removed from the store and the semantic index, not merely flagged. Returns { deleted: false } when no record with that id existed — an honest boolean, never a 200 that pretends a phantom row was removed.',
+        category: 'memory',
+        scopes: ['write:memory'],
+        http: { method: 'DELETE', path: '/api/memory/records/{id}' },
+        inputSchema: objectSchema({ id: STRING_SCHEMA }, ['id']),
+        outputSchema: MEMORY_RECORD_DELETE_OUTPUT_SCHEMA,
+    }),
+    methodDescriptor({
+        id: 'memory.records.list',
+        title: 'List Memory Records',
+        description: 'Bulk read from the canonical store: a literal (non-semantic) search returning the matching records as a plain array. An empty filter returns every record (getAll). This is the read a client surface uses instead of opening the store file for its browse/list and knowledge-injection paths.',
+        category: 'memory',
+        scopes: ['read:memory'],
+        http: { method: 'POST', path: '/api/memory/records/list' },
+        inputSchema: bodyEnvelopeSchema({ ...MEMORY_SEARCH_FILTER_FIELDS }),
+        outputSchema: MEMORY_RECORD_LIST_OUTPUT_SCHEMA,
+    }),
+    methodDescriptor({
+        id: 'memory.records.search-semantic',
+        title: 'Semantic Search Memory Records',
+        description: 'Rank records by semantic similarity against the query, returning scored results (distance, similarity, score). When the query has no vector match the store falls back to a lexical ranking rather than a silent empty. distance is null for a fallback (non-vector) result. Read-only against the daemon\'s canonical index.',
+        category: 'memory',
+        scopes: ['read:memory'],
+        http: { method: 'POST', path: '/api/memory/records/search-semantic' },
+        inputSchema: bodyEnvelopeSchema({ ...MEMORY_SEARCH_FILTER_FIELDS }),
+        outputSchema: MEMORY_RECORD_SEMANTIC_OUTPUT_SCHEMA,
+    }),
+    methodDescriptor({
+        id: 'memory.records.export',
+        title: 'Export Memory Bundle',
+        description: 'Export a no-loss bundle (records + links) for the given filter from the canonical store. The bundle round-trips through import id-keyed, so it is the wire form of the cross-surface fold/reconcile seam. Read-only.',
+        category: 'memory',
+        scopes: ['read:memory'],
+        http: { method: 'POST', path: '/api/memory/records/export' },
+        inputSchema: bodyEnvelopeSchema({ ...MEMORY_SEARCH_FILTER_FIELDS }),
+        outputSchema: entityOutputSchema('bundle', MEMORY_BUNDLE_SCHEMA),
+    }),
+    methodDescriptor({
+        id: 'memory.records.import',
+        title: 'Import Memory Bundle',
+        description: 'Import a bundle into the canonical store as an id-keyed union: an id already present is left untouched (counted skipped), a new id is added; a link is added only when both its endpoints exist. Never overwrites, never deletes, idempotent on re-run. The daemon is the single writer, so a client imports here instead of writing the store file.',
+        category: 'memory',
+        scopes: ['write:memory'],
+        http: { method: 'POST', path: '/api/memory/records/import' },
+        inputSchema: bodyEnvelopeSchema({ bundle: MEMORY_BUNDLE_SCHEMA }, ['bundle']),
+        outputSchema: entityOutputSchema('result', MEMORY_IMPORT_RESULT_SCHEMA),
+    }),
+    methodDescriptor({
+        id: 'memory.records.update',
+        title: 'Update Memory Record',
+        description: 'Edit a record\'s content fields (scope, summary, detail, tags) in the canonical store. This is distinct from the review update: it changes the record itself — e.g. moving scope project→team promotes a record to the shared surface. Returns 404 when no record with that id exists.',
+        category: 'memory',
+        scopes: ['write:memory'],
+        http: { method: 'POST', path: '/api/memory/records/{id}/update' },
+        inputSchema: bodyEnvelopeSchema({
+            id: STRING_SCHEMA,
+            scope: MEMORY_SCOPE_SCHEMA,
+            summary: STRING_SCHEMA,
+            detail: STRING_SCHEMA,
+            tags: arraySchema(STRING_SCHEMA),
+        }, ['id']),
+        outputSchema: entityOutputSchema('record', MEMORY_RECORD_SCHEMA),
+    }),
+    methodDescriptor({
+        id: 'memory.records.links.list',
+        title: 'List Memory Record Links',
+        description: 'Return every link where the record is the source or the target. Returns 404 when no record with that id exists — an honest not-found, distinct from a record that exists but has no links (an empty array).',
+        category: 'memory',
+        scopes: ['read:memory'],
+        http: { method: 'GET', path: '/api/memory/records/{id}/links' },
+        inputSchema: objectSchema({ id: STRING_SCHEMA }, ['id']),
+        outputSchema: MEMORY_RECORD_LINKS_OUTPUT_SCHEMA,
+    }),
+    methodDescriptor({
+        id: 'memory.records.links.add',
+        title: 'Link Memory Records',
+        description: 'Create a directed relation (e.g. "supersedes", "caused") from the path record to a target record. Returns 404 when either endpoint does not exist — never a 200 that pretends a link was made between records that do not both exist.',
+        category: 'memory',
+        scopes: ['write:memory'],
+        http: { method: 'POST', path: '/api/memory/records/{id}/links' },
+        inputSchema: bodyEnvelopeSchema({
+            id: STRING_SCHEMA,
+            toId: STRING_SCHEMA,
+            relation: STRING_SCHEMA,
+        }, ['id', 'toId', 'relation']),
+        outputSchema: entityOutputSchema('link', MEMORY_LINK_SCHEMA),
+    }),
     methodDescriptor({
         id: 'scheduler.capacity',
         title: 'Scheduler Capacity',

package/dist/platform/control-plane/method-catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"method-catalog.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/method-catalog.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EACV,sBAAsB,EACtB,uBAAuB,EACvB,uBAAuB,EACvB,oBAAoB,EACpB,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,4BAA4B,CAAC;AAOpC,YAAY,EACV,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACvB,oBAAoB,EACpB,uBAAuB,EACvB,8BAA8B,EAC9B,wBAAwB,EACxB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,4BAA4B,CAAC;AA6DpC,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8C;IACtE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6C;gBAExD,OAAO,GAAE;QAAE,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAA;KAAO;IAWhE,QAAQ,CACN,UAAU,EAAE,uBAAuB,EACnC,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,GAAE;QAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAO,GAC3C,MAAM,IAAI;IAcb,aAAa,CACX,UAAU,EAAE,sBAAsB,EAClC,OAAO,GAAE;QAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAO,GAC3C,MAAM,IAAI;IAcb,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAI/B,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIpC,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAa1C,IAAI,CAAC,OAAO,GAAE,wBAA6B,GAAG,uBAAuB,EAAE;IASvE,UAAU,CAAC,OAAO,GAAE,uBAA4B,GAAG,sBAAsB,EAAE;IAU3E,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,uBAAuB,GAAG,IAAI;IAI/C,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,sBAAsB,GAAG,IAAI;IAInD,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAI/B,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,uBAAuB,GAAG,IAAI;IAUnF,YAAY,CAAC,OAAO,GAAE;QAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,MAAM,EAAE;IAiBzE;;;;;;;;OAQG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC;CA8BhF"}
+{"version":3,"file":"method-catalog.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/method-catalog.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EACV,sBAAsB,EACtB,uBAAuB,EACvB,uBAAuB,EACvB,oBAAoB,EACpB,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,4BAA4B,CAAC;AAOpC,YAAY,EACV,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACvB,oBAAoB,EACpB,uBAAuB,EACvB,8BAA8B,EAC9B,wBAAwB,EACxB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,4BAA4B,CAAC;AA8DpC,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8C;IACtE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6C;gBAExD,OAAO,GAAE;QAAE,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAA;KAAO;IAWhE,QAAQ,CACN,UAAU,EAAE,uBAAuB,EACnC,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,GAAE;QAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAO,GAC3C,MAAM,IAAI;IAcb,aAAa,CACX,UAAU,EAAE,sBAAsB,EAClC,OAAO,GAAE;QAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAO,GAC3C,MAAM,IAAI;IAcb,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAI/B,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIpC,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAa1C,IAAI,CAAC,OAAO,GAAE,wBAA6B,GAAG,uBAAuB,EAAE;IASvE,UAAU,CAAC,OAAO,GAAE,uBAA4B,GAAG,sBAAsB,EAAE;IAU3E,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,uBAAuB,GAAG,IAAI;IAI/C,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,sBAAsB,GAAG,IAAI;IAInD,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAI/B,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,uBAAuB,GAAG,IAAI;IAUnF,YAAY,CAAC,OAAO,GAAE;QAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,MAAM,EAAE;IAiBzE;;;;;;;;OAQG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC;CA8BhF"}

package/dist/platform/control-plane/method-catalog.js

@@ -6,6 +6,7 @@ import { builtinGatewayCalendarMethodDescriptors, } from './method-catalog-calen
 import { builtinGatewayEventDescriptors, } from './method-catalog-events.js';
 import { builtinGatewayKnowledgeMethodDescriptors, } from './method-catalog-knowledge.js';
 import { builtinGatewayMediaMethodDescriptors, } from './method-catalog-media.js';
+import { builtinGatewayPushMethodDescriptors, } from './method-catalog-push.js';
 import { builtinGatewayRuntimeMethodDescriptors, } from './method-catalog-runtime.js';
 import { GatewayVerbError } from './routes/gateway-verb-error.js';
 import { SDKErrorCodes } from '@pellux/goodvibes-errors';
@@ -19,6 +20,7 @@ const BUILTIN_GATEWAY_METHODS = [
     ...builtinGatewayKnowledgeMethodDescriptors,
     ...builtinGatewayMediaMethodDescriptors,
     ...builtinGatewayAdminMethodDescriptors,
+    ...builtinGatewayPushMethodDescriptors,
 ];
 function normalizeDescriptor(descriptor) {
     const id = descriptor.id.trim();

package/dist/platform/control-plane/operator-contract-schemas-fleet.js

@@ -1,7 +1,7 @@
 /**
  * operator-contract-schemas-fleet.ts
  *
- * W3-S2 — contract schemas for fleet.*, checkpoints.*, and sessions.search.
+ * (see CHANGELOG 1.0.0) — contract schemas for fleet.*, checkpoints.*, and sessions.search.
  * Split out of operator-contract-schemas-runtime.ts (which was already at
  * the 800-line source-file cap) rather than grown into it; re-exported
  * through operator-contract-schemas.ts alongside the other schema modules.

package/dist/platform/control-plane/operator-contract-schemas-runtime.d.ts

@@ -65,4 +65,19 @@ export declare const HEALTH_SNAPSHOT_SCHEMA: Record<string, unknown>;
 export declare const INTELLIGENCE_SNAPSHOT_SCHEMA: Record<string, unknown>;
 export declare const MEMORY_VECTOR_STATS_SCHEMA: Record<string, unknown>;
 export declare const MEMORY_DOCTOR_REPORT_SCHEMA: Record<string, unknown>;
+export declare const MEMORY_SCOPE_SCHEMA: Record<string, unknown>;
+export declare const MEMORY_CLASS_SCHEMA: Record<string, unknown>;
+export declare const MEMORY_REVIEW_STATE_SCHEMA: Record<string, unknown>;
+export declare const MEMORY_PROVENANCE_KIND_SCHEMA: Record<string, unknown>;
+export declare const MEMORY_PROVENANCE_LINK_SCHEMA: Record<string, unknown>;
+export declare const MEMORY_RECORD_SCHEMA: Record<string, unknown>;
+export declare const MEMORY_RECORD_SEARCH_OUTPUT_SCHEMA: Record<string, unknown>;
+export declare const MEMORY_RECORD_DELETE_OUTPUT_SCHEMA: Record<string, unknown>;
+export declare const MEMORY_LINK_SCHEMA: Record<string, unknown>;
+export declare const MEMORY_SEMANTIC_RESULT_SCHEMA: Record<string, unknown>;
+export declare const MEMORY_BUNDLE_SCHEMA: Record<string, unknown>;
+export declare const MEMORY_IMPORT_RESULT_SCHEMA: Record<string, unknown>;
+export declare const MEMORY_RECORD_LIST_OUTPUT_SCHEMA: Record<string, unknown>;
+export declare const MEMORY_RECORD_SEMANTIC_OUTPUT_SCHEMA: Record<string, unknown>;
+export declare const MEMORY_RECORD_LINKS_OUTPUT_SCHEMA: Record<string, unknown>;
 //# sourceMappingURL=operator-contract-schemas-runtime.d.ts.map

package/dist/platform/control-plane/operator-contract-schemas-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operator-contract-schemas-runtime.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/operator-contract-schemas-runtime.ts"],"names":[],"mappings":"AAmCA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,+BAA+B,EAAyB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AA6B7F,eAAO,MAAM,iCAAiC,yBAQA,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,oCAAoC,yBAOe,CAAC;AAEjE,eAAO,MAAM,6BAA6B,yBAasB,CAAC;AAEjE,eAAO,MAAM,4BAA4B,yBAuBqI,CAAC;AAE/K,eAAO,MAAM,6BAA6B,yBAYsF,CAAC;AAEjI,eAAO,MAAM,6BAA6B,yBAO4B,CAAC;AAEvE,eAAO,MAAM,2CAA2C,yBAG7B,CAAC;AAE5B,eAAO,MAAM,mCAAmC,yBAOtB,CAAC;AAE3B,eAAO,MAAM,mCAAmC,yBAGnB,CAAC;AAE9B,eAAO,MAAM,oCAAoC,yBAkB/C,CAAC;AAEH,eAAO,MAAM,kCAAkC,yBAqB0D,CAAC;AAE1G,eAAO,MAAM,uBAAuB,yBAWoE,CAAC;AAEzG,eAAO,MAAM,8BAA8B,yBAOjB,CAAC;AAE3B,eAAO,MAAM,mCAAmC,yBAGrB,CAAC;AAE5B,eAAO,MAAM,iCAAiC,yBAGrB,CAAC;AAE1B,eAAO,MAAM,mCAAmC,yBAEjC,CAAC;AAEhB;;;;;;GAMG;AACH,eAAO,MAAM,qCAAqC,yBAIvB,CAAC;AAE5B,eAAO,MAAM,+CAA+C,yBAIlB,CAAC;AAE3C,eAAO,MAAM,2CAA2C,yBAMF,CAAC;AAEvD,eAAO,MAAM,0CAA0C;;CAK7C,CAAC;AAUX,eAAO,MAAM,mBAAmB,yBAqByD,CAAC;AAE1F,eAAO,MAAM,oBAAoB,yBAsBsB,CAAC;AAExD,eAAO,MAAM,wBAAwB,yBAgBO,CAAC;AAE7C,eAAO,MAAM,yBAAyB,yBASc,CAAC;AAErD,eAAO,MAAM,kBAAkB,yBAEnB,CAAC;AAEb,eAAO,MAAM,yBAAyB,yBAIM,CAAC;AAE7C,eAAO,MAAM,yBAAyB,yBAUiE,CAAC;AAWxG,eAAO,MAAM,6BAA6B,yBAgB8C,CAAC;AAEzF,eAAO,MAAM,wBAAwB,yBASuG,CAAC;AAE7I,eAAO,MAAM,4BAA4B,yBAIU,CAAC;AAOpD,eAAO,MAAM,6BAA6B,yBAKS,CAAC;AAEpD,eAAO,MAAM,6BAA6B,yBAE1B,CAAC;AA0EjB,eAAO,MAAM,gCAAgC,yBAMkB,CAAC;AAEhE,eAAO,MAAM,8BAA8B,yBAcqD,CAAC;AAqEjG,eAAO,MAAM,gCAAgC,yBAKmB,CAAC;AAEjE,eAAO,MAAM,sBAAsB,yBAcyF,CAAC;AAE7H,eAAO,MAAM,4BAA4B,yBASyG,CAAC;AAqBnJ,eAAO,MAAM,0BAA0B,yBAUyH,CAAC;AAEjK,eAAO,MAAM,2BAA2B,yBAIC,CAAC"}
+{"version":3,"file":"operator-contract-schemas-runtime.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/operator-contract-schemas-runtime.ts"],"names":[],"mappings":"AAmCA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,+BAA+B,EAAyB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AA6B7F,eAAO,MAAM,iCAAiC,yBAQA,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,oCAAoC,yBAOe,CAAC;AAEjE,eAAO,MAAM,6BAA6B,yBAasB,CAAC;AAEjE,eAAO,MAAM,4BAA4B,yBAuBqI,CAAC;AAE/K,eAAO,MAAM,6BAA6B,yBAYsF,CAAC;AAEjI,eAAO,MAAM,6BAA6B,yBAO4B,CAAC;AAEvE,eAAO,MAAM,2CAA2C,yBAG7B,CAAC;AAE5B,eAAO,MAAM,mCAAmC,yBAOtB,CAAC;AAE3B,eAAO,MAAM,mCAAmC,yBAGnB,CAAC;AAE9B,eAAO,MAAM,oCAAoC,yBAkB/C,CAAC;AAEH,eAAO,MAAM,kCAAkC,yBAqB0D,CAAC;AAE1G,eAAO,MAAM,uBAAuB,yBAWoE,CAAC;AAEzG,eAAO,MAAM,8BAA8B,yBAOjB,CAAC;AAE3B,eAAO,MAAM,mCAAmC,yBAGrB,CAAC;AAE5B,eAAO,MAAM,iCAAiC,yBAGrB,CAAC;AAE1B,eAAO,MAAM,mCAAmC,yBAEjC,CAAC;AAEhB;;;;;;GAMG;AACH,eAAO,MAAM,qCAAqC,yBAIvB,CAAC;AAE5B,eAAO,MAAM,+CAA+C,yBAIlB,CAAC;AAE3C,eAAO,MAAM,2CAA2C,yBAMF,CAAC;AAEvD,eAAO,MAAM,0CAA0C;;CAK7C,CAAC;AAUX,eAAO,MAAM,mBAAmB,yBAqByD,CAAC;AAE1F,eAAO,MAAM,oBAAoB,yBAsBsB,CAAC;AAExD,eAAO,MAAM,wBAAwB,yBAgBO,CAAC;AAE7C,eAAO,MAAM,yBAAyB,yBASc,CAAC;AAErD,eAAO,MAAM,kBAAkB,yBAEnB,CAAC;AAEb,eAAO,MAAM,yBAAyB,yBAIM,CAAC;AAE7C,eAAO,MAAM,yBAAyB,yBAUiE,CAAC;AAWxG,eAAO,MAAM,6BAA6B,yBAgB8C,CAAC;AAEzF,eAAO,MAAM,wBAAwB,yBASuG,CAAC;AAE7I,eAAO,MAAM,4BAA4B,yBAIU,CAAC;AAOpD,eAAO,MAAM,6BAA6B,yBAKS,CAAC;AAEpD,eAAO,MAAM,6BAA6B,yBAE1B,CAAC;AA0EjB,eAAO,MAAM,gCAAgC,yBAMkB,CAAC;AAEhE,eAAO,MAAM,8BAA8B,yBAcqD,CAAC;AAqEjG,eAAO,MAAM,gCAAgC,yBAKmB,CAAC;AAEjE,eAAO,MAAM,sBAAsB,yBAcyF,CAAC;AAE7H,eAAO,MAAM,4BAA4B,yBASyG,CAAC;AAqBnJ,eAAO,MAAM,0BAA0B,yBAUyH,CAAC;AAEjK,eAAO,MAAM,2BAA2B,yBAIC,CAAC;AAG1C,eAAO,MAAM,mBAAmB,yBAA6C,CAAC;AAC9E,eAAO,MAAM,mBAAmB,yBAE9B,CAAC;AACH,eAAO,MAAM,0BAA0B,yBAA6D,CAAC;AACrG,eAAO,MAAM,6BAA6B,yBAA2D,CAAC;AAEtG,eAAO,MAAM,6BAA6B,yBAIvB,CAAC;AAEpB,eAAO,MAAM,oBAAoB,yBAeiH,CAAC;AAEnJ,eAAO,MAAM,kCAAkC,yBAUiI,CAAC;AAEjL,eAAO,MAAM,kCAAkC,yBAG1B,CAAC;AAItB,eAAO,MAAM,kBAAkB,yBAKgB,CAAC;AAIhD,eAAO,MAAM,6BAA6B,yBAKL,CAAC;AAEtC,eAAO,MAAM,oBAAoB,yBAQ2D,CAAC;AAE7F,eAAO,MAAM,2BAA2B,yBAIkB,CAAC;AAE3D,eAAO,MAAM,gCAAgC,yBAE9B,CAAC;AAEhB,eAAO,MAAM,oCAAoC,yBAElC,CAAC;AAEhB,eAAO,MAAM,iCAAiC,yBAEjC,CAAC"}

package/dist/platform/control-plane/operator-contract-schemas-runtime.js

@@ -620,3 +620,84 @@ export const MEMORY_DOCTOR_REPORT_SCHEMA = objectSchema({
     embeddings: MEMORY_EMBEDDING_DOCTOR_REPORT_SCHEMA,
     checkedAt: NUMBER_SCHEMA,
 }, ['vector', 'embeddings', 'checkedAt']);
+// ── Memory record wire schemas (daemon-owned single-writer store) ──────────────
+export const MEMORY_SCOPE_SCHEMA = enumSchema(['session', 'project', 'team']);
+export const MEMORY_CLASS_SCHEMA = enumSchema([
+    'decision', 'constraint', 'incident', 'pattern', 'fact', 'risk', 'runbook', 'architecture', 'ownership',
+]);
+export const MEMORY_REVIEW_STATE_SCHEMA = enumSchema(['fresh', 'reviewed', 'stale', 'contradicted']);
+export const MEMORY_PROVENANCE_KIND_SCHEMA = enumSchema(['session', 'turn', 'task', 'event', 'file']);
+export const MEMORY_PROVENANCE_LINK_SCHEMA = objectSchema({
+    kind: MEMORY_PROVENANCE_KIND_SCHEMA,
+    ref: STRING_SCHEMA,
+    label: STRING_SCHEMA,
+}, ['kind', 'ref']);
+export const MEMORY_RECORD_SCHEMA = objectSchema({
+    id: STRING_SCHEMA,
+    scope: MEMORY_SCOPE_SCHEMA,
+    cls: MEMORY_CLASS_SCHEMA,
+    summary: STRING_SCHEMA,
+    detail: STRING_SCHEMA,
+    tags: STRING_LIST_SCHEMA,
+    provenance: arraySchema(MEMORY_PROVENANCE_LINK_SCHEMA),
+    reviewState: MEMORY_REVIEW_STATE_SCHEMA,
+    confidence: NUMBER_SCHEMA,
+    reviewedAt: NUMBER_SCHEMA,
+    reviewedBy: STRING_SCHEMA,
+    staleReason: STRING_SCHEMA,
+    createdAt: NUMBER_SCHEMA,
+    updatedAt: NUMBER_SCHEMA,
+}, ['id', 'scope', 'cls', 'summary', 'tags', 'provenance', 'reviewState', 'confidence', 'createdAt', 'updatedAt'], { additionalProperties: true });
+export const MEMORY_RECORD_SEARCH_OUTPUT_SCHEMA = objectSchema({
+    records: arraySchema(MEMORY_RECORD_SCHEMA),
+    mode: enumSchema(['literal', 'semantic']),
+    requestedSemantic: BOOLEAN_SCHEMA,
+    indexUnavailableReason: nullableSchema(STRING_SCHEMA),
+    caveat: nullableSchema(STRING_SCHEMA),
+    recallFiltered: BOOLEAN_SCHEMA,
+    excludedFlaggedCount: NUMBER_SCHEMA,
+    excludedBelowFloorCount: NUMBER_SCHEMA,
+    totalBeforeRecallFilter: NUMBER_SCHEMA,
+}, ['records', 'mode', 'requestedSemantic', 'indexUnavailableReason', 'caveat', 'recallFiltered', 'excludedFlaggedCount', 'excludedBelowFloorCount', 'totalBeforeRecallFilter']);
+export const MEMORY_RECORD_DELETE_OUTPUT_SCHEMA = objectSchema({
+    id: STRING_SCHEMA,
+    deleted: BOOLEAN_SCHEMA,
+}, ['id', 'deleted']);
+// ── Full-detach catalog wire schemas (1.2.0) ──────────────────────────────────
+export const MEMORY_LINK_SCHEMA = objectSchema({
+    fromId: STRING_SCHEMA,
+    toId: STRING_SCHEMA,
+    relation: STRING_SCHEMA,
+    createdAt: NUMBER_SCHEMA,
+}, ['fromId', 'toId', 'relation', 'createdAt']);
+// distance may be Infinity for a no-vector-match fallback; JSON serializes that to
+// null, so the wire field is nullable — honest about the "not ranked by vector" case.
+export const MEMORY_SEMANTIC_RESULT_SCHEMA = objectSchema({
+    record: MEMORY_RECORD_SCHEMA,
+    distance: nullableSchema(NUMBER_SCHEMA),
+    similarity: NUMBER_SCHEMA,
+    score: NUMBER_SCHEMA,
+}, ['record', 'similarity', 'score']);
+export const MEMORY_BUNDLE_SCHEMA = objectSchema({
+    schemaVersion: enumSchema(['v1']),
+    exportedAt: NUMBER_SCHEMA,
+    scope: enumSchema(['session', 'project', 'team', 'all']),
+    recordCount: NUMBER_SCHEMA,
+    linkCount: NUMBER_SCHEMA,
+    records: arraySchema(MEMORY_RECORD_SCHEMA),
+    links: arraySchema(MEMORY_LINK_SCHEMA),
+}, ['schemaVersion', 'exportedAt', 'scope', 'recordCount', 'linkCount', 'records', 'links']);
+export const MEMORY_IMPORT_RESULT_SCHEMA = objectSchema({
+    importedRecords: NUMBER_SCHEMA,
+    skippedRecords: NUMBER_SCHEMA,
+    importedLinks: NUMBER_SCHEMA,
+}, ['importedRecords', 'skippedRecords', 'importedLinks']);
+export const MEMORY_RECORD_LIST_OUTPUT_SCHEMA = objectSchema({
+    records: arraySchema(MEMORY_RECORD_SCHEMA),
+}, ['records']);
+export const MEMORY_RECORD_SEMANTIC_OUTPUT_SCHEMA = objectSchema({
+    results: arraySchema(MEMORY_SEMANTIC_RESULT_SCHEMA),
+}, ['results']);
+export const MEMORY_RECORD_LINKS_OUTPUT_SCHEMA = objectSchema({
+    links: arraySchema(MEMORY_LINK_SCHEMA),
+}, ['links']);

package/dist/platform/control-plane/routes/checkpoints.d.ts

@@ -1,7 +1,7 @@
 /**
  * routes/checkpoints.ts
  *
- * W3-S2 — `checkpoints.list` / `checkpoints.create` / `checkpoints.diff` /
+ * (see CHANGELOG 1.0.0) — `checkpoints.list` / `checkpoints.create` / `checkpoints.diff` /
  * `checkpoints.restore` gateway-method handlers over the ALREADY
  * daemon-resident `WorkspaceCheckpointManager` (constructed +
  * eagerly-`init()`'d at ../../runtime/services.ts:620, exposed on

package/dist/platform/control-plane/routes/fleet.d.ts

@@ -1,7 +1,7 @@
 /**
  * routes/fleet.ts
  *
- * W3-S2 — `fleet.snapshot` / `fleet.list` gateway-method handlers over the
+ * `fleet.snapshot` / `fleet.list` gateway-method handlers (see CHANGELOG 1.0.0) over the
  * ALREADY daemon-resident `ProcessRegistry` (createProcessRegistry(),
  * ../../runtime/fleet/registry.ts:204, constructed + exposed on
  * RuntimeServices at ../../runtime/services.ts:712/:242). This is thin verb
@@ -27,7 +27,7 @@ import type { GatewayMethodCatalog } from '../method-catalog.js';
 import type { GatewayMethodHandler } from '../method-catalog-shared.js';
 import type { ProcessRegistry } from '../../runtime/fleet/types.js';
 /**
- * `fleet.snapshot` payload cap (risk #1, W3-S2 brief): the registry's
+ * `fleet.snapshot` payload cap: the registry's
  * `query()` is a cheap O(n) in-memory scan, but the wire response must not
  * grow unbounded with fleet size. Nodes beyond this cap are dropped (newest
  * activity first is NOT guaranteed here — see `truncated`/`totalCount` so a

package/dist/platform/control-plane/routes/fleet.js

@@ -2,7 +2,7 @@ import { paginateItems } from '@pellux/goodvibes-daemon-sdk';
 import { GatewayVerbError } from './gateway-verb-error.js';
 import { readInvocationParams } from './invocation-params.js';
 /**
- * `fleet.snapshot` payload cap (risk #1, W3-S2 brief): the registry's
+ * `fleet.snapshot` payload cap: the registry's
  * `query()` is a cheap O(n) in-memory scan, but the wire response must not
  * grow unbounded with fleet size. Nodes beyond this cap are dropped (newest
  * activity first is NOT guaranteed here — see `truncated`/`totalCount` so a