@spinalfluid/ultrac 0.1.5 → 0.1.9

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 import { Command } from "commander";
 
 // src/commands/ask.ts
@@ -154,10 +154,10 @@ function readEnvBaseUrl() {
 }
 function resolveBaseUrl(stored) {
   if (baseUrlFlag) return { baseUrl: baseUrlFlag, source: "flag" };
-  const env = readEnvBaseUrl();
-  if (env) {
-    assertAllowedUltracBaseUrl(env);
-    return { baseUrl: env, source: "env" };
+  const env2 = readEnvBaseUrl();
+  if (env2) {
+    assertAllowedUltracBaseUrl(env2);
+    return { baseUrl: env2, source: "env" };
   }
   if (stored?.baseUrl) {
     const safe = safeStoredBaseUrl(stored.baseUrl, ULTRAC_DEFAULT_BASE_URL);
@@ -242,42 +242,51 @@ import { z as z5 } from "zod";
 
 // src/core/modes.ts
 var agentModeNames = ["default", "plan", "security", "coding", "review"];
-var sharedAgentTools = ["task", "skill", "memory_read", "ask_user"];
-var readOnlyCoreTools = [
+var sharedAgentTools = [
+  "task",
+  "skill",
+  "list_skills",
+  "memory_read",
+  "ask_user"
+];
+var sharedWriteMemory = ["memory_write"];
+var readExploreTools = [
   "list_files",
   "read_file",
+  "read_many_files",
   "search_files",
+  "inspect_project",
+  "repo_map",
+  "git_status",
+  "git_worktree_summary",
   "git_diff",
-  "git_log",
-  ...sharedAgentTools
+  "git_log"
 ];
+var readOnlyCoreTools = [...readExploreTools, ...sharedAgentTools];
 var coreTools = [
-  "list_files",
-  "read_file",
-  "search_files",
+  ...readExploreTools,
   "run_shell",
   "write_file",
   "replace_in_file",
   "multi_edit",
   "apply_patch",
-  "git_status",
-  "git_diff",
+  "git_commit",
+  "fetch_url",
   "todo_write",
   "todo_read",
-  ...sharedAgentTools
+  ...sharedAgentTools,
+  ...sharedWriteMemory
 ];
 var agentModePresets = {
   default: {
     name: "default",
     label: "Default",
     instructions: [
-      "Gather repository context before acting.",
+      "Gather repository context with tools before acting; the startup header is not the repository.",
       "Prefer narrow, reversible changes.",
       "Keep final answers concise and include verification status."
     ],
-    // The compact core, nothing else: the default mode does not know yet which
-    // way the task will go, so it pays only for what every task needs.
-    tools: coreTools,
+    tools: [...coreTools, "list_sessions", "read_session", "search_sessions"],
     externalTools: true
   },
   plan: {
@@ -288,10 +297,7 @@ var agentModePresets = {
       "Use read and search tools to build an accurate picture, then use todo_write to lay out the concrete steps.",
       "Finish by presenting the plan and the files it will touch, and wait for approval before switching to an editing mode."
     ],
-    // Read-only, plus the two things planning is: a map of the repository and a
-    // written list of steps. No editor, no shell - the mode promises not to
-    // change anything, and the advertised set says the same.
-    tools: [...readOnlyCoreTools, "repo_map", "todo_write", "todo_read"],
+    tools: [...readOnlyCoreTools, "repo_handbook", "verification_plan", "todo_write", "todo_read"],
     externalTools: false
   },
   security: {
@@ -304,14 +310,8 @@ var agentModePresets = {
       "Use fetch_url only against hosts the user named. It is an HTTP client, not a scanner.",
       "Separate confirmed findings from hypotheses and call out missing authorization or scope."
     ],
-    // Core plus local evidence collection and the HTTP client. Editors stay so
-    // a finding can become a patch in the same pass. list_processes is
-    // callable by name under shell; it is not advertised here because a
-    // security review of a checkout rarely needs the host process table.
     tools: [
       ...coreTools,
-      "fetch_url",
-      "inspect_project",
       "inspect_artifact",
       "hex_dump",
       "extract_strings",
@@ -329,10 +329,20 @@ var agentModePresets = {
       "Make the smallest coherent patch that satisfies the task.",
       "Run the most relevant verification when shell permission is available; otherwise say what was not run."
     ],
-    // Core plus the verification loop - tests, type/lint diagnostics, package
-    // scripts - and structural search, which is what makes an edit land in the
-    // right place across a large codebase.
-    tools: [...coreTools, "run_tests", "diagnostics", "run_package_script", "ast_search"],
+    tools: [
+      ...coreTools,
+      "ast_search",
+      "repo_handbook",
+      "verification_plan",
+      "git_show",
+      "git_push",
+      "run_tests",
+      "diagnostics",
+      "run_package_script",
+      "list_sessions",
+      "read_session",
+      "search_sessions"
+    ],
     externalTools: true
   },
   review: {
@@ -343,10 +353,14 @@ var agentModePresets = {
       "Lead with findings grounded in concrete file paths, lines, commands, or behavior.",
       "Avoid broad rewrites unless the user explicitly asks for an implementation pass."
     ],
-    // Read-only: a review reads the diff and its history, checks what the
-    // compiler and linter say, and writes its verdict through the verification
-    // tools. Nothing here edits the tree.
-    tools: [...readOnlyCoreTools, "diagnostics", "verification_plan", "verification_report"],
+    tools: [
+      ...readOnlyCoreTools,
+      "git_show",
+      "git_blame",
+      "diagnostics",
+      "verification_plan",
+      "verification_report"
+    ],
     externalTools: false
   }
 };
@@ -534,6 +548,9 @@ function ensurePrivateDirectory(path) {
   }
   chmodSync(path, 448);
 }
+function currentDiagnosticLogPath() {
+  return diagnosticPath;
+}
 function diagnosticEvent(event, fields = {}) {
   if (!diagnosticPath) return;
   const record3 = {
@@ -878,20 +895,32 @@ function contextUsageStatus(messages, usage, disposition) {
     ...disposition.error ? { error: disposition.error } : {}
   };
 }
+function contextOverflowMessage(usage, freedChars, safeWindowChars, pinned) {
+  const numbers = `system ${count(usage.systemChars)} + tools ${count(usage.toolsChars)} + history ${count(
+    usage.historyChars
+  )} = ${count(usage.totalChars)} characters against a ${count(usage.windowChars)}-character window (${count(
+    usage.contextTokens
+  )} tokens at ${CHARS_PER_TOKEN} chars/token)` + (safeWindowChars < usage.windowChars ? ` with a ${count(safeWindowChars)}-character safe wire ceiling` : "") + `${freedChars > 0 ? `, after dropping ${count(freedChars)} characters of earlier turns` : ""}`;
+  if (pinned) {
+    return `Pinned user instructions cannot fit the model's context window and will not be discarded: ${numbers}. Shorten the prompt, advertise fewer tools (--tools, or a narrower --mode), or raise --context-tokens / ULTRAC_MODEL_CONTEXT_TOKENS if the host window really is larger.`;
+  }
+  return `Request does not fit the model's context window: ${numbers}. Advertise fewer tools (--tools, or a narrower --mode), shorten the prompt, or raise --context-tokens / ULTRAC_MODEL_CONTEXT_TOKENS if the host window really is larger.`;
+}
 var ContextBudgetError = class extends Error {
   usage;
   constructor(usage, freedChars, safeWindowChars = usage.windowChars) {
-    super(
-      `Request does not fit the model's context window: system ${count(usage.systemChars)} + tools ${count(
-        usage.toolsChars
-      )} + history ${count(usage.historyChars)} = ${count(usage.totalChars)} characters against a ${count(
-        usage.windowChars
-      )}-character window (${count(usage.contextTokens)} tokens at ${CHARS_PER_TOKEN} chars/token)` + (safeWindowChars < usage.windowChars ? ` with a ${count(safeWindowChars)}-character safe wire ceiling` : "") + `${freedChars > 0 ? `, after dropping ${count(freedChars)} characters of earlier turns` : ""}. Advertise fewer tools (--tools, or a narrower --mode), shorten the prompt, or raise --context-tokens / ULTRAC_MODEL_CONTEXT_TOKENS if the host window really is larger.`
-    );
+    super(contextOverflowMessage(usage, freedChars, safeWindowChars, false));
     this.name = "ContextBudgetError";
     this.usage = usage;
   }
 };
+var PinnedContextBudgetError = class extends ContextBudgetError {
+  constructor(usage, freedChars, safeWindowChars = usage.windowChars) {
+    super(usage, freedChars, safeWindowChars);
+    this.name = "PinnedContextBudgetError";
+    this.message = contextOverflowMessage(usage, freedChars, safeWindowChars, true);
+  }
+};
 function planToolCallRequest(input) {
   return planRequest({
     units: groupNativeMessages(input.messages, input.isPinned),
@@ -964,6 +993,10 @@ function planRequest(input) {
   const usage = summarize(kept, input.toolsChars, window);
   const safeWindowChars = Math.floor(usage.windowChars * HARD_WINDOW_SAFETY_FRACTION);
   if (usage.totalChars > safeWindowChars) {
+    const droppableLeft = kept.some((unit) => !unit.pinned && !unit.system);
+    if (!droppableLeft && kept.some((unit) => unit.pinned && !unit.system)) {
+      throw new PinnedContextBudgetError(usage, freedChars, safeWindowChars);
+    }
     throw new ContextBudgetError(usage, freedChars, safeWindowChars);
   }
   return {
@@ -3769,12 +3802,17 @@ import { z as z6 } from "zod";
 
 // src/core/ask-runtime.ts
 var askUserRuntime;
-function setAskUserRuntime(fn) {
+var askUserRuntimeRemote = false;
+function setAskUserRuntime(fn, options = {}) {
   askUserRuntime = fn;
+  askUserRuntimeRemote = fn !== void 0 && options.remote === true;
 }
 function getAskUserRuntime() {
   return askUserRuntime;
 }
+function isAskUserRuntimeRemote() {
+  return askUserRuntimeRemote;
+}
 
 // src/tools/workspace/ask-user.ts
 var AskUserInput = z6.object({
@@ -3796,7 +3834,7 @@ var askUserTool = {
   async execute(input, context) {
     const ask2 = getAskUserRuntime();
     if (!ask2) return { ok: false, content: NO_ONE_TO_ASK };
-    if (!stdin.isTTY) return { ok: false, content: NO_ONE_TO_ASK };
+    if (!isAskUserRuntimeRemote() && !stdin.isTTY) return { ok: false, content: NO_ONE_TO_ASK };
     const answer = await ask2(input.question, input.options, context.signal);
     if (context.signal?.aborted) {
       return { ok: false, content: "Question cancelled; no answer was recorded." };
@@ -3927,17 +3965,17 @@ var SENSITIVE_ENV_PATTERNS = [
   /(?:^|_)WEBHOOK_SECRET$/
 ];
 function createSanitizedProcessEnv(source = process.env) {
-  const env = {};
+  const env2 = {};
   const redactedEnvKeys = [];
   for (const [key, value] of Object.entries(source)) {
     if (isSensitiveEnvName(key)) {
       redactedEnvKeys.push(key);
       continue;
     }
-    env[key] = value;
+    env2[key] = value;
   }
   redactedEnvKeys.sort();
-  return { env, redactedEnvKeys };
+  return { env: env2, redactedEnvKeys };
 }
 function isSensitiveEnvName(name) {
   const normalized = name.toUpperCase();
@@ -4026,12 +4064,12 @@ function runProcess(command, args, options) {
       redactedEnvKeys: []
     });
   }
-  const { env, redactedEnvKeys } = createSanitizedProcessEnv();
+  const { env: env2, redactedEnvKeys } = createSanitizedProcessEnv();
   return new Promise((resolve15, reject) => {
     const child = spawn(command, args, {
       cwd: options.cwd,
       stdio: ["pipe", "pipe", "pipe"],
-      env,
+      env: env2,
       shell: options.shell ?? false,
       // Its own process group, so the timeout can kill what the child started
       // as well as the child. Killing only the direct child leaves the grand-
@@ -5116,7 +5154,7 @@ function defaultContextFiles(files) {
 }
 function isPriorityContextFile(path) {
   const normalized = path.toLowerCase();
-  const basename3 = normalized.split("/").at(-1) ?? normalized;
+  const basename4 = normalized.split("/").at(-1) ?? normalized;
   return [
     "agents.md",
     "claude.md",
@@ -5126,12 +5164,12 @@ function isPriorityContextFile(path) {
     "pyproject.toml",
     "readme.md",
     "tsconfig.json"
-  ].includes(basename3) || normalized === "docs/architecture.md" || normalized === "docs/roadmap.md";
+  ].includes(basename4) || normalized === "docs/architecture.md" || normalized === "docs/roadmap.md";
 }
 function isLikelyEntrypoint(path) {
   const normalized = path.toLowerCase();
-  const basename3 = normalized.split("/").at(-1) ?? normalized;
-  return basename3 === "main.ts" || basename3 === "main.tsx" || basename3 === "cli.ts" || basename3 === "index.ts" || basename3 === "app.ts" || basename3.startsWith("next.config.") || basename3.startsWith("vite.config.") || normalized === "src/app/page.tsx" || normalized === "src/app/layout.tsx";
+  const basename4 = normalized.split("/").at(-1) ?? normalized;
+  return basename4 === "main.ts" || basename4 === "main.tsx" || basename4 === "cli.ts" || basename4 === "index.ts" || basename4 === "app.ts" || basename4.startsWith("next.config.") || basename4.startsWith("vite.config.") || normalized === "src/app/page.tsx" || normalized === "src/app/layout.tsx";
 }
 function summarizeRepository(files) {
   return {
@@ -7137,8 +7175,8 @@ var scanSecretsTool = {
       }
       scannedFiles += 1;
       const text = bytes.toString("utf8");
-      const basename3 = file.split("/").pop() ?? file;
-      const skipEntropy = lockfileNames.has(basename3);
+      const basename4 = file.split("/").pop() ?? file;
+      const skipEntropy = lockfileNames.has(basename4);
       collectLineFindings(file, text, rules, skipEntropy, findings, input.maxFindings);
     }
     const visible = findings.slice(0, input.maxFindings);
@@ -7166,7 +7204,7 @@ function compileCustomRules(rules) {
 }
 function collectLineFindings(path, text, rules, skipLockfileRules, findings, maxFindings) {
   const lines = text.split(/\r?\n/);
-  const basename3 = path.split("/").pop() ?? path;
+  const basename4 = path.split("/").pop() ?? path;
   for (const [index, line] of lines.entries()) {
     if (findings.length >= maxFindings) return;
     if (line.length > 4e3) continue;
@@ -7183,7 +7221,7 @@ function collectLineFindings(path, text, rules, skipLockfileRules, findings, max
         snippet: redactSecret(match[0])
       });
     }
-    if (skipLockfileRules || lockfileNames.has(basename3) || findings.length >= maxFindings) continue;
+    if (skipLockfileRules || lockfileNames.has(basename4) || findings.length >= maxFindings) continue;
     collectEntropyFinding(path, index + 1, line, findings);
   }
 }
@@ -8005,7 +8043,9 @@ async function createSkill(workspace, input) {
       name,
       description: input.description.trim(),
       ...input.whenToUse ? { when_to_use: input.whenToUse.trim() } : {},
-      ...permissions.length ? { permissions } : {}
+      ...permissions.length ? { permissions } : {},
+      ...input.command ? { command: input.command } : {},
+      ...input.argumentHint ? { "argument-hint": input.argumentHint } : {}
     },
     input.body?.trim() || `# ${name}
 
@@ -8022,7 +8062,8 @@ Describe the steps the agent should follow when this skill is invoked.`
     whenToUse: input.whenToUse?.trim(),
     permissions,
     body: document,
-    path
+    path,
+    ...input.command ? { command: { raw: input.command, argumentHint: input.argumentHint } } : {}
   };
 }
 async function loadSkillsContext(workspace) {
@@ -8542,7 +8583,7 @@ function summarizeExtensions(files) {
 }
 function isImportantFile(path) {
   const normalized = path.toLowerCase();
-  const basename3 = normalized.split("/").at(-1) ?? normalized;
+  const basename4 = normalized.split("/").at(-1) ?? normalized;
   if ([
     "agents.md",
     "claude.md",
@@ -8555,7 +8596,7 @@ function isImportantFile(path) {
   ].includes(normalized)) {
     return true;
   }
-  return basename3.startsWith("next.config.") || basename3.startsWith("vite.config.") || normalized.startsWith("docs/") || normalized.startsWith("infra/") || normalized === "src/cli.ts" || normalized === "src/main.tsx" || normalized === "src/app/page.tsx";
+  return basename4.startsWith("next.config.") || basename4.startsWith("vite.config.") || normalized.startsWith("docs/") || normalized.startsWith("infra/") || normalized === "src/cli.ts" || normalized === "src/main.tsx" || normalized === "src/app/page.tsx";
 }
 function formatBytes(bytes) {
   if (bytes < 1024) return `${bytes} B`;
@@ -8796,6 +8837,124 @@ import { z as z25 } from "zod";
 import { mkdir as mkdir11, writeFile as writeFile8 } from "fs/promises";
 import { join as join9 } from "path";
 
+// src/core/periodic-compaction.ts
+var DEFAULT_SUMMARY_INTERVAL_STEPS = 12;
+var MIN_PERIODIC_HISTORY_CHARS = 12e3;
+function summaryIntervalSteps(value = process.env.ULTRAC_SUMMARY_INTERVAL_STEPS) {
+  if (value === void 0 || value.trim() === "") return DEFAULT_SUMMARY_INTERVAL_STEPS;
+  if (!/^\d+$/.test(value) || !Number.isSafeInteger(Number(value)) || Number(value) > 1e3) throw new Error("ULTRAC_SUMMARY_INTERVAL_STEPS must be an integer from 0 to 1000.");
+  return Number(value);
+}
+function completeContextUnits(messages) {
+  const units = [];
+  for (const message of messages) {
+    if (message.role === "tool") {
+      const previous = units.at(-1);
+      if (!previous || previous[0].role !== "assistant") return null;
+      previous.push(message);
+    } else units.push([message]);
+  }
+  for (const unit of units) {
+    const first = unit[0];
+    if (first.role !== "assistant") continue;
+    if (!first.toolCalls?.length) {
+      if (unit.slice(1).some((message) => "toolCallId" in message)) return null;
+      continue;
+    }
+    const ids = new Set(first.toolCalls.map((call) => call.id));
+    const results = unit.slice(1).map((message) => message.toolCallId);
+    if (ids.size !== first.toolCalls.length || results.length !== ids.size || results.some((id) => !id || !ids.has(id)) || new Set(results).size !== ids.size) return null;
+  }
+  return units;
+}
+var PeriodicCompactor = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  lastAttemptStep = 0;
+  async compact(messages, pinned, provider, model, completedSteps, signal) {
+    const unchanged = () => ({ messages: [...messages], compacted: false });
+    const interval = this.options.intervalSteps ?? summaryIntervalSteps();
+    if (!interval || signal?.aborted || completedSteps - this.lastAttemptStep < interval) return unchanged();
+    const units = completeContextUnits(messages);
+    if (!units) return unchanged();
+    const recent = new Set(units.filter((unit) => unit[0].role === "assistant").slice(-2));
+    const pinnedSet = new Set(pinned);
+    const history = units.filter((unit) => !recent.has(unit) && !unit.some((message) => message.role === "user" || message.role === "system" || pinnedSet.has(message) || isCompactionSummary(message))).flat();
+    const removedChars = history.reduce((size, message) => size + JSON.stringify(message).length, 0);
+    if (history.length < 2 || removedChars < (this.options.minHistoryChars ?? MIN_PERIODIC_HISTORY_CHARS)) return unchanged();
+    this.lastAttemptStep = completedSteps;
+    const trace = startDiagnosticSpan("context.compaction", { path: "periodic", completedSteps, compactedMessageCount: history.length }, 5e3);
+    const controller = new AbortController();
+    let rejectCancelled;
+    const interrupted2 = new Promise((_resolve, reject) => {
+      rejectCancelled = reject;
+    });
+    const abort = () => {
+      controller.abort();
+      rejectCancelled(new Error("summary_interrupted"));
+    };
+    const timer = setTimeout(abort, this.options.timeoutMs ?? DEFAULT_SUMMARY_TIMEOUT_MS);
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+    try {
+      const completion = await Promise.race([provider.complete({ model, system: summaryInstructions(DEFAULT_MAX_SUMMARY_CHARS), messages: [{ role: "user", content: renderDroppedTranscript(history, { maxTranscriptChars: DEFAULT_MAX_TRANSCRIPT_CHARS }) }], signal: controller.signal, context: { purpose: "compaction_summary", compactedMessages: history.length } }), interrupted2]);
+      if (controller.signal.aborted) {
+        trace.end({ outcome: "skipped", reason: "interrupted" });
+        return unchanged();
+      }
+      const summary = completion.text.trim();
+      if (!summary || summary.length > DEFAULT_MAX_SUMMARY_CHARS || summary.length + 300 >= removedChars) {
+        trace.end({ outcome: "skipped", reason: "invalid-summary" });
+        return unchanged();
+      }
+      const removed = new Set(history);
+      const compacted = messages.filter((message) => !removed.has(message));
+      const firstRemoved = messages.findIndex((message) => removed.has(message));
+      const insertion = messages.slice(0, firstRemoved).filter((message) => !removed.has(message)).length;
+      compacted.splice(insertion, 0, compactionSummaryMessage(summary));
+      if (!completeContextUnits(compacted)) {
+        trace.end({ outcome: "skipped", reason: "invalid-pairing" });
+        return unchanged();
+      }
+      trace.end({ outcome: "compacted", summaryChars: summary.length });
+      return { messages: compacted, compacted: true };
+    } catch {
+      trace.end({ outcome: "failed", reason: controller.signal.aborted ? "interrupted" : "summary-failed" });
+      return unchanged();
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+    }
+  }
+};
+function snapshotMessages(messages) {
+  const result = [];
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    const native = message;
+    if (native.role !== "assistant" || !native.toolCalls?.length) {
+      result.push(message);
+      continue;
+    }
+    const replies = [];
+    while (messages[index + 1]?.role === "tool") replies.push(messages[++index]);
+    const ids = new Set(replies.map((reply) => reply.toolCallId));
+    const calls = native.toolCalls.filter((call) => ids.has(call.id));
+    const completedIds = new Set(calls.map((call) => call.id));
+    const base = { role: native.role, content: native.content };
+    result.push({ ...base, ...calls.length ? { toolCalls: calls } : {} });
+    result.push(...replies.filter((reply) => completedIds.has(reply.toolCallId)));
+  }
+  return result;
+}
+function snapshotWithConstraints(messages, constraints) {
+  const snapshot = snapshotMessages(messages);
+  for (const constraint of constraints) if (!snapshot.some((message) => message.role === "user" && message.content === constraint.content)) snapshot.push({ role: "user", content: constraint.content });
+  return snapshot;
+}
+
 // src/core/progress-events.ts
 var listeners = /* @__PURE__ */ new Set();
 function onAgentProgress(listener) {
@@ -8962,18 +9121,18 @@ function isConcurrencySafe(tool) {
 }
 function planToolBatches(calls, tools) {
   const batches = [];
-  let open8;
+  let open9;
   for (const call of calls) {
     if (!isConcurrencySafe(tools.get(call.tool))) {
       batches.push([call]);
-      open8 = void 0;
+      open9 = void 0;
       continue;
     }
-    if (!open8) {
-      open8 = [];
-      batches.push(open8);
+    if (!open9) {
+      open9 = [];
+      batches.push(open9);
     }
-    open8.push(call);
+    open9.push(call);
   }
   return batches;
 }
@@ -9511,6 +9670,17 @@ function readSessionUserConstraints(session) {
   }
   return constraints;
 }
+function readSessionContextSnapshot(session) {
+  if (session.contextSnapshot !== void 0) {
+    const snapshot = session.contextSnapshot;
+    if (!snapshot || typeof snapshot !== "object" || snapshot.version !== 1 || !["native", "text", "run"].includes(snapshot.kind) || !Number.isSafeInteger(snapshot.completedSteps) || snapshot.completedSteps < 0 || !Array.isArray(snapshot.messages) || snapshot.messages.some((message) => {
+      if (!message || typeof message !== "object" || !["user", "assistant", "system", "tool"].includes(message.role) || typeof message.content !== "string") return true;
+      const native = message;
+      return snapshot.kind !== "native" && (message.role === "system" || native.toolCalls !== void 0 || native.toolCallId !== void 0) || native.toolCalls !== void 0 && message.role !== "assistant" || native.toolCallId !== void 0 && message.role !== "tool" || snapshot.kind === "native" && message.role === "tool" && typeof native.toolCallId !== "string" || native.toolCallId !== void 0 && typeof native.toolCallId !== "string" || native.toolCalls !== void 0 && (!Array.isArray(native.toolCalls) || native.toolCalls.some((call) => !call || typeof call.id !== "string" || typeof call.name !== "string" || typeof call.arguments !== "string"));
+    }) || !completeContextUnits(snapshot.messages) || (readSessionUserConstraints(session) ?? [{ content: session.task }]).some((constraint) => !snapshot.messages.some((message) => message.role === "user" && message.content === constraint.content))) throw new Error(`Session ${session.id} has an invalid saved context snapshot and cannot be continued safely.`);
+  }
+  return session.contextSnapshot;
+}
 function createSessionId(date = /* @__PURE__ */ new Date()) {
   const stamp = date.toISOString().replace(/[:.]/g, "-");
   return `${stamp}-${randomBytes3(4).toString("hex")}`;
@@ -9788,6 +9958,7 @@ function validateSession(value, expectedId, label) {
   if (!isSafeSessionId(sessionId) || sessionId !== expectedId || session.parentSessionId !== void 0 && (typeof session.parentSessionId !== "string" || !isSafeSessionId(session.parentSessionId) || normalizedSessionId(session.parentSessionId) !== session.parentSessionId) || typeof session.task !== "string" || typeof session.workspace !== "string" || typeof session.provider !== "string" || typeof session.model !== "string" || typeof session.startedAt !== "string" || typeof session.endedAt !== "string" || typeof session.finalMessage !== "string" || !isToolPermissions(session.permissions) || !Array.isArray(session.steps) || session.mcpResultArchiveVersion !== void 0 && session.mcpResultArchiveVersion !== 1 || session.mode !== void 0 && !isAgentModeName2(session.mode) || session.stopReason !== void 0 && !isStopReason(session.stopReason) || session.subagents !== void 0 && !Array.isArray(session.subagents)) {
     invalid();
   }
+  readSessionContextSnapshot(value);
   const steps = session.steps;
   for (const stepValue of steps) {
     if (!stepValue || typeof stepValue !== "object" || Array.isArray(stepValue)) invalid();
@@ -9864,59 +10035,41 @@ var AgentRunner = class {
     const mode = options.mode ?? "default";
     const modePreset = getAgentModePreset(mode);
     const modePermissions = getEffectiveModePermissions(mode, options.permissions);
-    const readOnlyContext = {
-      workspace: options.workspace,
-      permissions: { write: false, shell: false, network: false },
-      ...options.signal ? { signal: options.signal } : {}
-    };
-    const [project, repoMap, repoHandbook, verificationPlan, worktree, snapshot] = await Promise.all([
-      this.registry.execute({ tool: "inspect_project", input: {} }, readOnlyContext),
-      this.registry.execute({ tool: "repo_map", input: { maxItems: 10 } }, readOnlyContext),
-      this.registry.execute({ tool: "repo_handbook", input: { maxFilesPerBehavior: 6 } }, readOnlyContext),
-      this.registry.execute({ tool: "verification_plan", input: {} }, readOnlyContext),
-      this.registry.execute({ tool: "git_worktree_summary", input: { includeStats: false } }, readOnlyContext),
-      this.registry.execute(
-        { tool: "list_files", input: { patterns: ["**/*"], includeHidden: false, maxResults: 80 } },
-        readOnlyContext
-      )
-    ]);
-    const [memory, skills] = await Promise.all([
-      loadMemoryContext(options.workspace),
-      this.registry.list().some((tool) => tool.name === "skill") ? loadSkillsContext(options.workspace) : Promise.resolve("Skills are unavailable in this tool set.")
-    ]);
+    const registered = this.registry.list();
+    const advertised = resolveAdvertisedTools(registered, mode, options.tools ?? "mode");
+    const workspaceContext = await gatherWorkspaceContext(
+      this.registry,
+      options.workspace,
+      advertised.map((tool) => tool.name)
+    );
     const fileProvenance = /* @__PURE__ */ new WeakMap();
     const restored = restorePreviousTranscript(previousSessions, options.maxToolResultChars, fileProvenance);
     if (previousSession) {
       noteContextEvent(describeRestore(previousSession, previousSessions, restored, priorConstraints));
     }
+    const workspaceMessage = {
+      role: "user",
+      content: workspaceContext
+    };
     const taskMessage = {
       role: "user",
-      content: buildInitialUserMessage(
-        options.task,
-        options.workspace,
-        contextSection(project),
-        contextSection(repoMap),
-        contextSection(repoHandbook),
-        contextSection(verificationPlan),
-        worktree.ok ? contextSection(worktree) : "No Git worktree detected.",
-        contextSection(snapshot),
-        modePreset.label,
-        memory,
-        skills,
-        options.previousSession,
-        restored
-      )
+      content: buildTaskUserMessage(options.task, modePreset.label, options.previousSession, restored)
     };
+    fileProvenance.set(workspaceMessage, unknownContextProvenance());
     fileProvenance.set(taskMessage, unknownContextProvenance());
     const constraintMessages = inheritedConstraints.map((constraint) => ({
       role: "user",
       content: constraint.content
     }));
-    const messages = [...restored.messages, ...constraintMessages, taskMessage];
+    const messages = [
+      ...restored.messages,
+      ...constraintMessages,
+      workspaceMessage,
+      taskMessage
+    ];
     const pinnedMessages = [...constraintMessages];
     const steps = [];
-    const registered = this.registry.list();
-    const advertised = resolveAdvertisedTools(registered, mode, options.tools ?? "mode");
+    const periodicCompactor = new PeriodicCompactor();
     const toolsByName = new Map(
       registered.map((tool) => [tool.name, tool])
     );
@@ -9939,7 +10092,8 @@ var AgentRunner = class {
       ...subagents2.length ? { subagents: subagents2 } : {},
       constraintVersion: 1,
       userConstraints: [...userConstraints],
-      mcpResultArchiveVersion: 1
+      mcpResultArchiveVersion: 1,
+      ...messages.some((message) => message.role === "user" && message.content.startsWith("[compacted-context]")) ? { contextSnapshot: { version: 1, kind: "run", messages: snapshotWithConstraints(messages, userConstraints), completedSteps: steps.length } } : {}
     });
     const depth = options.depth ?? 0;
     const isTopLevel = depth === 0;
@@ -9948,6 +10102,7 @@ var AgentRunner = class {
       try {
         await options.onCheckpoint(buildSession(void 0, listSubagentTranscripts()));
       } catch {
+        diagnosticEvent("session.checkpoint", { outcome: "failed", path: "run" });
       }
     };
     let stopReason = "max-steps";
@@ -9957,7 +10112,7 @@ var AgentRunner = class {
         break;
       }
       const nativeTools = options.nativeTools !== false && Boolean(options.provider.supportsToolCalling && options.provider.chatWithTools);
-      const system = buildSystemPrompt(advertised, modePermissions, modePreset, nativeTools);
+      const system = buildSystemPrompt(advertised, modePermissions, modePreset, nativeTools, options.autonomous);
       const requestContext = {
         turn: index + 1,
         mode,
@@ -9965,6 +10120,11 @@ var AgentRunner = class {
         transcriptKind: "run",
         fileProvenance
       };
+      const periodic = await periodicCompactor.compact(messages, [...pinnedMessages, taskMessage], options.provider, options.model, steps.length, options.signal);
+      if (periodic.compacted) {
+        messages.splice(0, messages.length, ...periodic.messages);
+        await checkpoint();
+      }
       await compactIfNeeded(options, messages, system, taskMessage, pinnedMessages, requestContext);
       if (options.signal?.aborted) {
         stopReason = "aborted";
@@ -10027,6 +10187,8 @@ var AgentRunner = class {
         role: "assistant",
         content: JSON.stringify(parsed)
       });
+      steps.push(step);
+      await checkpoint();
       const modeAllowlist = getEnforcedModeToolAllowlist(mode);
       const toolContext = {
         workspace: options.workspace,
@@ -10055,6 +10217,7 @@ var AgentRunner = class {
             pinnedMessages,
             fileProvenance
           );
+          await checkpoint();
           if (options.signal?.aborted) {
             stopReason = "aborted";
             break;
@@ -10107,6 +10270,7 @@ var AgentRunner = class {
             pinnedMessages,
             fileProvenance
           );
+          await checkpoint();
         }
         publishAgentProgress({ type: "batch-end", batchId });
         if (options.signal?.aborted) {
@@ -10114,8 +10278,6 @@ var AgentRunner = class {
           break;
         }
       }
-      steps.push(step);
-      await checkpoint();
       if (stopReason === "aborted") break;
       if (parsed.done && parsed.toolCalls.length === 0) {
         stopReason = "completed";
@@ -10159,6 +10321,10 @@ async function compactIfNeeded(options, messages, system, task, constraints, con
       summarisedTurns: plan.summarisedTurns
     });
   } catch (error) {
+    if (error instanceof PinnedContextBudgetError) {
+      trace.end({ outcome: "budget-error", error });
+      throw error;
+    }
     if (!(error instanceof ContextBudgetError)) {
       trace.end({ outcome: "error", error });
       throw error;
@@ -10220,52 +10386,28 @@ function capResultForTranscript(result, maxChars) {
   });
   return capped.truncated ? { ...result, content: capped.content } : result;
 }
-function contextSection(result) {
-  const content = capToolResultContent(result.content, { tool: result.tool }).content;
-  if (!hasTruncatedData(result.data)) return content;
-  return `${content}
-
-[ultrac: initial ${result.tool} context is incomplete; query the tool for a narrower view before assuming omitted items are absent.]`;
-}
-function hasTruncatedData(data) {
-  return typeof data === "object" && data !== null && "truncated" in data && data.truncated === true;
-}
-async function gatherWorkspaceContext(registry, workspace) {
-  const readOnlyContext = {
-    workspace,
-    permissions: { write: false, shell: false, network: false }
-  };
-  const [project, repoMap, repoHandbook, verificationPlan, worktree, snapshot] = await Promise.all([
-    registry.execute({ tool: "inspect_project", input: {} }, readOnlyContext),
-    registry.execute({ tool: "repo_map", input: { maxItems: 10 } }, readOnlyContext),
-    registry.execute({ tool: "repo_handbook", input: { maxFilesPerBehavior: 6 } }, readOnlyContext),
-    registry.execute({ tool: "verification_plan", input: {} }, readOnlyContext),
-    registry.execute({ tool: "git_worktree_summary", input: { includeStats: false } }, readOnlyContext),
-    registry.execute(
-      { tool: "list_files", input: { patterns: ["**/*"], includeHidden: false, maxResults: 80 } },
-      readOnlyContext
-    )
+var STARTUP_EXPLORE_TOOLS = [
+  "inspect_project",
+  "repo_map",
+  "repo_handbook",
+  "git_worktree_summary",
+  "git_status",
+  "list_files",
+  "read_file",
+  "read_many_files",
+  "search_files"
+];
+async function gatherWorkspaceContext(registry, workspace, advertisedNames) {
+  const [memory, skills] = await Promise.all([
+    loadMemoryContext(workspace),
+    registry.list().some((tool) => tool.name === "skill") ? loadSkillsContext(workspace) : Promise.resolve("Skills are unavailable in this tool set.")
   ]);
-  const [memory, skills] = await Promise.all([loadMemoryContext(workspace), registry.list().some((tool) => tool.name === "skill") ? loadSkillsContext(workspace) : Promise.resolve("Skills are unavailable in this tool set.")]);
+  const available = new Set(advertisedNames ?? registry.list().map((tool) => tool.name));
+  const explore = STARTUP_EXPLORE_TOOLS.filter((name) => available.has(name));
+  const exploreLine = explore.length ? `Call ${explore.join(", ")} for the files and structure this task needs. This header is a catalog, not the repository.` : "Inspect the workspace with the advertised tools before acting. This header is a catalog, not the repository.";
   return `Workspace: ${workspace}
 
-Project summary:
-${contextSection(project)}
-
-Repository map:
-${contextSection(repoMap)}
-
-Repo handbook:
-${contextSection(repoHandbook)}
-
-Verification plan:
-${contextSection(verificationPlan)}
-
-Worktree summary:
-${worktree.ok ? contextSection(worktree) : "No Git worktree detected."}
-
-Workspace snapshot:
-${contextSection(snapshot)}
+${exploreLine}
 
 Memory (stored facts - load a specific one with memory_read):
 ${memory}
@@ -10273,42 +10415,21 @@ ${memory}
 Skills (playbooks - load full steps with the skill tool before acting on a matching task):
 ${skills}`;
 }
-function buildInitialUserMessage(task, workspace, project, repoMap, repoHandbook, verificationPlan, worktree, snapshot, modeLabel, memory, skills, previousSession, restored) {
+function buildTaskUserMessage(task, modeLabel, previousSession, restored) {
   const previousContext = previousSession ? `
 Previous session:
 ${summarizePreviousSession(previousSession, restored)}
 ` : "";
-  return `Workspace: ${workspace}
-Mode: ${modeLabel}
+  return `Mode: ${modeLabel}
 ${previousContext}
-
-Project summary:
-${project}
-
-Repository map:
-${repoMap}
-
-Repo handbook:
-${repoHandbook}
-
-Verification plan:
-${verificationPlan}
-
-Worktree summary:
-${worktree}
-
-Workspace snapshot:
-${snapshot}
-
-Memory (stored facts - load a specific one with memory_read):
-${memory}
-
-Skills (playbooks - load full steps with the skill tool before acting on a matching task):
-${skills}
-
 Task:
 ${task}`;
 }
+function advertisedExploreGuidance(advertised) {
+  const names = STARTUP_EXPLORE_TOOLS.filter((name) => advertised.has(name));
+  if (!names.length) return void 0;
+  return `The startup header is a catalog, not the repository. Call ${names.join(", ")} for the files and structure this task needs; do not assume a file exists because it was mentioned earlier.`;
+}
 var NOTHING_RESTORED = {
   messages: [],
   steps: 0,
@@ -10317,7 +10438,7 @@ var NOTHING_RESTORED = {
   legacyMcpResults: 0
 };
 function restorePreviousTranscript(sessions, maxToolResultChars, fileProvenance) {
-  if (sessions.length === 0 || sessions.every((session) => session.steps.length === 0)) return NOTHING_RESTORED;
+  if (sessions.length === 0 || sessions.every((session) => session.steps.length === 0 && !readSessionContextSnapshot(session))) return NOTHING_RESTORED;
   const messages = [];
   let toolResults = 0;
   let truncatedResults = 0;
@@ -10325,6 +10446,11 @@ function restorePreviousTranscript(sessions, maxToolResultChars, fileProvenance)
   let steps = 0;
   for (const session of sessions) {
     steps += session.steps.length;
+    const snapshot = readSessionContextSnapshot(session);
+    if (snapshot?.kind === "run" || snapshot?.kind === "text") {
+      messages.splice(0, messages.length, ...snapshot.messages);
+      continue;
+    }
     for (const step of session.steps) {
       const content = step.parsed ? JSON.stringify(step.parsed) : step.modelText;
       if (content) messages.push({ role: "assistant", content });
@@ -10339,6 +10465,7 @@ function restorePreviousTranscript(sessions, maxToolResultChars, fileProvenance)
         fileProvenance?.set(entry.message, toolResultFileProvenance(result, entry.truncated));
       }
     }
+    if (snapshot) messages.push(...snapshot.messages.filter((message) => message.role === "user" && message.content.startsWith("[compacted-context]")).map((message) => ({ role: "user", content: message.content })));
   }
   return { messages, steps, toolResults, truncatedResults, legacyMcpResults };
 }
@@ -10372,7 +10499,15 @@ function summarizePreviousSession(session, restored) {
 function plural3(value, noun) {
   return `${value.toLocaleString("en-US")} ${noun}${value === 1 ? "" : "s"}`;
 }
-function buildSystemPrompt(tools, permissions, mode, nativeTools = false) {
+function autonomousGuidance(phone, askUserAdvertised) {
+  const ask2 = !askUserAdvertised ? "" : phone ? "\n- ask_user reaches the user's phone and interrupts them. Use it only for what you cannot decide or obtain yourself: a credential, a payment, an irreversible action outside this workspace, or a choice between materially different outcomes. For everything else, decide, state the assumption, and continue." : "\n- ask_user has no one to reach in this run. Decide, state the assumption, and continue.";
+  return `
+Autonomous run: no human is watching and every permission is granted.
+- Carry the task through to a verified finish. Do not stop to ask for confirmation, and do not end with a plan, a question or a list of next steps you could do yourself.
+- When something fails, diagnose it and try another approach before giving up.${ask2}
+`;
+}
+function buildSystemPrompt(tools, permissions, mode, nativeTools = false, autonomous) {
   const renderedTools = tools.map((tool) => {
     const permissionText = tool.permissions.length ? ` Requires: ${tool.permissions.join(", ")}.` : "";
     const optionalText = tool.optionalPermissions.length ? ` Uses when granted: ${tool.optionalPermissions.join(", ")}.` : "";
@@ -10380,6 +10515,7 @@ function buildSystemPrompt(tools, permissions, mode, nativeTools = false) {
   }).join("\n");
   const advertised = new Set(tools.map((tool) => tool.name));
   const guidance = [
+    advertisedExploreGuidance(advertised),
     advertised.has("context_bundle") ? "Use context_bundle when a task needs a portable working set for model handoff, eval fixtures, desktop copy flows, or future replay. Save it only when write permission is available or the user asked for an artifact." : void 0,
     advertised.has("verification_report") ? "When you have run or accounted for verification, use verification_report to summarize the outcome and evidence. Save it only when write permission is available or the user asked for an artifact." : void 0,
     advertised.has("diagnostics") ? "After any edit, call diagnostics with paths set to the files you just wrote, and fix what it reports before declaring the work done." : void 0,
@@ -10389,11 +10525,12 @@ function buildSystemPrompt(tools, permissions, mode, nativeTools = false) {
     advertised.has("memory_write") ? "When you learn a durable fact, preference, or a correction from the user, persist it with memory_write so it survives future sessions; read the full text of a relevant memory with memory_read." : void 0,
     advertised.has("scan_secrets") ? "For local evidence prefer inspect_artifact, hex_dump, extract_strings, scan_secrets, and file_timeline over a shell. scan_secrets redacts matches; do not round-trip those findings into a write that stores live secrets." : void 0
   ].filter((line) => Boolean(line));
+  const autonomyLines = autonomous ? autonomousGuidance(autonomous.phone, advertised.has("ask_user")) : "";
   return `You are ultrac, the terminal-native coding agent for Ultrac.
 
 Mode: ${mode.label}
 ${mode.instructions.map((instruction) => `- ${instruction}`).join("\n")}
-
+${autonomyLines}
 ${UNTRUSTED_CONTENT_GUIDANCE}
 
 ${nativeTools ? "Write complete code files or append complete sections across tool calls for large implementations. Verify files with tests or a compiler. Never replace requested code with placeholders or ellipses. Keep final explanations concise. Use the provided native function tools for actions. Do not put a JSON tool-call protocol in your answer. When the requested work is complete, give the final answer without calling more tools." : `Respond only with a JSON object:
@@ -13535,7 +13672,10 @@ function buildHarnessManifest() {
 }
 
 // src/commands/mcp.ts
-import { resolve as resolve9 } from "path";
+import { resolve as resolve9, dirname as dirname12, join as join12 } from "path";
+import { constants as constants5 } from "fs";
+import { lstat as lstat3, mkdir as mkdir14, open as open8, rename as rename2, unlink as unlink3 } from "fs/promises";
+import { randomUUID as randomUUID4 } from "crypto";
 import chalk5 from "chalk";
 
 // src/mcp/client.ts
@@ -13953,24 +14093,24 @@ var McpConnection = class {
 };
 function childEnvFor(spec, source = process.env) {
   const { env: sanitized } = createSanitizedProcessEnv(source);
-  const env = { ...sanitized };
+  const env2 = { ...sanitized };
   for (const key of spec.envPassthrough) {
     if (isSensitiveEnvName(key)) continue;
     const value = source[key];
     if (value !== void 0) {
-      env[key] = value;
+      env2[key] = value;
     }
   }
-  Object.assign(env, spec.env);
-  return env;
+  Object.assign(env2, spec.env);
+  return env2;
 }
 function spawnStdioTransport(spec, workspace) {
-  const env = childEnvFor(spec);
+  const env2 = childEnvFor(spec);
   const cwd = spec.cwd ? resolveInsideWorkspace(workspace, spec.cwd) : workspace;
   const child = spawn3(spec.command, spec.args, {
     cwd,
     stdio: ["pipe", "pipe", "pipe"],
-    env,
+    env: env2,
     detached: process.platform !== "win32",
     windowsHide: true
   });
@@ -14361,7 +14501,47 @@ function asError(error) {
 
 // src/commands/mcp.ts
 function registerMcpCommand(program2) {
-  const mcpCommand = program2.command("mcp").description("Inspect the MCP servers this workspace connects to");
+  const mcpCommand = program2.command("mcp").description("Configure and inspect workspace MCP servers");
+  mcpCommand.command("add <name> <command> [args...]").description("Add a stdio MCP server without starting it").option("-w, --workspace <path>", "Workspace directory", process.cwd()).option("--env <NAME=value>", "Explicit child environment value; prefer --env-pass for credentials", collect, []).option("--env-pass <NAME>", "Forward a named parent environment variable", collect, []).option("--cwd <path>", "Server working directory").option("--timeout <milliseconds>", "Per-request timeout", "30000").option("--disabled", "Keep the server disabled", false).option("--force", "Replace an existing server with this name", false).action(async (name, command, args, options) => {
+    validateServerName(name);
+    const env2 = {};
+    for (const entry of options.env) {
+      const separator = entry.indexOf("=");
+      if (separator < 1) throw new Error("--env must use NAME=value.");
+      const key = entry.slice(0, separator);
+      validateEnvironmentName(key);
+      Object.defineProperty(env2, key, { value: entry.slice(separator + 1), enumerable: true, configurable: true });
+    }
+    options.envPass.forEach(validateEnvironmentName);
+    const spec = McpServerSchema.parse({
+      command,
+      args,
+      env: env2,
+      envPassthrough: [...new Set(options.envPass)],
+      cwd: options.cwd,
+      enabled: !options.disabled,
+      timeoutMs: Number(options.timeout)
+    });
+    const workspace = await assertWorkspaceExists(options.workspace);
+    await updateMcpConfig(workspace, (config) => {
+      const servers = { ...config.mcpServers ?? {} };
+      if (Object.hasOwn(servers, name) && !options.force) throw new Error(`MCP server ${name} already exists. Use --force to replace it.`);
+      servers[name] = spec;
+      return { ...config, mcpServers: servers };
+    });
+    console.log(`Added MCP server ${name}. Run ultrac trust in this workspace to approve the updated settings.`);
+  });
+  mcpCommand.command("remove <name>").description("Remove a workspace MCP server").option("-w, --workspace <path>", "Workspace directory", process.cwd()).action(async (name, options) => {
+    validateServerName(name);
+    const workspace = await assertWorkspaceExists(options.workspace);
+    await updateMcpConfig(workspace, (config) => {
+      const servers = { ...config.mcpServers ?? {} };
+      if (!Object.hasOwn(servers, name)) throw new Error(`No MCP server named ${name}.`);
+      delete servers[name];
+      return { ...config, mcpServers: servers };
+    });
+    console.log(`Removed MCP server ${name}. Reapprove changed workspace settings with ultrac trust if required.`);
+  });
   mcpCommand.command("list", { isDefault: true }).description("Connect every configured server and report what it exports").option("-w, --workspace <path>", "Workspace directory", process.cwd()).option("--json", "Print the result as JSON", false).action(async (options) => {
     const workspace = resolve9(options.workspace);
     const loaded = await loadConfigWithTrust(workspace);
@@ -14387,6 +14567,7 @@ function registerMcpCommand(program2) {
     }
     const runtime = await withRuntime(workspace, servers, (active) => active);
     try {
+      if (runtime.statuses.some((status) => !status.ok)) process.exitCode = 1;
       if (options.json) {
         console.log(JSON.stringify({ servers: runtime.statuses }, null, 2));
         return;
@@ -14409,7 +14590,7 @@ function registerMcpCommand(program2) {
       runtime.close();
     }
   });
-  mcpCommand.command("call <server> <tool>").description("Call one MCP tool directly, for checking a server by hand").option("-w, --workspace <path>", "Workspace directory", process.cwd()).option("--input <json>", "Tool arguments as a JSON object", "{}").action(async (server, tool, options) => {
+  mcpCommand.command("call <server> <tool>").description("Call one MCP tool directly, for checking a server by hand").option("-w, --workspace <path>", "Workspace directory", process.cwd()).option("--input <json>", "Tool arguments as a JSON object", "{}").option("--json", "Print the result as JSON", false).action(async (server, tool, options) => {
     const workspace = resolve9(options.workspace);
     const loaded = await loadConfigWithTrust(workspace);
     const spec = loaded.config.mcpServers?.[server];
@@ -14427,6 +14608,7 @@ function registerMcpCommand(program2) {
     } catch (error) {
       throw new Error(`--input must be a JSON object: ${error instanceof Error ? error.message : String(error)}`);
     }
+    if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error("--input must be a JSON object.");
     const runtime = await withRuntime(workspace, { [server]: spec }, (active) => active);
     try {
       const status = runtime.statuses[0];
@@ -14451,6 +14633,68 @@ function registerMcpCommand(program2) {
     }
   });
 }
+function collect(value, previous) {
+  return [...previous, value];
+}
+function validateServerName(name) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,79}$/.test(name) || name.includes("__") || ["constructor", "prototype"].includes(name)) {
+    throw new Error("MCP server names must contain letters, numbers, dots, single underscores, or hyphens.");
+  }
+}
+function validateEnvironmentName(name) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) throw new Error("Environment variable names must contain letters, numbers, or underscores.");
+}
+async function updateMcpConfig(workspace, update) {
+  const target = configPath(workspace);
+  await resolveInsideWorkspaceReal(workspace, target);
+  await mkdir14(dirname12(target), { recursive: true, mode: 448 });
+  await resolveInsideWorkspaceReal(workspace, target);
+  const lockPath = `${target}.mcp-lock`;
+  const lock = await open8(lockPath, "wx", 384).catch((error) => {
+    if (error.code === "EEXIST") throw new Error("Another MCP configuration update is in progress.");
+    throw error;
+  });
+  const temporary = join12(dirname12(target), `.mcp-config-${randomUUID4()}.tmp`);
+  try {
+    let config = defaultConfig();
+    const existing = await lstat3(target).catch((error) => {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (existing) {
+      if (!existing.isFile() || existing.isSymbolicLink() || existing.size > 1048576) throw new Error("MCP config must be a regular JSON file no larger than 1 MiB.");
+      const handle2 = await open8(target, constants5.O_RDONLY | constants5.O_NOFOLLOW);
+      try {
+        const content = await handle2.readFile("utf8");
+        try {
+          config = JSON.parse(content);
+        } catch {
+          throw new Error("Workspace config is not valid JSON.");
+        }
+      } finally {
+        await handle2.close();
+      }
+      if (!config || typeof config !== "object" || Array.isArray(config)) throw new Error("Workspace config must be a JSON object.");
+      if (!UltracConfigSchema.safeParse(config).success) throw new Error("Workspace config does not match the Ultrac configuration schema.");
+    }
+    const next = update(config);
+    UltracConfigSchema.parse(next);
+    const handle = await open8(temporary, "wx", 384);
+    try {
+      await handle.writeFile(`${JSON.stringify(next, null, 2)}
+`, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await resolveInsideWorkspaceReal(workspace, target);
+    await rename2(temporary, target);
+  } finally {
+    await unlink3(temporary).catch(() => void 0);
+    await lock.close();
+    await unlink3(lockPath).catch(() => void 0);
+  }
+}
 async function withRuntime(workspace, servers, use) {
   const packageInfo = readPackageInfo();
   const runtime = await connectMcpServers(servers, {
@@ -14562,10 +14806,479 @@ async function readStdin() {
   return Buffer.concat(chunks).toString("utf8");
 }
 
+// src/commands/notify.ts
+import chalk6 from "chalk";
+
+// src/notify/config.ts
+import { chmod as chmod3, readFile as readFile12, rm as rm4, writeFile as writeFile11 } from "fs/promises";
+import { join as join13 } from "path";
+import { z as z31 } from "zod";
+var TelegramSchema = z31.object({
+  botToken: z31.string().min(1),
+  chatId: z31.string().min(1)
+});
+var TwilioSchema = z31.object({
+  accountSid: z31.string().regex(/^AC[0-9a-fA-F]{32}$/, "Twilio account SIDs start with AC followed by 32 hex characters."),
+  authToken: z31.string().min(1),
+  /** The Twilio number Ultrac texts and calls from, E.164. */
+  from: z31.string().regex(/^\+[1-9]\d{6,14}$/, "Use E.164 format, e.g. +14155550100."),
+  /** The user's phone, E.164. */
+  to: z31.string().regex(/^\+[1-9]\d{6,14}$/, "Use E.164 format, e.g. +919812345678."),
+  /** Escalate an unanswered question to a voice call. */
+  call: z31.boolean().default(true)
+});
+var NotifyConfigSchema = z31.object({
+  version: z31.literal(1).default(1),
+  telegram: TelegramSchema.optional(),
+  twilio: TwilioSchema.optional(),
+  /** How long a question waits for a text reply before Ultrac phones. */
+  callAfterSeconds: z31.number().int().min(0).max(3600).default(180),
+  /** How long a question waits in total before the agent proceeds on its own judgement. */
+  answerTimeoutSeconds: z31.number().int().min(30).max(86400).default(1800)
+});
+function notifyConfigPath() {
+  return join13(ultracHomeDir(), "notify.json");
+}
+async function readStoredNotifyConfig() {
+  let text;
+  try {
+    text = await readFile12(notifyConfigPath(), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+  return NotifyConfigSchema.parse(JSON.parse(text));
+}
+async function writeNotifyConfig(config) {
+  await ensureUltracHome();
+  const path = notifyConfigPath();
+  const parsed = NotifyConfigSchema.parse(config);
+  await writeFile11(path, `${JSON.stringify(parsed, null, 2)}
+`, { mode: 384 });
+  await chmod3(path, 384).catch(() => void 0);
+  return path;
+}
+async function removeNotifyConfig() {
+  await rm4(notifyConfigPath(), { force: true });
+}
+function env(name) {
+  return process.env[name]?.trim() || void 0;
+}
+async function loadNotifyConfig() {
+  const stored = await readStoredNotifyConfig();
+  const base = stored ?? NotifyConfigSchema.parse({});
+  const telegramToken = env("ULTRAC_TELEGRAM_BOT_TOKEN");
+  const telegramChat = env("ULTRAC_TELEGRAM_CHAT_ID");
+  const telegram = telegramToken && telegramChat ? { botToken: telegramToken, chatId: telegramChat } : base.telegram;
+  const sid = env("ULTRAC_TWILIO_ACCOUNT_SID");
+  const token = env("ULTRAC_TWILIO_AUTH_TOKEN");
+  const from = env("ULTRAC_TWILIO_FROM");
+  const to = env("ULTRAC_NOTIFY_PHONE");
+  const twilio = sid && token && from && to ? { accountSid: sid, authToken: token, from, to, call: base.twilio?.call ?? true } : base.twilio;
+  const merged = NotifyConfigSchema.parse({ ...base, telegram, twilio });
+  return merged.telegram || merged.twilio ? merged : null;
+}
+function redact(secret) {
+  return secret.length <= 4 ? "****" : `****${secret.slice(-4)}`;
+}
+
+// src/notify/channel.ts
+function sleep(ms, signal) {
+  if (signal?.aborted) return Promise.resolve(false);
+  return new Promise((resolve15) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve15(true);
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve15(false);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function withTimeout2(signal, ms) {
+  const timeout = AbortSignal.timeout(ms);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+var NotifyChannelError = class extends Error {
+  constructor(channel, message) {
+    super(`${channel}: ${message}`);
+    this.name = "NotifyChannelError";
+  }
+};
+
+// src/notify/telegram.ts
+var API = "https://api.telegram.org";
+var LONG_POLL_SECONDS = 25;
+var RETRY_DELAY_MS = 5e3;
+var MAX_MESSAGE_CHARS = 4e3;
+async function callTelegram(fetchFn, botToken, method, body, signal) {
+  const response = await fetchFn(`${API}/bot${botToken}/${method}`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+    signal
+  });
+  const json = await response.json().catch(() => ({ ok: false }));
+  if (!response.ok || !json.ok || json.result === void 0) {
+    throw new NotifyChannelError("telegram", json.description ?? `HTTP ${response.status}`);
+  }
+  return json.result;
+}
+var TelegramChannel = class {
+  constructor(config, fetchFn = fetch) {
+    this.config = config;
+    this.fetchFn = fetchFn;
+  }
+  config;
+  fetchFn;
+  name = "telegram";
+  offset;
+  async send(text, signal) {
+    await callTelegram(
+      this.fetchFn,
+      this.config.botToken,
+      "sendMessage",
+      { chat_id: this.config.chatId, text: text.slice(0, MAX_MESSAGE_CHARS) },
+      withTimeout2(signal, 15e3)
+    );
+  }
+  async waitForReply(since, signal) {
+    const sinceSeconds = Math.floor(since.getTime() / 1e3);
+    while (!signal.aborted) {
+      let updates;
+      try {
+        updates = await callTelegram(
+          this.fetchFn,
+          this.config.botToken,
+          "getUpdates",
+          {
+            timeout: LONG_POLL_SECONDS,
+            allowed_updates: ["message"],
+            ...this.offset !== void 0 ? { offset: this.offset } : {}
+          },
+          withTimeout2(signal, (LONG_POLL_SECONDS + 10) * 1e3)
+        );
+      } catch {
+        if (signal.aborted) return null;
+        await sleep(RETRY_DELAY_MS, signal);
+        continue;
+      }
+      for (const update of updates) {
+        this.offset = update.update_id + 1;
+        const message = update.message;
+        if (!message?.text) continue;
+        if (String(message.chat.id) !== this.config.chatId) continue;
+        if (message.date < sinceSeconds) continue;
+        return message.text;
+      }
+    }
+    return null;
+  }
+};
+async function discoverTelegramChat(botToken, signal, fetchFn = fetch) {
+  const startedSeconds = Math.floor(Date.now() / 1e3) - 60;
+  let offset;
+  while (!signal.aborted) {
+    let updates;
+    try {
+      updates = await callTelegram(
+        fetchFn,
+        botToken,
+        "getUpdates",
+        { timeout: LONG_POLL_SECONDS, allowed_updates: ["message"], ...offset !== void 0 ? { offset } : {} },
+        withTimeout2(signal, (LONG_POLL_SECONDS + 10) * 1e3)
+      );
+    } catch (error) {
+      if (signal.aborted) return null;
+      throw error;
+    }
+    for (const update of updates) {
+      offset = update.update_id + 1;
+      const message = update.message;
+      if (!message || message.date < startedSeconds) continue;
+      const chat = message.chat;
+      return { chatId: String(chat.id), name: chat.title ?? chat.username ?? chat.first_name ?? String(chat.id) };
+    }
+  }
+  return null;
+}
+
+// src/notify/twilio.ts
+var API2 = "https://api.twilio.com/2010-04-01";
+var POLL_INTERVAL_MS = 1e4;
+var MAX_SMS_CHARS = 1500;
+var MAX_SPOKEN_CHARS = 1e3;
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+var TwilioChannel = class {
+  constructor(config, fetchFn = fetch) {
+    this.config = config;
+    this.fetchFn = fetchFn;
+  }
+  config;
+  fetchFn;
+  name = "sms";
+  seen = /* @__PURE__ */ new Set();
+  get authHeader() {
+    return `Basic ${Buffer.from(`${this.config.accountSid}:${this.config.authToken}`).toString("base64")}`;
+  }
+  async request(method, path, params, signal) {
+    const search = new URLSearchParams(params);
+    const url = `${API2}/Accounts/${this.config.accountSid}/${path}${method === "GET" ? `?${search}` : ""}`;
+    const response = await this.fetchFn(url, {
+      method,
+      headers: {
+        authorization: this.authHeader,
+        ...method === "POST" ? { "content-type": "application/x-www-form-urlencoded" } : {}
+      },
+      ...method === "POST" ? { body: search.toString() } : {},
+      signal: withTimeout2(signal, 15e3)
+    });
+    const json = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      throw new NotifyChannelError("twilio", json.message ?? `HTTP ${response.status}`);
+    }
+    return json;
+  }
+  async send(text, signal) {
+    await this.request(
+      "POST",
+      "Messages.json",
+      { To: this.config.to, From: this.config.from, Body: text.slice(0, MAX_SMS_CHARS) },
+      signal
+    );
+  }
+  async call(text, signal) {
+    if (!this.config.call) return;
+    const spoken = escapeXml(text.slice(0, MAX_SPOKEN_CHARS));
+    const twiml = `<Response><Say>${spoken}</Say><Pause length="2"/><Say>Again. ${spoken}</Say></Response>`;
+    await this.request("POST", "Calls.json", { To: this.config.to, From: this.config.from, Twiml: twiml }, signal);
+  }
+  async waitForReply(since, signal) {
+    const day = since.toISOString().slice(0, 10);
+    while (!signal.aborted) {
+      try {
+        const page = await this.request(
+          "GET",
+          "Messages.json",
+          { To: this.config.from, From: this.config.to, "DateSent>": day, PageSize: "50" },
+          signal
+        );
+        const replies = page.messages.filter((message) => message.direction === "inbound" && !this.seen.has(message.sid)).map((message) => ({ message, at: new Date(message.date_sent ?? message.date_created) })).filter(({ at }) => at.getTime() >= since.getTime()).sort((left, right) => left.at.getTime() - right.at.getTime());
+        const first = replies[0];
+        if (first) {
+          this.seen.add(first.message.sid);
+          return first.message.body;
+        }
+      } catch {
+        if (signal.aborted) return null;
+      }
+      await sleep(POLL_INTERVAL_MS, signal);
+    }
+    return null;
+  }
+};
+
+// src/notify/notifier.ts
+var CLOCK_SKEW_MS = 5e3;
+var Notifier = class {
+  constructor(channels, timing, heading = "Ultrac", now = () => /* @__PURE__ */ new Date()) {
+    this.channels = channels;
+    this.timing = timing;
+    this.heading = heading;
+    this.now = now;
+    if (channels.length === 0) throw new Error("A notifier needs at least one channel.");
+  }
+  channels;
+  timing;
+  heading;
+  now;
+  describe() {
+    return this.channels.map((channel) => channel.name).join(" + ");
+  }
+  /**
+   * Fire-and-report: send `text` everywhere and return the channels that
+   * failed. Throws only when every channel failed.
+   */
+  async send(text, signal) {
+    const results = await Promise.allSettled(this.channels.map((channel) => channel.send(`${this.heading}: ${text}`, signal)));
+    const failures = results.flatMap(
+      (result, index) => result.status === "rejected" ? [`${this.channels[index].name}: ${String(result.reason?.message ?? result.reason)}`] : []
+    );
+    if (failures.length === this.channels.length) {
+      throw new Error(`Could not reach the user on any channel (${failures.join("; ")}).`);
+    }
+    return failures;
+  }
+  async ask(question, options, signal) {
+    const since = new Date(this.now().getTime() - CLOCK_SKEW_MS);
+    const optionLines = options?.length ? `
+
+${options.map((option, index) => `${index + 1}. ${option}`).join("\n")}
+
+Reply with a number or your own answer.` : "\n\nReply to this message with your answer.";
+    await this.send(`needs your input.
+
+${question}${optionLines}`, signal);
+    if (signal?.aborted) return null;
+    const wait = new AbortController();
+    const stop = () => wait.abort();
+    signal?.addEventListener("abort", stop, { once: true });
+    try {
+      const replies = this.channels.map(
+        (channel) => channel.waitForReply(since, wait.signal).catch(() => null).then((reply2) => {
+          if (reply2 === null) return new Promise(() => void 0);
+          return reply2;
+        })
+      );
+      void (async () => {
+        if (!await sleep(this.timing.callAfterMs, wait.signal)) return;
+        const spoken = `This is Ultrac. Your agent needs your input. ${question} ${options?.length ? `Options: ${options.map((option, index) => `${index + 1}, ${option}.`).join(" ")}` : ""} Reply to the text message to answer.`;
+        await Promise.allSettled(this.channels.map((channel) => channel.call?.(spoken, wait.signal)));
+      })();
+      const timeout = sleep(this.timing.timeoutMs, wait.signal).then(() => null);
+      const cancelled = new Promise((resolve15) => wait.signal.addEventListener("abort", () => resolve15(null), { once: true }));
+      const reply = await Promise.race([...replies, timeout, cancelled]);
+      return reply === null ? null : pickOption(reply, options);
+    } finally {
+      signal?.removeEventListener("abort", stop);
+      wait.abort();
+    }
+  }
+};
+function pickOption(reply, options) {
+  const answer = reply.trim();
+  const picked = Number.parseInt(answer, 10);
+  if (options?.length && String(picked) === answer && picked >= 1 && picked <= options.length) {
+    return options[picked - 1];
+  }
+  return answer;
+}
+function createNotifier(config, heading, fetchFn = fetch) {
+  const channels = [];
+  if (config.telegram) channels.push(new TelegramChannel(config.telegram, fetchFn));
+  if (config.twilio) channels.push(new TwilioChannel(config.twilio, fetchFn));
+  return new Notifier(
+    channels,
+    { callAfterMs: config.callAfterSeconds * 1e3, timeoutMs: config.answerTimeoutSeconds * 1e3 },
+    heading
+  );
+}
+
+// src/commands/notify.ts
+var DISCOVERY_TIMEOUT_MS = 12e4;
+function parseSeconds(value, flag) {
+  if (value === void 0) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 0 || String(parsed) !== value.trim()) {
+    throw new Error(`${flag} must be a whole number of seconds.`);
+  }
+  return parsed;
+}
+function describeNotifyConfig(config) {
+  const lines = [];
+  if (config.telegram) {
+    lines.push(`telegram  chat ${config.telegram.chatId}, bot token ${redact(config.telegram.botToken)}`);
+  }
+  if (config.twilio) {
+    lines.push(
+      `sms       ${config.twilio.from} -> ${config.twilio.to}, voice calls ${config.twilio.call ? "on" : "off"}, account ${redact(config.twilio.accountSid)}`
+    );
+  }
+  lines.push(`timing    calls after ${config.callAfterSeconds}s unanswered, gives up after ${config.answerTimeoutSeconds}s`);
+  return lines;
+}
+function registerNotifyCommand(program2) {
+  const notify = program2.command("notify").description("Let Ultrac reach your phone: questions from autonomous runs, and results when they finish");
+  notify.command("setup").description("Configure Telegram and/or Twilio (SMS + voice calls). Stored in ~/.ultrac/notify.json, never in a workspace").option("--telegram-token <token>", "Telegram bot token from @BotFather").option("--telegram-chat <id>", "Telegram chat id (omit to detect it: send your bot any message during setup)").option("--twilio-sid <sid>", "Twilio account SID").option("--twilio-token <token>", "Twilio auth token").option("--twilio-from <number>", "Your Twilio phone number, E.164 (e.g. +14155550100)").option("--phone <number>", "Your phone number, E.164 (e.g. +919812345678)").option("--no-call", "Text only; never escalate an unanswered question to a voice call").option("--call-after <seconds>", "Seconds a question waits for a text reply before Ultrac calls (default 180)").option("--timeout <seconds>", "Seconds a question waits before the agent proceeds on its own (default 1800)").option("--no-test", "Skip the test message").action(async (options) => {
+    const stored = await readStoredNotifyConfig() ?? NotifyConfigSchema.parse({});
+    const next = { ...stored };
+    if (options.telegramToken) {
+      let chatId = options.telegramChat;
+      if (!chatId) {
+        console.log(chalk6.cyan("Open Telegram and send any message to your bot now. Waiting up to 2 minutes\u2026"));
+        const found = await discoverTelegramChat(options.telegramToken, AbortSignal.timeout(DISCOVERY_TIMEOUT_MS));
+        if (!found) throw new Error("No message reached the bot. Send it a message and run setup again, or pass --telegram-chat.");
+        console.log(chalk6.green(`Found chat: ${found.name} (${found.chatId})`));
+        chatId = found.chatId;
+      }
+      next.telegram = { botToken: options.telegramToken, chatId };
+    } else if (options.telegramChat) {
+      throw new Error("--telegram-chat needs --telegram-token.");
+    }
+    const twilioFlags = [options.twilioSid, options.twilioToken, options.twilioFrom, options.phone];
+    if (twilioFlags.some(Boolean)) {
+      if (!twilioFlags.every(Boolean)) {
+        throw new Error("Twilio needs all four of --twilio-sid, --twilio-token, --twilio-from and --phone.");
+      }
+      next.twilio = {
+        accountSid: options.twilioSid,
+        authToken: options.twilioToken,
+        from: options.twilioFrom,
+        to: options.phone,
+        call: options.call
+      };
+    } else if (next.twilio && options.call === false) {
+      next.twilio = { ...next.twilio, call: false };
+    }
+    const callAfter = parseSeconds(options.callAfter, "--call-after");
+    const timeout = parseSeconds(options.timeout, "--timeout");
+    if (callAfter !== void 0) next.callAfterSeconds = callAfter;
+    if (timeout !== void 0) next.answerTimeoutSeconds = timeout;
+    if (!next.telegram && !next.twilio) {
+      throw new Error(
+        "Configure at least one channel: --telegram-token, or --twilio-sid/--twilio-token/--twilio-from/--phone."
+      );
+    }
+    const path = await writeNotifyConfig(next);
+    console.log(chalk6.green(`Saved ${path}`));
+    for (const line of describeNotifyConfig(NotifyConfigSchema.parse(next))) console.log(`  ${line}`);
+    if (options.test) {
+      const failures = await createNotifier(NotifyConfigSchema.parse(next)).send(
+        "is connected. This is where your agent will reach you."
+      );
+      for (const failure of failures) console.error(chalk6.yellow(`  ${failure}`));
+      console.log(chalk6.green("Test message sent."));
+    }
+  });
+  notify.command("status").description("Show the configured phone channels").action(async () => {
+    const config = await loadNotifyConfig();
+    if (!config) {
+      console.log("No phone channel configured. Run `ultrac notify setup`.");
+      return;
+    }
+    console.log(chalk6.bold(`Phone channels (${notifyConfigPath()} + environment)`));
+    for (const line of describeNotifyConfig(config)) console.log(`  ${line}`);
+  });
+  notify.command("test").description("Send a test message; with --ask, wait for your reply (and call you if it does not come)").option("--ask", "Ask a question and wait for the reply", false).action(async (options) => {
+    const config = await loadNotifyConfig();
+    if (!config) throw new Error("No phone channel configured. Run `ultrac notify setup`.");
+    const notifier = createNotifier(config);
+    if (!options.ask) {
+      const failures = await notifier.send("test message. Your phone channel works.");
+      for (const failure of failures) console.error(chalk6.yellow(failure));
+      console.log(chalk6.green(`Sent via ${notifier.describe()}.`));
+      return;
+    }
+    const controller = new AbortController();
+    process.once("SIGINT", () => controller.abort());
+    console.log(chalk6.cyan(`Asked via ${notifier.describe()}. Reply from your phone (Ctrl-C to stop)\u2026`));
+    const answer = await notifier.ask("This is a test. Reply with anything.", ["Works", "Something is off"], controller.signal);
+    console.log(answer === null ? chalk6.yellow("No reply before the timeout.") : chalk6.green(`Reply: ${answer}`));
+  });
+  notify.command("remove").description("Delete ~/.ultrac/notify.json (environment variables are not affected)").action(async () => {
+    await removeNotifyConfig();
+    console.log(`Removed ${notifyConfigPath()}`);
+  });
+}
+
 // src/commands/repl.ts
-import { createInterface as createInterface3 } from "readline";
+import { createInterface as createInterface3, emitKeypressEvents } from "readline";
 import { stdin as stdin5, stdout as stdout5 } from "process";
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 
 // src/config/budget.ts
 function applyBudgetFlags(flags, config) {
@@ -14595,7 +15308,7 @@ function parseIntFlag(raw, flag) {
 
 // src/commands/trust.ts
 import { resolve as resolve11 } from "path";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 
 // src/ui/confirm.ts
 import { stdin as stdin4, stdout as stdout2 } from "process";
@@ -14666,41 +15379,41 @@ function redactCommand(command) {
 }
 function printTrustReview(workspace, raw, escalations, status) {
   if (escalations) {
-    console.log(chalk6.yellow(`
+    console.log(chalk7.yellow(`
   This workspace's .ultrac/config.json asks for ${describeEscalations(escalations)}.`));
   } else if (status === "legacy") {
-    console.log(chalk6.yellow("\n  This workspace has an older approval that was not bound to its config."));
+    console.log(chalk7.yellow("\n  This workspace has an older approval that was not bound to its config."));
   } else if (status === "changed") {
-    console.log(chalk6.yellow("\n  This workspace's security-sensitive config changed since it was approved."));
+    console.log(chalk7.yellow("\n  This workspace's security-sensitive config changed since it was approved."));
   } else {
-    console.log(chalk6.dim("\n  This workspace's config asks for no additional permissions or MCP servers."));
+    console.log(chalk7.dim("\n  This workspace's config asks for no additional permissions or MCP servers."));
   }
   const preview = renderMcpTrustPreview(raw);
-  for (const line of preview.lines) console.log(chalk6.dim(`  ${line}`));
-  console.log(chalk6.dim("  Literal MCP env values are hidden; only variable names are shown."));
-  console.log(chalk6.dim("  MCP processes are not sandboxed and run with your OS user's privileges."));
-  console.log(chalk6.dim("  Argument redaction is best-effort; review .ultrac/config.json locally for secrets before approval."));
-  console.log(chalk6.dim("  Approval is local to this workspace and bound to its current permissions and MCP launch config."));
+  for (const line of preview.lines) console.log(chalk7.dim(`  ${line}`));
+  console.log(chalk7.dim("  Literal MCP env values are hidden; only variable names are shown."));
+  console.log(chalk7.dim("  MCP processes are not sandboxed and run with your OS user's privileges."));
+  console.log(chalk7.dim("  Argument redaction is best-effort; review .ultrac/config.json locally for secrets before approval."));
+  console.log(chalk7.dim("  Approval is local to this workspace and bound to its current permissions and MCP launch config."));
   return { hasInvalidServers: preview.hasInvalidServers };
 }
 async function offerWorkspaceTrust(workspace, escalations, snapshot, status) {
   const raw = await readRawConfig(workspace);
   if (workspaceTrustSnapshot(raw).securityFingerprint !== snapshot.securityFingerprint) {
-    console.log(chalk6.yellow("\n  Workspace security config changed during review. Nothing was approved; review it again."));
+    console.log(chalk7.yellow("\n  Workspace security config changed during review. Nothing was approved; review it again."));
     return false;
   }
   const { hasInvalidServers } = printTrustReview(workspace, raw, escalations, status);
   if (hasInvalidServers) {
-    console.log(chalk6.yellow("  Invalid MCP entries cannot be approved. Fix the config and review it again.\n"));
+    console.log(chalk7.yellow("  Invalid MCP entries cannot be approved. Fix the config and review it again.\n"));
     return false;
   }
   const granted = await confirmYesNo(`  Trust ${escapeTerminalControls(workspace)}? [y/N]`, false);
   if (granted) {
     const recorded = await trustWorkspace(workspace, snapshot);
-    console.log(chalk6.green(`  Trusted ${escapeTerminalControls(recorded)}.`));
+    console.log(chalk7.green(`  Trusted ${escapeTerminalControls(recorded)}.`));
     return true;
   }
-  console.log(chalk6.dim(`  Not trusted. Those settings were not applied; run ${chalk6.cyan("ultrac trust")} here to allow them.
+  console.log(chalk7.dim(`  Not trusted. Those settings were not applied; run ${chalk7.cyan("ultrac trust")} here to allow them.
 `));
   return false;
 }
@@ -14709,7 +15422,7 @@ function registerTrustCommand(program2) {
     if (options.list) {
       const trusted = await listTrustedWorkspaces();
       if (trusted.length === 0) {
-        console.log(chalk6.dim("No trusted workspaces."));
+        console.log(chalk7.dim("No trusted workspaces."));
         return;
       }
       for (const path of trusted) console.log(escapeTerminalControls(path));
@@ -14719,7 +15432,7 @@ function registerTrustCommand(program2) {
     if (options.revoke) {
       const had = await untrustWorkspace(workspace);
       const safeWorkspace = escapeTerminalControls(workspace);
-      console.log(had ? `No longer trusting ${safeWorkspace}.` : chalk6.dim(`${safeWorkspace} was not trusted.`));
+      console.log(had ? `No longer trusting ${safeWorkspace}.` : chalk7.dim(`${safeWorkspace} was not trusted.`));
       return;
     }
     const raw = await readRawConfig(workspace);
@@ -14728,10 +15441,10 @@ function registerTrustCommand(program2) {
     if (status === "trusted") {
       const preview = printTrustReview(workspace, raw, snapshot.escalations, status);
       if (preview.hasInvalidServers) {
-        console.log(chalk6.yellow("This stored approval no longer has valid MCP launch config. Revoke it before changing the config."));
+        console.log(chalk7.yellow("This stored approval no longer has valid MCP launch config. Revoke it before changing the config."));
         return;
       }
-      console.log(chalk6.green(`Already trusted for ${escapeTerminalControls(workspace)}.`));
+      console.log(chalk7.green(`Already trusted for ${escapeTerminalControls(workspace)}.`));
       return;
     }
     await offerWorkspaceTrust(workspace, snapshot.escalations, snapshot, status);
@@ -14741,6 +15454,9 @@ function registerTrustCommand(program2) {
 // src/core/manual-compaction.ts
 async function compactManually(messages, pinned, provider, model, focus = "", signal) {
   const retained = new Set(pinned);
+  const units = completeContextUnits(messages);
+  if (!units) throw new Error("Compaction found incomplete tool units; original context was kept.");
+  for (const unit of units) if (unit.some((message) => retained.has(message))) for (const message of unit) retained.add(message);
   const history = messages.filter(
     (message) => message.role !== "system" && !retained.has(message) && !isCompactionSummary(message)
   );
@@ -14796,6 +15512,10 @@ Give extra attention to this user-supplied focus: ${focus}` : ""
 }
 
 // src/core/interactive.ts
+var SKIPPED_FOR_QUEUED_MESSAGE = "Skipped; a new user message was queued after the previous tool. Follow that message instead of retrying this call.";
+function skippedForQueuedMessage(tool) {
+  return { tool, ok: false, content: SKIPPED_FOR_QUEUED_MESSAGE };
+}
 function permissionDeniedMessage(tool, permission, sticky) {
   const denied = `User denied ${permission} permission for ${tool}.`;
   if (!sticky) return denied;
@@ -14854,6 +15574,7 @@ var InteractiveSession = class {
   started = false;
   /** How the last turn ended. Absent until one has. */
   lastStopReason;
+  periodicCompactor = new PeriodicCompactor();
   pinnedMessages = [];
   /** Tools described in this turn's system prompt. `/mode` can change it. */
   advertisedTools() {
@@ -14892,6 +15613,7 @@ var InteractiveSession = class {
   }
   async restoreSessions(sessions) {
     if (this.steps.length || this.userConstraints.length) throw new Error("Restore requires a fresh session.");
+    for (const saved of sessions) readSessionContextSnapshot(saved);
     await this.start();
     this.parentSessionId = sessions.at(-1)?.id;
     this.firstTask = sessions.at(-1)?.task ?? "";
@@ -14912,6 +15634,17 @@ var InteractiveSession = class {
         for (const { call, result } of step.toolResults) this.messages.push({ role: "tool", content: JSON.stringify({ call, result: capResultForTranscript(result, this.options.maxToolResultChars) }) });
       }
     }
+    const snapshot = sessions.at(-1)?.contextSnapshot;
+    if (snapshot && snapshot.kind !== "text") this.messages.push(...snapshot.messages.filter(isCompactionSummary).map((message) => ({ role: "user", content: message.content })));
+    if (snapshot?.kind === "text") {
+      this.messages.splice(0, this.messages.length, ...snapshot.messages);
+      this.pinnedMessages.splice(0, this.pinnedMessages.length, ...this.messages.filter((message) => message.role === "user" && !isCompactionSummary(message)));
+      for (const constraint of this.userConstraints) if (!this.messages.some((message) => message.role === "user" && message.content === constraint.content)) {
+        const message = { role: "user", content: constraint.content };
+        this.messages.push(message);
+        this.pinnedMessages.push(message);
+      }
+    }
   }
   contextStatus() {
     const mode = getAgentModePreset(this.activeMode);
@@ -14951,7 +15684,11 @@ var InteractiveSession = class {
   }
   async start() {
     if (this.started) return;
-    const context = await gatherWorkspaceContext(this.registry, this.options.workspace);
+    const context = await gatherWorkspaceContext(
+      this.registry,
+      this.options.workspace,
+      this.advertisedToolNames
+    );
     const modeLabel = getAgentModePreset(this.activeMode).label;
     const contextMessage = {
       role: "user",
@@ -14965,6 +15702,14 @@ Acknowledge that you have the context and wait for the user's first request.`
     this.fileProvenance.set(contextMessage, unknownContextProvenance());
     this.started = true;
   }
+  async checkpoint(handlers) {
+    if (!handlers.onCheckpoint) return;
+    try {
+      await handlers.onCheckpoint(this.toSession());
+    } catch {
+      diagnosticEvent("session.checkpoint", { outcome: "failed", path: "interactive" });
+    }
+  }
   appendQueuedMessages(handlers) {
     const queued = handlers.drainQueuedMessages?.() ?? [];
     let appended = 0;
@@ -15005,6 +15750,11 @@ Acknowledge that you have the context and wait for the user's first request.`
           modePreset
         );
         const turn = this.steps.length + 1;
+        const periodic = await this.periodicCompactor.compact(this.messages, this.pinnedMessages, this.options.provider, this.activeModel, this.steps.length, handlers.signal);
+        if (periodic.compacted) {
+          this.messages.splice(0, this.messages.length, ...periodic.messages);
+          await this.checkpoint(handlers);
+        }
         await this.compactIfNeeded(system, handlers, turn);
         handlers.onModelStart?.();
         let text;
@@ -15043,12 +15793,15 @@ Acknowledge that you have the context and wait for the user's first request.`
         finalMessage = parsed.message;
         if (parsed.message) handlers.onAssistantMessage?.(parsed.message);
         this.messages.push({ role: "assistant", content: JSON.stringify(parsed) });
-        for (const call of parsed.toolCalls) {
+        this.steps.push(step);
+        await this.checkpoint(handlers);
+        for (let callIndex = 0; callIndex < parsed.toolCalls.length; callIndex += 1) {
+          const call = parsed.toolCalls[callIndex];
           if (handlers.signal?.aborted) break;
           const authorization = await this.authorize(call, handlers);
           if (handlers.signal?.aborted) break;
           if (authorization.denied) {
-            const result2 = {
+            const result = {
               tool: call.tool,
               ok: false,
               content: authorization.message ?? permissionDeniedMessage(
@@ -15058,24 +15811,34 @@ Acknowledge that you have the context and wait for the user's first request.`
               )
             };
             if (authorization.permission) handlers.onToolDenied?.(call, authorization.permission);
-            step.toolResults.push({ call, result: result2 });
-            this.pushToolResult(call, result2);
-            continue;
+            step.toolResults.push({ call, result });
+            this.pushToolResult(call, result);
+            await this.checkpoint(handlers);
+          } else {
+            handlers.onToolStart?.(call);
+            const modeAllowlist = getEnforcedModeToolAllowlist(this.activeMode);
+            const rawResult = await this.registry.execute(call, {
+              workspace: this.options.workspace,
+              permissions: getEffectiveModePermissions(this.activeMode, authorization.permissions),
+              ...handlers.signal ? { signal: handlers.signal } : {},
+              ...modeAllowlist ? { modeAllowlist } : {}
+            });
+            const result = await this.mcpResultArchive.store(rawResult, this.options.maxToolResultChars);
+            handlers.onToolResult?.(call, result);
+            step.toolResults.push({ call, result });
+            this.pushToolResult(call, result);
+            await this.checkpoint(handlers);
+          }
+          if (this.appendQueuedMessages(handlers) > 0) {
+            for (const skipped of parsed.toolCalls.slice(callIndex + 1)) {
+              const result = skippedForQueuedMessage(skipped.tool);
+              step.toolResults.push({ call: skipped, result });
+              this.pushToolResult(skipped, result);
+              await this.checkpoint(handlers);
+            }
+            break;
           }
-          handlers.onToolStart?.(call);
-          const modeAllowlist = getEnforcedModeToolAllowlist(this.activeMode);
-          const rawResult = await this.registry.execute(call, {
-            workspace: this.options.workspace,
-            permissions: getEffectiveModePermissions(this.activeMode, authorization.permissions),
-            ...handlers.signal ? { signal: handlers.signal } : {},
-            ...modeAllowlist ? { modeAllowlist } : {}
-          });
-          const result = await this.mcpResultArchive.store(rawResult, this.options.maxToolResultChars);
-          handlers.onToolResult?.(call, result);
-          step.toolResults.push({ call, result });
-          this.pushToolResult(call, result);
         }
-        this.steps.push(step);
         if (handlers.signal?.aborted) {
           stopReason = "aborted";
           handlers.onInterrupted?.();
@@ -15134,7 +15897,7 @@ Acknowledge that you have the context and wait for the user's first request.`
             mode: this.activeMode,
             purpose: "turn"
           }),
-          // The turn's own signal: a Ctrl-C abandons the summary, not the turn.
+          // The turn's own signal: Esc abandons the summary, not the turn.
           ...handlers.signal ? { signal: handlers.signal } : {}
         }
       );
@@ -15151,6 +15914,10 @@ Acknowledge that you have the context and wait for the user's first request.`
         summarisedTurns: plan.summarisedTurns
       });
     } catch (error) {
+      if (error instanceof PinnedContextBudgetError) {
+        trace.end({ outcome: "budget-error", error });
+        throw error;
+      }
       if (!(error instanceof ContextBudgetError)) {
         trace.end({ outcome: "error", error });
         throw error;
@@ -15277,6 +16044,7 @@ Acknowledge that you have the context and wait for the user's first request.`
       constraintVersion: 1,
       userConstraints: [...this.userConstraints],
       mcpResultArchiveVersion: 1,
+      ...this.messages.some(isCompactionSummary) ? { contextSnapshot: { version: 1, kind: "text", messages: snapshotWithConstraints(this.messages, this.userConstraints), completedSteps: this.steps.length } } : {},
       // How the last turn ended, so a saved interactive transcript says whether
       // its final message is an answer or the place it ran out of room - the
       // same question `ultrac run` already answers for a one-shot run.
@@ -15329,6 +16097,7 @@ var NativeSession = class {
   started = false;
   /** How the last turn ended. Absent until one has. */
   lastStopReason;
+  periodicCompactor = new PeriodicCompactor();
   pinnedMessages = [];
   /**
    * The tools this turn advertises. Resolved per turn rather than once in the
@@ -15370,6 +16139,7 @@ var NativeSession = class {
   }
   async restoreSessions(sessions) {
     if (this.steps.length || this.userConstraints.length) throw new Error("Restore requires a fresh session.");
+    for (const saved of sessions) readSessionContextSnapshot(saved);
     await this.start();
     this.parentSessionId = sessions.at(-1)?.id;
     this.firstTask = sessions.at(-1)?.task ?? "";
@@ -15397,6 +16167,17 @@ var NativeSession = class {
         }
       }
     }
+    const snapshot = sessions.at(-1)?.contextSnapshot;
+    if (snapshot && snapshot.kind !== "native") this.messages.push(...snapshot.messages.filter(isCompactionSummary).map((message) => ({ role: "user", content: message.content })));
+    if (snapshot?.kind === "native") {
+      this.messages.splice(0, this.messages.length, ...snapshot.messages);
+      this.pinnedMessages.splice(0, this.pinnedMessages.length, ...this.messages.filter((message) => message.role === "user" && !isCompactionSummary(message)));
+      for (const constraint of this.userConstraints) if (!this.messages.some((message) => message.role === "user" && message.content === constraint.content)) {
+        const message = { role: "user", content: constraint.content };
+        this.messages.push(message);
+        this.pinnedMessages.push(message);
+      }
+    }
   }
   contextStatus() {
     const system = this.systemPrompt();
@@ -15436,7 +16217,11 @@ var NativeSession = class {
   }
   async start() {
     if (this.started) return;
-    const context = await gatherWorkspaceContext(this.registry, this.options.workspace);
+    const context = await gatherWorkspaceContext(
+      this.registry,
+      this.options.workspace,
+      this.advertisedToolNames
+    );
     this.messages.push({ role: "system", content: this.systemPrompt() });
     const contextMessage = {
       role: "user",
@@ -15448,6 +16233,14 @@ ${context}`
     this.fileProvenance.set(contextMessage, unknownContextProvenance());
     this.started = true;
   }
+  async checkpoint(handlers) {
+    if (!handlers.onCheckpoint) return;
+    try {
+      await handlers.onCheckpoint(this.toSession());
+    } catch {
+      diagnosticEvent("session.checkpoint", { outcome: "failed", path: "interactive" });
+    }
+  }
   appendQueuedMessages(handlers) {
     const queued = handlers.drainQueuedMessages?.() ?? [];
     let appended = 0;
@@ -15484,6 +16277,11 @@ ${context}`
         this.refreshSystemPrompt();
         const tools = toToolSchemas(this.advertisedTools());
         const turn = this.steps.length + 1;
+        const periodic = await this.periodicCompactor.compact(this.messages, this.pinnedMessages, this.options.provider, this.activeModel, this.steps.length, handlers.signal);
+        if (periodic.compacted) {
+          this.messages.splice(0, this.messages.length, ...periodic.messages);
+          await this.checkpoint(handlers);
+        }
         await this.compactIfNeeded(tools, handlers, turn);
         handlers.onModelStart?.();
         let response;
@@ -15530,8 +16328,9 @@ ${context}`
             toolCalls: response.toolCalls
           });
         }
+        this.steps.push(step);
+        await this.checkpoint(handlers);
         if (!response.toolCalls.length) {
-          this.steps.push(step);
           if (handlers.signal?.aborted) {
             stopReason = "aborted";
             handlers.onInterrupted?.();
@@ -15543,13 +16342,14 @@ ${context}`
           }
           continue;
         }
-        for (const call of response.toolCalls) {
+        for (let callIndex = 0; callIndex < response.toolCalls.length; callIndex += 1) {
+          const call = response.toolCalls[callIndex];
           if (handlers.signal?.aborted) break;
           const displayCall = { tool: call.name, input: safeParseArgs(call.arguments) };
           const authorization = await this.authorize(call.name, handlers, displayCall);
           if (handlers.signal?.aborted) break;
           if (authorization.denied) {
-            const result2 = {
+            const result = {
               tool: call.name,
               ok: false,
               content: authorization.message ?? permissionDeniedMessage(
@@ -15559,27 +16359,38 @@ ${context}`
               )
             };
             if (authorization.permission) handlers.onToolDenied?.(displayCall, authorization.permission);
-            step.toolResults.push({ call: displayCall, result: result2 });
-            this.pushToolResult(call, result2);
-            continue;
+            step.toolResults.push({ call: displayCall, result });
+            this.pushToolResult(call, result);
+            await this.checkpoint(handlers);
+          } else {
+            handlers.onToolStart?.(displayCall);
+            const modeAllowlist = getEnforcedModeToolAllowlist(this.activeMode);
+            const rawResult = await this.registry.execute(
+              { tool: call.name, input: displayCall.input },
+              {
+                workspace: this.options.workspace,
+                permissions: getEffectiveModePermissions(this.activeMode, authorization.permissions),
+                ...handlers.signal ? { signal: handlers.signal } : {},
+                ...modeAllowlist ? { modeAllowlist } : {}
+              }
+            );
+            const result = await this.mcpResultArchive.store(rawResult, this.options.maxToolResultChars);
+            handlers.onToolResult?.(displayCall, result);
+            step.toolResults.push({ call: displayCall, result });
+            this.pushToolResult(call, result);
+            await this.checkpoint(handlers);
           }
-          handlers.onToolStart?.(displayCall);
-          const modeAllowlist = getEnforcedModeToolAllowlist(this.activeMode);
-          const rawResult = await this.registry.execute(
-            { tool: call.name, input: displayCall.input },
-            {
-              workspace: this.options.workspace,
-              permissions: getEffectiveModePermissions(this.activeMode, authorization.permissions),
-              ...handlers.signal ? { signal: handlers.signal } : {},
-              ...modeAllowlist ? { modeAllowlist } : {}
+          if (this.appendQueuedMessages(handlers) > 0) {
+            for (const skipped of response.toolCalls.slice(callIndex + 1)) {
+              const skippedCall = { tool: skipped.name, input: safeParseArgs(skipped.arguments) };
+              const result = skippedForQueuedMessage(skipped.name);
+              step.toolResults.push({ call: skippedCall, result });
+              this.pushToolResult(skipped, result);
+              await this.checkpoint(handlers);
             }
-          );
-          const result = await this.mcpResultArchive.store(rawResult, this.options.maxToolResultChars);
-          handlers.onToolResult?.(displayCall, result);
-          step.toolResults.push({ call: displayCall, result });
-          this.pushToolResult(call, result);
+            break;
+          }
         }
-        this.steps.push(step);
         if (handlers.signal?.aborted) {
           stopReason = "aborted";
           handlers.onInterrupted?.();
@@ -15634,7 +16445,7 @@ ${context}`
             mode: this.activeMode,
             purpose: "turn"
           }),
-          // The turn's own signal: a Ctrl-C abandons the summary, not the turn.
+          // The turn's own signal: Esc abandons the summary, not the turn.
           ...handlers.signal ? { signal: handlers.signal } : {}
         }
       );
@@ -15651,6 +16462,10 @@ ${context}`
         summarisedTurns: plan.summarisedTurns
       });
     } catch (error) {
+      if (error instanceof PinnedContextBudgetError) {
+        trace.end({ outcome: "budget-error", error });
+        throw error;
+      }
       if (!(error instanceof ContextBudgetError)) {
         trace.end({ outcome: "error", error });
         throw error;
@@ -15750,6 +16565,7 @@ ${context}`
     const mode = getAgentModePreset(this.activeMode);
     const advertised = new Set(this.advertisedToolNames);
     const guidance = [
+      advertisedExploreGuidance(advertised),
       advertised.has("diagnostics") ? "After any edit, call diagnostics with paths set to the files you just wrote, and fix what it reports before declaring the work done." : void 0,
       advertised.has("run_tests") && advertised.has("run_package_script") ? "Prefer run_tests over run_package_script when you want classified test failures." : void 0,
       advertised.has("task") ? "Delegate search-heavy exploration to task so its transcript stays out of this conversation." : void 0,
@@ -15793,6 +16609,7 @@ ${guidance.join("\n")}` : ""}`;
       constraintVersion: 1,
       userConstraints: [...this.userConstraints],
       mcpResultArchiveVersion: 1,
+      ...this.messages.some(isCompactionSummary) ? { contextSnapshot: { version: 1, kind: "native", messages: snapshotWithConstraints(this.messages, this.userConstraints), completedSteps: this.steps.length } } : {},
       // How the last turn ended, so a saved interactive transcript says whether
       // its final message is an answer or the place it ran out of room - the
       // same question `ultrac run` already answers for a one-shot run.
@@ -15843,8 +16660,18 @@ function createSessionCheckpointWriter(workspace, onFailure) {
   return Object.assign(writeCheckpoint, { warnFailure });
 }
 
+// src/ui/ghost.ts
+var quietSessions = /* @__PURE__ */ new WeakSet();
+function isGhostEnabled(session) {
+  return quietSessions.has(session);
+}
+function setGhostEnabled(session, enabled) {
+  if (enabled) quietSessions.add(session);
+  else quietSessions.delete(session);
+}
+
 // src/ui/output.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 var stopReasonDetail = {
   "max-steps": "partial answer - hit the step cap before the model said it was done",
   aborted: "partial answer - the run was interrupted before the model said it was done",
@@ -15856,15 +16683,15 @@ function stopReasonLine(stopReason) {
   const detail = stopReasonDetail[reason] ?? "partial answer";
   return `Stopped: ${reason} (${detail})`;
 }
-function printSession(session, sessionPath2) {
+function printSession(session, sessionPath2, options = {}) {
   for (const step of session.steps) {
     if (step.parsed?.message) {
-      console.log(chalk7.gray(`step ${step.index + 1}:`), step.parsed.message);
+      console.log(chalk8.gray(`step ${step.index + 1}:`), step.parsed.message);
     }
     for (const toolResult of step.toolResults) {
-      const status = toolResult.result.ok ? chalk7.green("ok") : chalk7.red("failed");
-      console.log(chalk7.cyan(toolResult.call.tool), status);
-      console.log(chalk7.gray(indent2(toolResult.result.content)));
+      const status = toolResult.result.ok ? chalk8.green("ok") : chalk8.red("failed");
+      console.log(chalk8.cyan(toolResult.call.tool), status);
+      console.log(chalk8.gray(indent2(formatToolOutput(toolResult.result.content, { verbose: options.verboseTools, failed: !toolResult.result.ok, hint: "Use --verbose-tools or inspect the saved session for full output." }))));
     }
   }
   if (session.finalMessage) {
@@ -15874,30 +16701,44 @@ function printSession(session, sessionPath2) {
   console.log();
   const stopped = stopReasonLine(session.stopReason);
   if (stopped) {
-    console.log(chalk7.yellow(stopped));
-    console.log(chalk7.gray(`Resume with: ultrac run --continue ${session.id}`));
+    console.log(chalk8.yellow(stopped));
+    console.log(chalk8.gray(`Resume with: ultrac run --continue ${session.id}`));
   }
-  console.log(chalk7.gray(`Session saved: ${sessionPath2}`));
+  console.log(chalk8.gray(`Session saved: ${sessionPath2}`));
 }
 function printTools(tools) {
   for (const tool of tools) {
-    const permissionText = tool.permissions.length ? chalk7.yellow(` [${tool.permissions.join(", ")}]`) : "";
-    const optionalText = tool.optionalPermissions.length ? chalk7.gray(` [optional: ${tool.optionalPermissions.join(", ")}]`) : "";
-    console.log(`${chalk7.cyan(tool.name)}${permissionText}${optionalText}`);
-    console.log(chalk7.gray(indent2(tool.description)));
+    const permissionText = tool.permissions.length ? chalk8.yellow(` [${tool.permissions.join(", ")}]`) : "";
+    const optionalText = tool.optionalPermissions.length ? chalk8.gray(` [optional: ${tool.optionalPermissions.join(", ")}]`) : "";
+    console.log(`${chalk8.cyan(tool.name)}${permissionText}${optionalText}`);
+    console.log(chalk8.gray(indent2(tool.description)));
   }
 }
-function printToolResult(result) {
-  const status = result.ok ? chalk7.green("ok") : chalk7.red("failed");
-  console.log(`${chalk7.cyan(result.tool)} ${status}`);
-  console.log(chalk7.gray(indent2(result.content)));
+function printToolResult(result, options = {}) {
+  const status = result.ok ? chalk8.green("ok") : chalk8.red("failed");
+  console.log(`${chalk8.cyan(result.tool)} ${status}`);
+  console.log(chalk8.gray(indent2(formatToolOutput(result.content, { verbose: options.verboseTools, failed: !result.ok, hint: "Use --verbose-tools or --result-json for full output." }))));
 }
 function indent2(value) {
   return value.split("\n").map((line) => `  ${line}`).join("\n");
 }
+function formatToolOutput(content, options = {}) {
+  if (options.verbose) return content;
+  const lines = content.split(/\r?\n/);
+  const shown = lines.length <= 6 ? lines : options.failed ? [...lines.slice(0, 3), ...lines.slice(-3)] : lines.slice(0, 6);
+  const clipped = shown.some((line) => line.length > 200);
+  const preview = shown.map((line) => line.length > 200 ? `${line.slice(0, 199)}\u2026` : line).join("\n");
+  const hidden = lines.length - shown.length;
+  if (!hidden && !clipped) return preview;
+  return `${preview}
+\u2026 ${hidden ? `${hidden} more lines` : "Long lines shortened"}. ${options.hint ?? "Full output remains available in the saved session."}`;
+}
 
 // src/skills/commands.ts
 var BUILTIN_SLASH_COMMANDS = [
+  "logs",
+  "ghost",
+  "output",
   "usage",
   "max-steps",
   "resume",
@@ -16096,7 +16937,7 @@ function formatSkillCommandHelp(index) {
 
 // src/ui/progress.ts
 import { stdout as stdout3 } from "process";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 var PENDING_GLYPH = "\u25CB";
 var DONE_GLYPH = "\u25CF";
 var REPAINT_MS = 100;
@@ -16123,12 +16964,12 @@ function formatElapsed(ms) {
 }
 function formatProgressLine(snapshot) {
   const finished = snapshot.done >= snapshot.total;
-  const glyph = finished ? chalk8.green(DONE_GLYPH) : chalk8.cyan(PENDING_GLYPH);
+  const glyph = finished ? chalk9.green(DONE_GLYPH) : chalk9.cyan(PENDING_GLYPH);
   const noun = snapshot.total === 1 ? "agent" : "agents";
   const stats = [`${snapshot.done}/${snapshot.total} ${noun} done`, formatElapsed(snapshot.elapsedMs)];
   if (snapshot.tokens !== void 0) stats.push(`\u2193 ${formatTokens(snapshot.tokens)} tokens`);
-  const rendered = stats.map((stat11) => chalk8.dim(stat11)).join(chalk8.dim(" \xB7 "));
-  return `  ${glyph} ${chalk8.cyan(snapshot.label)}  ${snapshot.description}  ${rendered}`;
+  const rendered = stats.map((stat11) => chalk9.dim(stat11)).join(chalk9.dim(" \xB7 "));
+  return `  ${glyph} ${chalk9.cyan(snapshot.label)}  ${snapshot.description}  ${rendered}`;
 }
 var ProgressLine = class {
   constructor(label, description, total) {
@@ -16264,7 +17105,10 @@ var Spinner = class {
   label;
   timer;
   index = 0;
-  start() {
+  holdWhile;
+  held = false;
+  start(holdWhile) {
+    this.holdWhile = holdWhile;
     if (!stdout4.isTTY || this.timer) return;
     this.render();
     this.timer = setInterval(() => this.render(), 90);
@@ -16283,6 +17127,15 @@ var Spinner = class {
     }
   }
   render() {
+    if (this.holdWhile?.()) {
+      if (!this.held) {
+        stdout4.clearLine(0);
+        stdout4.cursorTo(0);
+        this.held = true;
+      }
+      return;
+    }
+    this.held = false;
     this.index = (this.index + 1) % FRAMES.length;
     stdout4.clearLine(0);
     stdout4.cursorTo(0);
@@ -16362,7 +17215,7 @@ function humanize(value) {
 }
 
 // src/ui/welcome.ts
-import chalk9, { Chalk } from "chalk";
+import chalk10, { Chalk } from "chalk";
 var LOGO = [
   "\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557",
   "\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551  \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D",
@@ -16373,7 +17226,7 @@ var LOGO = [
 ];
 function renderWelcome(info, options = {}) {
   const columns = normalizeColumns(options.columns);
-  const paint = new Chalk({ level: options.color === false ? 0 : chalk9.level });
+  const paint = new Chalk({ level: options.color === false ? 0 : chalk10.level });
   const cardWidth = Math.min(88, Math.max(42, columns));
   const innerWidth = cardWidth - 4;
   const wide = columns >= 64;
@@ -16398,12 +17251,12 @@ function renderWelcome(info, options = {}) {
   lines.push(cardLine(`logs ${shortenMiddle(info.diagnosticPath, Math.max(8, innerWidth - 5))}`, innerWidth, paint.gray));
   lines.push(paint.cyan(`\u2570${"\u2500".repeat(cardWidth - 2)}\u256F`));
   lines.push(
-    wide ? `${paint.gray("  /help commands")} ${paint.dim("\xB7")} ${paint.gray("/exit quit")} ${paint.dim("\xB7")} ${paint.gray("Ctrl-C interrupt")}` : paint.gray("  /help \xB7 /exit \xB7 Ctrl-C")
+    wide ? `${paint.gray("  /help commands")} ${paint.dim("\xB7")} ${paint.gray("Esc stop")} ${paint.dim("\xB7")} ${paint.gray("Ctrl-C exit")}` : paint.gray("  /help \xB7 Esc \xB7 Ctrl-C")
   );
   return lines.join("\n");
 }
 function renderComposer(columns = 80, color = true) {
-  const paint = new Chalk({ level: color ? chalk9.level : 0 });
+  const paint = new Chalk({ level: color ? chalk10.level : 0 });
   const width = Math.min(88, Math.max(28, normalizeColumns(columns)));
   const label = " message ";
   const fill = Math.max(1, width - label.length - 2);
@@ -16436,14 +17289,14 @@ function shortenMiddle(value, width) {
 // src/update/check.ts
 import { spawn as spawn4 } from "child_process";
 import { randomBytes as randomBytes4 } from "crypto";
-import { readFile as readFile12, rename as rename2, unlink as unlink3, writeFile as writeFile11 } from "fs/promises";
-import { join as join12 } from "path";
+import { readFile as readFile13, rename as rename3, unlink as unlink4, writeFile as writeFile12 } from "fs/promises";
+import { join as join14 } from "path";
 var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var QUERY_TIMEOUT_MS = 5e3;
 var INSTALL_TIMEOUT_MS = 5 * 60 * 1e3;
 async function checkForUpdate(options) {
   const now = options.now ?? Date.now();
-  const cachePath = options.cachePath ?? join12(await ensureUltracHome(), "update-check.json");
+  const cachePath = options.cachePath ?? join14(await ensureUltracHome(), "update-check.json");
   const maxAgeMs = options.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
   let latestVersion;
   if (!options.force) {
@@ -16511,7 +17364,7 @@ function parseVersion(version) {
 }
 async function readCache(path) {
   try {
-    const raw = await readFile12(path, "utf8");
+    const raw = await readFile13(path, "utf8");
     if (raw.length > 1024) return void 0;
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || !("checkedAt" in parsed) || typeof parsed.checkedAt !== "number" || !("latestVersion" in parsed) || parsed.latestVersion !== null && typeof parsed.latestVersion !== "string") {
@@ -16525,21 +17378,21 @@ async function readCache(path) {
 async function writeCache(path, cache) {
   const temporary = `${path}.${randomBytes4(8).toString("hex")}.tmp`;
   try {
-    await writeFile11(temporary, `${JSON.stringify(cache)}
+    await writeFile12(temporary, `${JSON.stringify(cache)}
 `, { encoding: "utf8", mode: 384, flag: "wx" });
-    await rename2(temporary, path);
+    await rename3(temporary, path);
   } catch {
-    await unlink3(temporary).catch(() => void 0);
+    await unlink4(temporary).catch(() => void 0);
   }
 }
 async function runNpm(args, options) {
-  const env = { ...process.env };
-  for (const key of Object.keys(env)) {
-    if (key.startsWith("ULTRAC_")) delete env[key];
+  const env2 = { ...process.env };
+  for (const key of Object.keys(env2)) {
+    if (key.startsWith("ULTRAC_")) delete env2[key];
   }
   return new Promise((resolve15) => {
     const child = spawn4(process.platform === "win32" ? "npm.cmd" : "npm", args, {
-      env,
+      env: env2,
       stdio: options.capture ? ["ignore", "pipe", "ignore"] : "inherit",
       windowsHide: true
     });
@@ -16587,11 +17440,18 @@ var HELP = `Commands:
   /allow <perm>         Grant a permission for this session (write, shell, network)
   /whoami               Show sign-in state
   /tools                List available tools
+  /logs                 Show the private diagnostic log path
+  /ghost [on|off|status] Quiet activity output; diagnostics stay enabled
+  /output [number|list]  Inspect saved tool output (latest by default)
   /memory               List and inspect stored memories
   /skills               List installed skills
   /update               Show how to install an available CLI update
   /clear                Start a fresh conversation
   /exit, /quit          End the session
+Keys:
+  Type during a turn    Queue a follow-up for after the current tool call
+  Esc                   Stop the current turn; the session stays open
+  Ctrl-C                Exit and save the session
 Custom commands come from skills that declare a 'command:' key in their
 frontmatter; built-ins always win a name clash. Type anything else to talk to Ultrac.`;
 var EXIT_REPL_NOT_STARTED = 1;
@@ -16659,14 +17519,14 @@ async function runRepl(options, initialTask = "") {
   if (loaded.needsApproval && await offerWorkspaceTrust(workspace, loaded.withheld, loaded.trustSnapshot, loaded.trustStatus)) {
     loaded = await loadConfigWithTrust(workspace);
     if (loaded.needsApproval) {
-      console.log(chalk10.yellow(`
+      console.log(chalk11.yellow(`
   ${withheldNotice(workspace, loaded.withheld, loaded.trustStatus)}
 `));
     }
   }
   const config = loaded.config;
   const toolSelection = applyBudgetFlags(options, config);
-  setContextBudgetNotice((message) => console.log(chalk10.yellow(`
+  setContextBudgetNotice((message) => console.log(chalk11.yellow(`
   ! ${message}`)));
   const providerName = options.provider ?? config.provider;
   if (!isProviderName(providerName)) {
@@ -16682,8 +17542,8 @@ async function runRepl(options, initialTask = "") {
   }
   const hasFallbackChain = Boolean(config.fallback?.chain?.length);
   if (providerName === "ultrac" && !hasFallbackChain && !await resolveUltracCredentials()) {
-    console.log(chalk10.yellow("You are not signed in to Ultrac."));
-    console.log(`Run ${chalk10.cyan("ultrac login")} first, or start with ${chalk10.cyan("--provider echo")}.`);
+    console.log(chalk11.yellow("You are not signed in to Ultrac."));
+    console.log(`Run ${chalk11.cyan("ultrac login")} first, or start with ${chalk11.cyan("--provider echo")}.`);
     process.exitCode = EXIT_REPL_NOT_STARTED;
     return;
   }
@@ -16695,26 +17555,26 @@ async function runRepl(options, initialTask = "") {
       model,
       fallback: config.fallback,
       onFailover: (event) => {
-        console.log(chalk10.yellow(formatFailoverNotice(event)));
+        console.log(chalk11.yellow(formatFailoverNotice(event)));
         if (event.to) {
-          console.log(chalk10.gray(`  now answering: provider ${event.to.provider} \xB7 model ${event.to.model}`));
+          console.log(chalk11.gray(`  now answering: provider ${event.to.provider} \xB7 model ${event.to.model}`));
         }
       },
       // A tool-calling turn served by an entry without native tool calling still
       // answers, but over the JSON tool protocol. Say so rather than letting the
       // banner's "native tools" claim go stale.
-      onDowngrade: (event) => console.log(chalk10.yellow(formatDowngradeNotice(event))),
+      onDowngrade: (event) => console.log(chalk11.yellow(formatDowngradeNotice(event))),
       onRetry: (event) => {
         diagnosticEvent("provider.retry", event);
         console.log(
-          chalk10.yellow(
+          chalk11.yellow(
             `  retrying ${event.target.provider} (${event.target.model}) in ${event.delayMs}ms after ${event.classification.reason}`
           )
         );
       }
     });
   } catch (error) {
-    console.log(chalk10.red(error instanceof Error ? error.message : String(error)));
+    console.log(chalk11.red(error instanceof Error ? error.message : String(error)));
     process.exitCode = EXIT_REPL_NOT_STARTED;
     return;
   }
@@ -16746,7 +17606,7 @@ async function runRepl(options, initialTask = "") {
     permissions: basePermissions
   });
   const writeCheckpoint = createSessionCheckpointWriter(workspace, (message) => {
-    console.error(chalk10.yellow(message));
+    console.error(chalk11.yellow(message));
   });
   const persistSession = async (target = session) => {
     const snapshot = target.toSession();
@@ -16764,7 +17624,7 @@ async function runRepl(options, initialTask = "") {
     diagnosticPath2
   );
   if (mcpRuntime && mcpRuntime.statuses.length > 0) {
-    console.log(chalk10.bold("\nMCP servers"));
+    console.log(chalk11.bold("\nMCP servers"));
     console.log(renderMcpStatuses(mcpRuntime.statuses));
   }
   try {
@@ -16774,9 +17634,9 @@ async function runRepl(options, initialTask = "") {
   }
   const update = await updateCheck;
   if (update?.updateAvailable && update.latestVersion) {
-    console.log(chalk10.yellow(`
+    console.log(chalk11.yellow(`
   \u2191 Update available: ${update.currentVersion} \u2192 ${update.latestVersion}`));
-    console.log(chalk10.gray("    Run `ultrac update` after this session."));
+    console.log(chalk11.gray("    Run `ultrac update` after this session."));
   }
   const rl = createInterface3({ input: stdin5, output: stdout5 });
   const reader = new LineReader(rl);
@@ -16786,13 +17646,13 @@ async function runRepl(options, initialTask = "") {
   };
   const drainQueuedMessages = () => reader.drainQueuedMessages();
   setAskUserRuntime(async (text, options2, signal) => {
-    console.log(chalk10.cyan(`
+    console.log(chalk11.cyan(`
   ? ${text}`));
     if (options2?.length) {
-      options2.forEach((option, index) => console.log(chalk10.gray(`     ${index + 1}. ${option}`)));
-      console.log(chalk10.gray("     (type a number, or answer in your own words)"));
+      options2.forEach((option, index) => console.log(chalk11.gray(`     ${index + 1}. ${option}`)));
+      console.log(chalk11.gray("     (type a number, or answer in your own words)"));
     }
-    const rawAnswer = await question(chalk10.cyan("  \u203A "), signal);
+    const rawAnswer = await question(chalk11.cyan("  \u203A "), signal);
     if (signal?.aborted) return null;
     const answer = (rawAnswer ?? "").trim();
     const picked = Number.parseInt(answer, 10);
@@ -16803,12 +17663,21 @@ async function runRepl(options, initialTask = "") {
   });
   let running = true;
   let turnAbort;
-  rl.on("SIGINT", () => {
-    if (handleReplInterrupt(turnAbort) === "abort-turn") return;
+  const exitSession = () => {
+    handleReplExit(turnAbort);
     running = false;
-    console.log(chalk10.gray("\nExiting ultrac\u2026"));
+    console.log(chalk11.gray("\nExiting ultrac\u2026"));
     rl.close();
-  });
+  };
+  rl.on("SIGINT", exitSession);
+  const onKeypress = (_input, key) => {
+    if (!key || key.name !== "escape" || key.ctrl || key.meta) return;
+    handleReplEscape(turnAbort);
+  };
+  if (stdin5.isTTY) {
+    emitKeypressEvents(stdin5, rl);
+    stdin5.on("keypress", onKeypress);
+  }
   const terminate = () => {
     running = false;
     turnAbort?.abort();
@@ -16825,9 +17694,9 @@ async function runRepl(options, initialTask = "") {
   };
   try {
     if (initialTask) {
-      console.log(chalk10.cyan(`
+      console.log(chalk11.cyan(`
 \u203A ${initialTask}`));
-      await withInterrupt((signal) => runAndCheckpointTurn(session, initialTask, question, signal, persistSession, drainQueuedMessages));
+      await withInterrupt((signal) => runAndCheckpointTurn(session, initialTask, question, signal, persistSession, drainQueuedMessages, () => reader.composing));
     }
     while (running) {
       if (stdout5.isTTY) {
@@ -16835,7 +17704,7 @@ async function runRepl(options, initialTask = "") {
         console.log(composer.frame);
         stdout5.write(composer.prompt);
       } else {
-        stdout5.write(chalk10.cyan("\n\u203A "));
+        stdout5.write(chalk11.cyan("\n\u203A "));
       }
       const line = await reader.next();
       if (line === null) break;
@@ -16852,9 +17721,9 @@ async function runRepl(options, initialTask = "") {
               permissions: session.currentPermissions
             });
             resetContextBudgetNotices();
-            console.log(chalk10.gray("Started a fresh conversation."));
+            console.log(chalk11.gray("Started a fresh conversation."));
           }, async (prompt) => {
-            await runAndCheckpointTurn(session, prompt, question, signal, persistSession, drainQueuedMessages);
+            await runAndCheckpointTurn(session, prompt, question, signal, persistSession, drainQueuedMessages, () => reader.composing);
           }, signal, async (id) => {
             const lineage = await loadSessionLineage(workspace, id);
             const restored = createSession({ model: session.model, mode: session.mode, permissions: session.currentPermissions });
@@ -16883,35 +17752,43 @@ async function runRepl(options, initialTask = "") {
         }
         continue;
       }
-      await withInterrupt((signal) => runAndCheckpointTurn(session, raw, question, signal, persistSession, drainQueuedMessages));
+      await withInterrupt((signal) => runAndCheckpointTurn(session, raw, question, signal, persistSession, drainQueuedMessages, () => reader.composing));
     }
   } finally {
     process.off("SIGTERM", terminate);
+    if (stdin5.isTTY) stdin5.off("keypress", onKeypress);
     setAskUserRuntime(void 0);
     rl.close();
     await saveTranscript(session, writeCheckpoint);
     mcpRuntime?.close();
   }
-  console.log(chalk10.gray("Goodbye."));
+  console.log(chalk11.gray("Goodbye."));
 }
-async function runTurn(session, input, question, signal, drainQueuedMessages) {
+async function runTurn(session, input, question, signal, drainQueuedMessages, persist, isComposing) {
   const spinner = new Spinner();
-  const detachProgress = attachProgressUi();
+  const quiet = isGhostEnabled(session);
+  const detachProgress = quiet ? () => {
+  } : attachProgressUi();
   let deltaChars = 0;
   try {
     await session.ask(input, {
       ...signal ? { signal } : {},
+      ...persist ? {
+        onCheckpoint: async () => {
+          await persist(session);
+        }
+      } : {},
       onInterrupted: () => {
         spinner.stop();
-        console.log(chalk10.dim("\n  Interrupted \u2014 current work stopped. Session preserved."));
+        console.log(chalk11.dim("\n  Interrupted \u2014 current work stopped. Session preserved."));
       },
       onModelStart: () => {
         deltaChars = 0;
-        spinner.start();
+        if (!quiet) spinner.start(isComposing);
       },
       onModelDelta: (text) => {
         deltaChars += text.length;
-        spinner.update(`thinking (${deltaChars} chars)`);
+        if (!quiet) spinner.update(`thinking (${deltaChars} chars)`);
       },
       onModelSettled: () => spinner.stop(),
       onAssistantMessage: (message) => {
@@ -16921,41 +17798,41 @@ ${message.trim()}`);
         }
       },
       onToolStart: (call) => {
-        console.log(chalk10.dim(`  ${toolActivityLabel(call)}`));
+        if (!quiet) console.log(chalk11.dim(`  ${toolActivityLabel(call)}`));
       },
       onToolResult: (_call, result) => printToolResult2(result),
       ...drainQueuedMessages ? {
         drainQueuedMessages,
-        onQueuedMessage: () => {
+        onQueuedMessage: (message) => {
           spinner.stop();
-          console.log(chalk10.dim("  Queued message added to the current turn."));
+          console.log(chalk11.dim(`  Queued for after the current tool: ${message}`));
         }
       } : {},
       onToolDenied: (call, permission) => {
-        console.log(chalk10.yellow(`  \u2717 denied ${permission} for ${call.tool}`));
+        console.log(chalk11.yellow(`  \u2717 denied ${permission} for ${call.tool}`));
       },
       onProviderNotice: (notice) => {
-        console.log(chalk10.yellow(`  ! ${notice}`));
+        console.log(chalk11.yellow(`  ! ${notice}`));
       },
       onStopped: (reason) => {
         if (reason === "aborted") return;
         const line = stopReasonLine(reason);
         const hint = turnStopHint(reason, session.maxSteps);
         if (!line || !hint) return;
-        console.log(chalk10.yellow(`
+        console.log(chalk11.yellow(`
   \u26A0 ${line}`));
-        console.log(chalk10.gray(`  ${hint}`));
+        console.log(chalk11.gray(`  ${hint}`));
       },
       requestPermission: async (call, permission) => {
         const prompt = permission === "shell" && call.tool === "run_shell" ? shellApprovalPrompt(call, session.toSession().workspace) : permission === "shell" ? `  ${call.tool} wants shell access. [o]nce (this call only) / [a]lways (all shell tools for this session) / [n]o (this call) / n[e]ver (this session) \u203A ` : `  ${call.tool} wants ${permission} access. [o]nce / [a]lways / [n]o / n[e]ver \u203A `;
-        const rawAnswer = await question(chalk10.yellow(prompt), signal);
+        const rawAnswer = await question(chalk11.yellow(prompt), signal);
         if (signal?.aborted || rawAnswer === null) return "deny";
         const answer = rawAnswer.trim().toLowerCase();
         if (answer === "a" || answer === "always") return "always";
         if (answer === "o" || answer === "once" || answer === "y" || answer === "yes") return "once";
         if (answer === "e" || answer === "never") {
           console.log(
-            chalk10.gray(
+            chalk11.gray(
               `  ${permission} refused for the rest of the session \u2014 nothing will ask again. /allow ${permission} undoes it.`
             )
           );
@@ -16973,9 +17850,9 @@ ${message.trim()}`);
     detachProgress();
   }
 }
-async function runAndCheckpointTurn(session, input, question, signal, persist, drainQueuedMessages) {
+async function runAndCheckpointTurn(session, input, question, signal, persist, drainQueuedMessages, isComposing) {
   try {
-    return await runTurn(session, input, question, signal, drainQueuedMessages);
+    return await runTurn(session, input, question, signal, drainQueuedMessages, persist, isComposing);
   } finally {
     await persist(session);
   }
@@ -16992,27 +17869,27 @@ function turnStopHint(reason, maxSteps) {
 }
 function printTurnError(error) {
   if (error instanceof ProviderChainError) {
-    console.log(chalk10.red("\n  \u2717 Turn failed: no provider in the chain could answer."));
+    console.log(chalk11.red("\n  \u2717 Turn failed: no provider in the chain could answer."));
     for (const failure of error.failures) {
       const attempts = failure.attempts === 1 ? "1 attempt" : `${failure.attempts} attempts`;
       console.log(
-        chalk10.red(`    - ${failure.provider} (${failure.model}), ${attempts}: ${errorMessage2(failure.error)}`)
+        chalk11.red(`    - ${failure.provider} (${failure.model}), ${attempts}: ${errorMessage2(failure.error)}`)
       );
     }
     console.log(
-      chalk10.gray("  Fix the provider (ultrac login, or --provider echo) and try again; the session is still open.")
+      chalk11.gray("  Fix the provider (ultrac login, or --provider echo) and try again; the session is still open.")
     );
     return;
   }
-  console.log(chalk10.red(`
+  console.log(chalk11.red(`
   \u2717 Turn failed: ${errorMessage2(error)}`));
-  console.log(chalk10.gray("  The session is still open. Try again, or /exit to end it."));
+  console.log(chalk11.gray("  The session is still open. Try again, or /exit to end it."));
 }
 async function saveTranscript(session, writeCheckpoint) {
   const snapshot = session.toSession();
   if (!hasSavedSessionContent(snapshot)) return;
   const stored = await writeCheckpoint(snapshot);
-  if (stored) console.log(chalk10.gray(`
+  if (stored) console.log(chalk11.gray(`
 Session saved: ${stored}`));
 }
 function hasSavedSessionContent(session) {
@@ -17047,6 +17924,21 @@ async function handleSlashCommand(raw, session, providerName, workspace, onClear
   const command = (name ?? "").toLowerCase();
   const argument = rest.join(" ").trim();
   switch (command) {
+    case "logs": {
+      console.log(currentDiagnosticLogPath() ?? "Diagnostic logging has not been configured for this process.");
+      return "ok";
+    }
+    case "ghost": {
+      if (argument && !["on", "off", "status"].includes(argument.toLowerCase())) {
+        console.log("Usage: /ghost [on|off|status]");
+        return "ok";
+      }
+      if (argument.toLowerCase() !== "status") {
+        setGhostEnabled(session, argument ? argument.toLowerCase() === "on" : !isGhostEnabled(session));
+      }
+      console.log(`Ghost mode: ${isGhostEnabled(session) ? "on" : "off"}. Quiet activity output; private diagnostics remain enabled. Network routing and permissions are unchanged.`);
+      return "ok";
+    }
     case "help": {
       console.log(HELP);
       const index = await listSkillCommands(workspace);
@@ -17054,7 +17946,7 @@ async function handleSlashCommand(raw, session, providerName, workspace, onClear
       if (extra) console.log(`
 ${extra}`);
       for (const conflict of index.conflicts) {
-        console.log(chalk10.yellow(`  ! ${conflict.message}`));
+        console.log(chalk11.yellow(`  ! ${conflict.message}`));
       }
       return "ok";
     }
@@ -17068,7 +17960,7 @@ ${extra}`);
     case "model":
       if (argument) {
         session.setModel(argument);
-        console.log(chalk10.gray(`Model set to ${argument}.`));
+        console.log(chalk11.gray(`Model set to ${argument}.`));
       } else {
         console.log(`Model: ${session.model}`);
       }
@@ -17076,10 +17968,10 @@ ${extra}`);
     case "mode":
       if (argument) {
         if (!isAgentModeName(argument)) {
-          console.log(chalk10.red(`Unknown mode. Expected one of: ${agentModeNames.join(", ")}.`));
+          console.log(chalk11.red(`Unknown mode. Expected one of: ${agentModeNames.join(", ")}.`));
         } else {
           session.setMode(argument);
-          console.log(chalk10.gray(`Mode set to ${argument}.`));
+          console.log(chalk11.gray(`Mode set to ${argument}.`));
         }
       } else {
         console.log(`Mode: ${session.mode}`);
@@ -17128,7 +18020,7 @@ ${extra}`);
       console.log(
         `Selected ${info.selectedMessages.toLocaleString("en-US")} of ${info.messages.toLocaleString("en-US")} messages; would omit ${info.omittedMessages.toLocaleString("en-US")} messages in ${info.omittedTurns.toLocaleString("en-US")} earlier turns. Prompt headroom ${info.promptRemainingTokens.toLocaleString("en-US")} tokens; window headroom ${info.windowRemainingTokens.toLocaleString("en-US")} of ${info.contextTokens.toLocaleString("en-US")} tokens.`
       );
-      if (info.error) console.log(chalk10.yellow(`Context error: ${info.error}`));
+      if (info.error) console.log(chalk11.yellow(`Context error: ${info.error}`));
       return "ok";
     }
     case "compact":
@@ -17136,7 +18028,7 @@ ${extra}`);
         await session.compactContext(argument, signal);
         console.log("Context compacted. User instructions were retained; earlier activity was replaced by a bounded continuation record.");
       } catch (error) {
-        console.log(chalk10.red(errorMessage2(error)));
+        console.log(chalk11.red(errorMessage2(error)));
       }
       return "ok";
     case "resume":
@@ -17147,7 +18039,7 @@ ${extra}`);
       try {
         await resume(argument);
       } catch (error) {
-        console.log(chalk10.red(errorMessage2(error)));
+        console.log(chalk11.red(errorMessage2(error)));
       }
       return "ok";
     case "save": {
@@ -17198,7 +18090,7 @@ ${extra}`);
       const refused = session.refusedPermissions;
       if (refused.length) {
         console.log(
-          chalk10.gray(`refused for this session: ${refused.join(", ")} (undo with /allow <perm>)`)
+          chalk11.gray(`refused for this session: ${refused.join(", ")} (undo with /allow <perm>)`)
         );
       }
       return "ok";
@@ -17207,9 +18099,9 @@ ${extra}`);
     case "allow": {
       if (argument === "write" || argument === "shell" || argument === "network") {
         session.setPermission(argument, command === "allow");
-        console.log(chalk10.gray(`${command === "allow" ? "Granted" : "Revoked"} ${argument} for this session.`));
+        console.log(chalk11.gray(`${command === "allow" ? "Granted" : "Revoked"} ${argument} for this session.`));
       } else {
-        console.log(chalk10.red(`Usage: /${command} <write|shell|network>`));
+        console.log(chalk11.red(`Usage: /${command} <write|shell|network>`));
       }
       return "ok";
     }
@@ -17224,11 +18116,32 @@ ${extra}`);
       }
       return "ok";
     }
+    case "output": {
+      const results = session.toSession().steps.flatMap((step) => step.toolResults);
+      if (!results.length) {
+        console.log("No saved tool output in this session.");
+        return "ok";
+      }
+      if (argument === "list") {
+        for (const [index, entry2] of results.entries()) console.log(`${index + 1}. ${toolActivityLabel(entry2.call)} (${entry2.result.ok ? "ok" : "failed"})`);
+        return "ok";
+      }
+      const selected = argument ? Number(argument) : results.length;
+      if (!Number.isSafeInteger(selected) || selected < 1 || selected > results.length) {
+        console.log(`Usage: /output [1-${results.length}|list]`);
+        return "ok";
+      }
+      const entry = results[selected - 1];
+      console.log(`${selected}. ${toolActivityLabel(entry.call)} (${entry.result.ok ? "ok" : "failed"})`);
+      console.log(entry.result.content);
+      for (const warning of getMcpArchiveWarnings(entry.result)) console.log(chalk11.yellow(`Warning: ${warning}`));
+      return "ok";
+    }
     case "tools": {
       const names = session.advertisedToolNames;
       console.log(`Advertised to the model this turn (${names.length}): ${names.join(", ")}`);
       console.log(
-        chalk10.gray(
+        chalk11.gray(
           "Registered tools remain subject to permission and mode checks. `ultrac tools` lists them all with schemas; --tools all advertises them all."
         )
       );
@@ -17237,7 +18150,7 @@ ${extra}`);
     case "memory": {
       const memories = await listMemories(workspace);
       if (!memories.length) {
-        console.log(chalk10.gray("No stored memories. Add one with `ultrac memory add`."));
+        console.log(chalk11.gray("No stored memories. Add one with `ultrac memory add`."));
       } else {
         for (const memory of memories) {
           console.log(`- [${memory.scope}/${memory.name}] (${memory.type}) ${memory.description}`);
@@ -17248,7 +18161,7 @@ ${extra}`);
     case "skills": {
       const skills = await listSkills(workspace);
       if (!skills.length) {
-        console.log(chalk10.gray("No skills installed. Create one with `ultrac skills create`."));
+        console.log(chalk11.gray("No skills installed. Create one with `ultrac skills create`."));
       } else {
         for (const skill of skills) {
           console.log(`- ${skill.name} (${skill.scope}): ${skill.description}`);
@@ -17264,12 +18177,12 @@ ${extra}`);
         force: true
       });
       if (!update.latestVersion) {
-        console.log(chalk10.yellow("Could not check npm. Confirm npm access, then run `ultrac update --check` outside this session."));
+        console.log(chalk11.yellow("Could not check npm. Confirm npm access, then run `ultrac update --check` outside this session."));
       } else if (update.updateAvailable) {
-        console.log(chalk10.yellow(`Update available: ${update.currentVersion} \u2192 ${update.latestVersion}`));
-        console.log(chalk10.gray("Exit this session, then run `ultrac update`."));
+        console.log(chalk11.yellow(`Update available: ${update.currentVersion} \u2192 ${update.latestVersion}`));
+        console.log(chalk11.gray("Exit this session, then run `ultrac update`."));
       } else {
-        console.log(chalk10.green(`ultrac ${update.currentVersion} is up to date.`));
+        console.log(chalk11.green(`ultrac ${update.currentVersion} is up to date.`));
       }
       return "ok";
     }
@@ -17281,33 +18194,31 @@ async function runSkillCommand(session, raw, workspace, question) {
   const resolved = await resolveSkillCommand(workspace, raw);
   if (resolved.status === "ok") {
     console.log(
-      chalk10.gray(`  /${resolved.command.command} \u2192 skill ${resolved.command.skillName} (${resolved.command.scope})`)
+      chalk11.gray(`  /${resolved.command.command} \u2192 skill ${resolved.command.skillName} (${resolved.command.scope})`)
     );
     await runTurn(session, resolved.prompt, question);
     return;
   }
   if (resolved.status === "conflict") {
-    console.log(chalk10.red(resolved.message));
+    console.log(chalk11.red(resolved.message));
     return;
   }
   if (resolved.status === "builtin") {
-    console.log(chalk10.red(`/${resolved.command} is a built-in command and was not handled. Try /help.`));
+    console.log(chalk11.red(`/${resolved.command} is a built-in command and was not handled. Try /help.`));
     return;
   }
   if (resolved.status === "unknown") {
-    console.log(chalk10.red(`Unknown command: /${resolved.command}. Try /help.`));
+    console.log(chalk11.red(`Unknown command: /${resolved.command}. Try /help.`));
     if (resolved.available.length) {
-      console.log(chalk10.gray(`Skill commands: ${resolved.available.map((name) => `/${name}`).join(", ")}`));
+      console.log(chalk11.gray(`Skill commands: ${resolved.available.map((name) => `/${name}`).join(", ")}`));
     }
     return;
   }
-  console.log(chalk10.red("Unknown command. Try /help."));
+  console.log(chalk11.red("Unknown command. Try /help."));
 }
 var LineReader = class {
-  queue = [];
-  waiters = [];
-  closed = false;
   constructor(rl) {
+    this.rl = rl;
     rl.on("line", (line) => {
       const waiter = this.waiters.shift();
       if (waiter) {
@@ -17323,6 +18234,10 @@ var LineReader = class {
       }
     });
   }
+  rl;
+  queue = [];
+  waiters = [];
+  closed = false;
   next(signal) {
     return this.waitForLine(signal, true);
   }
@@ -17333,6 +18248,10 @@ var LineReader = class {
   nextFresh(signal) {
     return this.waitForLine(signal, false);
   }
+  /** True while the user is typing a line that has not been submitted yet. */
+  get composing() {
+    return this.rl.line.length > 0;
+  }
   /**
    * Drain ordinary messages in arrival order. A slash command is a control
    * boundary and remains queued for the main REPL loop along with everything
@@ -17378,11 +18297,15 @@ var LineReader = class {
     waiter.resolve(line);
   }
 };
-function handleReplInterrupt(activeTurn) {
+function handleReplEscape(activeTurn) {
   if (activeTurn && !activeTurn.signal.aborted) {
     activeTurn.abort();
     return "abort-turn";
   }
+  return "idle";
+}
+function handleReplExit(activeTurn) {
+  activeTurn?.abort();
   return "exit-session";
 }
 function printBanner(version, providerName, model, mode, workspace, protocol, budget, diagnosticPath2) {
@@ -17416,9 +18339,9 @@ function describeAdvertisedTools(mode, selection, registry = createDefaultToolRe
 }
 function printToolResult2(result) {
   const failure = toolFailurePreview(result);
-  if (failure) console.log(chalk10.red(`    Failed: ${failure}`));
+  if (failure) console.log(chalk11.red(`    Failed: ${failure}`));
   for (const warning of getMcpArchiveWarnings(result)) {
-    console.log(chalk10.yellow(indent3(`Warning: ${warning}`)));
+    console.log(chalk11.yellow(indent3(`Warning: ${warning}`)));
   }
 }
 function shellApprovalPrompt(call, workspace) {
@@ -17445,31 +18368,186 @@ function indent3(value) {
 }
 
 // src/commands/run.ts
-import chalk11 from "chalk";
+import { basename as basename3 } from "path";
+import chalk12 from "chalk";
+
+// src/core/autonomous.ts
+import { createHash as createHash7, randomUUID as randomUUID5 } from "crypto";
+var AUTONOMOUS_CONTINUE_TASK = "Continue the task from where the previous round stopped. Check what is already done, finish the rest, and verify it.";
+var DEFAULT_AUTONOMOUS_MAX_ROUNDS = 5;
+var AUTONOMOUS_MAX_STEPS = 200;
+var DEFAULT_AUTONOMOUS_MAX_ELAPSED_MS = 6 * 60 * 60 * 1e3;
+var DEFAULT_AUTONOMOUS_BASE_DELAY_MS = 1e3;
+var DEFAULT_AUTONOMOUS_MAX_DELAY_MS = 3e4;
+var DEFAULT_AUTONOMOUS_STALL_ROUNDS = 3;
+function shouldResume(stopReason) {
+  return stopReason === "max-steps" || stopReason === "error";
+}
+function boundedInteger(value, name, min, max) {
+  if (!Number.isSafeInteger(value) || value < min || value > max) throw new Error(`${name} must be an integer from ${min} to ${max}.`);
+  return value;
+}
+function abortableSleep(milliseconds, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve15, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", abort);
+      resolve15();
+    }, milliseconds);
+    const abort = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", abort);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+  });
+}
+function progress(session) {
+  const hash = createHash7("sha256");
+  let completedTools = 0;
+  hash.update(session.finalMessage ?? "");
+  for (const step of session.steps ?? []) {
+    hash.update(step.modelText ?? "");
+    for (const tool of step.toolResults ?? []) {
+      completedTools += 1;
+      hash.update(tool.call.tool);
+      hash.update(tool.result.ok ? "ok" : "failed");
+      hash.update(tool.result.content ?? "");
+      try {
+        hash.update(JSON.stringify(tool.call.input));
+      } catch {
+        hash.update("unserializable-input");
+      }
+    }
+  }
+  return { fingerprint: hash.digest("hex"), completedTools };
+}
+async function runAutonomousLoop(options) {
+  boundedInteger(options.maxRounds, "maxRounds", 1, 1e3);
+  const maxElapsedMs = boundedInteger(options.maxElapsedMs ?? DEFAULT_AUTONOMOUS_MAX_ELAPSED_MS, "maxElapsedMs", 1, 7 * 24 * 60 * 60 * 1e3);
+  const baseDelay = boundedInteger(options.baseDelayMs ?? DEFAULT_AUTONOMOUS_BASE_DELAY_MS, "baseDelayMs", 0, 3e5);
+  const maxDelay = boundedInteger(options.maxDelayMs ?? DEFAULT_AUTONOMOUS_MAX_DELAY_MS, "maxDelayMs", baseDelay, 3e5);
+  const stallLimit = boundedInteger(options.stallRounds ?? DEFAULT_AUTONOMOUS_STALL_ROUNDS, "stallRounds", 1, 1e3);
+  const now = options.now ?? (() => performance.now());
+  const started = now();
+  const elapsed = () => Math.max(0, now() - started);
+  const budget = new AbortController();
+  const deadline = setTimeout(() => budget.abort(new DOMException("Autonomous elapsed budget reached.", "TimeoutError")), maxElapsedMs);
+  deadline.unref?.();
+  const signal = options.signal ? AbortSignal.any([options.signal, budget.signal]) : budget.signal;
+  const sleep2 = options.sleep ?? abortableSleep;
+  const id = randomUUID5();
+  let previous;
+  let lastFingerprint;
+  let stalls = 0;
+  let consecutiveErrors = 0;
+  try {
+    signal.throwIfAborted();
+    for (let round = 1; ; round += 1) {
+      const roundStart = now();
+      diagnosticEvent("round.start", { id, round, maxRounds: options.maxRounds, elapsedMs: elapsed() });
+      let session;
+      try {
+        session = await options.runRound(round, previous, signal);
+      } catch (error) {
+        diagnosticEvent("round.end", { id, round, reason: signal.aborted ? "aborted" : "exception", elapsedMs: elapsed(), durationMs: Math.max(0, now() - roundStart) });
+        throw error;
+      }
+      const current = progress(session);
+      const unchanged = lastFingerprint !== void 0 && current.fingerprint === lastFingerprint;
+      stalls = unchanged ? stalls + 1 : 0;
+      lastFingerprint = current.fingerprint;
+      const classification = session.stopReason === "error" ? options.classifyFailure?.(session) : void 0;
+      consecutiveErrors = session.stopReason === "error" ? consecutiveErrors + 1 : 0;
+      let haltReason;
+      if (session.stopReason === "completed") haltReason = "completed";
+      else if (budget.signal.aborted || elapsed() >= maxElapsedMs) haltReason = "elapsed_budget";
+      else if (signal.aborted || session.stopReason === "aborted") haltReason = "aborted";
+      else if (classification && !classification.retryable) haltReason = "permanent_error";
+      else if (!shouldResume(session.stopReason)) haltReason = "stopped";
+      else if (stalls >= stallLimit) haltReason = "stalled";
+      else if (round >= options.maxRounds) haltReason = "max_rounds";
+      const retryDelay = Math.min(maxDelay, baseDelay * 2 ** Math.min(30, consecutiveErrors - 1));
+      if (!haltReason && session.stopReason === "error" && elapsed() + retryDelay >= maxElapsedMs) haltReason = "elapsed_budget";
+      diagnosticEvent("round.end", {
+        id,
+        round,
+        sessionId: session.id,
+        reason: haltReason ?? session.stopReason,
+        failureKind: classification?.kind,
+        attempt: consecutiveErrors,
+        completedTools: current.completedTools,
+        elapsedMs: elapsed(),
+        durationMs: Math.max(0, now() - roundStart)
+      });
+      if (haltReason === "stalled") diagnosticEvent("round.stall", { id, round, repeats: stalls, completedTools: current.completedTools, elapsedMs: elapsed() });
+      await options.onRoundEnd?.(round, session, !haltReason);
+      if (haltReason) return { session, rounds: round, haltReason };
+      if (session.stopReason === "error") {
+        const delayMs = retryDelay;
+        if (elapsed() + delayMs >= maxElapsedMs) return { session, rounds: round, haltReason: "elapsed_budget" };
+        diagnosticEvent("round.retry", {
+          id,
+          round,
+          nextRound: round + 1,
+          attempt: consecutiveErrors,
+          failureKind: classification?.kind ?? "unclassified",
+          delayMs,
+          elapsedMs: elapsed()
+        });
+        try {
+          await sleep2(delayMs, signal);
+        } catch (error) {
+          if (!signal.aborted) throw error;
+          return { session, rounds: round, haltReason: budget.signal.aborted ? "elapsed_budget" : "aborted" };
+        }
+      }
+      if (signal.aborted || elapsed() >= maxElapsedMs) return { session, rounds: round, haltReason: budget.signal.aborted || elapsed() >= maxElapsedMs ? "elapsed_budget" : "aborted" };
+      previous = session;
+    }
+  } finally {
+    clearTimeout(deadline);
+  }
+}
+
+// src/commands/run.ts
+function parsePositiveInt(value, flag) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 1 || String(parsed) !== value.trim()) {
+    throw new Error(`${flag} must be a positive integer.`);
+  }
+  return parsed;
+}
 var EXIT_INCOMPLETE_RUN = 2;
+var NOTIFY_SUMMARY_CHARS = 1200;
 function registerRunCommand(program2) {
   program2.command("run").alias("chat").description("Run a one-shot coding agent task").argument("<task...>", "Task for the agent").option("-w, --workspace <path>", "Workspace path", ".").option("--provider <name>", "Provider: ultrac (default) or echo (offline test stub)").option("--model <model>", "Model name").option("--base-url <url>", "Ultrac API base URL (overrides ULTRAC_BASE_URL and the stored login)").option("--mode <name>", `Agent mode: ${agentModeNames.join(", ")}`).option("--max-steps <number>", "Maximum agent steps").option("--no-native-tools", "Use the legacy JSON tool protocol").option("--allow-write", "Allow file writes", false).option("--allow-shell", "Grant the model broad, unsandboxed shell access", false).option("--allow-network", "Allow HTTP(S) URL fetches", false).option("--continue <id>", "Continue from a saved session id").option("--tools <list>", "Tools to advertise: `all`, or a comma-separated list. Default: the mode's set").option("--context-tokens <number>", "Model context window in tokens (default 262144)").option("--max-tool-result-chars <number>", "Cap on one tool result in the transcript (default 6000)").option(
     "--allow-incomplete",
     `Exit 0 even when the run stops without finishing. By default an unfinished run (step cap, abort, error) exits ${EXIT_INCOMPLETE_RUN} so a script or a \`&&\` chain can tell a partial answer from a real one; pass this when hitting --max-steps on a long task is an acceptable outcome. The stop reason is still printed either way.`,
     false
-  ).option("--json", "Print the session JSON", false).action(async (taskParts, options) => {
+  ).option(
+    "--autonomous",
+    `Run with no human in the loop: write, shell and network are granted, each round may take up to ${AUTONOMOUS_MAX_STEPS} steps, and a round that runs out of steps or fails resumes on its own. With a phone channel configured (\`ultrac notify setup\`), questions go to your phone and you are told when it finishes.`,
+    false
+  ).option("--max-rounds <number>", `With --autonomous: how many times a run may resume itself (default ${DEFAULT_AUTONOMOUS_MAX_ROUNDS})`).option("--notify", "Send ask_user questions and the final result to your phone (see `ultrac notify setup`)", false).option("--verbose-tools", "Print complete tool results instead of previews", false).option("--json", "Print the session JSON", false).action(async (taskParts, options) => {
     const task = taskParts.join(" ").trim();
     if (!task) {
       throw new Error("A task is required.");
     }
     const workspace = await assertWorkspaceExists(options.workspace);
     const diagnosticPath2 = configureDiagnosticLog(workspace, "run");
-    console.error(chalk11.gray(`Diagnostic log: ${diagnosticPath2}`));
+    console.error(chalk12.gray(`Diagnostic log: ${diagnosticPath2}`));
     if (options.baseUrl) {
       setBaseUrlFlag(options.baseUrl);
     }
     const loaded = await loadConfigWithTrust(workspace);
     const config = loaded.config;
     if (loaded.needsApproval) {
-      console.error(chalk11.yellow(withheldNotice(workspace, loaded.withheld, loaded.trustStatus)));
+      console.error(chalk12.yellow(withheldNotice(workspace, loaded.withheld, loaded.trustStatus)));
     }
     const toolSelection = applyBudgetFlags(options, config);
-    setContextBudgetNotice((message) => console.error(chalk11.yellow(message)));
+    setContextBudgetNotice((message) => console.error(chalk12.yellow(message)));
     const providerName = options.provider ?? config.provider;
     const mode = options.mode ?? config.mode;
     const previousSessionLineage = options.continue ? await loadSessionLineage(workspace, options.continue) : void 0;
@@ -17480,24 +18558,49 @@ function registerRunCommand(program2) {
     if (!isAgentModeName(mode)) {
       throw new Error(`Unknown mode: ${mode}. Expected one of: ${agentModeNames.join(", ")}.`);
     }
-    const maxSteps = Number.parseInt(options.maxSteps ?? String(config.maxSteps), 10);
+    const autonomous = options.autonomous;
+    const maxSteps = Number.parseInt(
+      options.maxSteps ?? String(autonomous ? AUTONOMOUS_MAX_STEPS : config.maxSteps),
+      10
+    );
     if (!Number.isInteger(maxSteps) || maxSteps < 1) {
       throw new Error("--max-steps must be a positive integer.");
     }
+    if (options.maxRounds !== void 0 && !autonomous) {
+      throw new Error("--max-rounds only applies with --autonomous.");
+    }
+    const maxRounds = autonomous ? parsePositiveInt(options.maxRounds ?? String(DEFAULT_AUTONOMOUS_MAX_ROUNDS), "--max-rounds") : 1;
+    const notifyConfig = options.notify || autonomous ? await loadNotifyConfig() : null;
+    if (options.notify && !notifyConfig) {
+      throw new Error("--notify needs a phone channel. Run `ultrac notify setup` first.");
+    }
+    const notifier = notifyConfig ? createNotifier(notifyConfig, `Ultrac (${basename3(workspace)})`) : void 0;
+    if (autonomous) {
+      console.error(
+        chalk12.yellow(
+          `Autonomous run: file writes, unsandboxed shell and network are granted with no approvals, up to ${maxRounds} round${maxRounds === 1 ? "" : "s"} of ${maxSteps} steps.`
+        )
+      );
+      console.error(
+        chalk12.gray(
+          notifier ? `Questions and the result go to your phone via ${notifier.describe()}.` : "No phone channel is configured, so the agent decides on its own. Run `ultrac notify setup` to be reached when it needs you."
+        )
+      );
+    }
     const model = options.model ?? (options.provider ? providerDefaultModels[providerName] : config.model);
     const provider = createFallbackProvider({
       provider: providerName,
       model,
       fallback: config.fallback,
       // stderr, so --json keeps stdout parseable.
-      onFailover: (event) => console.error(chalk11.yellow(formatFailoverNotice(event))),
+      onFailover: (event) => console.error(chalk12.yellow(formatFailoverNotice(event))),
       // AgentRunner uses native tool calls when supported; wired
       // anyway so a non-interactive run stays honest if that ever changes.
-      onDowngrade: (event) => console.error(chalk11.yellow(formatDowngradeNotice(event))),
+      onDowngrade: (event) => console.error(chalk12.yellow(formatDowngradeNotice(event))),
       onRetry: (event) => {
         diagnosticEvent("provider.retry", event);
         console.error(
-          chalk11.yellow(
+          chalk12.yellow(
             `Retrying ${event.target.provider} (${event.target.model}) in ${event.delayMs}ms after ${event.classification.reason}`
           )
         );
@@ -17506,47 +18609,106 @@ function registerRunCommand(program2) {
     const registry = createDefaultToolRegistry();
     const mcpRuntime = await connectWorkspaceMcpServers(config.mcpServers, { workspace, registry });
     setSubagentRuntime({ provider, model, mode, registry });
+    if (notifier) {
+      setAskUserRuntime(
+        async (question, choices, signal) => {
+          console.error(chalk12.cyan(`Asking you on ${notifier.describe()}: ${question}`));
+          try {
+            const answer = await notifier.ask(question, choices, signal);
+            console.error(chalk12.gray(answer === null ? "No reply; the agent will proceed on its own judgement." : `Reply: ${answer}`));
+            return answer;
+          } catch (error) {
+            console.error(chalk12.yellow(`Could not reach your phone: ${error.message}`));
+            return null;
+          }
+        },
+        { remote: true }
+      );
+    }
     try {
       if (mcpRuntime && mcpRuntime.statuses.length > 0) {
-        console.error(chalk11.bold("MCP servers"));
+        console.error(chalk12.bold("MCP servers"));
         console.error(renderMcpStatuses(mcpRuntime.statuses));
       }
       const detachProgress = attachProgressUi();
       const runner = new AgentRunner(registry);
       const writeCheckpoint = createSessionCheckpointWriter(workspace, (message) => {
-        console.error(chalk11.yellow(message));
+        console.error(chalk12.yellow(message));
       });
       const controller = new AbortController();
       const abortRun = () => controller.abort();
       process.on("SIGINT", abortRun);
       process.on("SIGTERM", abortRun);
+      const permissions = autonomous ? { write: true, shell: true, network: true } : {
+        write: options.allowWrite || config.permissions.write,
+        shell: options.allowShell || config.permissions.shell,
+        network: options.allowNetwork || config.permissions.network
+      };
+      const roundFailures = /* @__PURE__ */ new Map();
       let result;
       try {
-        result = await runner.run({
-          task,
-          workspace,
-          provider,
-          model,
-          mode,
-          nativeTools: options.nativeTools,
-          maxSteps,
-          previousSession,
-          previousSessionLineage,
-          ...toolSelection ? { tools: toolSelection } : {},
-          permissions: {
-            write: options.allowWrite || config.permissions.write,
-            shell: options.allowShell || config.permissions.shell,
-            network: options.allowNetwork || config.permissions.network
-          },
+        result = await runAutonomousLoop({
+          maxRounds,
           signal: controller.signal,
-          // Write the session after every step, atomically, so a run that dies
-          // partway - a crash, a kill, a closed laptop mid-scan - is on disk up to
-          // its last completed step and can be resumed with --continue rather than
-          // restarted from nothing.
-          onCheckpoint: async (session) => {
-            await writeCheckpoint(session);
+          classifyFailure: (session) => roundFailures.get(session.id),
+          runRound: async (round, previous, roundSignal) => {
+            const lineage = previous ? await loadSessionLineage(workspace, previous.id) : previousSessionLineage;
+            let lastCheckpoint;
+            let checkpointFailed = false;
+            try {
+              const { session } = await runner.run({
+                task: previous ? AUTONOMOUS_CONTINUE_TASK : task,
+                workspace,
+                provider,
+                model,
+                mode,
+                nativeTools: options.nativeTools,
+                maxSteps,
+                previousSession: previous ?? previousSession,
+                previousSessionLineage: lineage,
+                ...toolSelection ? { tools: toolSelection } : {},
+                permissions,
+                signal: roundSignal,
+                ...autonomous ? { autonomous: { phone: Boolean(notifier) } } : {},
+                // Write the session after every step, atomically, so a run that dies
+                // partway - a crash, a kill, a closed laptop mid-scan - is on disk up to
+                // its last completed step and can be resumed with --continue rather than
+                // restarted from nothing.
+                onCheckpoint: async (session2) => {
+                  try {
+                    const checkpointPath = await writeCheckpoint(session2);
+                    checkpointFailed = !checkpointPath;
+                    if (checkpointPath) lastCheckpoint = await loadSession(workspace, session2.id);
+                  } catch (error) {
+                    checkpointFailed = true;
+                    throw error;
+                  }
+                }
+              });
+              return session;
+            } catch (error) {
+              if (!autonomous || !lastCheckpoint || checkpointFailed || roundSignal.aborted) throw error;
+              const classification = classifyProviderError(error);
+              roundFailures.set(lastCheckpoint.id, classification);
+              console.error(
+                chalk12.yellow(`Round ${round} failed (${classification.kind}). The latest checkpoint is saved.`)
+              );
+              return { ...lastCheckpoint, stopReason: "error" };
+            }
+          },
+          onRoundEnd: async (round, session, willResume) => {
+            if (!willResume) return;
+            await saveSession(workspace, session);
+            console.error(
+              chalk12.yellow(
+                `Round ${round} stopped (${session.stopReason}); resuming in round ${round + 1} of ${maxRounds}.`
+              )
+            );
           }
         });
+      } catch (error) {
+        await notifier?.send(`stopped with an error: ${error.message}`).catch(() => void 0);
+        throw error;
       } finally {
         process.off("SIGINT", abortRun);
         process.off("SIGTERM", abortRun);
@@ -17562,21 +18724,33 @@ function registerRunCommand(program2) {
           { cause: error }
         );
       }
+      if (["stalled", "elapsed_budget", "permanent_error"].includes(result.haltReason ?? "")) {
+        console.error(chalk12.yellow(`Autonomous recovery stopped: ${result.haltReason}. The latest checkpoint is saved.`));
+      }
       const stopReason = result.session.stopReason;
       for (const warning of getSessionMcpArchiveWarnings(result.session)) {
-        console.error(chalk11.yellow(`Warning: ${warning}`));
+        console.error(chalk12.yellow(`Warning: ${warning}`));
       }
       if (options.json) {
         console.log(
-          JSON.stringify({ sessionPath: sessionPath2, stopReason: stopReason ?? null, session: result.session }, null, 2)
+          JSON.stringify({ sessionPath: sessionPath2, stopReason: stopReason ?? null, haltReason: result.haltReason ?? null, rounds: result.rounds, session: result.session }, null, 2)
         );
       } else {
-        printSession(result.session, sessionPath2);
+        printSession(result.session, sessionPath2, { verboseTools: options.verboseTools });
+      }
+      if (notifier) {
+        const outcome = stopReason === "completed" ? "finished" : `stopped without finishing (${stopReason ?? "unknown"})`;
+        const rounds = result.rounds > 1 ? ` after ${result.rounds} rounds` : "";
+        const summary = result.session.finalMessage.trim().slice(0, NOTIFY_SUMMARY_CHARS);
+        await notifier.send(`${outcome}${rounds}.${summary ? `
+
+${summary}` : ""}`).catch((error) => console.error(chalk12.yellow(`Could not send the result to your phone: ${error.message}`)));
       }
       if (isIncompleteStop(stopReason) && !options.allowIncomplete) {
         process.exitCode = EXIT_INCOMPLETE_RUN;
       }
     } finally {
+      if (notifier) setAskUserRuntime(void 0);
       mcpRuntime?.close();
     }
   });
@@ -17587,7 +18761,7 @@ import { resolve as resolve12 } from "path";
 function registerSessionsCommand(program2) {
   const sessions = program2.command("sessions").description("Inspect saved Ultrac session transcripts");
   sessions.command("list").description("List saved sessions").option("-w, --workspace <path>", "Workspace path", ".").option("--json", "Print JSON output", false).option("--max-results <number>", "Maximum sessions to show", "20").action(async (options) => {
-    await runSessionTool("list_sessions", { maxResults: parsePositiveInt(options.maxResults) }, options);
+    await runSessionTool("list_sessions", { maxResults: parsePositiveInt2(options.maxResults) }, options);
   });
   sessions.command("show").description("Show a saved session by id").argument("<id>", "Session id").option("-w, --workspace <path>", "Workspace path", ".").option("--json", "Print JSON output", false).action(async (id, options) => {
     await runSessionTool("read_session", { id }, options);
@@ -17595,14 +18769,14 @@ function registerSessionsCommand(program2) {
   sessions.command("search").description("Search saved sessions").argument("<query...>", "Search query").option("-w, --workspace <path>", "Workspace path", ".").option("--json", "Print JSON output", false).option("--max-results <number>", "Maximum sessions to show", "20").action(async (queryParts, options) => {
     await runSessionTool(
       "search_sessions",
-      { query: queryParts.join(" ").trim(), maxResults: parsePositiveInt(options.maxResults) },
+      { query: queryParts.join(" ").trim(), maxResults: parsePositiveInt2(options.maxResults) },
       options
     );
   });
   sessions.command("export").description("Export a saved session as an auditable episode package").argument("<id>", "Session id").option("-w, --workspace <path>", "Workspace path", ".").option("--format <format>", "Output format: markdown or json", "markdown").option("--max-chars <number>", "Maximum characters per model/tool text block in markdown", "4000").option("--outcome <outcome>", "Outcome status: pass, fail, blocked, or unknown", "unknown").option("--notes <text>", "Outcome notes to include in the episode package").option("--out <path>", "Write export to a path inside the workspace instead of stdout").action(async (id, options) => {
     const workspace = resolve12(options.workspace);
     const format3 = parseExportFormat(options.format);
-    const maxChars = parsePositiveInt(options.maxChars);
+    const maxChars = parsePositiveInt2(options.maxChars);
     const outcome = parseOutcomeStatus(options.outcome);
     const session = await loadSession(workspace, id);
     const episode = buildEpisodePackage(session, { outcome, notes: options.notes ?? "" });
@@ -17631,7 +18805,7 @@ async function runSessionTool(tool, input, options) {
   }
   console.log(result.content);
 }
-function parsePositiveInt(value) {
+function parsePositiveInt2(value) {
   const parsed = Number.parseInt(value, 10);
   if (!Number.isInteger(parsed) || parsed < 1) {
     throw new Error("Value must be a positive integer.");
@@ -17816,17 +18990,25 @@ function registerSkillsCommand(program2) {
     console.log("");
     console.log(skill.body);
   });
-  skills.command("create").description("Scaffold a new SKILL.md").argument("<name>", "Skill name (kebab-case)").requiredOption("--description <text>", "One-line description").option("--when <text>", "When the agent should use this skill").option("--permissions <list>", "Comma-separated: write,shell,network").option("--scope <scope>", "global or project", "project").option("-w, --workspace <path>", "Workspace path", ".").action(
+  skills.command("create").description("Scaffold a new SKILL.md").argument("<name>", "Skill name (kebab-case)").requiredOption("--description <text>", "One-line description").option("--when <text>", "When the agent should use this skill").option("--permissions <list>", "Comma-separated: write,shell,network").option("--scope <scope>", "global or project", "project").option("--command <name>", "Expose this skill as a custom slash command").option("--argument-hint <text>", "Describe the slash command arguments").option("-w, --workspace <path>", "Workspace path", ".").action(
     async (name, options) => {
+      const command = options.command ? normalizeCommandName(options.command) : void 0;
+      if (command && isBuiltinSlashCommand(command)) throw new Error(`/${command} is a built-in command. Choose another skill command name.`);
+      if (options.argumentHint && !command) throw new Error("--argument-hint requires --command.");
+      const argumentHint = options.argumentHint?.trim();
+      if (argumentHint && (argumentHint.length > 256 || /[\r\n]/.test(argumentHint))) throw new Error("Argument hints must be one line, at most 256 characters.");
       const skill = await createSkill(resolve13(options.workspace), {
         name,
         description: options.description,
         whenToUse: options.when,
         permissions: parsePermissions(options.permissions),
-        scope: parseScope2(options.scope)
+        scope: parseScope2(options.scope),
+        command,
+        argumentHint
       });
       console.log(`Created ${skill.scope} skill "${skill.name}" at ${skill.path}`);
       console.log("Edit that file to add the step-by-step instructions.");
+      if (command) console.log(`Invoke this skill with /${command}${argumentHint ? ` ${argumentHint}` : ""} in a trusted workspace.`);
     }
   );
   skills.command("path").description("Print the skills directory path for a scope").option("-w, --workspace <path>", "Workspace path", ".").option("--scope <scope>", "global or project", "project").action((options) => {
@@ -17849,7 +19031,7 @@ function parsePermissions(list) {
 }
 
 // src/commands/tasks.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 
 // src/runs/api.ts
 var RUN_STATUSES = ["queued", "running", "succeeded", "failed", "cancelled"];
@@ -18154,7 +19336,7 @@ function record2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 async function followRun(client, runId, options = {}) {
-  const sleep = options.sleep ?? defaultSleep2;
+  const sleep2 = options.sleep ?? defaultSleep2;
   const minBackoffMs = options.minBackoffMs ?? 1e3;
   const maxBackoffMs = options.maxBackoffMs ?? 15e3;
   const signal = options.signal;
@@ -18266,7 +19448,7 @@ async function followRun(client, runId, options = {}) {
         failures,
         message: errorMessage3(cause)
       });
-      await sleep(delayMs2, signal);
+      await sleep2(delayMs2, signal);
       continue;
     }
     if (!response.ok) {
@@ -18281,7 +19463,7 @@ async function followRun(client, runId, options = {}) {
           failures,
           message: apiError.message
         });
-        await sleep(delayMs2, signal);
+        await sleep2(delayMs2, signal);
         continue;
       }
       throw apiError;
@@ -18290,7 +19472,7 @@ async function followRun(client, runId, options = {}) {
       failures += 1;
       const delayMs2 = backoff();
       options.onReconnect?.({ reason: "stream_failed", delayMs: delayMs2, lastEventId: state.lastEventId, failures, message: "empty body" });
-      await sleep(delayMs2, signal);
+      await sleep2(delayMs2, signal);
       continue;
     }
     let broke = null;
@@ -18308,7 +19490,7 @@ async function followRun(client, runId, options = {}) {
         const event = { id: message.id, event: message.event, data: parseData(message.data) };
         const applied = apply(event);
         options.onEvent?.(event, state);
-        const result = applied && "reconcileStatus" in applied ? await reconcileTerminalOutput(client, runId, applied, state, signal, sleep) : applied;
+        const result = applied && "reconcileStatus" in applied ? await reconcileTerminalOutput(client, runId, applied, state, signal, sleep2) : applied;
         if (result) return result;
         throwIfAborted();
       }
@@ -18328,12 +19510,12 @@ async function followRun(client, runId, options = {}) {
       if (!sawEvent) failures = 0;
       options.onReconnect?.({ reason: "stream_ended", delayMs, lastEventId: state.lastEventId, failures });
     }
-    await sleep(delayMs, signal);
+    await sleep2(delayMs, signal);
   }
 }
 var OUTPUT_READ_TIMEOUT_MS = 1500;
 var OUTPUT_READ_DELAYS_MS = [100, 300];
-async function reconcileTerminalOutput(client, runId, pending, state, signal, sleep) {
+async function reconcileTerminalOutput(client, runId, pending, state, signal, sleep2) {
   const { reconcileStatus, ...result } = pending;
   for (let attempt = 0; attempt < OUTPUT_READ_DELAYS_MS.length + 1; attempt += 1) {
     if (signal?.aborted) throw new FollowAbortedError(state);
@@ -18351,7 +19533,7 @@ async function reconcileTerminalOutput(client, runId, pending, state, signal, sl
     } catch {
       if (signal?.aborted) throw new FollowAbortedError(state);
     }
-    if (attempt < OUTPUT_READ_DELAYS_MS.length) await sleep(OUTPUT_READ_DELAYS_MS[attempt], signal);
+    if (attempt < OUTPUT_READ_DELAYS_MS.length) await sleep2(OUTPUT_READ_DELAYS_MS[attempt], signal);
   }
   return { ...result, text: state.text, outputSource: "incomplete" };
 }
@@ -18385,7 +19567,7 @@ function registerTasksCommand(program2, deps = {}) {
     }
     r.out(formatRunTable(page.data, r.now()));
     if (page.next_cursor) {
-      r.err(chalk12.gray(`More: ultrac tasks --cursor ${page.next_cursor}
+      r.err(chalk13.gray(`More: ultrac tasks --cursor ${page.next_cursor}
 `));
     }
   });
@@ -18444,7 +19626,7 @@ async function runTask(promptParts, options, deps) {
 `);
   } else {
     r.err(
-      chalk12.gray(
+      chalk13.gray(
         `Run ${run.id} queued. Following; Ctrl-C ${options.detach ? "leaves it running" : "cancels it"}.
 `
       )
@@ -18462,7 +19644,7 @@ async function follow(r, runId, options) {
       controller.abort();
       return;
     }
-    r.err(chalk12.yellow(`
+    r.err(chalk13.yellow(`
 Leaving run ${runId} as it is.
 `));
     r.exit(EXIT_CANCELLED);
@@ -18478,7 +19660,7 @@ Leaving run ${runId} as it is.
         if (status === "running") {
           const attempt = typeof data?.attempt === "number" ? data.attempt : null;
           if (data?.restarted === true || attempt !== null && attempt > 1) {
-            r.err(chalk12.yellow(`${lead()}[attempt ${attempt ?? "?"} restarted; streaming from the start]
+            r.err(chalk13.yellow(`${lead()}[attempt ${attempt ?? "?"} restarted; streaming from the start]
 `));
           }
           printed = "";
@@ -18493,7 +19675,7 @@ Leaving run ${runId} as it is.
         return;
       }
       case "tool_call": {
-        r.err(chalk12.cyan(`${lead()}[tool_call ${String(data?.name ?? "")} ${String(data?.arguments ?? "")}]
+        r.err(chalk13.cyan(`${lead()}[tool_call ${String(data?.name ?? "")} ${String(data?.arguments ?? "")}]
 `));
         return;
       }
@@ -18533,7 +19715,7 @@ Leaving run ${runId} as it is.
 `);
         } else {
           const seconds = Math.round(info.delayMs / 100) / 10;
-          r.err(chalk12.gray(`${lead()}[reconnecting in ${seconds}s${info.message ? `: ${info.message}` : ""}]
+          r.err(chalk13.gray(`${lead()}[reconnecting in ${seconds}s${info.message ? `: ${info.message}` : ""}]
 `));
         }
       }
@@ -18565,27 +19747,27 @@ Leaving run ${runId} as it is.
     return result.outputSource === "incomplete" ? EXIT_FAILED : exitCodeFor(result.status);
   }
   if (result.outputSource === "incomplete") {
-    r.err(chalk12.yellow(lead() + "[stored task output could not be confirmed; showing text received from the stream]\n"));
+    r.err(chalk13.yellow(lead() + "[stored task output could not be confirmed; showing text received from the stream]\n"));
   }
   switch (result.status) {
     case "succeeded":
       finishHuman(result.text);
       if (result.toolCalls.length && !result.text) {
         const count3 = result.toolCalls.length;
-        r.err(chalk12.gray(`Done with ${count3} tool call${count3 === 1 ? "" : "s"} and no text.
+        r.err(chalk13.gray(`Done with ${count3} tool call${count3 === 1 ? "" : "s"} and no text.
 `));
       }
       return result.outputSource === "incomplete" ? EXIT_FAILED : EXIT_DONE;
     case "failed": {
       finishHuman(result.text);
       const code = result.error?.code ? ` (${result.error.code})` : "";
-      r.err(chalk12.red(`Run ${runId} failed${code}: ${result.error?.message ?? "The task failed."}
+      r.err(chalk13.red(`Run ${runId} failed${code}: ${result.error?.message ?? "The task failed."}
 `));
       return EXIT_FAILED;
     }
     case "cancelled":
       finishHuman(result.text);
-      r.err(chalk12.yellow(`Run ${runId} was cancelled.
+      r.err(chalk13.yellow(`Run ${runId} was cancelled.
 `));
       return EXIT_CANCELLED;
   }
@@ -18598,13 +19780,13 @@ async function interrupted(r, runId, options, printed) {
 `);
     } else {
       r.err(
-        chalk12.yellow(`${lead}Detached. Run ${runId} continues; follow it again with \`ultrac tasks follow ${runId}\`.
+        chalk13.yellow(`${lead}Detached. Run ${runId} continues; follow it again with \`ultrac tasks follow ${runId}\`.
 `)
       );
     }
     return EXIT_CANCELLED;
   }
-  if (!options.json) r.err(chalk12.yellow(`${lead}Cancelling run ${runId}...
+  if (!options.json) r.err(chalk13.yellow(`${lead}Cancelling run ${runId}...
 `));
   try {
     const cancelled = await r.client.cancelRun(runId);
@@ -18612,7 +19794,7 @@ async function interrupted(r, runId, options, printed) {
       r.out(`${JSON.stringify({ id: null, event: "cancel", data: cancelled })}
 `);
     } else {
-      r.err(chalk12.yellow(`${describeCancel(cancelled)}
+      r.err(chalk13.yellow(`${describeCancel(cancelled)}
 `));
     }
   } catch (error) {
@@ -18621,12 +19803,12 @@ async function interrupted(r, runId, options, printed) {
       r.out(`${JSON.stringify({ id: null, event: "cancel_failed", data: { runId, message } })}
 `);
     } else if (error instanceof UltracApiError && error.code === "run_already_finished") {
-      r.err(chalk12.yellow(`${error.message} Nothing to cancel.
+      r.err(chalk13.yellow(`${error.message} Nothing to cancel.
 `));
     } else {
-      r.err(chalk12.red(`Could not cancel run ${runId}: ${message}
+      r.err(chalk13.red(`Could not cancel run ${runId}: ${message}
 `));
-      r.err(chalk12.gray(`Try again with \`ultrac tasks cancel ${runId}\`.
+      r.err(chalk13.gray(`Try again with \`ultrac tasks cancel ${runId}\`.
 `));
     }
   }
@@ -18738,7 +19920,7 @@ ${run.output}${run.output.endsWith("\n") ? "" : "\n"}`;
 
 // src/commands/tools.ts
 import { resolve as resolve14 } from "path";
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 function registerToolsCommand(program2) {
   const toolsCommand = program2.command("tools");
   toolsCommand.description("List built-in agent tools").option("--json", "Print tool metadata as JSON", false).option("--mode <name>", `Only the tools a mode advertises: ${agentModeNames.join(", ")}`).option("--budget", "Print what each mode's tool set costs in characters", false).action((options) => {
@@ -18758,7 +19940,7 @@ function registerToolsCommand(program2) {
     printTools(tools);
     if (options.mode) {
       console.log(
-        chalk13.gray(
+        chalk14.gray(
           `
 ${tools.length} of ${all.length} tools advertised in ${options.mode} mode, ${serializedToolsSize(
             toToolSchemas(tools)
@@ -18767,7 +19949,7 @@ ${tools.length} of ${all.length} tools advertised in ${options.mode} mode, ${ser
       );
     }
   });
-  toolsCommand.command("run").description("Execute one built-in agent tool").argument("<tool>", "Tool name").argument("[input]", "JSON object input", "{}").option("-w, --workspace <path>", "Workspace path", ".").option("--allow-write", "Allow file writes", false).option("--allow-shell", "Allow this tool to execute unsandboxed shell commands", false).option("--allow-network", "Allow HTTP(S) URL fetches", false).option("--result-json", "Print the tool result as JSON", false).action(async (tool, inputText, options) => {
+  toolsCommand.command("run").description("Execute one built-in agent tool").argument("<tool>", "Tool name").argument("[input]", "JSON object input", "{}").option("-w, --workspace <path>", "Workspace path", ".").option("--allow-write", "Allow file writes", false).option("--allow-shell", "Allow this tool to execute unsandboxed shell commands", false).option("--allow-network", "Allow HTTP(S) URL fetches", false).option("--verbose-tools", "Print the complete tool result", false).option("--result-json", "Print the tool result as JSON", false).action(async (tool, inputText, options) => {
     const input = parseToolInput(inputText);
     const result = await createDefaultToolRegistry().execute(
       { tool, input },
@@ -18783,7 +19965,7 @@ ${tools.length} of ${all.length} tools advertised in ${options.mode} mode, ${ser
     if (options.resultJson) {
       console.log(JSON.stringify({ result }, null, 2));
     } else {
-      printToolResult(result);
+      printToolResult(result, { verboseTools: options.verboseTools });
     }
     if (!result.ok) {
       process.exitCode = 1;
@@ -18807,11 +19989,11 @@ function printToolBudget(all, json) {
   }
   for (const row of [...rows, { ...everything, names: all.map((tool) => tool.name) }]) {
     console.log(
-      `${chalk13.cyan(row.mode.padEnd(9))} ${String(row.tools).padStart(2)} tools  ${String(
+      `${chalk14.cyan(row.mode.padEnd(9))} ${String(row.tools).padStart(2)} tools  ${String(
         row.chars.toLocaleString("en-US")
       ).padStart(7)} chars`
     );
-    console.log(chalk13.gray(`  ${row.names.join(", ")}`));
+    console.log(chalk14.gray(`  ${row.names.join(", ")}`));
   }
 }
 function parseToolInput(inputText) {
@@ -18823,7 +20005,7 @@ function parseToolInput(inputText) {
 }
 
 // src/commands/update.ts
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 function registerUpdateCommand(program2) {
   const packageInfo = readPackageInfo();
   program2.command("update").alias("upgrade").description(`Check for and install the latest ${packageInfo.name} release`).option("--check", "Only check; do not install an available update", false).action(async (options) => {
@@ -18838,7 +20020,7 @@ function registerUpdateCommand(program2) {
       );
     }
     if (!status.updateAvailable) {
-      console.log(chalk14.green(`ultrac ${status.currentVersion} is up to date.`));
+      console.log(chalk15.green(`ultrac ${status.currentVersion} is up to date.`));
       return;
     }
     if (options.check) {
@@ -18847,12 +20029,12 @@ function registerUpdateCommand(program2) {
     }
     console.log(`Updating ultrac ${status.currentVersion} \u2192 ${status.latestVersion}\u2026`);
     await installLatestVersion(packageInfo.name);
-    console.log(chalk14.green(`Updated to ultrac ${status.latestVersion}. Restart ultrac to use the new version.`));
+    console.log(chalk15.green(`Updated to ultrac ${status.latestVersion}. Restart ultrac to use the new version.`));
   });
 }
 function printAvailable(currentVersion, latestVersion) {
-  console.log(chalk14.yellow(`Update available: ultrac ${currentVersion} \u2192 ${latestVersion}`));
-  console.log(chalk14.gray("Run `ultrac update` to install it."));
+  console.log(chalk15.yellow(`Update available: ultrac ${currentVersion} \u2192 ${latestVersion}`));
+  console.log(chalk15.gray("Run `ultrac update` to install it."));
 }
 
 // src/cli.ts
@@ -18878,10 +20060,11 @@ registerUpdateCommand(program);
 registerSessionsCommand(program);
 registerMemoryCommand(program);
 registerMcpCommand(program);
+registerNotifyCommand(program);
 registerSkillsCommand(program);
 registerReplCommand(program);
 program.parseAsync(process.argv).catch((error) => {
   const message = error instanceof Error ? error.message : String(error);
-  console.error(chalk15.red(message));
+  console.error(chalk16.red(message));
   process.exitCode = 1;
 });