@iowarp/clio-coder 0.3.2 → 0.3.4

package/dist/{chunk-OHHN2SO4.js → chunk-VMNQ6OZA.js}

@@ -1,27 +1,27 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  BASH_HARD_CAP_BYTES,
-  HEADLESS_PERMISSION_DENIED_MARKER,
-  combineBashOutput,
-  runBashCommand
-} from "./chunk-MNA4JGU4.js";
+  HEADLESS_PERMISSION_DENIED_MARKER
+} from "./chunk-K7VKOLQQ.js";
 import {
   hashToolCall
 } from "./chunk-UOV2BYIW.js";
 import {
   describeDispatchPlan
-} from "./chunk-G2DE3C7R.js";
+} from "./chunk-EDRHSCIE.js";
 import {
   RESPONSE_SCHEMA_RUNTIME_ID,
   applyToolProfile,
+  bashTool,
   builtin,
-  createTaskBoardStore,
   networkToolsDisabled,
   readMaxBytes,
   readTool,
-  renderAgentLedger,
+  renderAgentLedger
+} from "./chunk-ZYKPLLNQ.js";
+import {
+  createTaskBoardStore,
   taskBoardCounts
-} from "./chunk-MQSRRFWA.js";
+} from "./chunk-WPQLXFOZ.js";
 import {
   DEFAULT_AUTONOMY_EXPOSURE,
   DEFAULT_AUTONOMY_LEVEL,
@@ -29,15 +29,17 @@ import {
   autonomyDenyRejection,
   formatModelRejection,
   mapAutonomy
-} from "./chunk-STBPMHSX.js";
+} from "./chunk-7RXG6QRZ.js";
+import {
+  classify
+} from "./chunk-AOCYTWAV.js";
 import {
   CLIO_ARTIFACT_DIR,
   artifactDefaultPath,
-  classify,
   detectValidationCommand,
   protectArtifact,
   protectedArtifactMutationBlockReason
-} from "./chunk-5UUP6MWO.js";
+} from "./chunk-MV3K5QF2.js";
 import {
   parseAgentLedgerBody
 } from "./chunk-CMZWFGD2.js";
@@ -47,7 +49,7 @@ import {
 import {
   gitTool,
   verifyToolSurface
-} from "./chunk-ARBGF5F7.js";
+} from "./chunk-NILBFAPG.js";
 import {
   codeNavToolSurface
 } from "./chunk-XN3L4EYL.js";
@@ -59,35 +61,35 @@ import {
   rgIgnoreArgs
 } from "./chunk-VG7TBQIY.js";
 import {
-  expandPath,
   resolveReadPath,
   resolveToCwd,
   toPosixPath
 } from "./chunk-OQE5J4C6.js";
 import {
   contextToolSurface
-} from "./chunk-OKGUZO2U.js";
+} from "./chunk-SPULKLCF.js";
 import {
   evaluateSkillToolSurface,
   skillActivationFromToolDetails
-} from "./chunk-T6YILFSB.js";
+} from "./chunk-BEY543CS.js";
 import {
-  DEFAULT_MAX_LINES,
-  GREP_MAX_LINE_LENGTH,
+  DEFAULT_TOOL_RESULT_MAX_BYTES,
   OBSERVATION_POLICY_SLACK_BYTES,
   OBSERVE_SELF_CAPS,
   commitObservationReservation,
   finalizeObservation,
-  formatSize,
+  isDispositionedToolResultError,
   observationBudgetExhausted,
   releaseObservation,
   reserveObservation,
   shapeToolResult,
-  truncateHead,
-  truncateLine,
-  truncateTail,
-  writeToolOffload
-} from "./chunk-VAKQQHWR.js";
+  toolResultContextText,
+  truncateHead
+} from "./chunk-5M54SPOL.js";
+import {
+  GREP_MAX_LINE_LENGTH,
+  truncateLine
+} from "./chunk-OZNBF4L3.js";
 import {
   truncateUtf8
 } from "./chunk-6XLNIQDB.js";
