@iowarp/clio-coder 0.3.3 → 0.3.6

package/dist/{chunk-2DJ2KNFG.js → chunk-ZXF4XRKW.js}

@@ -7,24 +7,31 @@ import {
   TASK_MEMORY_POLICY_DEFAULT_TIMEOUT_MS,
   runTaskMemoryPolicy,
   taskMemoryBankDelta
-} from "./chunk-OAO4GE4M.js";
+} from "./chunk-WHGPSPT5.js";
+import {
+  isTerminalRunEnvelope
+} from "./chunk-XXQNGV4M.js";
 import {
-  isTerminalRunEnvelope,
   taskBoardCounts
-} from "./chunk-LWLEKMDQ.js";
+} from "./chunk-43AOLP7E.js";
+import {
+  SKILL_SUGGESTION_ANCHOR,
+  SKILL_SUGGESTION_PREFIX
+} from "./chunk-GOXNB3AO.js";
 import {
-  SKILL_SUGGESTION_ANCHOR
-} from "./chunk-T6YILFSB.js";
+  legacyToolResultDigest,
+  sanitizeToolResultDigest
+} from "./chunk-ODFEOB4F.js";
 import {
   ToolNames
 } from "./chunk-CGKSTWHD.js";
-import {
-  ceilChars
-} from "./chunk-LZSJBIVT.js";
 import {
   reportCommitAttributionDiagnostic,
   withManagedGitCommitAttributionEnvironment
-} from "./chunk-COU2UHX6.js";
+} from "./chunk-VEZEGCGW.js";
+import {
+  ceilChars
+} from "./chunk-GEYXPTRF.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -61,6 +68,10 @@ function metadataNumber(input, key) {
   const value = input.metadata?.[key];
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
+function metadataString(input, key) {
+  const value = input.metadata?.[key];
+  return typeof value === "string" ? value : null;
+}
 function isMiddlewareHook(value) {
   return MIDDLEWARE_HOOKS.includes(value);
 }
@@ -187,8 +198,93 @@ init_esm_shims();
 init_esm_shims();
 var STALLED_TURN_REGISTRATION_ID = "nudge.stalled-turn";
 var STALLED_TURN_REQUEST_CONTINUATION_MESSAGE = "You ended your turn after announcing an action without executing it: no tools were called. Continue now and perform the announced action, or state plainly that you are finished and waiting for the user.";
