chainlesschain 0.166.129 → 0.166.131

package/src/lib/context-memory-kernel/memory-service.js

@@ -403,13 +403,21 @@ export class CliCanonicalMemoryService {
     return result;
   }
 
-  async list({ limit = 20, category, scopeAdmissions, sink, tags } = {}) {
+  async list({
+    limit = 20,
+    category,
+    scopeAdmissions,
+    sink,
+    tags,
+    signal,
+  } = {}) {
     const records = await this.runtime.memoryPort.listRecords({
       limit: Math.max(1, Number(limit) || 20),
       category,
       scopeAdmissions,
       sink,
       tags,
+      signal,
     });
     return records
       .filter((record) => !category || record.category === category)
@@ -548,13 +556,16 @@ export class CliCanonicalMemoryService {
   async recallScoped(query, options = {}) {
     const scope = normalizedScope(options.scope, options.scopeId);
     const limit = Math.max(1, Math.min(1000, Number(options.limit) || 10));
-    const recalled = await this.runtime.kernel.recallMemory({
-      query: String(query || "").trim() || "*",
-      sink: options.sink || "cli.display",
-      scopeAdmissions: [scope],
-      limit: 1000,
-      tokenBudget: 1_048_576,
-    });
+    const recalled = await this.runtime.kernel.recallMemory(
+      {
+        query: String(query || "").trim() || "*",
+        sink: options.sink || "cli.display",
+        scopeAdmissions: [scope],
+        limit: 1000,
+        tokenBudget: 1_048_576,
+      },
+      { signal: options.signal },
+    );
     const tags = normalizedTags(options.tags);
     const entries = recalled.results
       .filter(
@@ -567,14 +578,17 @@ export class CliCanonicalMemoryService {
     return { ...recalled, results: entries };
   }
 
-  async search(query, { limit = 20, sink = "cli.display" } = {}) {
-    const recalled = await this.runtime.kernel.recallMemory({
-      query,
-      sink,
-      scopeAdmissions: [{ scope: "user", scopeId: "local-user" }],
-      limit: Math.max(1, Number(limit) || 20),
-      tokenBudget: 32_768,
-    });
+  async search(query, { limit = 20, sink = "cli.display", signal } = {}) {
+    const recalled = await this.runtime.kernel.recallMemory(
+      {
+        query,
+        sink,
+        scopeAdmissions: [{ scope: "user", scopeId: "local-user" }],
+        limit: Math.max(1, Number(limit) || 20),
+        tokenBudget: 32_768,
+      },
+      { signal },
+    );
     return {
       ...recalled,
       entries: recalled.results.map((result) =>

package/src/lib/context-memory-kernel/memory-shard-snapshots.js

@@ -0,0 +1,63 @@
+import { queryDigest } from "./memory-query-index.js";
+
+export const DEFAULT_DECODED_SHARD_CACHE_BYTES = 16 * 1024 * 1024;
+
+// Cache validated object graphs, not permission to skip disk reads. Every hit
+// requires the newly captured authority bytes, the current physical authority
+// identity and the exact manifest generation. Values stay internal to the port.
+export class MemoryShardSnapshots {
+  #entries = new Map();
+  #generation = null;
+  #bytes = 0;
+
+  constructor(maxBytes = DEFAULT_DECODED_SHARD_CACHE_BYTES) {
+    if (
+      !Number.isSafeInteger(maxBytes) ||
+      maxBytes < 0 ||
+      maxBytes > 64 * 1024 * 1024
+    )
+      throw new TypeError("decodedShardCacheBytes must be 0-67108864");
+    this.maxBytes = maxBytes;
+  }
+
+  observe(generation) {
+    if (generation === this.#generation) return;
+    this.#entries.clear();
+    this.#bytes = 0;
+    this.#generation = generation;
+  }
+
+  read(generation, bucket, bytes, decode) {
+    if (
+      !generation ||
+      generation !== this.#generation ||
+      bytes.length > this.maxBytes
+    )
+      return decode();
+    const digest = queryDigest(bytes);
+    const cached = this.#entries.get(bucket);
+    if (cached?.digest === digest) {
+      this.#entries.delete(bucket);
+      this.#entries.set(bucket, cached);
+      return cached.value;
+    }
+    if (cached) {
+      this.#entries.delete(bucket);
+      this.#bytes -= cached.bytes;
+    }
+    const value = decode();
+    // A nested host operation must not repopulate a superseded generation.
+    if (generation !== this.#generation) return value;
+    while (
+      this.#entries.size >= 32 ||
+      this.#bytes + bytes.length > this.maxBytes
+    ) {
+      const oldest = this.#entries.keys().next().value;
+      this.#bytes -= this.#entries.get(oldest).bytes;
+      this.#entries.delete(oldest);
+    }
+    this.#entries.set(bucket, { digest, bytes: bytes.length, value });
+    this.#bytes += bytes.length;
+    return value;
+  }
+}

package/src/lib/context-memory-kernel/provider-context.js

@@ -5,6 +5,7 @@ import {
   normalizeContextItem,
 } from "@chainlesschain/context-memory-kernel";
 import { resolveModelCapabilityProfile } from "../model-capabilities.js";
+import { raceWithAbort } from "../abort-utils.js";
 import { createCliContextMemoryRuntime } from "./runtime.js";
 import {
   contextItemsToMessages,
@@ -64,20 +65,32 @@ async function resolveSemanticCandidates({
   sink,
   scopeAdmissions,
   limit,
+  signal,
 }) {
   if (!provider) return undefined;
-  const candidates = await provider(
-    Object.freeze({
-      schema: SEMANTIC_CANDIDATE_REQUEST_SCHEMA,
-      sessionId,
-      query,
-      sink,
-      scopeAdmissions: Object.freeze(
-        scopeAdmissions.map((entry) => Object.freeze({ ...entry })),
-      ),
-      limit,
-      maxCandidates: 1000,
+  signal?.throwIfAborted();
+  const request = Object.freeze({
+    schema: SEMANTIC_CANDIDATE_REQUEST_SCHEMA,
+    sessionId,
+    query,
+    sink,
+    scopeAdmissions: Object.freeze(
+      scopeAdmissions.map((entry) => Object.freeze({ ...entry })),
+    ),
+    limit,
+    maxCandidates: 1000,
+  });
+  // Attach cancellation observers before invoking host code. A source may
+  // ignore Stop, or abort synchronously and then reject; neither can revive
+  // this request or produce an unhandled late rejection. The live signal is
+  // a host control, never part of the serialized semantic request contract.
+  const candidates = await raceWithAbort(
+    Promise.resolve().then(() => {
+      signal?.throwIfAborted();
+      return provider(request, Object.freeze({ signal }));
     }),
+    signal,
+    "Semantic Memory recall interrupted",
   );
   if (!Array.isArray(candidates)) {
     throw new TypeError(
@@ -141,6 +154,7 @@ export async function prepareCanonicalProviderContext(
   messagesInput,
   options = {},
 ) {
+  options.signal?.throwIfAborted();
   const messages = Array.isArray(messagesInput) ? messagesInput : [];
   const sessionId = String(options.sessionId || "ephemeral-cli-session");
   const planningRequested = options.contextMemorySkipPlanning !== true;
@@ -215,23 +229,31 @@ export async function prepareCanonicalProviderContext(
     sink,
     scopeAdmissions,
     limit: recallLimit,
+    signal: options.signal,
   });
+  options.signal?.throwIfAborted();
   const recall = recallEnabled
-    ? await runtime.kernel.recallMemory({
-        query,
-        sink,
-        scopeAdmissions,
-        limit: recallLimit,
-        tokenBudget: Math.max(
-          1,
-          Math.min(32_768, Number(options.contextMemoryRecallTokens) || 4096),
-        ),
-        ...(semanticCandidates === undefined ? {} : { semanticCandidates }),
-      })
+    ? await runtime.kernel.recallMemory(
+        {
+          query,
+          sink,
+          scopeAdmissions,
+          limit: recallLimit,
+          tokenBudget: Math.max(
+            1,
+            Math.min(32_768, Number(options.contextMemoryRecallTokens) || 4096),
+          ),
+          ...(semanticCandidates === undefined ? {} : { semanticCandidates }),
+        },
+        { signal: options.signal },
+      )
     : {
         results: [],
-        memoryRevision: await runtime.memoryPort.getRevision(),
+        memoryRevision: await runtime.memoryPort.getRevision({
+          signal: options.signal,
+        }),
       };
+  options.signal?.throwIfAborted();
   const imageTransport = captureContextImageTransport(messages);
   const messageItems = adjustContextImageTokenEstimates(
     messagesToContextItems(imageTransport.messages, {
@@ -259,7 +281,15 @@ export async function prepareCanonicalProviderContext(
   );
   const safetyMarginTokens = Math.min(
     modelWindowTokens - reservedOutputTokens - 1,
-    Math.max(64, Math.floor(modelWindowTokens * 0.05)),
+    Math.max(
+      64,
+      Math.floor(modelWindowTokens * 0.05),
+      // Some models cap input independently of the shared context window.
+      // Reserve that unavailable headroom before selecting any context items.
+      modelWindowTokens -
+        reservedOutputTokens -
+        (modelCapabilities.advertisedMaxInputTokens ?? modelWindowTokens),
+    ),
   );
   const inputBudget =
     modelWindowTokens - reservedOutputTokens - safetyMarginTokens;
@@ -310,6 +340,7 @@ export async function prepareCanonicalProviderContext(
     sessionHead,
     memoryRevision: recall.memoryRevision,
   });
+  options.signal?.throwIfAborted();
   const selectedMessages = contextItemsToMessages(
     plan.selected.filter((item) => item.kind !== "tool-schema"),
     { sessionId },