chainlesschain 0.166.135 → 0.166.138

package/src/lib/background-launch-profile.js

@@ -48,6 +48,29 @@ function positive(value, integer = false) {
   return integer ? Math.floor(number) : number;
 }
 
+function invalidProfileField(field) {
+  const error = new Error(`Invalid background launch profile field: ${field}`);
+  error.code = "BACKGROUND_LAUNCH_PROFILE_INVALID";
+  return error;
+}
+
+function policyBudget(value, field) {
+  const text = String(value).trim();
+  const cost = field.toLowerCase().includes("cost");
+  const number = Number(value);
+  if (
+    value == null ||
+    !(cost ? /^\+?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i : /^\+?\d+$/).test(
+      text,
+    ) ||
+    !Number.isFinite(number) ||
+    number <= 0 ||
+    (!cost && !Number.isSafeInteger(number))
+  )
+    throw invalidProfileField(`budget.${field}`);
+  return number;
+}
+
 function sortedStrings(values, { split = false, pathsFrom = null } = {}) {
   const raw = Array.isArray(values) ? values : values ? [values] : [];
   const expanded = split
@@ -356,6 +379,17 @@ export function captureBackgroundLaunchProfile({
       index++;
       return next;
     };
+    const takePolicy = (allowEmpty = false) => {
+      const next = inline !== null ? inline : args[index + 1];
+      if (
+        next == null ||
+        (inline === null && next.startsWith("--")) ||
+        (!allowEmpty && next.trim() === "")
+      )
+        throw invalidProfileField(`argv.${name}`);
+      if (inline === null) index++;
+      return next;
+    };
     switch (name) {
       case "--provider":
         profile.llm.provider = scalar(take());
@@ -376,14 +410,17 @@ export function captureBackgroundLaunchProfile({
         fallbackModels.push(...orderedStrings(take(), { split: true }));
         break;
       case "--allowed-tools":
-        profile.tools.allowed = sortedStrings(take(), { split: true });
+        profile.tools.allowed = sortedStrings(takePolicy(true), {
+          split: true,
+        });
         break;
       case "--disallowed-tools":
-        profile.tools.disallowed = sortedStrings(take(), { split: true });
+        profile.tools.disallowed = sortedStrings(takePolicy(true), {
+          split: true,
+        });
         break;
       case "--permission-mode": {
-        const mode = scalar(take());
-        profile.permission.mode = PERMISSION_MODES.has(mode) ? mode : "default";
+        profile.permission.mode = scalar(takePolicy());
         break;
       }
       case "--allow-dangerous-bypass":
@@ -395,7 +432,7 @@ export function captureBackgroundLaunchProfile({
         profile.permission.unattended = true;
         break;
       case "--unattended-allow":
-        profile.permission.unattendedAllow = sortedStrings(take(), {
+        profile.permission.unattendedAllow = sortedStrings(takePolicy(true), {
           split: true,
         });
         break;
@@ -413,8 +450,7 @@ export function captureBackgroundLaunchProfile({
         profile.sandbox.image = scalar(take(true));
         break;
       case "--sandbox-mode": {
-        const mode = scalar(take());
-        profile.sandbox.mode = SANDBOX_MODES.has(mode) ? mode : null;
+        profile.sandbox.mode = scalar(takePolicy());
         break;
       }
       case "--sandbox-network":
@@ -427,6 +463,12 @@ export function captureBackgroundLaunchProfile({
         profile.mcp.disabled = true;
         profile.runtime.noMcpAutoConnect = true;
         break;
+      case "--no-mcp-auto-connect":
+        profile.runtime.noMcpAutoConnect = true;
+        break;
+      case "--no-plugins":
+        profile.plugins.disabled = true;
+        break;
       case "--strict-mcp-config":
         profile.mcp.strict = true;
         break;
@@ -461,28 +503,43 @@ export function captureBackgroundLaunchProfile({
         addDirs.push(take());
         break;
       case "--max-turns":
-        profile.budget.maxTurns = positive(take(), true);
+        profile.budget.maxTurns = policyBudget(takePolicy(), "maxTurns");
         break;
       case "--max-budget-usd":
-        profile.budget.maxCostUsd = positive(take());
+        profile.budget.maxCostUsd = policyBudget(takePolicy(), "maxCostUsd");
         break;
       case "--thinking-budget":
-        profile.budget.thinkingTokens = positive(take(), true);
+        profile.budget.thinkingTokens = policyBudget(
+          takePolicy(),
+          "thinkingTokens",
+        );
         break;
       case "--max-rewakes":
-        profile.budget.maxRewakes = positive(take(), true);
+        profile.budget.maxRewakes = policyBudget(takePolicy(), "maxRewakes");
         break;
       case "--max-outer-turns":
-        profile.budget.maxOuterTurns = positive(take(), true);
+        profile.budget.maxOuterTurns = policyBudget(
+          takePolicy(),
+          "maxOuterTurns",
+        );
         break;
       case "--goal-max-tokens":
-        profile.budget.goalMaxTokens = positive(take(), true);
+        profile.budget.goalMaxTokens = policyBudget(
+          takePolicy(),
+          "goalMaxTokens",
+        );
         break;
       case "--goal-max-cost":
-        profile.budget.goalMaxCostUsd = positive(take());
+        profile.budget.goalMaxCostUsd = policyBudget(
+          takePolicy(),
+          "goalMaxCostUsd",
+        );
         break;
       case "--goal-max-time":
-        profile.budget.goalMaxTimeMs = positive(take(), true);
+        profile.budget.goalMaxTimeMs = policyBudget(
+          takePolicy(),
+          "goalMaxTimeMs",
+        );
         break;
       case "--safe-mode":
         profile.runtime.safeMode = true;
@@ -667,12 +724,70 @@ export function normalizeBackgroundLaunchProfile(input) {
     );
   }
   const rejectField = (field) => {
-    const error = new Error(
-      `Invalid background launch profile field: ${field}`,
-    );
-    error.code = "BACKGROUND_LAUNCH_PROFILE_INVALID";
-    throw error;
+    throw invalidProfileField(field);
   };
+  for (const group of [
+    "llm",
+    "tools",
+    "permission",
+    "sandbox",
+    "mcp",
+    "plugins",
+    "runtime",
+    "budget",
+  ])
+    if (
+      input[group] != null &&
+      (typeof input[group] !== "object" || Array.isArray(input[group]))
+    )
+      rejectField(group);
+  for (const [group, fields] of Object.entries({
+    permission: [
+      "dangerousBypass",
+      "unattended",
+      "interactiveApprovals",
+      "remoteControl",
+    ],
+    sandbox: ["enabled", "network"],
+    mcp: ["disabled", "strict", "project"],
+    plugins: ["disabled"],
+    runtime: [
+      "safeMode",
+      "bare",
+      "managedCheckpoint",
+      "noProjectMemory",
+      "noFileRefs",
+      "noSlashMacros",
+      "noRecallMemory",
+      "noMcpAutoConnect",
+      "autoRewake",
+      "autoPin",
+      "noStream",
+      "noParkOnExit",
+    ],
+  }))
+    for (const field of fields)
+      if (
+        input[group]?.[field] !== undefined &&
+        typeof input[group][field] !== "boolean"
+      )
+        rejectField(`${group}.${field}`);
+  for (const field of ["ide", "pdh", "jetbrains"])
+    if (input.mcp?.[field] != null && !TRI_STATES.has(input.mcp[field]))
+      rejectField(`mcp.${field}`);
+  for (const [group, fields] of Object.entries({
+    tools: ["allowed", "disallowed"],
+    permission: ["unattendedAllow"],
+  }))
+    for (const field of fields) {
+      const value = input[group]?.[field];
+      if (
+        value != null &&
+        (!Array.isArray(value) ||
+          value.some((item) => typeof item !== "string" || !item.trim()))
+      )
+        rejectField(`${group}.${field}`);
+    }
   // A persisted policy must not silently fall back to a weaker default.
   if (
     input.permission?.mode != null &&
@@ -692,14 +807,8 @@ export function normalizeBackgroundLaunchProfile(input) {
     "goalMaxTimeMs",
   ]) {
     const value = input.budget?.[field];
-    if (value == null || value === "") continue;
-    const number = Number(value);
-    if (
-      !Number.isFinite(number) ||
-      number <= 0 ||
-      (!field.toLowerCase().includes("cost") && !Number.isSafeInteger(number))
-    )
-      rejectField(`budget.${field}`);
+    if (value == null) continue;
+    policyBudget(value, field);
   }
   const cwd = canonicalPath(input.workspace?.cwd || process.cwd());
   const safeBase = sanitizeBackgroundBaseUrl(input.llm?.baseUrl);
@@ -1020,6 +1129,11 @@ export function buildArgvFromBackgroundLaunchProfile(profile) {
   pushFlag(argv, "--sandbox-network", p.sandbox.network);
   pushValue(argv, "--mcp-config", p.mcp.configFile);
   pushFlag(argv, "--no-mcp", p.mcp.disabled);
+  pushFlag(
+    argv,
+    "--no-mcp-auto-connect",
+    p.runtime.noMcpAutoConnect && !p.mcp.disabled,
+  );
   pushFlag(argv, "--strict-mcp-config", p.mcp.strict);
   pushFlag(argv, "--project-mcp", p.mcp.project);
   for (const [key, value] of [
@@ -1032,6 +1146,7 @@ export function buildArgvFromBackgroundLaunchProfile(profile) {
   }
   pushValue(argv, "--settings", p.settings.file);
   pushValue(argv, "--bundle", p.plugins.bundle);
+  pushFlag(argv, "--no-plugins", p.plugins.disabled && !p.runtime.bare);
   for (const dir of p.workspace.addDirs) pushValue(argv, "--add-dir", dir);
   pushValue(argv, "--max-turns", p.budget.maxTurns);
   pushValue(argv, "--max-budget-usd", p.budget.maxCostUsd);

package/src/lib/coding-task-guidance.js

@@ -2,9 +2,11 @@
 export const CODING_TASK_QUALITY_GUIDANCE = `Coding task quality:
 - Read the actual implementation and its exported API before writing a caller or test. Verify parameter order, return shapes, fixture requirements and the delegated owner of each lifecycle transition.
 - Keep progress explanations to one or two sentences. Resolve uncertainty with targeted reads, reuse unchanged source already inspected, and put code directly in write/edit arguments.
+- Omitted or undelivered source has not been inspected. For an incomplete source excerpt, select a complete enclosing statement or container; a larger range or whole file within the tool limits may be necessary. Do not keep halving the same omitted page. For oversized output, select bounded fields or sections. If safe source remains unavailable, report that limitation without claiming completion.
 - Resolve each relative import from the destination file's directory. Read back completed files and fix newDiagnostics. A successful write proves persistence, not test execution or acceptance.
 - Map every acceptance requirement to a fixture, real production call path and observable assertion. Positive and negative controls must reach the same boundary with unrelated prerequisites valid. Avoid mocks that bypass it; identify which assertion would fail without that boundary.
 - Derive case allocation from the user's requirements. A test-count cap does not waive coverage: merge redundant cases to cover gaps within the cap, authorized scope and remaining budget. Report unresolved gaps as incomplete.
+- Keep test fixtures and assertions within the runner's memory and time limits. For large binary payloads, assert lengths and use Buffer.equals or a digest for content checks; avoid deep matchers that enumerate every byte or print the entire payload on failure. Check boundary rejection before allocating a large body when the contract permits it.
 - For races, control the intended transition and complete the current worker/request when testing cancellation or replacement. An earlier unrelated rejection does not prove the target guard. Derive expectations independently from the contract or authoritative state, not by calling the function under test.
 - Trace rejection before asserting its aftermath: it may precede registration or persistence. Inspect whether state stays unchanged, a failed record exists or an event is emitted. Compare independently recorded identities and provenance; equal text does not prove ownership.
 - Inspect persistence projections before comparing histories. Host notices, lineage and imports may accompany user/assistant messages; verify their provenance separately. Report defects that cannot be repaired within the permitted scope instead of inventing passing behavior.

package/src/lib/context-memory-kernel/jsonl-session-context-port.js

@@ -54,12 +54,17 @@ function compactStats(event, messages) {
 
 /** SessionContextPort backed by the CLI's verified, anchored JSONL transcript. */
 export class JsonlSessionContextPort {
-  constructor({ sessionId, allowedSinks = ["*"] } = {}) {
+  constructor({
+    sessionId,
+    allowedSinks = ["*"],
+    requiredUserMessages = [],
+  } = {}) {
     if (typeof sessionId !== "string" || !sessionId.trim()) {
       throw new TypeError("JsonlSessionContextPort requires sessionId");
     }
     this.sessionId = sessionId.trim();
     this.allowedSinks = [...allowedSinks];
+    this.requiredUserMessages = requiredUserMessages;
     this.ownedHeadAdvances = new Map();
   }
 
@@ -113,16 +118,20 @@ export class JsonlSessionContextPort {
             memoryRevision = revision;
           }
         },
-        finish: (authority) => ({
-          sessionId,
-          head: authority.headHash,
-          memoryRevision,
-          items: messagesToContextItems(authority.readMessages(), {
+        finish: (authority) => {
+          const messages = authority.readMessages();
+          return {
             sessionId,
-            allowedSinks: this.allowedSinks,
-            allowExternalization: true,
-          }),
-        }),
+            head: authority.headHash,
+            memoryRevision,
+            items: messagesToContextItems(messages, {
+              sessionId,
+              allowedSinks: this.allowedSinks,
+              allowExternalization: true,
+              requiredUserMessages: this.requiredUserMessages,
+            }),
+          };
+        },
       };
     });
   }

package/src/lib/context-memory-kernel/live-compaction.js

@@ -1,3 +1,9 @@
+import { isDeepStrictEqual } from "node:util";
+import {
+  resolveTaskBinding,
+  taskBindingMatchCount,
+  advanceTaskBinding,
+} from "./task-binding.js";
 import { randomUUID } from "node:crypto";
 import {
   canonicalDigest,
@@ -84,6 +90,7 @@ class CallbackSessionContextPort extends InMemorySessionContextPort {
     head,
     physicalAuthority,
     allowExternalization = false,
+    requiredUserMessages = [],
   }) {
     const initialHead =
       head ||
@@ -99,6 +106,7 @@ class CallbackSessionContextPort extends InMemorySessionContextPort {
         items: messagesToContextItems(messages, {
           sessionId,
           allowExternalization,
+          requiredUserMessages,
         }),
       },
     ]);
@@ -262,10 +270,22 @@ export async function compactLiveMessagesCanonical(
           !isCompactionHostBase(message) &&
           !isRuntimeOnlySessionMessage(message),
       );
+  const requiredUserBindings = (options.requiredUserBindings || []).map(
+    (binding) => ({
+      ...binding,
+      message: structuredClone(binding.message),
+      matchCount: taskBindingMatchCount(binding),
+    }),
+  );
+  const summarizerOptions = { ...(options.compressOptions || {}) };
+  delete summarizerOptions.requiredUserBindings;
+  for (const binding of requiredUserBindings)
+    resolveTaskBinding(liveMessages, binding);
   const ephemeralMessages = [];
+  const durableSourceIndexes = new Map();
   {
     let sequence = 0;
-    for (const message of liveMessages) {
+    for (const [liveIndex, message] of liveMessages.entries()) {
       if (
         isRuntimeOnlySessionMessage(message) ||
         isCompactionHostBase(message) ||
@@ -274,9 +294,29 @@ export async function compactLiveMessagesCanonical(
           !getDurableSystemMessageProvenance(message))
       )
         ephemeralMessages.push({ sequence, message });
-      else sequence += 1;
+      else {
+        durableSourceIndexes.set(liveIndex, sequence);
+        sequence += 1;
+      }
     }
   }
+  // Carry host-resolved source indexes into the verified authority projection.
+  // Identical historical user text is not a substitute for this source identity.
+  const requiredUserMessages = requiredUserBindings.map((binding) => ({
+    index: durableSourceIndexes.get(
+      resolveTaskBinding(liveMessages, binding).index,
+    ),
+    message: binding.message,
+  }));
+  const initialItems = messagesToContextItems(messages, {
+    sessionId,
+    allowExternalization: persistentSession,
+    requiredUserMessages,
+  });
+  const boundItems = requiredUserMessages.map(({ index }, bindingIndex) => ({
+    item: initialItems.find((item) => item.sourceRef.eventSequence === index),
+    binding: requiredUserBindings[bindingIndex],
+  }));
   if (typeof options.commit === "function") {
     const bootstrapRuntime = createCliContextMemoryRuntime({
       sessionId,
@@ -288,6 +328,7 @@ export async function compactLiveMessagesCanonical(
     if (persistentSession) {
       verifiedAuthoritySnapshot = await new JsonlSessionContextPort({
         sessionId,
+        requiredUserMessages,
       }).readSnapshot(sessionId);
     }
     const sessionPort = new CallbackSessionContextPort({
@@ -298,6 +339,7 @@ export async function compactLiveMessagesCanonical(
       trigger,
       summaryStats: () => summaryStats,
       allowExternalization: persistentSession,
+      requiredUserMessages,
       ...(verifiedAuthoritySnapshot?.head
         ? { head: verifiedAuthoritySnapshot.head, physicalAuthority: true }
         : {}),
@@ -312,6 +354,10 @@ export async function compactLiveMessagesCanonical(
     });
   } else if (persistentSession) {
     runtime = createCliContextMemoryRuntime({
+      sessionPort: new JsonlSessionContextPort({
+        sessionId,
+        requiredUserMessages,
+      }),
       sessionId,
       scopeKey: `cli:session:${sessionId}`,
       env: options.env,
@@ -336,6 +382,7 @@ export async function compactLiveMessagesCanonical(
         items: messagesToContextItems(messages, {
           sessionId,
           allowExternalization: false,
+          requiredUserMessages,
         }),
       },
     ]);
@@ -362,6 +409,7 @@ export async function compactLiveMessagesCanonical(
     const inputItems = messagesToContextItems(messages, {
       sessionId,
       allowExternalization: true,
+      requiredUserMessages,
     });
     const inputDigest = canonicalDigest(
       inputItems.map((item) => item.digest),
@@ -384,11 +432,59 @@ export async function compactLiveMessagesCanonical(
   const model = options.model || "default";
   const memoryRevision = await runtime.memoryPort.getRevision();
   let settledOutputItems = null;
-  if (ephemeralMessages.length) {
+  {
     const appendCompaction = runtime.sessionPort.appendCompaction.bind(
       runtime.sessionPort,
     );
     runtime.sessionPort.appendCompaction = async (event, expectedHead) => {
+      const outputMessages = contextItemsToMessages(event.outputItems, {
+        sessionId,
+      });
+      for (const { item, binding } of boundItems) {
+        resolveTaskBinding(messagesInput, binding);
+        const retained = event.outputItems.filter(
+          (output) => output.itemId === item.itemId,
+        );
+        const originalOutputs = contextItemsToMessages(
+          event.outputItems.filter((output) =>
+            initialItems.some(
+              (input) =>
+                input.itemId === output.itemId &&
+                input.digest === output.digest,
+            ),
+          ),
+          { sessionId },
+        );
+        // A summary can faithfully retain an older identical user turn from
+        // its verified dropped parents. Such history is not a new task copy.
+        const derivedParents = new Set(
+          event.outputItems
+            .filter(
+              (output) =>
+                !initialItems.some((input) => input.itemId === output.itemId),
+            )
+            .flatMap((output) => output.provenance.parentDigests || []),
+        );
+        const historicalOutputs = contextItemsToMessages(
+          initialItems.filter((input) => derivedParents.has(input.digest)),
+          { sessionId },
+        );
+        const matches = (list) =>
+          list.filter((message) => isDeepStrictEqual(message, binding.message))
+            .length;
+        if (
+          retained.length !== 1 ||
+          retained[0].digest !== item.digest ||
+          matches(outputMessages) >
+            matches(originalOutputs) + matches(historicalOutputs)
+        ) {
+          const error = new Error(
+            "The current user task was lost, changed or duplicated in compaction output",
+          );
+          error.code = "CC_AGENT_TASK_CONTEXT_LOST";
+          throw error;
+        }
+      }
       const result = await appendCompaction(event, expectedHead);
       if (result?.ok === true) settledOutputItems = event.outputItems;
       return result;
@@ -427,7 +523,7 @@ export async function compactLiveMessagesCanonical(
         });
         const result = await compressor.compress(droppedMessages, {
           preserveToolPairs: true,
-          ...(options.compressOptions || {}),
+          ...summarizerOptions,
         });
         summaryStats = result.stats || {};
         summaryReceipt = usageReceipt(summaryStats, provider, model);
@@ -513,7 +609,9 @@ export async function compactLiveMessagesCanonical(
       receipt,
     };
   }
-  const snapshot = await runtime.sessionPort.readSnapshot(sessionId);
+  const snapshot = settledOutputItems
+    ? null
+    : await runtime.sessionPort.readSnapshot(sessionId);
   // Reattach host policy and private retry nudges at their durable sequence
   // boundaries. They remain live, never enter the receipt, and do not move a
   // retry instruction behind tool exchanges that happened after that retry.
@@ -531,11 +629,21 @@ export async function compactLiveMessagesCanonical(
       ephemeralMessages[ephemeralIndex].sequence <= sequence
     )
       restoredMessages.push(ephemeralMessages[ephemeralIndex++].message);
-    restoredMessages.push(...contextItemsToMessages([item], { sessionId }));
+    const bound = boundItems.find((entry) => entry.item.itemId === item.itemId);
+    restoredMessages.push(
+      ...(bound
+        ? [bound.binding.original]
+        : contextItemsToMessages([item], { sessionId })),
+    );
   }
   restoredMessages.push(
     ...ephemeralMessages.slice(ephemeralIndex).map(({ message }) => message),
   );
+  // Advance only the host binding's known multiplicity after a verified commit;
+  // older identical turns may have been legitimately summarized away.
+  requiredUserBindings.forEach((_, index) => {
+    advanceTaskBinding(options.requiredUserBindings[index], restoredMessages);
+  });
   return {
     messages: restoredMessages,
     stats: {

package/src/lib/context-memory-kernel/message-adapter.js

@@ -206,17 +206,22 @@ 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 requiredUsers =
+    options.requiredUserMessages ||
+    (options.requiredUserMessage ? [options.requiredUserMessage] : []);
+  for (const requiredUser of requiredUsers) {
+    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 requiredIndexes = new Set(requiredUsers.map(({ index }) => index));
   const trustedSystemIndexes = new Set(
     Array.isArray(options.trustedSystemIndexes)
       ? options.trustedSystemIndexes.filter(Number.isSafeInteger)
@@ -305,14 +310,13 @@ export function messagesToContextItems(messagesInput, options = {}) {
     const item = items[index];
     if (
       index !== lastIndex &&
-      item.sourceRef.eventSequence !== requiredUser?.index
+      !requiredIndexes.has(item.sourceRef.eventSequence)
     )
       continue;
     const payload = JSON.parse(loadBundleContent(item, sessionId));
     if (
       payload.messages.at(-1)?.role === "user" &&
-      (index === lastIndex ||
-        item.sourceRef.eventSequence === requiredUser?.index)
+      (index === lastIndex || requiredIndexes.has(item.sourceRef.eventSequence))
     ) {
       const protectedItem = { ...item };
       delete protectedItem.digest;

package/src/lib/context-memory-kernel/task-binding.js

@@ -0,0 +1,41 @@
+import { isDeepStrictEqual } from "node:util";
+
+const committedMatchCounts = new WeakMap();
+export function taskBindingMatchCount(binding) {
+  return committedMatchCounts.get(binding) ?? binding.matchCount ?? 1;
+}
+export function advanceTaskBinding(binding, messages) {
+  committedMatchCounts.set(
+    binding,
+    messages.filter((message) => isDeepStrictEqual(message, binding.message))
+      .length,
+  );
+}
+
+// A compaction may recreate objects, but may never reconstruct the user's task
+// from a generated summary. Only an exact, unambiguous snapshot can relocate.
+export function resolveTaskBinding(messages, binding) {
+  if (!binding) return null;
+  const identities = messages.flatMap((message, index) =>
+    message === binding.original ? [index] : [],
+  );
+  const matches = messages.flatMap((message, index) =>
+    message?.role === "user" && isDeepStrictEqual(message, binding.message)
+      ? [index]
+      : [],
+  );
+  if (
+    matches.length !== taskBindingMatchCount(binding) ||
+    identities.length > 1 ||
+    (identities.length === 1 && !matches.includes(identities[0])) ||
+    (!identities.length &&
+      (binding.allowContentRelocation !== true || matches.length !== 1))
+  ) {
+    const error = new Error(
+      "The current user task was lost, changed or duplicated in compaction context",
+    );
+    error.code = "CC_AGENT_TASK_CONTEXT_LOST";
+    throw error;
+  }
+  return { index: identities[0] ?? matches[0], message: binding.message };
+}