@iowarp/clio-coder 0.3.3 → 0.3.4

package/dist/{chunk-COU2UHX6.js → chunk-VEZEGCGW.js}

@@ -1,4 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  clampTimerDelayMs
+} from "./chunk-FQ4SKYE4.js";
 import {
   clioStateDir
 } from "./chunk-BNAZZHFG.js";
@@ -390,11 +393,176 @@ function withManagedGitCommitAttributionEnvironment(source, options = {}) {
   return { env, diagnostic: null };
 }
 
+// src/core/safe-exec.ts
+init_esm_shims();
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+var SAFE_EXEC_DEFAULT_TIMEOUT_MS = 12e4;
+var SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES = 6e5;
+var ENV_ALLOWLIST = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "LANG",
+  "LC_ALL",
+  "TMPDIR",
+  "TEMP",
+  "TMP",
+  "CI",
+  "NO_COLOR"
+];
+function buildSafeToolEnv(extra = {}) {
+  const env = {};
+  for (const key of ENV_ALLOWLIST) {
+    const value = process.env[key];
+    if (value !== void 0) env[key] = value;
+  }
+  for (const [key, value] of Object.entries(extra)) {
+    if (!/^[A-Z_][A-Z0-9_]*$/i.test(key)) continue;
+    env[key] = value;
+  }
+  env.AI_AGENT = AI_AGENT_NAME;
+  return env;
+}
+function resolveSafeCwd(cwd, workspaceRoot = process.cwd()) {
+  const root = path.resolve(workspaceRoot);
+  const resolved = cwd === void 0 ? root : path.isAbsolute(cwd) ? path.resolve(cwd) : path.resolve(root, cwd);
+  const rel = path.relative(root, resolved);
+  if (rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel)) return resolved;
+  throw new Error(`cwd escapes workspace root: ${resolved}`);
+}
+function runCommandVector(file, args, options = {}) {
+  return new Promise((resolve2) => {
+    const startedAt = performance.now();
+    const cwd = resolveSafeCwd(options.cwd, options.workspaceRoot);
+    const timeoutMs = clampTimerDelayMs(options.timeoutMs ?? SAFE_EXEC_DEFAULT_TIMEOUT_MS);
+    const maxOutputBytes = options.maxOutputBytes ?? SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES;
+    const attribution = withManagedGitCommitAttributionEnvironment(buildSafeToolEnv(options.env), {
+      cwd,
+      enabled: gitCommitAttributionEnabled(process.env)
+    });
+    reportCommitAttributionDiagnostic(attribution.diagnostic);
+    let aborted = false;
+    let timedOut = false;
+    let outputCapped = false;
+    let outputBytes = 0;
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let killSent = false;
+    let timeoutId = null;
+    let killGraceTimer = null;
+    const child = spawn(file, [...args], {
+      cwd,
+      env: attribution.env,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const clearKillGraceTimer = () => {
+      if (killGraceTimer) clearTimeout(killGraceTimer);
+      killGraceTimer = null;
+    };
+    const sendSignal = (signalName) => {
+      const pid = child.pid;
+      if (pid && process.platform !== "win32") {
+        try {
+          process.kill(-pid, signalName);
+          return;
+        } catch {
+        }
+      }
+      child.kill(signalName);
+    };
+    const killChild = () => {
+      if (killSent) return;
+      killSent = true;
+      sendSignal("SIGTERM");
+      killGraceTimer = setTimeout(() => sendSignal("SIGKILL"), 3e3);
+    };
+    const onAbort = () => {
+      aborted = true;
+      killChild();
+    };
+    if (timeoutMs > 0) {
+      timeoutId = setTimeout(() => {
+        timedOut = true;
+        killChild();
+      }, timeoutMs);
+    }
+    if (options.signal?.aborted) onAbort();
+    else options.signal?.addEventListener("abort", onAbort, { once: true });
+    const appendChunk = (target, chunk) => {
+      outputBytes += chunk.byteLength;
+      if (outputBytes > maxOutputBytes) {
+        outputCapped = true;
+        killChild();
+        return;
+      }
+      if (target === "stdout") stdout += chunk.toString("utf8");
+      else stderr += chunk.toString("utf8");
+    };
+    child.stdout?.on("data", (chunk) => appendChunk("stdout", chunk));
+    child.stderr?.on("data", (chunk) => appendChunk("stderr", chunk));
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      clearKillGraceTimer();
+      options.signal?.removeEventListener("abort", onAbort);
+      resolve2({
+        file,
+        args: [...args],
+        cwd,
+        stdout,
+        stderr: stderr.length > 0 ? stderr : error.message,
+        exitCode: null,
+        signal: null,
+        aborted,
+        timedOut,
+        outputCapped,
+        durationMs: Math.round(performance.now() - startedAt)
+      });
+    });
+    child.on("close", (code, signalName) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      clearKillGraceTimer();
+      options.signal?.removeEventListener("abort", onAbort);
+      resolve2({
+        file,
+        args: [...args],
+        cwd,
+        stdout,
+        stderr,
+        exitCode: code,
+        signal: signalName,
+        aborted,
+        timedOut,
+        outputCapped,
+        durationMs: Math.round(performance.now() - startedAt)
+      });
+    });
+  });
+}
+function combineSafeOutput(result) {
+  const { stdout, stderr } = result;
+  return stderr.length > 0 ? `${stdout}${stdout.endsWith("\n") || stdout.length === 0 ? "" : "\n"}${stderr}` : stdout;
+}
+
 export {
   attributeCommitMessage,
   reportCommitAttributionDiagnostic,
   setGitCommitAttributionEnabled,
   gitCommitAttributionEnabled,
-  withManagedGitCommitAttributionEnvironment
+  withManagedGitCommitAttributionEnvironment,
+  SAFE_EXEC_DEFAULT_TIMEOUT_MS,
+  SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES,
+  buildSafeToolEnv,
+  resolveSafeCwd,
+  runCommandVector,
+  combineSafeOutput
 };
-//# sourceMappingURL=chunk-COU2UHX6.js.map
+//# sourceMappingURL=chunk-VEZEGCGW.js.map

package/dist/{chunk-LW6DSM3M.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-J7CWMCQD.js";
+  HEADLESS_PERMISSION_DENIED_MARKER
+} from "./chunk-K7VKOLQQ.js";
 import {
   hashToolCall
 } from "./chunk-UOV2BYIW.js";
 import {
   describeDispatchPlan
-} from "./chunk-DUYJ5IO6.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-LWLEKMDQ.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-TZK7PACC.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-VPAYEGVX.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-375KUB3Y.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-LW6DSM3M.js.map
+//# sourceMappingURL=chunk-VMNQ6OZA.js.map