@pellux/goodvibes-sdk 1.1.0 → 1.2.0

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;AA6H1E,eAAO,MAAM,sCAAsC,EAAE,SAAS,uBAAuB,EA2cpF,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, 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, 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',
@@ -515,6 +529,86 @@ export const builtinGatewayRuntimeMethodDescriptors = [
         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/operator-contract-schemas-runtime.d.ts

@@ -73,4 +73,11 @@ 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;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"}
+{"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

@@ -663,3 +663,41 @@ 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/runtime/memory-spine/client.d.ts

@@ -19,6 +19,14 @@
  *    NEVER opens the file. Enforced structurally here — the active branch only ever
  *    touches `this.transport`, never `this.local`.
  *
+ * FULL DETACH (SDK 1.2.0). The 1.1.0 wire family covered five verbs (add,
+ * honestSearch, get, updateReview, delete). That was enough for a surface to store
+ * and recall a fact over the wire, but NOT enough to fully detach every consumer
+ * from the store file: the agent's `list`/`update`/semantic-search paths and the
+ * TUI's `/recall` browse/link/queue/export paths still fell back to a local file.
+ * This client now exposes the FULL read/write catalog those consumers need
+ * (see MemoryExtendedAccess), so a wire client never opens the file for ANY of them.
+ *
  * ONE-WRITER ENFORCEMENT RULING. The platform's convention (see canonical-memory.ts
  * and the session spine) is honest sequential/owned access plus stated posture, NOT
  * an OS advisory lock — sql.js exposes no lock and a cross-process flock would be a
@@ -38,30 +46,84 @@
  * would be the exact dishonest-recall failure this whole design exists to prevent.
  * A sustained daemon loss is handled by `deactivate()`, which returns the surface
  * to owned-local mode explicitly.
+ *
+ * VERSION TOLERANCE. The five CORE verbs are required of every transport. The
+ * EXTENDED verbs are OPTIONAL on the transport (`MemoryTransport`) so a surface
+ * pinned to an older SDK/daemon pair that predates a verb still satisfies the type.
+ * When a client in wire mode calls an extended verb its adopted daemon does not
+ * implement, the call REJECTS with a stated reason — it never silently reaches into
+ * the local file, which would break the one-writer invariant and lie about which
+ * store answered.
  */
 import { logger } from '../../utils/logger.js';
-import type { MemoryAddOptions, MemoryRecord, MemoryReviewPatch, MemorySearchFilter } from '../../state/memory-store.js';
+import type { MemoryAddOptions, MemoryBundle, MemoryDoctorReport, MemoryImportResult, MemoryLink, MemoryRecord, MemoryReviewPatch, MemoryScope, MemorySearchFilter, MemorySemanticSearchResult } from '../../state/memory-store.js';
+import type { MemoryVectorStats } from '../../state/memory-vector-store.js';
 import type { HonestMemorySearchOptions, HonestMemorySearchResult } from '../../state/memory-recall-contract.js';
+import { type MemoryRecallSnapshot, type MemoryRecallRefreshOptions } from './recall-snapshot.js';
+/** Patch shape accepted by an editable-field update (scope/summary/detail/tags). */
+export interface MemoryUpdatePatch {
+    readonly scope?: MemoryScope | undefined;
+    readonly summary?: string | undefined;
+    readonly detail?: string | undefined;
+    readonly tags?: string[] | undefined;
+}
 /**
- * The memory read/write surface a caller uses without caring whether it resolves
- * locally or over the wire. Every method is async so a local (sync store) and a
- * wire (async) backend present the SAME shape.
+ * The five CORE verbs, shipped in 1.1.0. Every transport must implement all five —
+ * they are the minimum that lets a surface store and recall a fact over the wire.
  */
-export interface MemoryAccess {
+export interface MemoryCoreAccess {
     add(opts: MemoryAddOptions): Promise<MemoryRecord>;
     honestSearch(filter: MemorySearchFilter, options?: HonestMemorySearchOptions): Promise<HonestMemorySearchResult>;
     get(id: string): Promise<MemoryRecord | null>;
     updateReview(id: string, patch: MemoryReviewPatch): Promise<MemoryRecord | null>;
     delete(id: string): Promise<boolean>;
 }
+/**
+ * The EXTENDED verbs added in 1.2.0 so a wire client can fully detach from the file.
+ * Each maps to a MemoryRegistry read/write the consumers were still doing locally:
+ *  - `list`          — bulk read (getAll / literal browse): knowledge injection + agent `list`.
+ *  - `searchSemantic`— scored semantic recall: agent semantic path + TUI `/recall --semantic`.
+ *  - `update`        — edit scope/summary/detail/tags (a scope edit is how a record is "promoted" project→team).
+ *  - `link`/`linksFor` — relate records / read a record's links.
+ *  - `reviewQueue`   — records prioritised for review (the curator/queue surface).
+ *  - `exportBundle`/`importBundle` — the no-loss bundle seam over the wire.
+ *  - `vectorStats`/`doctor` — read the daemon's canonical index diagnostics.
+ *
+ * DELIBERATELY NOT HERE (host-only, ruled in the full-detach decision record):
+ * `rebuildVectors`/`rebuildVectorsAsync`. Rebuilding the vector index is maintenance
+ * a store performs on its OWN index; the daemon keeps its canonical index current on
+ * every add/import and exposes an admin `POST /api/memory/vector/rebuild` for a forced
+ * rebuild. A wire client owns no index to rebuild, so a client-initiated rebuild is an
+ * admin/diagnostic action against a store it does not own — it stays out of band, not
+ * a per-record detach need.
+ */
+export interface MemoryExtendedAccess {
+    list(filter?: MemorySearchFilter): Promise<readonly MemoryRecord[]>;
+    searchSemantic(filter?: MemorySearchFilter): Promise<readonly MemorySemanticSearchResult[]>;
+    update(id: string, patch: MemoryUpdatePatch): Promise<MemoryRecord | null>;
+    link(fromId: string, toId: string, relation: string): Promise<MemoryLink | null>;
+    linksFor(id: string): Promise<readonly MemoryLink[]>;
+    reviewQueue(limit?: number, scope?: MemoryScope): Promise<readonly MemoryRecord[]>;
+    exportBundle(filter?: MemorySearchFilter): Promise<MemoryBundle>;
+    importBundle(bundle: MemoryBundle): Promise<MemoryImportResult>;
+    vectorStats(): Promise<MemoryVectorStats>;
+    doctor(): Promise<MemoryDoctorReport>;
+}
+/**
+ * The full memory read/write surface a caller uses without caring whether it
+ * resolves locally or over the wire. Every method is async so a local (sync store)
+ * and a wire (async) backend present the SAME shape.
+ */
+export interface MemoryAccess extends MemoryCoreAccess, MemoryExtendedAccess {
+}
 /**
  * The injected wire transport. A consumer builds a thin adapter over the daemon's
- * memory.records.* routes (POST /api/memory/records, /search, GET/DELETE
- * /api/memory/records/:id, POST /api/memory/records/:id/review). The core only ever
- * calls these methods — it never assumes a typed client exists, so a surface pinned
- * to an older SDK can still adapt raw REST, exactly like the session spine.
+ * memory.records.* routes. The five CORE verbs are required; the EXTENDED verbs are
+ * optional so a surface pinned to an older SDK/daemon still satisfies the type — a
+ * client calling an extended verb the adopted daemon lacks gets an honest rejection,
+ * never a silent local-file read.
  */
-export type MemoryTransport = MemoryAccess;
+export type MemoryTransport = MemoryCoreAccess & Partial<MemoryExtendedAccess>;
 /**
  * The local embedded store surface. The SDK's `MemoryRegistry` satisfies this
  * structurally (its methods are mostly synchronous; the facade normalizes them to
@@ -73,8 +135,18 @@ export interface LocalMemoryStore {
     get(id: string): MemoryRecord | null;
     review(id: string, patch: MemoryReviewPatch): MemoryRecord | null;
     delete(id: string): boolean;
+    search(filter?: MemorySearchFilter): MemoryRecord[];
+    searchSemantic(filter?: MemorySearchFilter): MemorySemanticSearchResult[];
+    update(id: string, patch: MemoryUpdatePatch): MemoryRecord | null;
+    link(fromId: string, toId: string, relation: string): Promise<MemoryLink | null> | MemoryLink | null;
+    linksFor(id: string): MemoryLink[];
+    reviewQueue(limit?: number, scope?: MemoryScope): MemoryRecord[];
+    exportBundle(filter?: MemorySearchFilter): MemoryBundle;
+    importBundle(bundle: MemoryBundle): Promise<MemoryImportResult> | MemoryImportResult;
+    vectorStats(): MemoryVectorStats;
+    doctor(): Promise<MemoryDoctorReport> | MemoryDoctorReport;
 }
-/** Wrap a local embedded store (e.g. a MemoryRegistry) as a MemoryAccess. */
+/** Wrap a local embedded store (e.g. a MemoryRegistry) as a full MemoryAccess. */
 export declare function createLocalMemoryAccess(store: LocalMemoryStore): MemoryAccess;
 /** Current access posture — honest, reportable, never guessed. */
 export type MemoryAccessMode = 'local' | 'client';
@@ -88,8 +160,14 @@ export interface MemorySpineClientOptions {
      * (a surface that adopts a daemon later, or runs offline forever).
      */
     readonly transport?: MemoryTransport | undefined;
+    /**
+     * How long a recall snapshot stays "fresh" before `recallSnapshot()` reports it
+     * stale. Defaults to {@link DEFAULT_RECALL_SNAPSHOT_STALE_AFTER_MS}.
+     */
+    readonly recallSnapshotStaleAfterMs?: number | undefined;
     readonly log?: SpineLogger;
 }
+export type { MemoryRecallSnapshot, MemoryRecallRefreshOptions } from './recall-snapshot.js';
 /**
  * Routes memory access to the LOCAL embedded store or, when a daemon has been
  * adopted, THROUGH the wire — never both. Implements {@link MemoryAccess} so a
@@ -99,6 +177,9 @@ export declare class MemorySpineClient implements MemoryAccess {
     private readonly local;
     private transport;
     private readonly log;
+    private readonly staleAfterMs;
+    /** Last recall snapshot captured by refreshRecallSnapshot(); null until first refresh. */
+    private snapshot;
     constructor(options: MemorySpineClientOptions);
     /** The current posture: 'client' when routing over the wire, 'local' otherwise. */
     mode(): MemoryAccessMode;
@@ -117,11 +198,43 @@ export declare class MemorySpineClient implements MemoryAccess {
     get(id: string): Promise<MemoryRecord | null>;
     updateReview(id: string, patch: MemoryReviewPatch): Promise<MemoryRecord | null>;
     delete(id: string): Promise<boolean>;
+    list(filter?: MemorySearchFilter): Promise<readonly MemoryRecord[]>;
+    searchSemantic(filter?: MemorySearchFilter): Promise<readonly MemorySemanticSearchResult[]>;
+    update(id: string, patch: MemoryUpdatePatch): Promise<MemoryRecord | null>;
+    link(fromId: string, toId: string, relation: string): Promise<MemoryLink | null>;
+    linksFor(id: string): Promise<readonly MemoryLink[]>;
+    reviewQueue(limit?: number, scope?: MemoryScope): Promise<readonly MemoryRecord[]>;
+    exportBundle(filter?: MemorySearchFilter): Promise<MemoryBundle>;
+    importBundle(bundle: MemoryBundle): Promise<MemoryImportResult>;
+    vectorStats(): Promise<MemoryVectorStats>;
+    doctor(): Promise<MemoryDoctorReport>;
+    /**
+     * Refresh the cached recall snapshot ASYNCHRONOUSLY over the CURRENT route (wire
+     * when adopted, local otherwise). Call this from an async pre-turn hook so a
+     * SYNCHRONOUS prompt builder can read the result via {@link recallSnapshot}
+     * without awaiting the wire. Runs the honest recall search (recall-injection
+     * contract ON by default), stamps the capture time and mode, and stores it.
+     */
+    refreshRecallSnapshot(filter?: MemorySearchFilter, options?: MemoryRecallRefreshOptions): Promise<MemoryRecallSnapshot>;
+    /**
+     * Read the last recall snapshot SYNCHRONOUSLY (for a sync prompt builder). Never
+     * opens the file and never awaits: it returns whatever the last async refresh
+     * captured, with a freshly-computed age, a `stale` flag, and an HONEST `note`. If
+     * no refresh has happened yet it returns an EMPTY snapshot whose note says exactly
+     * that — never a silent empty that reads as "nothing was ever stored."
+     */
+    recallSnapshot(now?: number): MemoryRecallSnapshot;
     /**
      * The single choke point that realizes the one-writer invariant: in client mode
      * EVERY op resolves through the transport and the local store is never reached.
      */
     private route;
+    /**
+     * Route an extended verb. Local mode → the local store. Client mode → the
+     * transport's verb if it implements it, otherwise an HONEST rejection stating the
+     * adopted daemon does not support it (never a silent local-file read, which would
+     * break the single-writer invariant and misreport which store answered).
+     */
+    private routeExtended;
 }
-export {};
 //# sourceMappingURL=client.d.ts.map

package/dist/platform/runtime/memory-spine/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/memory-spine/client.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/memory-spine/client.ts"],"names":[],"mappings":"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"}

package/dist/platform/runtime/memory-spine/client.js

@@ -19,6 +19,14 @@
  *    NEVER opens the file. Enforced structurally here — the active branch only ever
  *    touches `this.transport`, never `this.local`.
  *
+ * FULL DETACH (SDK 1.2.0). The 1.1.0 wire family covered five verbs (add,
+ * honestSearch, get, updateReview, delete). That was enough for a surface to store
+ * and recall a fact over the wire, but NOT enough to fully detach every consumer
+ * from the store file: the agent's `list`/`update`/semantic-search paths and the
+ * TUI's `/recall` browse/link/queue/export paths still fell back to a local file.
+ * This client now exposes the FULL read/write catalog those consumers need
+ * (see MemoryExtendedAccess), so a wire client never opens the file for ANY of them.
+ *
  * ONE-WRITER ENFORCEMENT RULING. The platform's convention (see canonical-memory.ts
  * and the session spine) is honest sequential/owned access plus stated posture, NOT
  * an OS advisory lock — sql.js exposes no lock and a cross-process flock would be a
@@ -38,9 +46,18 @@
  * would be the exact dishonest-recall failure this whole design exists to prevent.
  * A sustained daemon loss is handled by `deactivate()`, which returns the surface
  * to owned-local mode explicitly.
+ *
+ * VERSION TOLERANCE. The five CORE verbs are required of every transport. The
+ * EXTENDED verbs are OPTIONAL on the transport (`MemoryTransport`) so a surface
+ * pinned to an older SDK/daemon pair that predates a verb still satisfies the type.
+ * When a client in wire mode calls an extended verb its adopted daemon does not
+ * implement, the call REJECTS with a stated reason — it never silently reaches into
+ * the local file, which would break the one-writer invariant and lie about which
+ * store answered.
  */
 import { logger } from '../../utils/logger.js';
-/** Wrap a local embedded store (e.g. a MemoryRegistry) as a MemoryAccess. */
+import { buildRecallSnapshot, emptyRecallSnapshot, DEFAULT_RECALL_SNAPSHOT_STALE_AFTER_MS, } from './recall-snapshot.js';
+/** Wrap a local embedded store (e.g. a MemoryRegistry) as a full MemoryAccess. */
 export function createLocalMemoryAccess(store) {
     return {
         add: (opts) => Promise.resolve(store.add(opts)),
@@ -48,6 +65,16 @@ export function createLocalMemoryAccess(store) {
         get: (id) => Promise.resolve(store.get(id)),
         updateReview: (id, patch) => Promise.resolve(store.review(id, patch)),
         delete: (id) => Promise.resolve(store.delete(id)),
+        list: (filter) => Promise.resolve(store.search(filter ?? {})),
+        searchSemantic: (filter) => Promise.resolve(store.searchSemantic(filter ?? {})),
+        update: (id, patch) => Promise.resolve(store.update(id, patch)),
+        link: (fromId, toId, relation) => Promise.resolve(store.link(fromId, toId, relation)),
+        linksFor: (id) => Promise.resolve(store.linksFor(id)),
+        reviewQueue: (limit, scope) => Promise.resolve(store.reviewQueue(limit, scope)),
+        exportBundle: (filter) => Promise.resolve(store.exportBundle(filter ?? {})),
+        importBundle: (bundle) => Promise.resolve(store.importBundle(bundle)),
+        vectorStats: () => Promise.resolve(store.vectorStats()),
+        doctor: () => Promise.resolve(store.doctor()),
     };
 }
 /**
@@ -59,10 +86,14 @@ export class MemorySpineClient {
     local;
     transport;
     log;
+    staleAfterMs;
+    /** Last recall snapshot captured by refreshRecallSnapshot(); null until first refresh. */
+    snapshot = null;
     constructor(options) {
         this.local = options.local;
         this.transport = options.transport ?? null;
         this.log = options.log ?? logger;
+        this.staleAfterMs = options.recallSnapshotStaleAfterMs ?? DEFAULT_RECALL_SNAPSHOT_STALE_AFTER_MS;
     }
     /** The current posture: 'client' when routing over the wire, 'local' otherwise. */
     mode() {
@@ -88,6 +119,7 @@ export class MemorySpineClient {
         this.transport = null;
         this.log.info('memory spine deactivated — reverting to owned-local memory access', { reason });
     }
+    // ── Core verbs (routed local-or-wire) ─────────────────────────────────────────
     add(opts) {
         return this.route().add(opts);
     }
@@ -103,6 +135,64 @@ export class MemorySpineClient {
     delete(id) {
         return this.route().delete(id);
     }
+    // ── Extended verbs (routed local-or-wire; honest reject if the daemon lacks one) ─
+    list(filter) {
+        return this.routeExtended('list', (a) => a.list(filter), (t) => t.list?.(filter));
+    }
+    searchSemantic(filter) {
+        return this.routeExtended('searchSemantic', (a) => a.searchSemantic(filter), (t) => t.searchSemantic?.(filter));
+    }
+    update(id, patch) {
+        return this.routeExtended('update', (a) => a.update(id, patch), (t) => t.update?.(id, patch));
+    }
+    link(fromId, toId, relation) {
+        return this.routeExtended('link', (a) => a.link(fromId, toId, relation), (t) => t.link?.(fromId, toId, relation));
+    }
+    linksFor(id) {
+        return this.routeExtended('linksFor', (a) => a.linksFor(id), (t) => t.linksFor?.(id));
+    }
+    reviewQueue(limit, scope) {
+        return this.routeExtended('reviewQueue', (a) => a.reviewQueue(limit, scope), (t) => t.reviewQueue?.(limit, scope));
+    }
+    exportBundle(filter) {
+        return this.routeExtended('exportBundle', (a) => a.exportBundle(filter), (t) => t.exportBundle?.(filter));
+    }
+    importBundle(bundle) {
+        return this.routeExtended('importBundle', (a) => a.importBundle(bundle), (t) => t.importBundle?.(bundle));
+    }
+    vectorStats() {
+        return this.routeExtended('vectorStats', (a) => a.vectorStats(), (t) => t.vectorStats?.());
+    }
+    doctor() {
+        return this.routeExtended('doctor', (a) => a.doctor(), (t) => t.doctor?.());
+    }
+    // ── The sync-recall seam ──────────────────────────────────────────────────────
+    /**
+     * Refresh the cached recall snapshot ASYNCHRONOUSLY over the CURRENT route (wire
+     * when adopted, local otherwise). Call this from an async pre-turn hook so a
+     * SYNCHRONOUS prompt builder can read the result via {@link recallSnapshot}
+     * without awaiting the wire. Runs the honest recall search (recall-injection
+     * contract ON by default), stamps the capture time and mode, and stores it.
+     */
+    async refreshRecallSnapshot(filter = {}, options = {}) {
+        const recall = options.recall ?? true;
+        const result = await this.route().honestSearch(filter, { recall });
+        this.snapshot = buildRecallSnapshot(result, this.mode(), Date.now(), this.staleAfterMs);
+        return this.snapshot;
+    }
+    /**
+     * Read the last recall snapshot SYNCHRONOUSLY (for a sync prompt builder). Never
+     * opens the file and never awaits: it returns whatever the last async refresh
+     * captured, with a freshly-computed age, a `stale` flag, and an HONEST `note`. If
+     * no refresh has happened yet it returns an EMPTY snapshot whose note says exactly
+     * that — never a silent empty that reads as "nothing was ever stored."
+     */
+    recallSnapshot(now = Date.now()) {
+        const cached = this.snapshot;
+        if (cached === null || cached.search === null || cached.capturedAt === null)
+            return emptyRecallSnapshot(this.mode());
+        return buildRecallSnapshot(cached.search, cached.mode, cached.capturedAt, this.staleAfterMs, now);
+    }
     /**
      * The single choke point that realizes the one-writer invariant: in client mode
      * EVERY op resolves through the transport and the local store is never reached.
@@ -110,4 +200,22 @@ export class MemorySpineClient {
     route() {
         return this.transport ?? this.local;
     }
+    /**
+     * Route an extended verb. Local mode → the local store. Client mode → the
+     * transport's verb if it implements it, otherwise an HONEST rejection stating the
+     * adopted daemon does not support it (never a silent local-file read, which would
+     * break the single-writer invariant and misreport which store answered).
+     */
+    routeExtended(verb, local, wire) {
+        if (this.transport === null)
+            return local(this.local);
+        const call = wire(this.transport);
+        if (call === undefined) {
+            return Promise.reject(new Error(`memory spine: the adopted daemon does not support the '${verb}' memory verb over the wire — `
+                + 'upgrade the daemon to a build that serves it, or run this surface offline (no daemon adopted). '
+                + 'A wire client will not read its own local store for this op, because that would break the '
+                + 'single-writer invariant and report a divergent local copy as if it were the canonical store.'));
+        }
+        return call;
+    }
 }

package/dist/platform/runtime/memory-spine/index.d.ts

@@ -6,6 +6,12 @@
  * directly; a surface that has adopted a compatible daemon routes memory THROUGH
  * the wire and never opens the store file. Mirrors the session-spine pattern; the
  * offline fallback stays, so the agent and TUI keep working with no daemon running.
+ *
+ * As of 1.2.0 the client exposes the FULL read/write catalog (see
+ * MemoryExtendedAccess) so a wire client fully detaches from the file, plus a
+ * freshness-stamped recall snapshot (recall-snapshot.ts) for the synchronous
+ * per-turn prompt-injection seam.
  */
-export { MemorySpineClient, createLocalMemoryAccess, type MemoryAccess, type MemoryAccessMode, type MemoryTransport, type LocalMemoryStore, type MemorySpineClientOptions, } from './client.js';
+export { MemorySpineClient, createLocalMemoryAccess, type MemoryAccess, type MemoryCoreAccess, type MemoryExtendedAccess, type MemoryAccessMode, type MemoryTransport, type MemoryUpdatePatch, type LocalMemoryStore, type MemorySpineClientOptions, type MemoryRecallSnapshot, type MemoryRecallRefreshOptions, } from './client.js';
+export { buildRecallSnapshot, emptyRecallSnapshot, DEFAULT_RECALL_SNAPSHOT_STALE_AFTER_MS, } from './recall-snapshot.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/platform/runtime/memory-spine/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/memory-spine/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,GAC9B,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/memory-spine/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,GAChC,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,sCAAsC,GACvC,MAAM,sBAAsB,CAAC"}

package/dist/platform/runtime/memory-spine/index.js

@@ -6,5 +6,11 @@
  * directly; a surface that has adopted a compatible daemon routes memory THROUGH
  * the wire and never opens the store file. Mirrors the session-spine pattern; the
  * offline fallback stays, so the agent and TUI keep working with no daemon running.
+ *
+ * As of 1.2.0 the client exposes the FULL read/write catalog (see
+ * MemoryExtendedAccess) so a wire client fully detaches from the file, plus a
+ * freshness-stamped recall snapshot (recall-snapshot.ts) for the synchronous
+ * per-turn prompt-injection seam.
  */
 export { MemorySpineClient, createLocalMemoryAccess, } from './client.js';
+export { buildRecallSnapshot, emptyRecallSnapshot, DEFAULT_RECALL_SNAPSHOT_STALE_AFTER_MS, } from './recall-snapshot.js';