+var SKILL_SUGGESTION_WAIT_CONTINUATION_MESSAGE = "You ended your turn on a skill suggestion without doing the task. The suggestion line has already made the offer and only the operator loads a skill, so nothing is needed from them before you proceed. Continue the task now without the skill.";
 var INTENT_PATTERN = /\b(let me|i['’]ll|i will|i am going to|i['’]m going to|now i|next i|let's|let us)\b/i;
+var CONCRETE_ACTION_STEMS = [
+  "add",
+  "analyse",
+  "analyze",
+  "apply",
+  "audit",
+  "build",
+  "change",
+  "check",
+  "compare",
+  "compile",
+  "create",
+  "debug",
+  "delete",
+  "edit",
+  "execute",
+  "explore",
+  "find",
+  "fix",
+  "format",
+  "grep",
+  "implement",
+  "inspect",
+  "install",
+  "investigate",
+  "list",
+  "load",
+  "look",
+  "modify",
+  "open",
+  "patch",
+  "query",
+  "read",
+  "refactor",
+  "remove",
+  "rename",
+  "replace",
+  "review",
+  "run",
+  "scan",
+  "search",
+  "test",
+  "trace",
+  "update",
+  "validate",
+  "verify",
+  "write"
+];
+var DOUBLED_CONSONANT_STEMS = /* @__PURE__ */ new Set(["debug", "format", "run", "scan"]);
+function concreteActionForms(stem) {
+  const forms = /* @__PURE__ */ new Set([stem, `${stem}s`, `${stem}ed`, `${stem}ing`]);
+  if (/(?:ch|sh|s|x|z)$/.test(stem)) forms.add(`${stem}es`);
+  if (stem.endsWith("e")) {
+    forms.add(`${stem}d`);
+    forms.add(`${stem.slice(0, -1)}ing`);
+  }
+  if (stem.endsWith("y")) {
+    forms.add(`${stem.slice(0, -1)}ies`);
+    forms.add(`${stem.slice(0, -1)}ied`);
+  }
+  if (DOUBLED_CONSONANT_STEMS.has(stem)) {
+    const doubled = `${stem}${stem.slice(-1)}`;
+    forms.add(`${doubled}ed`);
+    forms.add(`${doubled}ing`);
+  }
+  return [...forms];
+}
+var CONCRETE_ACTION_PATTERN = new RegExp(
+  `\\b(?:${CONCRETE_ACTION_STEMS.flatMap(concreteActionForms).join("|")})\\b`,
+  "giu"
+);
+var NAMED_PATH_EXTENSIONS = "c|cc|cfg|cjs|cmake|conf|cpp|cs|css|csv|env|go|h|hpp|html|ini|java|jl|js|json|jsx|lock|log|lua|md|mjs|nc|php|py|rb|rs|rst|sh|sql|toml|ts|tsx|txt|yaml|yml";
+var NAMED_PATH_PATTERN = new RegExp(
+  `(?:^|[\\s\`"'(\\[])(?:[\\w@.\\-/]*[\\w@\\-]\\.(?:${NAMED_PATH_EXTENSIONS})\\b|(?:\\.{1,2}|~)\\/[\\w@.\\-/]+)`,
+  "iu"
+);
+var NAMED_COMMAND_PATTERN = /\b(?:npm|npx|pnpm|yarn|bun|git|cargo|rustc|cmake|ctest|ninja|meson|bazel|gradle|mvn|pytest|pip|python3?|node|deno|tsc|biome|eslint|prettier|jest|vitest|ruff|mypy|docker|kubectl|mpirun|srun|sbatch|gcc|clang)\s+[-\w./]/iu;
+var ACTION_OBJECT_CONNECTOR_PATTERN = /^(?:at|for|in|into|on|through|to)\s+/i;
+var ACTION_OBJECT_DETERMINER_PATTERN = /^(?:a|an|my|our|that|the|their|these|this|those|your)\s+/i;
+var ACTION_OBJECT_PATTERN = /^(?!(?:again|everyone|later|next|now|soon|then|you)\b)[`"'./~]*[\p{L}\p{N}_-]/iu;
+var CONDITIONAL_LEAD_IN_PATTERN = /\b(?:if|once|unless|until|when|whenever)\b/i;
+var CONDITIONAL_INVITATION_PATTERN = /\b(?:ask|give|point|say|send|share|tell)\b[\s\S]*\b(?:and|then)\s*$/i;
+var CONDITIONAL_OFFER_SUFFIX_PATTERN = /\b(?:if\s+(?:needed|necessary|requested)\b|if\b[^.!?]*\byou\b|when(?:ever)?\s+you\b)/i;
 var LET_ME_KNOW_PATTERN = /\blet me know\b/i;
+var DEFERRAL_LEAD_PATTERN = /^\s*(?:just\s+|simply\s+|now\s+)?(?:wait|hold\s+off|hold|stand\s+by|pause|defer)\b/i;
 var COMPLETION_PATTERN = /^\s*(?:all\s+done|done|complete|completed|all\s+set)\b|^\s*(?:here(?:'s| is)\s+)?(?:a\s+)?summary\b|^\s*summary\s*:?$/i;
 var STALLED_TURN_RULE_DEFINITION = {
   rule: {
@@ -202,6 +298,24 @@ var STALLED_TURN_RULE_DEFINITION = {
   effects: [{ kind: "request_continuation", message: STALLED_TURN_REQUEST_CONTINUATION_MESSAGE }],
   predicate: shouldRequestStalledTurnContinuation
 };
+var SKILL_WAIT_PATTERN = /\/skill\b|\bskills?\b|\bskip\b/i;
+function isSkillSuggestionWait(input) {
+  if (input.hook !== "turn_end") return false;
+  if (!isNormalStopReason(input.metadata?.stopReason)) return false;
+  const text = input.text ?? "";
+  if (!text.includes(SKILL_SUGGESTION_PREFIX)) return false;
+  const toolNames = metadataString(input, "turnToolNames");
+  if (toolNames === null) {
+    if ((metadataNumber(input, "turnToolCalls") ?? 0) !== 0) return false;
+  } else if (toolNames.split(",").filter((name) => name.length > 0).some((name) => name !== ToolNames.Context)) {
+    return false;
+  }
+  const lastLine = lastNonEmptyLine(text);
+  if (lastLine === null) return false;
+  const finalSentence = lastSentence(lastLine);
+  if (finalSentence.length === 0) return false;
+  return SKILL_WAIT_PATTERN.test(finalSentence) || isQuestion(finalSentence) || LET_ME_KNOW_PATTERN.test(finalSentence);
+}
 function shouldRequestStalledTurnContinuation(input) {
   if (input.hook !== "turn_end") return false;
   if (input.metadata?.turnToolCalls !== 0) return false;
@@ -213,7 +327,34 @@ function shouldRequestStalledTurnContinuation(input) {
   if (isQuestion(finalSentence)) return false;
   if (LET_ME_KNOW_PATTERN.test(finalSentence)) return false;
   if (COMPLETION_PATTERN.test(lastLine) || COMPLETION_PATTERN.test(finalSentence)) return false;
-  return finalSentence.endsWith(":") || INTENT_PATTERN.test(finalSentence);
+  return announcesConcreteAction(finalSentence);
+}
+function announcesConcreteAction(sentence) {
+  const intent = INTENT_PATTERN.exec(sentence);
+  if (intent) {
+    const leadIn = sentence.slice(0, intent.index);
+    if (CONDITIONAL_LEAD_IN_PATTERN.test(leadIn) || CONDITIONAL_INVITATION_PATTERN.test(leadIn) || CONDITIONAL_OFFER_SUFFIX_PATTERN.test(sentence)) {
+      return false;
+    }
+    const clause = sentence.slice(intent.index + intent[0].length);
+    if (DEFERRAL_LEAD_PATTERN.test(clause)) return false;
+    if (hasActionWithObject(clause)) return true;
+    if (CONDITIONAL_LEAD_IN_PATTERN.test(clause)) return false;
+    return namesToolTarget(clause);
+  }
+  return sentence.endsWith(":") && hasActionWithObject(sentence);
+}
+function namesToolTarget(clause) {
+  return NAMED_PATH_PATTERN.test(clause) || NAMED_COMMAND_PATTERN.test(clause);
+}
+function hasActionWithObject(clause) {
+  for (const action of clause.matchAll(CONCRETE_ACTION_PATTERN)) {
+    const remainder = clause.slice((action.index ?? 0) + action[0].length).trimStart();
+    const withoutConnector = remainder.replace(ACTION_OBJECT_CONNECTOR_PATTERN, "");
+    const object = withoutConnector.replace(ACTION_OBJECT_DETERMINER_PATTERN, "");
+    if (ACTION_OBJECT_PATTERN.test(object)) return true;
+  }
+  return false;
 }
 function isNormalStopReason(value) {
   if (value === void 0 || value === null) return true;
@@ -229,10 +370,16 @@ function lastNonEmptyLine(text) {
   }
   return null;
 }
+var SENTENCE_TERMINATOR_PATTERN = /[.!?]+["'’)\]]*(?=\s|$)/gu;
 function lastSentence(line) {
-  const matches = line.match(/[^.!?]+[.!?]+(?:["')\]]+)?|[^.!?]+$/g);
-  const sentence = matches?.at(-1)?.trim() ?? line.trim();
-  return sentence.replace(/^[\s"'([{-]+/, "").trim();
+  const trimmed = line.trimEnd();
+  let start = 0;
+  for (const terminator of trimmed.matchAll(SENTENCE_TERMINATOR_PATTERN)) {
+    const end = (terminator.index ?? 0) + terminator[0].length;
+    if (end >= trimmed.length) break;
+    start = end;
+  }
+  return trimmed.slice(start).replace(/^[\s"'([{-]+/, "").trim();
 }
 function isQuestion(sentence) {
   return /[?]["')\]]*$/.test(sentence.trim());
@@ -432,6 +579,12 @@ function cloneHookInput(input) {
   if (input.metadata !== void 0) cloned.metadata = { ...input.metadata };
   if (input.toolArgs !== void 0) cloned.toolArgs = { ...input.toolArgs };
   if (input.toolResultDetails !== void 0) cloned.toolResultDetails = { ...input.toolResultDetails };
+  if (input.toolResultDigest !== void 0) {
+    cloned.toolResultDigest = {
+      text: input.toolResultDigest.text,
+      provenance: { ...input.toolResultDigest.provenance }
+    };
+  }
   if (input.text !== void 0) cloned.text = input.text.slice(0, MIDDLEWARE_HOOK_TEXT_MAX_CHARS);
   return cloned;
 }
@@ -1232,7 +1385,6 @@ var MEMORY_INTERVENTION_DEFAULT_WINDOW_STEPS = 8;
 var MEMORY_INTERVENTION_DEFAULT_MAX_TOKENS = 400;
 var MEMORY_INTERVENTION_DEFAULT_EVERY_N_TOOLS = 10;
 var MEMORY_INTERVENTION_ACTIVITY_LIMIT = 20;
-var RESULT_DIGEST_MAX_CHARS = 240;
 var CALL_DESCRIPTION_MAX_CHARS = 180;
 var NO_EFFECTS = [];
 function createMemoryInterventionRegistration(deps) {
@@ -1242,7 +1394,7 @@ function createMemoryInterventionRegistration(deps) {
   let toolStep = 0;
   let lastTurnEndStep = 0;
   let reactivateAfterCompaction = false;
-  let lastInjectedFingerprint = null;
+  let lastInjectedOperationFingerprint = null;
   let currentTask = "(current task unavailable)";
   let toolsSinceMemoryStep = 0;
   let consecutiveErrors = 0;
@@ -1291,6 +1443,7 @@ function createMemoryInterventionRegistration(deps) {
             return effects;
           }
           case "on_compaction":
+            if (input.metadata?.stage === "working_set_recall") return NO_EFFECTS;
             reactivateAfterCompaction = true;
             return NO_EFFECTS;
           case "turn_start": {
@@ -1510,12 +1663,12 @@ function createMemoryInterventionRegistration(deps) {
   function observeBeforeTool(input) {
     const prepared = prepareToolStep(input);
     if (prepared === null) return;
-    setBounded(pending, pendingKey(input, prepared.fingerprint), prepared, settings().windowSteps);
+    setBounded(pending, pendingKey(input, prepared.operationFingerprint), prepared, settings().windowSteps);
   }
   function observeAfterTool(input) {
     const fallback = prepareToolStep(input);
     if (fallback === null) return NO_EFFECTS;
-    const key = pendingKey(input, fallback.fingerprint);
+    const key = pendingKey(input, fallback.operationFingerprint);
     const prepared = pending.get(key) ?? fallback;
     pending.delete(key);
     const outcome = input.metadata?.resultKind === "error" ? "error" : "ok";
@@ -1529,11 +1682,13 @@ function createMemoryInterventionRegistration(deps) {
     } else {
       consecutiveErrors = 0;
     }
+    const digest = resultDigest(input, outcome);
     const step = {
       ...prepared,
       step: toolStep,
       outcome,
-      resultDigest: resultDigest(input, outcome)
+      resultDigest: digest.text,
+      resultDigestProvenance: digest.provenance
     };
     trajectory.push(step);
     if (trajectory.length > live.windowSteps) trajectory.splice(0, trajectory.length - live.windowSteps);
@@ -1542,19 +1697,19 @@ function createMemoryInterventionRegistration(deps) {
     return annotateRepeatedFailure(step);
   }
   function annotateRepeatedFailure(step) {
-    if (annotatedThisTurn.has(step.fingerprint)) return NO_EFFECTS;
+    if (annotatedThisTurn.has(step.operationFingerprint)) return NO_EFFECTS;
     const occurrences = trajectory.filter(
-      (candidate) => candidate.outcome === "error" && candidate.fingerprint === step.fingerprint
+      (candidate) => candidate.outcome === "error" && candidate.operationFingerprint === step.operationFingerprint
     ).length;
-    const failure = failures.get(step.fingerprint);
+    const failure = failures.get(step.operationFingerprint);
     if (occurrences < 2 || failure === void 0) return NO_EFFECTS;
     const message = boundedReminder(
       `Memory: [${failure.entryId}] you already tried ${failure.callDescription} at step ${failure.firstStep} and it failed with ${failure.errorDigest}. Change the approach rather than repeating it.`,
       settings().maxTokens
     );
     if (message.length === 0) return NO_EFFECTS;
-    annotatedThisTurn.add(step.fingerprint);
-    lastInjectedFingerprint = step.fingerprint;
+    annotatedThisTurn.add(step.operationFingerprint);
+    lastInjectedOperationFingerprint = step.operationFingerprint;
     lastDecision = "injected";
     rulesInjectedSincePromptedStep = true;
     annotatedSinceTurnEnd = true;
@@ -1563,7 +1718,7 @@ function createMemoryInterventionRegistration(deps) {
     return [{ kind: "annotate_tool_result", message, severity: "warn" }];
   }
   function rememberFailure(step) {
-    const previous = failures.get(step.fingerprint);
+    const previous = failures.get(step.operationFingerprint);
     const attempts = (previous?.attempts ?? 0) + 1;
     const firstStep = previous?.firstStep ?? step.step;
     const content = proceduralContent(step.callDescription, attempts, firstStep, step.resultDigest);
@@ -1579,7 +1734,7 @@ function createMemoryInterventionRegistration(deps) {
     }
     setBounded(
       failures,
-      step.fingerprint,
+      step.operationFingerprint,
       {
         entryId,
         attempts,
@@ -1594,20 +1749,20 @@ function createMemoryInterventionRegistration(deps) {
     try {
       for (let index = trajectory.length - 1; index >= 0; index -= 1) {
         const step = trajectory[index];
-        if (step === void 0 || step.outcome !== "error" || step.step <= lastTurnEndStep || step.fingerprint === lastInjectedFingerprint) {
+        if (step === void 0 || step.outcome !== "error" || step.step <= lastTurnEndStep || step.operationFingerprint === lastInjectedOperationFingerprint) {
           continue;
         }
         const occurrences = trajectory.filter(
-          (candidate) => candidate.outcome === "error" && candidate.fingerprint === step.fingerprint
+          (candidate) => candidate.outcome === "error" && candidate.operationFingerprint === step.operationFingerprint
         ).length;
-        const failure = failures.get(step.fingerprint);
+        const failure = failures.get(step.operationFingerprint);
         if (occurrences < 2 || failure === void 0) continue;
         const message = boundedReminder(
           `Memory: [${failure.entryId}] you already tried ${failure.callDescription} at step ${failure.firstStep} and it failed with ${failure.errorDigest}.`,
           settings().maxTokens
         );
         if (message.length === 0) return NO_EFFECTS;
-        lastInjectedFingerprint = step.fingerprint;
+        lastInjectedOperationFingerprint = step.operationFingerprint;
         lastInjectedMessage = message;
         lastDecision = "injected";
         rulesInjectedSincePromptedStep = true;
@@ -1649,29 +1804,33 @@ function prepareToolStep(input) {
   const canonical = hashToolCall(toolName, input.toolArgs ?? {});
   return {
     toolName,
-    fingerprint: createHash2("sha256").update(canonical).digest("hex").slice(0, 16),
+    operationFingerprint: createHash2("sha256").update(canonical).digest("hex").slice(0, 16),
     callDescription: shortText(canonical, CALL_DESCRIPTION_MAX_CHARS)
   };
 }
-function pendingKey(input, fingerprint) {
-  return input.toolCallId ?? `anonymous:${fingerprint}`;
+function pendingKey(input, operationFingerprint) {
+  return input.toolCallId ?? `anonymous:${operationFingerprint}`;
 }
 function resultDigest(input, outcome) {
+  if (input.toolResultDigest !== void 0) return sanitizeToolResultDigest(input.toolResultDigest);
   if (outcome === "error") {
     const metadataMessage = input.metadata?.errorMessage;
     if (typeof metadataMessage === "string" && metadataMessage.trim().length > 0) {
-      return shortText(diagnosticLine(metadataMessage), RESULT_DIGEST_MAX_CHARS);
+      return legacyToolResultDigest(diagnosticLine(metadataMessage), { outcome });
     }
     for (const key of ["error", "message"]) {
       const value = input.toolResultDetails?.[key];
       if (typeof value === "string" && value.trim().length > 0) {
-        return shortText(diagnosticLine(value), RESULT_DIGEST_MAX_CHARS);
+        return legacyToolResultDigest(diagnosticLine(value), { outcome });
       }
     }
-    return "an unknown tool error";
+    return legacyToolResultDigest("", { outcome });
   }
   const resultFingerprint = input.metadata?.resultFingerprint;
-  return typeof resultFingerprint === "string" ? `ok result ${resultFingerprint.slice(0, 16)}` : "ok";
+  return legacyToolResultDigest(
+    typeof resultFingerprint === "string" ? `ok result ${resultFingerprint.slice(0, 16)}` : "ok",
+    { outcome }
+  );
 }
 var DIAGNOSTIC_HINT = /\b(error|failed|failure|cannot|unable|expected|refused|denied|missing|not found|timed out|timeout|fatal)\b/iu;
 function diagnosticLine(value) {
@@ -1713,7 +1872,7 @@ init_esm_shims();
 var SKILLS_REMINDER_REGISTRATION_ID = "observer.skills-reminder";
 function skillsReminderMessage(installed, installable = 0) {
   const counts = installable > 0 ? `${installed} installed, ${installable} installable from the marketplace` : `${installed} installed`;
-  return `[Skills] ${counts}. Start this task by listing them with context(scope="skills") and checking for a match; if one matches, open your reply with the line \`${SKILL_SUGGESTION_ANCHOR}\` (a comma-separated sequence, in order, when several compose) and wait for the operator; load only on operator request, and a marketplace skill is offered for install when the operator runs it. If none match, do not mention skills and continue with the task.`;
+  return `[Skills] ${counts}. Start this task by listing them with context(scope="skills") and checking for a match; if one matches, open your reply with the line \`${SKILL_SUGGESTION_ANCHOR}\` (a comma-separated sequence, in order, when several compose) and then continue the task in the same turn without the skill. Only the operator loads a skill, and a marketplace skill is offered for install when the operator runs it. If none match, do not mention skills and continue with the task.`;
 }
 var NO_EFFECTS2 = [];
 var GREETING_WORDS = /* @__PURE__ */ new Set([
@@ -1767,9 +1926,12 @@ function createSkillsReminderRegistration(deps) {
   let observedAnyTurn = false;
   return {
     id: SKILLS_REMINDER_REGISTRATION_ID,
-    description: "once per session, on the first substantive turn, teaches the skill-suggestion reply protocol",
-    hooks: ["turn_start"],
+    description: "once per session, on the first substantive turn, teaches the skill-suggestion reply protocol; keeps a turn going that stopped on the suggestion",
+    hooks: ["turn_start", "turn_end"],
     evaluate(input) {
+      if (input.hook === "turn_end") {
+        return isSkillSuggestionWait(input) ? [{ kind: "request_continuation", message: SKILL_SUGGESTION_WAIT_CONTINUATION_MESSAGE }] : NO_EFFECTS2;
+      }
       const sessionId = input.sessionId ?? null;
       if (lastSeenSessionId === void 0) {
         lastSeenSessionId = sessionId;
@@ -2092,4 +2254,4 @@ export {
   createMiddlewareToolChoiceControl,
   MiddlewareDomainModule
 };
-//# sourceMappingURL=chunk-2DJ2KNFG.js.map
+//# sourceMappingURL=chunk-ZXF4XRKW.js.map

package/dist/chunk-ZZMN5OM4.js

@@ -0,0 +1,122 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  EMPTY_WORKING_SET_VIEW,
+  callPathsByToolCallId,
+  offloadPathOf,
+  parseRefKey,
+  primaryPathOf,
+  refKey,
+  toolResultPayload,
+  toolResultText
+} from "./chunk-TZSKNMZG.js";
+import {
+  filterEntriesToActivePath
+} from "./chunk-W6GROXXM.js";
+import {
+  ceilChars
+} from "./chunk-GEYXPTRF.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/context/working-set/recall.ts
+init_esm_shims();
+function isThinkingEntry(entry) {
+  return entry.kind === "message" && entry.role === "assistant";
+}
+function isToolResultEntry(entry) {
+  return entry.kind === "message" && entry.role === "tool_result";
+}
+function resolveRecall(entries, view, ref, activeLeafTurnId) {
+  const parsed = parseRefKey(ref);
+  if (parsed === null) return { ok: false, error: { kind: "invalid_ref", ref } };
+  const key = refKey(parsed);
+  const active = filterEntriesToActivePath(entries, activeLeafTurnId);
+  const entry = active.find((candidate) => candidate.turnId === key);
+  if (entry === void 0) {
+    return { ok: false, error: { kind: "not_on_active_path", ref: key } };
+  }
+  if (isThinkingEntry(entry) || !view.evicted.has(key) || !isToolResultEntry(entry)) {
+    return { ok: false, error: { kind: "not_evicted", ref: key } };
+  }
+  const payload = toolResultPayload(entry.payload);
+  const body = toolResultText(payload.result);
+  const offloadPath = offloadPathOf(payload);
+  return {
+    ok: true,
+    result: {
+      ref: parsed,
+      entry,
+      body,
+      tokens: ceilChars(body.length),
+      ...offloadPath !== void 0 ? { offloadPath } : {}
+    }
+  };
+}
+function recallParentTurnId(entries, activeLeafTurnId) {
+  const active = filterEntriesToActivePath(entries, activeLeafTurnId);
+  for (let i = active.length - 1; i >= 0; i -= 1) {
+    const candidate = active[i];
+    if (candidate?.kind === "message") return candidate.turnId;
+  }
+  return null;
+}
+function buildRecallFields(result, meta) {
+  return {
+    kind: "contextRecall",
+    ref: { entry: result.ref.entry },
+    trigger: meta.trigger,
+    tokensReadmitted: result.tokens,
+    ...meta.toolCallId !== void 0 ? { toolCallId: meta.toolCallId } : {}
+  };
+}
+var MAX_LISTED_REFS = 8;
+function recallableRefListing(entries, view) {
+  const byTurnId = /* @__PURE__ */ new Map();
+  for (const entry of entries) byTurnId.set(entry.turnId, entry);
+  const callPaths = callPathsByToolCallId(entries);
+  const refs = [];
+  for (const key of view.evicted.keys()) {
+    const entry = byTurnId.get(key);
+    if (entry === void 0 || !isToolResultEntry(entry)) continue;
+    const payload = toolResultPayload(entry.payload);
+    const toolCallId = typeof payload.obj.toolCallId === "string" ? payload.obj.toolCallId : void 0;
+    const path = primaryPathOf(payload) ?? (toolCallId === void 0 ? void 0 : callPaths.get(toolCallId));
+    refs.push(`${key} (${payload.toolName}${path === void 0 ? "" : ` ${path}`})`);
+  }
+  return {
+    refs: refs.slice(0, MAX_LISTED_REFS),
+    remaining: Math.max(0, refs.length - MAX_LISTED_REFS)
+  };
+}
+function recallableRefMessage(entries, view) {
+  const listing = recallableRefListing(entries, view);
+  if (listing.refs.length === 0) return "No recallable refs on the active path.";
+  const more = listing.remaining > 0 ? `, and ${listing.remaining} more` : "";
+  return `Recallable refs on the active path: ${listing.refs.join(", ")}${more}.`;
+}
+function recallErrorMessage(error, entries = [], view = EMPTY_WORKING_SET_VIEW) {
+  const listing = ` ${recallableRefMessage(entries, view)}`;
+  switch (error.kind) {
+    case "invalid_ref":
+      return `recall ref must be a single turnId without whitespace; got '${error.ref}'.`;
+    case "not_on_active_path":
+      return `ref ${error.ref} is not on the active path of this session (unknown or on an abandoned branch).${listing}`;
+    case "not_evicted": {
+      const entry = entries.find((candidate) => candidate.turnId === error.ref);
+      if (entry !== void 0 && isThinkingEntry(entry)) {
+        return `ref ${error.ref} is an assistant turn; thinking is not recallable.${listing}`;
+      }
+      return `ref ${error.ref} is not evicted; its content is already in context.${listing}`;
+    }
+  }
+}
+
+export {
+  resolveRecall,
+  recallParentTurnId,
+  buildRecallFields,
+  recallableRefListing,
+  recallErrorMessage
+};
+//# sourceMappingURL=chunk-ZZMN5OM4.js.map