chainlesschain 0.166.130 → 0.166.132

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/message-adapter.js

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from "node:util";
 import {
   canonicalDigest,
   canonicalJson,
@@ -205,6 +206,17 @@ export function messagesToContextItems(messagesInput, options = {}) {
     ? [...options.allowedSinks]
     : DEFAULT_ALLOWED_SINKS;
   const items = [];
+  const requiredUser = options.requiredUserMessage;
+  if (
+    requiredUser != null &&
+    (!Number.isSafeInteger(requiredUser.index) ||
+      requiredUser.index < 0 ||
+      requiredUser.index >= messages.length ||
+      requiredUser.message?.role !== "user" ||
+      !isDeepStrictEqual(messages[requiredUser.index], requiredUser.message))
+  ) {
+    throw new TypeError("Invalid current-user task binding");
+  }
   const trustedSystemIndexes = new Set(
     Array.isArray(options.trustedSystemIndexes)
       ? options.trustedSystemIndexes.filter(Number.isSafeInteger)
@@ -289,11 +301,20 @@ export function messagesToContextItems(messagesInput, options = {}) {
   const lastIndex = items.findLastIndex(
     (item) => item.kind !== "system-policy",
   );
-  const last = items[lastIndex];
-  if (last) {
-    const payload = JSON.parse(loadBundleContent(last, sessionId));
-    if (payload.messages.at(-1)?.role === "user") {
-      const protectedItem = { ...last };
+  for (let index = 0; index < items.length; index++) {
+    const item = items[index];
+    if (
+      index !== lastIndex &&
+      item.sourceRef.eventSequence !== requiredUser?.index
+    )
+      continue;
+    const payload = JSON.parse(loadBundleContent(item, sessionId));
+    if (
+      payload.messages.at(-1)?.role === "user" &&
+      (index === lastIndex ||
+        item.sourceRef.eventSequence === requiredUser?.index)
+    ) {
+      const protectedItem = { ...item };
       delete protectedItem.digest;
       protectedItem.kind = "task-state";
       protectedItem.priority = 900_000;
@@ -301,7 +322,7 @@ export function messagesToContextItems(messagesInput, options = {}) {
         taskState: "waiting",
         requiredForRecovery: true,
       };
-      items[lastIndex] = normalizeContextItem(protectedItem);
+      items[index] = normalizeContextItem(protectedItem);
     }
   }
   return items;

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

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from "node:util";
 import {
   canonicalDigest,
   canonicalJson,
@@ -5,6 +6,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 +66,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 +155,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;
@@ -189,6 +204,40 @@ export async function prepareCanonicalProviderContext(
     };
   }
 
+  // Resolve against the final provider projection, never a pre-projection index.
+  // Exact role/content/metadata matching prevents a transformed tool result or
+  // an ambiguous duplicate from taking the original user's task-state binding.
+  const taskBinding = options.contextMemoryRequiredUserBinding;
+  const requiredUserMessage = taskBinding?.message;
+  function resolveRequiredUserIndex() {
+    if (requiredUserMessage == null) return null;
+    const identities = messages.flatMap((message, index) =>
+      message === taskBinding.original ? [index] : [],
+    );
+    const candidates = identities.length
+      ? identities
+      : taskBinding.allowContentRelocation === true
+        ? messages.map((_, index) => index)
+        : [];
+    const matches = candidates.filter((index) => {
+      const message = messages[index];
+      return (
+        message?.role === "user" &&
+        requiredUserMessage.role === "user" &&
+        isDeepStrictEqual(message, requiredUserMessage)
+      );
+    });
+    if (matches.length !== 1 || identities.length > 1) {
+      const error = new Error(
+        "The current user task was lost, changed or duplicated in provider context",
+      );
+      error.code = "CC_AGENT_TASK_CONTEXT_LOST";
+      throw error;
+    }
+    return matches[0];
+  }
+  let requiredUserIndex = resolveRequiredUserIndex();
+
   // Review can exclude recalled author/session data while retaining the exact
   // canonical context, tool and output-token planning boundary.
   const recallEnabled = options.contextMemoryRecall !== false;
@@ -197,9 +246,9 @@ export async function prepareCanonicalProviderContext(
     : null;
   const sink = String(options.contextMemorySink || `provider.${provider}`);
   const scopeAdmissions = defaultAdmissions(sessionId, options);
-  const lastUser = [...messages]
-    .reverse()
-    .find((message) => message?.role === "user");
+  const lastUser =
+    requiredUserMessage ||
+    [...messages].reverse().find((message) => message?.role === "user");
   const query =
     typeof lastUser?.content === "string" && lastUser.content.trim()
       ? lastUser.content.trim().slice(0, 32 * 1024)
@@ -215,23 +264,34 @@ 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();
+  // Recall awaits host and storage work. Revalidate the captured task and its
+  // current position before image transformation and immutable item creation.
+  requiredUserIndex = resolveRequiredUserIndex();
   const imageTransport = captureContextImageTransport(messages);
   const messageItems = adjustContextImageTokenEstimates(
     messagesToContextItems(imageTransport.messages, {
@@ -239,6 +299,13 @@ export async function prepareCanonicalProviderContext(
       allowedSinks: [sink],
       trustCurrentSystemPolicy: true,
       trustedSystemIndexes: options.contextMemoryTrustedSystemIndexes,
+      requiredUserMessage:
+        requiredUserIndex === null
+          ? null
+          : {
+              index: requiredUserIndex,
+              message: imageTransport.messages[requiredUserIndex],
+            },
       allowExternalization: false,
     }),
     imageTransport.captures,
@@ -259,7 +326,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 +385,7 @@ export async function prepareCanonicalProviderContext(
     sessionHead,
     memoryRevision: recall.memoryRevision,
   });
+  options.signal?.throwIfAborted();
   const selectedMessages = contextItemsToMessages(
     plan.selected.filter((item) => item.kind !== "tool-schema"),
     { sessionId },