@@ -102,9 +104,8 @@ import {
   incompleteInstallationAdvice
 } from "./chunk-65DEGPJ6.js";
 import {
-  buildSafeToolEnv,
-  resolveSafeCwd
-} from "./chunk-SRF2PJNW.js";
+  buildSafeToolEnv
+} from "./chunk-VEZEGCGW.js";
 import {
   GUARDRAIL_DEFAULTS,
   isWorkerToolCallCapExceededReason,
@@ -123,7 +124,7 @@ import {
 } from "./chunk-BNAZZHFG.js";
 import {
   BusChannels
-} from "./chunk-OQ33BKR3.js";
+} from "./chunk-TTNYS3EA.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -1269,6 +1270,7 @@ function createRegistry(deps) {
   let approvalRequestCounter = 0;
   const approvalRequestToken = randomBytes(4).toString("hex");
   const runSpec = async (spec, call, decision, options) => {
+    let resultDisposition = spec.metadata?.resultDisposition;
     try {
       const beforeEffects = runToolHook("before_tool", spec, call, decision, options);
       const block = firstBlockToolEffect(beforeEffects);
@@ -1282,17 +1284,18 @@ function createRegistry(deps) {
       }
       try {
         const preparedArgs = prepareToolArgs(spec, call.args ?? {});
-        const result = shapeToolResult(spec, await spec.run(preparedArgs, options), options);
+        resultDisposition = resolveToolResultDisposition(spec, preparedArgs);
+        const result = await spec.run(preparedArgs, options);
         const afterEffects = runToolHook("after_tool", spec, call, decision, options, result);
-        const finalResult = shapeToolResult(spec, applyToolResultEffects(result, afterEffects), options);
+        const finalResult = shapeToolResult(spec, applyToolResultEffects(result, afterEffects), options, resultDisposition);
         return { kind: "ok", result: finalResult, decision };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        const result = shapeToolResult(spec, { kind: "error", message }, options);
+        const result = { kind: "error", message };
         const afterEffects = runToolHook("after_tool", spec, call, decision, options, result);
         return {
           kind: "ok",
-          result: shapeToolResult(spec, applyToolResultEffects(result, afterEffects), options),
+          result: shapeToolResult(spec, applyToolResultEffects(result, afterEffects), options, resultDisposition),
           decision
         };
       }
@@ -1609,6 +1612,23 @@ function prepareToolArgs(spec, args) {
     return args;
   }
 }
+function resolveToolResultDisposition(spec, args) {
+  const declared = spec.metadata?.resultDisposition;
+  if (!spec.resolveResultDisposition) return declared;
+  try {
+    return spec.resolveResultDisposition(args, declared);
+  } catch (error) {
+    const maxBytes = declared !== void 0 && declared.context.maxBytes !== void 0 ? declared.context.maxBytes : DEFAULT_TOOL_RESULT_MAX_BYTES;
+    return {
+      presentation: declared?.presentation ?? { foldDefault: "folded", showDiffWhenFolded: false, failureExcerpt: true },
+      context: { mode: "metadata-only", maxBytes },
+      // The narrowing is recorded with the result, so a resolver bug shows up
+      // on the transcript row and in the model's header instead of reading as
+      // a deliberate metadata-only request.
+      fallback: { reason: "resolver-error", message: error instanceof Error ? error.message : String(error) }
+    };
+  }
+}
 function disposeAdmissionArgs(spec, args) {
   try {
     spec?.disposeAdmissionArguments?.(args);
@@ -1780,12 +1800,14 @@ function applyToolResultEffects(result, effects) {
 
 ${annotations.join("\n")}`;
   if (result.kind === "ok") {
-    const annotated = { kind: "ok", output: `${result.output}${suffix}` };
-    if (result.details !== void 0) annotated.details = result.details;
-    if (result.terminate === true) annotated.terminate = true;
-    return annotated;
+    const annotated2 = { kind: "ok", output: `${result.output}${suffix}` };
+    if (result.details !== void 0) annotated2.details = result.details;
+    if (result.terminate === true) annotated2.terminate = true;
+    return annotated2;
   }
-  return { kind: "error", message: `${result.message}${suffix}` };
+  const annotated = { kind: "error", message: `${result.message}${suffix}` };
+  if (result.details !== void 0) annotated.details = result.details;
+  return annotated;
 }
 function annotationMessages(effects) {
   const messages = [];
@@ -1800,8 +1822,20 @@ function annotationMessages(effects) {
 // src/engine/agent.ts
 init_esm_shims();
 import { Agent } from "@earendil-works/pi-agent-core";
+function dispositionAwareAfterToolCall(delegate) {
+  return async (context, signal) => {
+    const override = await delegate?.(context, signal);
+    const effectiveResult = override?.details === void 0 ? context.result : { ...context.result, details: override.details };
+    if (isDispositionedToolResultError(effectiveResult)) return { ...override, isError: true };
+    return override;
+  };
+}
 function createEngineAgent(options = {}) {
-  const agent = new Agent({ streamFn: engineStreamSimple, ...options });
+  const agent = new Agent({
+    streamFn: engineStreamSimple,
+    ...options,
+    afterToolCall: dispositionAwareAfterToolCall(options.afterToolCall)
+  });
   return {
     agent,
     state: () => agent.state
@@ -1814,10 +1848,10 @@ import { performance as performance2 } from "node:perf_hooks";
 function projectToolResult(result) {
   const details = { ...result.details ?? {}, kind: result.kind };
   if (result.kind === "error") {
-    return { content: [{ type: "text", text: result.message }], details };
+    return { content: [{ type: "text", text: toolResultContextText(result) }], details };
   }
   return {
-    content: [{ type: "text", text: result.output }],
+    content: [{ type: "text", text: toolResultContextText(result) }],
     details,
     ...result.terminate === true ? { terminate: true } : {}
   };
@@ -1872,12 +1906,15 @@ async function runValidatedToolCall(input) {
       reason: verdict.result.message,
       decision: verdict.decision
     });
-    throw new Error(verdict.result.message);
+    if (input.returnDispositionedErrors === true && isDispositionedToolResultError(verdict.result)) {
+      return projectToolResult(verdict.result);
+    }
+    throw new Error(toolResultContextText(verdict.result));
   }
   const toolDetails = isRecord2(verdict.result.details) ? verdict.result.details : {};
   const skillActivation = spec.name === ToolNames.Context ? skillActivationFromToolDetails(toolDetails, input.invokeOptions?.turnId) : null;
   const result = {
-    content: [{ type: "text", text: verdict.result.output }],
+    content: [{ type: "text", text: toolResultContextText(verdict.result) }],
     details: { ...toolDetails, kind: "ok" }
   };
   if (verdict.result.terminate === true) {
@@ -1941,7 +1978,8 @@ function toAgentTool(spec, registry, telemetry, invokeOptions) {
       const callInput = {
         spec,
         args: params,
-        registry
+        registry,
+        returnDispositionedErrors: true
       };
       if (signal) callInput.signal = signal;
       if (telemetry) callInput.telemetry = telemetry;
@@ -2345,161 +2383,6 @@ function createArtifactTool(deps = {}) {
   };
 }
 
-// src/tools/bash.ts
-init_esm_shims();
-var BASH_DISPLAY_MAX_BYTES = 16 * 1024;
-var BASH_TAIL_NOTE_RESERVE = 512;
-function shapeBashProgress(rawOutput) {
-  const truncation = truncateTail(rawOutput, {
-    maxLines: DEFAULT_MAX_LINES,
-    maxBytes: BASH_DISPLAY_MAX_BYTES - BASH_TAIL_NOTE_RESERVE
-  });
-  const bytes = Buffer.byteLength(rawOutput, "utf8");
-  return {
-    kind: "ok",
-    output: truncation.content,
-    details: {
-      resultSize: {
-        bytes,
-        shownBytes: truncation.outputBytes,
-        maxBytes: BASH_DISPLAY_MAX_BYTES,
-        truncated: truncation.truncated,
-        policy: "tail"
-      }
-    }
-  };
-}
-function shapeBashOutput(rawOutput, context) {
-  const truncation = truncateTail(rawOutput, {
-    maxLines: DEFAULT_MAX_LINES,
-    maxBytes: BASH_DISPLAY_MAX_BYTES - BASH_TAIL_NOTE_RESERVE
-  });
-  if (!truncation.truncated) return { text: rawOutput };
-  const totalBytes = Buffer.byteLength(rawOutput, "utf8");
-  const offloadPath = writeToolOffload(rawOutput, context, BASH_HARD_CAP_BYTES);
-  const startLine = truncation.totalLines - truncation.outputLines + 1;
-  const scope = truncation.lastLinePartial ? `last ${formatSize(truncation.outputBytes)} of line ${truncation.totalLines} (line is large)` : `lines ${startLine}-${truncation.totalLines} of ${truncation.totalLines}`;
-  const location = offloadPath !== null ? ` Full output saved to ${offloadPath}; read it with offset/limit.` : "";
-  const note = `[Output tail-truncated: showing ${scope} (${formatSize(BASH_DISPLAY_MAX_BYTES)} display limit).${location}]`;
-  const details = {
-    resultSize: {
-      bytes: totalBytes,
-      shownBytes: truncation.outputBytes,
-      maxBytes: BASH_DISPLAY_MAX_BYTES,
-      truncated: true,
-      policy: "tail",
-      followUpHint: "Read the full-output offload file with offset/limit, or re-run a narrower command.",
-      ...offloadPath !== null ? { offloadPath } : {}
-    }
-  };
-  return { text: `${truncation.content}
-
-${note}`, details };
-}
-function withDetails(base, details) {
-  if (details === void 0) return base;
-  if (base.kind === "ok") return { ...base, details };
-  return { ...base, details };
-}
-var OBSERVE_COMMAND_PATTERN = /^\s*(?:cat|head|tail|ls|grep|rg|find)\b/;
-var OBSERVE_NUDGE_SESSION_LIMIT = 64;
-var observeNudgeSeenSessions = /* @__PURE__ */ new Set();
-function observeToolsNudge(command, sessionId) {
-  if (!OBSERVE_COMMAND_PATTERN.test(command)) return "";
-  const key = sessionId ?? "no-session";
-  if (observeNudgeSeenSessions.has(key)) return "";
-  if (observeNudgeSeenSessions.size >= OBSERVE_NUDGE_SESSION_LIMIT) {
-    const oldest = observeNudgeSeenSessions.values().next().value;
-    if (oldest !== void 0) observeNudgeSeenSessions.delete(oldest);
-  }
-  observeNudgeSeenSessions.add(key);
-  return "\n\n[note: prefer the structured observe tools over shell file inspection: read pages files with offset/limit, ls lists directories, grep and find search, code_nav maps symbols. Their results are capped and continuable; keep bash for builds, git, and scripts.]";
-}
-var bashTool = {
-  name: ToolNames.Bash,
-  description: "Execute a bash command and return stdout and stderr. Runs inside the session workspace. Default timeout 300000 ms.",
-  parameters: typebox_exports.Object({
-    command: typebox_exports.String({ description: "Bash command to execute." }),
-    cwd: typebox_exports.Optional(
-      typebox_exports.String({
-        description: "Omit this. The command already runs at the session workspace root. Set it only to run in a subdirectory of that root, as a relative path; an absolute path outside the root is blocked."
-      })
-    ),
-    timeout_ms: typebox_exports.Optional(typebox_exports.Number({ description: "Timeout in milliseconds." }))
-  }),
-  baseActionClass: "execute",
-  executionMode: "sequential",
-  async run(args, options) {
-    if (typeof args.command !== "string" || args.command.length === 0) {
-      return { kind: "error", message: "bash: missing command argument" };
-    }
-    const cwdArg = typeof args.cwd === "string" && args.cwd.length > 0 ? args.cwd : void 0;
-    let cwd;
-    try {
-      cwd = resolveSafeCwd(cwdArg === void 0 ? void 0 : expandPath(cwdArg), process.cwd());
-    } catch {
-      return {
-        kind: "error",
-        message: `bash: cwd '${cwdArg}' escapes workspace root '${process.cwd()}'; use a typed tool or a project policy entry with explicit cwd`
-      };
-    }
-    const timeout = typeof args.timeout_ms === "number" && args.timeout_ms > 0 ? args.timeout_ms : 3e5;
-    try {
-      const runOptions = {
-        cwd,
-        timeoutMs: timeout,
-        ...options?.signal === void 0 ? {} : { signal: options.signal }
-      };
-      if (options?.onUpdate !== void 0) {
-        runOptions.onUpdate = (progress) => {
-          options.onUpdate?.(shapeBashProgress(combineBashOutput(progress)));
-        };
-      }
-      const result = await runBashCommand(args.command, runOptions);
-      const { error, aborted, timedOut, outputCapped } = result;
-      if (aborted) {
-        return { kind: "error", message: "bash: command aborted" };
-      }
-      const shaped = shapeBashOutput(combineBashOutput(result), options);
-      const output = shaped.text.trim();
-      if (timedOut) {
-        const status = `bash: command timed out after ${timeout}ms`;
-        return withDetails(
-          { kind: "error", message: output.length > 0 ? `${output}
-
-${status}` : status },
-          shaped.details
-        );
-      }
-      if (outputCapped) {
-        const status = `bash: command output exceeded ${BASH_HARD_CAP_BYTES} bytes and was stopped`;
-        return withDetails(
-          { kind: "error", message: output.length > 0 ? `${output}
-
-${status}` : status },
-          shaped.details
-        );
-      }
-      if (error) {
-        const code = typeof error.code === "number" ? error.code : error.code;
-        const status = `bash: command failed (exit ${code ?? "?"})`;
-        const message = output.length > 0 ? `${output}
-
-${status}` : `${status}: ${error.message}`;
-        return withDetails({ kind: "error", message }, shaped.details);
-      }
-      const body = shaped.text.length > 0 ? shaped.text : "(no output)";
-      return withDetails(
-        { kind: "ok", output: `${body}${observeToolsNudge(args.command, options?.sessionId)}` },
-        shaped.details
-      );
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { kind: "error", message: `bash: ${msg}` };
-    }
-  }
-};
-
 // src/tools/credential-present.ts
 init_esm_shims();
 import { createReadStream } from "node:fs";
@@ -5019,13 +4902,13 @@ function registerCoreTools(registry, deps = {}) {
   });
   registry.register({
     ...builtin(
-      lazyTool(verifyToolSurface, async () => (await import("./verify-G6V4D2G7.js")).verifyTool),
+      lazyTool(verifyToolSurface, async () => (await import("./verify-X5HDROLA.js")).verifyTool),
       { path: "src/tools/verify/index.ts", scope: "core" }
     )
   });
   registry.register({
     ...builtin(
-      lazyTool(codeNavToolSurface, async () => (await import("./code-nav-7AX6FYE6.js")).codeNavTool),
+      lazyTool(codeNavToolSurface, async () => (await import("./code-nav-AXCXSBHX.js")).codeNavTool),
       { path: "src/tools/codewiki/code-nav.ts", scope: "core" }
     )
   });
@@ -5046,14 +4929,27 @@ function registerCoreTools(registry, deps = {}) {
     ...builtin(credentialPresentTool, { path: "src/tools/credential-present.ts", scope: "core" })
   });
   const session = deps.session;
+  const readSessionEntries = deps.readSessionEntries;
   registry.register({
     ...builtin(
       lazyTool(contextToolSurface, async () => {
-        const { createContextTool } = await import("./context-5VKGUVJJ.js");
+        const { createContextTool } = await import("./context-EKDCKUUZ.js");
         if (!session) return createContextTool(skillToolDeps);
         const { probeWorkspace } = await import("./workspace-G4ZWUIPR.js");
         return createContextTool({
           ...skillToolDeps,
+          ...readSessionEntries ? {
+            session: {
+              hasSession: () => session.current() !== null,
+              readEntries: readSessionEntries,
+              activeLeafTurnId: () => {
+                const meta = session.current();
+                return meta ? session.tree(meta.id).leafId ?? void 0 : void 0;
+              },
+              appendEntry: (entry) => session.appendEntry(entry),
+              ...deps.onContextRecalled ? { onRecalled: deps.onContextRecalled } : {}
+            }
+          } : {},
           workspace: {
             hasSession: () => session.current() !== null,
             getSnapshot: () => session.current()?.workspace ?? null,
@@ -5132,4 +5028,4 @@ export {
   assertRegisteredBuiltinTools,
   createRegistry
 };
-//# sourceMappingURL=chunk-OHHN2SO4.js.map
+//# sourceMappingURL=chunk-VMNQ6OZA.js.map

package/dist/chunk-VSNATDE6.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-BPGS2WCQ.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-VSNATDE6.js.map

package/dist/chunk-W6GROXXM.js

@@ -0,0 +1,69 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/session/tree/active-path.ts
+init_esm_shims();
+function filterEntriesToActivePath(entries, leafTurnId) {
+  const messages = [];
+  const messagesById = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.kind !== "message") continue;
+    messages.push(entry);
+    messagesById.set(entry.turnId, entry);
+  }
+  const latest = messages[messages.length - 1];
+  const pinnedLeaf = resolveLeafMessage(entries, messagesById, leafTurnId);
+  if (!hasBranch(messages) && (pinnedLeaf === void 0 || pinnedLeaf.turnId === latest?.turnId)) return [...entries];
+  const leaf = pinnedLeaf ?? latest;
+  if (!leaf) return [...entries];
+  const pathIds = /* @__PURE__ */ new Set();
+  let current = leaf;
+  while (current && !pathIds.has(current.turnId)) {
+    pathIds.add(current.turnId);
+    if (current.parentTurnId === null) break;
+    current = messagesById.get(current.parentTurnId);
+  }
+  const leafIndex = entries.findIndex((entry) => entry.kind === "message" && entry.turnId === leaf.turnId);
+  return entries.filter((entry, index) => entryBelongsToPath(entry, pathIds, leafIndex >= 0 && index <= leafIndex));
+}
+function resolveLeafMessage(entries, messagesById, leafTurnId) {
+  if (leafTurnId === void 0) return void 0;
+  const direct = messagesById.get(leafTurnId);
+  if (direct) return direct;
+  const sidecar = entries.find((entry) => entry.turnId === leafTurnId);
+  if (!sidecar) return void 0;
+  const anchor = sidecarAnchorTurnId(sidecar);
+  return anchor === null ? void 0 : messagesById.get(anchor);
+}
+function sidecarAnchorTurnId(entry) {
+  if (entry.kind === "label") return entry.targetTurnId;
+  if (entry.kind === "sessionInfo") return entry.targetTurnId ?? entry.parentTurnId;
+  if (entry.kind === "compactionSummary" && entry.firstKeptTurnId.length > 0) return entry.firstKeptTurnId;
+  return entry.parentTurnId;
+}
+function hasBranch(messages) {
+  const seenParents = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    if (message.parentTurnId === null) continue;
+    if (seenParents.has(message.parentTurnId)) return true;
+    seenParents.add(message.parentTurnId);
+  }
+  return false;
+}
+function entryBelongsToPath(entry, pathIds, atOrBeforeLeaf) {
+  if (entry.kind === "message") return pathIds.has(entry.turnId);
+  if (entry.kind === "label") return pathIds.has(entry.targetTurnId);
+  if (entry.kind === "sessionInfo") return entry.targetTurnId === void 0 || pathIds.has(entry.targetTurnId);
+  if (entry.kind === "compactionSummary" && entry.firstKeptTurnId.length > 0 && pathIds.has(entry.firstKeptTurnId)) {
+    return true;
+  }
+  return entry.parentTurnId === null ? atOrBeforeLeaf : pathIds.has(entry.parentTurnId);
+}
+
+export {
+  filterEntriesToActivePath,
+  entryBelongsToPath
+};
+//# sourceMappingURL=chunk-W6GROXXM.js.map