@spinalfluid/ultrac 0.1.6 → 0.1.11

package/dist/cli.js

@@ -286,7 +286,7 @@ var agentModePresets = {
       "Prefer narrow, reversible changes.",
       "Keep final answers concise and include verification status."
     ],
-    tools: [...coreTools, "list_sessions", "read_session", "search_sessions"],
+    tools: [...coreTools, "create_skill", "list_sessions", "read_session", "search_sessions"],
     externalTools: true
   },
   plan: {
@@ -331,6 +331,7 @@ var agentModePresets = {
     ],
     tools: [
       ...coreTools,
+      "create_skill",
       "ast_search",
       "repo_handbook",
       "verification_plan",
@@ -548,6 +549,9 @@ function ensurePrivateDirectory(path) {
   }
   chmodSync(path, 448);
 }
+function currentDiagnosticLogPath() {
+  return diagnosticPath;
+}
 function diagnosticEvent(event, fields = {}) {
   if (!diagnosticPath) return;
   const record3 = {
@@ -1219,20 +1223,20 @@ function compactRun(input, options = {}) {
 }
 async function compactShape(shape, options) {
   const reserveChars = options.summarise ? Math.max(0, options.reserveChars ?? shape.reserveChars ?? 0) : 0;
-  const plain = planKeepingSummaries(shape, shape.messages, reserveChars);
+  const plain2 = planKeepingSummaries(shape, shape.messages, reserveChars);
   const skip = (reason) => ({
-    ...reserveChars > 0 ? planKeepingSummaries(shape, shape.messages, shape.reserveChars ?? 0) : plain,
+    ...reserveChars > 0 ? planKeepingSummaries(shape, shape.messages, shape.reserveChars ?? 0) : plain2,
     compacted: false,
     summarisedMessages: 0,
     summarisedTurns: 0,
     skipped: reason
   });
-  if (plain.dropped.length === 0) return skip("nothing-dropped");
+  if (plain2.dropped.length === 0) return skip("nothing-dropped");
   if (!options.summarise) return skip("no-summariser");
-  const source = plain.dropped.filter((message2) => !isCompactionSummary(message2));
+  const source = plain2.dropped.filter((message2) => !isCompactionSummary(message2));
   if (source.length === 0) return skip("only-summaries");
   const ceiling = options.maxSummaryChars ?? DEFAULT_MAX_SUMMARY_CHARS;
-  const slack = plain.usage.promptLimitChars - plain.usage.totalChars - summaryEnvelopeChars();
+  const slack = plain2.usage.promptLimitChars - plain2.usage.totalChars - summaryEnvelopeChars();
   const maxChars = Math.min(ceiling, slack);
   if (maxChars < MIN_SUMMARY_CHARS) return skip("no-room");
   const transcript = renderDroppedTranscript(source, {
@@ -1257,21 +1261,21 @@ async function compactShape(shape, options) {
   const text = truncateToLine(summary.trim(), maxChars);
   if (!text) return skip("summariser-empty");
   const message = compactionSummaryMessage(text);
-  const plan = replan(shape, plain, message);
+  const plan = replan(shape, plain2, message);
   if (!plan) return skip("would-drop-more");
   return {
     ...plan,
     // The re-plan saw a transcript the span was already out of, so it has
     // nothing to report about it. What was dropped is what `plain` dropped.
-    dropped: plain.dropped,
-    droppedMessages: plain.droppedMessages,
-    droppedTurns: plain.droppedTurns,
-    droppedChars: plain.droppedChars,
+    dropped: plain2.dropped,
+    droppedMessages: plain2.droppedMessages,
+    droppedTurns: plain2.droppedTurns,
+    droppedChars: plain2.droppedChars,
     compacted: true,
     summary: text,
-    summarisedMessages: plain.dropped.length,
-    summarisedTurns: plain.droppedTurns,
-    warning: compactionWarning(plan, plain)
+    summarisedMessages: plain2.dropped.length,
+    summarisedTurns: plain2.droppedTurns,
+    warning: compactionWarning(plan, plain2)
   };
 }
 function planKeepingSummaries(shape, messages, reserveChars) {
@@ -1287,8 +1291,8 @@ function planKeepingSummaries(shape, messages, reserveChars) {
     return shape.plan(messages, callerPinned, reserveChars);
   }
 }
-function replan(shape, plain, summary) {
-  const kept = plain.messages;
+function replan(shape, plain2, summary) {
+  const kept = plain2.messages;
   const insertAt = kept.findIndex((message) => message.role !== "system");
   const at = insertAt < 0 ? kept.length : insertAt;
   const next = [...kept.slice(0, at), summary, ...kept.slice(at)];
@@ -1304,9 +1308,9 @@ function replan(shape, plain, summary) {
   if (!kept.every((message) => survived.has(message))) return void 0;
   return plan;
 }
-function compactionWarning(plan, plain) {
-  const turns = plural2(plain.droppedTurns, "earlier turn");
-  const messages = plural2(plain.dropped.length, "message");
+function compactionWarning(plan, plain2) {
+  const turns = plural2(plain2.droppedTurns, "earlier turn");
+  const messages = plural2(plain2.dropped.length, "message");
   return `Context budget: compacted ${turns} (${messages}) into a summary to stay under the ${count2(plan.usage.promptLimitChars)}-character prompt limit. The summary is in the transcript in their place; the recent turns are untouched.`;
 }
 function truncateToLine(text, maxChars) {
@@ -4080,7 +4084,7 @@ function runProcess(command, args, options) {
     });
     const untrack = trackProcessGroup(child.pid);
     const stdout6 = createCapture(maxBytes);
-    const stderr = createCapture(maxBytes);
+    const stderr2 = createCapture(maxBytes);
     let settled = false;
     let started = false;
     let termination;
@@ -4136,7 +4140,7 @@ function runProcess(command, args, options) {
     };
     const onAbort = () => beginTermination("aborted");
     child.stdout.on("data", (chunk) => stdout6.push(chunk));
-    child.stderr.on("data", (chunk) => stderr.push(chunk));
+    child.stderr.on("data", (chunk) => stderr2.push(chunk));
     child.stdout.on("error", () => {
     });
     child.stderr.on("error", () => {
@@ -4149,7 +4153,7 @@ function runProcess(command, args, options) {
         if (termination === "aborted") {
           resolve15({
             stdout: stdout6.text(),
-            stderr: stderr.text(),
+            stderr: stderr2.text(),
             started,
             aborted: true,
             exitCode: null,
@@ -4157,7 +4161,7 @@ function runProcess(command, args, options) {
             timedOut: false,
             timeoutMs,
             ...stdout6.truncation() ? { stdoutTruncation: stdout6.truncation() } : {},
-            ...stderr.truncation() ? { stderrTruncation: stderr.truncation() } : {},
+            ...stderr2.truncation() ? { stderrTruncation: stderr2.truncation() } : {},
             redactedEnvKeys
           });
           return;
@@ -4167,11 +4171,11 @@ function runProcess(command, args, options) {
     });
     child.on("close", (exitCode, signal) => {
       const stdoutTruncation = stdout6.truncation();
-      const stderrTruncation = stderr.truncation();
+      const stderrTruncation = stderr2.truncation();
       finish(
         () => resolve15({
           stdout: stdout6.text(),
-          stderr: stderr.text(),
+          stderr: stderr2.text(),
           started,
           aborted: termination === "aborted",
           exitCode,
@@ -5181,7 +5185,7 @@ function topCounts(values) {
   for (const value of values) {
     counts.set(value, (counts.get(value) ?? 0) + 1);
   }
-  return [...counts.entries()].map(([name, count3]) => ({ name, count: count3 })).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+  return [...counts.entries()].map(([name, count4]) => ({ name, count: count4 })).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
 }
 async function collectGitContext(workspace, signal) {
   const statusResult = await runGit(["status", "--short", "--branch"], { cwd: workspace, signal });
@@ -6966,8 +6970,8 @@ function shannonEntropy(value) {
     counts.set(char, (counts.get(char) ?? 0) + 1);
   }
   let entropy = 0;
-  for (const count3 of counts.values()) {
-    const probability = count3 / value.length;
+  for (const count4 of counts.values()) {
+    const probability = count4 / value.length;
     entropy -= probability * Math.log2(probability);
   }
   return entropy;
@@ -8040,7 +8044,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}
 
@@ -8057,7 +8063,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) {
@@ -8076,6 +8083,213 @@ async function loadSkillsContext(workspace) {
   }).join("\n") + notice;
 }
 
+// src/skills/commands.ts
+var BUILTIN_SLASH_COMMANDS = [
+  "doctor",
+  "mcp",
+  "continue",
+  "autonomous",
+  "skill",
+  "update",
+  "logs",
+  "ghost",
+  "output",
+  "usage",
+  "max-steps",
+  "resume",
+  "deny",
+  "plan",
+  "review",
+  "coding",
+  "status",
+  "context",
+  "compact",
+  "diff",
+  "sessions",
+  "save",
+  "test",
+  "init",
+  "new",
+  "allow",
+  "clear",
+  "exit",
+  "help",
+  "memory",
+  "mode",
+  "model",
+  "permissions",
+  "quit",
+  "skills",
+  "tools",
+  "whoami"
+];
+var COMMAND_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var MAX_COMMAND_LENGTH = 64;
+function parseSlashInput(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) return null;
+  const rest = trimmed.slice(1);
+  const match = rest.match(/^(\S+)(?:\s+([\s\S]*))?$/);
+  if (!match) return null;
+  return { command: match[1], args: (match[2] ?? "").trim() };
+}
+function isBuiltinSlashCommand(command) {
+  return BUILTIN_SLASH_COMMANDS.includes(command.toLowerCase());
+}
+function normalizeCommandName(value) {
+  const candidate = value.trim().replace(/^\/+/, "").trim();
+  if (!candidate) {
+    throw new Error("Slash command name is empty; expected kebab-case, for example: open-pr.");
+  }
+  if (candidate.length > MAX_COMMAND_LENGTH) {
+    throw new Error(
+      `Slash command name "${candidate}" is longer than ${MAX_COMMAND_LENGTH} characters.`
+    );
+  }
+  if (!COMMAND_NAME_RE.test(candidate)) {
+    throw new Error(
+      `Invalid slash command name "${candidate}": use kebab-case - lowercase letters, digits, and single hyphens, no spaces or slashes (for example: open-pr).`
+    );
+  }
+  return candidate;
+}
+async function collectEntries(workspace) {
+  const skills = await discoverSkills(workspace);
+  const claimed = /* @__PURE__ */ new Map();
+  const conflicts = [];
+  for (const skill of skills) {
+    let declaration;
+    try {
+      declaration = skill.command ?? null;
+    } catch (error) {
+      conflicts.push({
+        command: "",
+        skillName: skill.name,
+        scope: skill.scope,
+        path: skill.path,
+        reason: "invalid",
+        message: `Skill "${skill.name}" (${skill.scope}) was skipped: ${error instanceof Error ? error.message : String(error)}`
+      });
+      continue;
+    }
+    if (!declaration) continue;
+    let command;
+    try {
+      command = normalizeCommandName(declaration.raw);
+    } catch (error) {
+      conflicts.push({
+        command: declaration.raw,
+        skillName: skill.name,
+        scope: skill.scope,
+        path: skill.path,
+        reason: "invalid",
+        message: `Skill "${skill.name}" (${skill.scope}) declares a malformed command: ${error instanceof Error ? error.message : String(error)}`
+      });
+      continue;
+    }
+    if (isBuiltinSlashCommand(command)) {
+      conflicts.push({
+        command,
+        skillName: skill.name,
+        scope: skill.scope,
+        path: skill.path,
+        reason: "builtin",
+        message: `Skill "${skill.name}" (${skill.scope}) declares /${command}, which is a built-in command. Built-ins always win - rename the command: key in ${skill.path}.`
+      });
+      continue;
+    }
+    const entry = {
+      skill,
+      command: {
+        command,
+        skillName: skill.name,
+        description: skill.description,
+        argumentHint: declaration.argumentHint,
+        scope: skill.scope,
+        path: skill.path
+      }
+    };
+    const existing = claimed.get(command);
+    if (!existing) {
+      claimed.set(command, entry);
+      continue;
+    }
+    const winner = existing.skill.scope === "global" && skill.scope === "project" ? entry : existing;
+    const loser = winner === entry ? existing : entry;
+    claimed.set(command, winner);
+    conflicts.push({
+      command,
+      skillName: loser.skill.name,
+      scope: loser.skill.scope,
+      path: loser.skill.path,
+      reason: "duplicate",
+      message: `/${command} is declared by both "${winner.skill.name}" (${winner.skill.scope}) and "${loser.skill.name}" (${loser.skill.scope}). "${winner.skill.name}" wins; rename the command: key in ${loser.skill.path}.`
+    });
+  }
+  const entries = [...claimed.values()].sort((a, b) => a.command.command.localeCompare(b.command.command));
+  return { entries, conflicts };
+}
+async function listSkillCommands(workspace) {
+  const { entries, conflicts } = await collectEntries(workspace);
+  return { commands: entries.map((entry) => entry.command), conflicts };
+}
+function buildSkillCommandPrompt(skill, command, args) {
+  const argumentLine = command.argumentHint ? `Arguments (${command.argumentHint}): ${args || "(none provided)"}` : `Arguments: ${args || "(none provided)"}`;
+  const header = [
+    `The user ran the /${command.command} slash command, which runs the "${skill.name}" skill (${skill.scope}).`,
+    skill.description ? `Description: ${skill.description}` : void 0,
+    argumentLine,
+    skill.permissions.length ? `Permissions needed: ${skill.permissions.join(", ")}` : void 0,
+    "Follow the instructions below now, applying the arguments where they are relevant."
+  ].filter(Boolean).join("\n");
+  return `${header}
+
+--- instructions ---
+${skill.body}`;
+}
+async function resolveSkillCommand(workspace, input) {
+  const parsed = parseSlashInput(input);
+  if (!parsed) return { status: "not-a-command" };
+  const command = parsed.command.toLowerCase();
+  if (isBuiltinSlashCommand(command)) {
+    return { status: "builtin", command };
+  }
+  const { entries, conflicts } = await collectEntries(workspace);
+  const match = entries.find((entry) => entry.command.command === command);
+  if (!match) {
+    const related = conflicts.filter((conflict) => conflict.command === command);
+    if (related.length) {
+      return {
+        status: "conflict",
+        command,
+        message: related.map((conflict) => conflict.message).join("\n"),
+        conflicts: related
+      };
+    }
+    return {
+      status: "unknown",
+      command,
+      available: entries.map((entry) => entry.command.command)
+    };
+  }
+  return {
+    status: "ok",
+    command: match.command,
+    skill: match.skill,
+    args: parsed.args,
+    prompt: buildSkillCommandPrompt(match.skill, match.command, parsed.args)
+  };
+}
+function formatSkillCommandHelp(index) {
+  if (!index.commands.length) return "";
+  const lines = index.commands.map((command) => {
+    const invocation = command.argumentHint ? `/${command.command} ${command.argumentHint}` : `/${command.command}`;
+    const description = command.description || `Run the ${command.skillName} skill`;
+    return `  ${invocation.padEnd(22)}${description} (skill: ${command.skillName})`;
+  });
+  return ["Skill commands:", ...lines].join("\n");
+}
+
 // src/tools/workspace/skill-tools.ts
 var SkillInput = z17.object({
   name: z17.string().min(1).describe("Name of the skill to load, as shown in the skills list.")
@@ -8122,6 +8336,26 @@ var listSkillsTool = {
     };
   }
 };
+var CreateSkillInput = z17.object({
+  name: z17.string().min(1).max(80),
+  description: z17.string().trim().min(1).max(512),
+  body: z17.string().trim().min(1).max(6e4),
+  command: z17.string().min(1).max(64).optional(),
+  argumentHint: z17.string().max(256).optional()
+});
+var createSkillTool = {
+  name: "create_skill",
+  description: "Create a project SKILL.md with instructions; never overwrites. Trust is required before loading project skills.",
+  permissions: ["write"],
+  inputSchema: CreateSkillInput,
+  async execute(input, context) {
+    const command = input.command ? normalizeCommandName(input.command) : void 0;
+    if (command && isBuiltinSlashCommand(command)) throw new Error(`/${command} is reserved.`);
+    if (input.argumentHint && (!command || /[\r\n]/.test(input.argumentHint))) throw new Error("Argument hint requires a command and a single line.");
+    const skill = await createSkill(context.workspace, { ...input, command, scope: "project" });
+    return { changed: true, content: `Created ${skill.name}: ${skill.path}. Project skills require workspace trust before use.`, data: { name: skill.name, path: skill.path } };
+  }
+};
 
 // src/tools/workspace/todo-tools.ts
 import { z as z18 } from "zod";
@@ -8562,7 +8796,7 @@ function summarizeDirectories(files) {
     const directory = dirname9(file.path).split(/[\\/]/)[0] || ".";
     counts.set(directory, (counts.get(directory) ?? 0) + 1);
   }
-  return [...counts.entries()].map(([name, count3]) => ({ name, count: count3 })).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+  return [...counts.entries()].map(([name, count4]) => ({ name, count: count4 })).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
 }
 function summarizeExtensions(files) {
   const summaries = /* @__PURE__ */ new Map();
@@ -8831,6 +9065,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) {
@@ -8997,18 +9349,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;
 }
@@ -9546,6 +9898,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")}`;
@@ -9823,6 +10186,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();
@@ -9933,6 +10297,7 @@ var AgentRunner = class {
     ];
     const pinnedMessages = [...constraintMessages];
     const steps = [];
+    const periodicCompactor = new PeriodicCompactor();
     const toolsByName = new Map(
       registered.map((tool) => [tool.name, tool])
     );
@@ -9955,7 +10320,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;
@@ -9964,6 +10330,7 @@ var AgentRunner = class {
       try {
         await options.onCheckpoint(buildSession(void 0, listSubagentTranscripts()));
       } catch {
+        diagnosticEvent("session.checkpoint", { outcome: "failed", path: "run" });
       }
     };
     let stopReason = "max-steps";
@@ -9981,6 +10348,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";
@@ -10294,7 +10666,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;
@@ -10302,6 +10674,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 });
@@ -10316,6 +10693,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 };
 }
@@ -11201,8 +11579,8 @@ function tokenizeCommand(command) {
 function renderCommandLine(plan) {
   return [plan.command, ...plan.args].join(" ");
 }
-function parseTestOutput(runner, stdout6, stderr, workspace) {
-  const combined = [stdout6, stderr].filter(Boolean).join("\n");
+function parseTestOutput(runner, stdout6, stderr2, workspace) {
+  const combined = [stdout6, stderr2].filter(Boolean).join("\n");
   if (runner === "vitest" || runner === "jest") {
     const report = extractJestStyleReport(stdout6) ?? extractJestStyleReport(combined);
     if (report) return parseJestStyleReport(report, workspace);
@@ -12648,64 +13026,67 @@ function decodeCodePoint(value, fallback) {
 // src/tools/workspace.ts
 function createDefaultToolRegistry() {
   const { todoWriteTool, todoReadTool } = createTodoTools();
-  return new ToolRegistry().register(listFilesTool).register(readFileTool).register(readManyFilesTool).register(searchFilesTool).register(astSearchTool).register(inspectProjectTool).register(inspectArtifactTool).register(hexDumpTool).register(extractStringsTool).register(scanSecretsTool).register(fileTimelineTool).register(repoMapTool).register(repoHandbookTool).register(contextBundleTool).register(verificationPlanTool).register(verificationReportTool).register(writeFileTool).register(replaceInFileTool).register(multiEditTool).register(applyPatchTool).register(gitStatusTool).register(gitWorktreeSummaryTool).register(gitDiffTool).register(gitLogTool).register(gitShowTool).register(gitBlameTool).register(gitCommitTool).register(gitPushTool).register(runPackageScriptTool).register(runTestsTool).register(diagnosticsTool).register(listSessionsTool).register(readSessionTool).register(searchSessionsTool).register(fetchUrlTool).register(runShellTool).register(listProcessesTool).register(memoryWriteTool).register(memoryReadTool).register(memoryListTool).register(memorySearchTool).register(memoryDeleteTool).register(skillTool).register(listSkillsTool).register(todoWriteTool).register(todoReadTool).register(taskTool).register(askUserTool);
+  return new ToolRegistry().register(listFilesTool).register(readFileTool).register(readManyFilesTool).register(searchFilesTool).register(astSearchTool).register(inspectProjectTool).register(inspectArtifactTool).register(hexDumpTool).register(extractStringsTool).register(scanSecretsTool).register(fileTimelineTool).register(repoMapTool).register(repoHandbookTool).register(contextBundleTool).register(verificationPlanTool).register(verificationReportTool).register(writeFileTool).register(replaceInFileTool).register(multiEditTool).register(applyPatchTool).register(gitStatusTool).register(gitWorktreeSummaryTool).register(gitDiffTool).register(gitLogTool).register(gitShowTool).register(gitBlameTool).register(gitCommitTool).register(gitPushTool).register(runPackageScriptTool).register(runTestsTool).register(diagnosticsTool).register(listSessionsTool).register(readSessionTool).register(searchSessionsTool).register(fetchUrlTool).register(runShellTool).register(listProcessesTool).register(memoryWriteTool).register(memoryReadTool).register(memoryListTool).register(memorySearchTool).register(memoryDeleteTool).register(skillTool).register(listSkillsTool).register(createSkillTool).register(todoWriteTool).register(todoReadTool).register(taskTool).register(askUserTool);
 }
 
 // src/commands/doctor.ts
 function registerDoctorCommand(program2) {
   program2.command("doctor").description("Check the local ultrac setup").option("-w, --workspace <path>", "Workspace path", ".").option("--json", "Print JSON output", false).action(async (options) => {
-    const workspace = resolve7(options.workspace);
-    const workspaceReady = await stat10(workspace).then((entry) => entry.isDirectory(), () => false);
-    const [nodeMajor = 0, nodeMinor = 0] = process.versions.node.split(".").map(Number);
-    const nodeReady = nodeMajor > 22 || nodeMajor === 22 && nodeMinor >= 12;
-    const config = await loadConfig(workspace).catch(() => null);
-    const configExists = await hasConfig(workspace);
-    const isGitRepo = await pathExists(resolve7(workspace, ".git"));
-    const ultracCredentials = await resolveUltracCredentials();
-    const baseUrl = ultracCredentials ? { baseUrl: ultracCredentials.baseUrl, source: ultracCredentials.baseUrlSource } : resolveBaseUrl();
-    const tools = createDefaultToolRegistry().list();
-    const toolSchemasReady = tools.every((tool) => tool.inputSchema && typeof tool.inputSchema === "object");
-    const checks = [
-      { label: "node", value: `${process.versions.node} (requires >=22.12.0)`, ok: nodeReady },
-      {
-        label: "workspace",
-        value: workspaceReady ? workspace : `${workspace} - must be an accessible directory`,
-        ok: workspaceReady
-      },
-      { label: "git repository", value: isGitRepo ? "found" : "not found", ok: isGitRepo },
-      {
-        label: "config",
-        value: config ? configExists ? configPath(workspace) : "using defaults" : `unable to load configuration - check ${configPath(workspace)} and local trust settings`,
-        ok: config !== null
-      },
-      {
-        label: "tool schemas",
-        value: `${tools.length} exported`,
-        ok: toolSchemasReady
-      },
-      { label: "provider", value: config?.provider ?? "unavailable", ok: config !== null },
-      { label: "model", value: config?.model ?? "unavailable", ok: config !== null },
-      {
-        label: "Ultrac sign-in",
-        value: ultracCredentials ? `signed in via ${describeKeySource(ultracCredentials)}` : "not signed in - run `ultrac login` or set ULTRAC_API_KEY",
-        ok: config?.provider !== "ultrac" || Boolean(ultracCredentials)
-      },
-      {
-        label: "Ultrac API base URL",
-        value: `${baseUrl.baseUrl} via ${describeBaseUrlSource(baseUrl.source)}`,
-        ok: true
-      }
-    ];
-    if (options.json) {
-      console.log(JSON.stringify({ ok: checks.every((check) => check.ok), checks }, null, 2));
-    } else {
-      checks.forEach((check) => printCheck(check));
-    }
-    if (checks.some((check) => !check.ok)) {
-      process.exitCode = 1;
-    }
+    await runDoctor(options.workspace, options.json);
   });
 }
+async function runDoctor(workspacePath, json = false, setExitCode = true) {
+  const workspace = resolve7(workspacePath);
+  const workspaceReady = await stat10(workspace).then((entry) => entry.isDirectory(), () => false);
+  const [nodeMajor = 0, nodeMinor = 0] = process.versions.node.split(".").map(Number);
+  const nodeReady = nodeMajor > 22 || nodeMajor === 22 && nodeMinor >= 12;
+  const config = await loadConfig(workspace).catch(() => null);
+  const configExists = await hasConfig(workspace);
+  const isGitRepo = await pathExists(resolve7(workspace, ".git"));
+  const ultracCredentials = await resolveUltracCredentials();
+  const baseUrl = ultracCredentials ? { baseUrl: ultracCredentials.baseUrl, source: ultracCredentials.baseUrlSource } : resolveBaseUrl();
+  const tools = createDefaultToolRegistry().list();
+  const toolSchemasReady = tools.every((tool) => tool.inputSchema && typeof tool.inputSchema === "object");
+  const checks = [
+    { label: "node", value: `${process.versions.node} (requires >=22.12.0)`, ok: nodeReady },
+    {
+      label: "workspace",
+      value: workspaceReady ? workspace : `${workspace} - must be an accessible directory`,
+      ok: workspaceReady
+    },
+    { label: "git repository", value: isGitRepo ? "found" : "not found", ok: isGitRepo },
+    {
+      label: "config",
+      value: config ? configExists ? configPath(workspace) : "using defaults" : `unable to load configuration - check ${configPath(workspace)} and local trust settings`,
+      ok: config !== null
+    },
+    {
+      label: "tool schemas",
+      value: `${tools.length} exported`,
+      ok: toolSchemasReady
+    },
+    { label: "provider", value: config?.provider ?? "unavailable", ok: config !== null },
+    { label: "model", value: config?.model ?? "unavailable", ok: config !== null },
+    {
+      label: "Ultrac sign-in",
+      value: ultracCredentials ? `signed in via ${describeKeySource(ultracCredentials)}` : "not signed in - run `ultrac login` or set ULTRAC_API_KEY",
+      ok: config?.provider !== "ultrac" || Boolean(ultracCredentials)
+    },
+    {
+      label: "Ultrac API base URL",
+      value: `${baseUrl.baseUrl} via ${describeBaseUrlSource(baseUrl.source)}`,
+      ok: true
+    }
+  ];
+  if (json) {
+    console.log(JSON.stringify({ ok: checks.every((check) => check.ok), checks }, null, 2));
+  } else {
+    checks.forEach((check) => printCheck(check));
+  }
+  if (setExitCode && checks.some((check) => !check.ok)) {
+    process.exitCode = 1;
+  }
+}
 async function pathExists(path) {
   try {
     await access2(path);
@@ -13522,7 +13903,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
@@ -14348,7 +14732,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);
@@ -14374,6 +14798,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;
@@ -14396,7 +14821,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];
@@ -14414,6 +14839,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];
@@ -14438,6 +14864,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, {
@@ -14554,7 +15042,7 @@ 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 join12 } from "path";
+import { join as join13 } from "path";
 import { z as z31 } from "zod";
 var TelegramSchema = z31.object({
   botToken: z31.string().min(1),
@@ -14580,7 +15068,7 @@ var NotifyConfigSchema = z31.object({
   answerTimeoutSeconds: z31.number().int().min(30).max(86400).default(1800)
 });
 function notifyConfigPath() {
-  return join12(ultracHomeDir(), "notify.json");
+  return join13(ultracHomeDir(), "notify.json");
 }
 async function readStoredNotifyConfig() {
   let text;
@@ -15019,8 +15507,8 @@ function registerNotifyCommand(program2) {
 }
 
 // src/commands/repl.ts
-import { createInterface as createInterface3 } from "readline";
-import { stdin as stdin5, stdout as stdout5 } from "process";
+import { createInterface as createInterface3, emitKeypressEvents } from "readline";
+import { stdin as stdin5, stdout as stdout5, stderr } from "process";
 import chalk11 from "chalk";
 
 // src/config/budget.ts
@@ -15197,6 +15685,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)
   );
@@ -15252,6 +15743,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;
@@ -15310,6 +15805,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() {
@@ -15348,6 +15844,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 ?? "";
@@ -15368,6 +15865,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);
@@ -15430,6 +15938,7 @@ Acknowledge that you have the context and wait for the user's first request.`
     try {
       await handlers.onCheckpoint(this.toSession());
     } catch {
+      diagnosticEvent("session.checkpoint", { outcome: "failed", path: "interactive" });
     }
   }
   appendQueuedMessages(handlers) {
@@ -15472,6 +15981,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;
@@ -15512,12 +16026,13 @@ Acknowledge that you have the context and wait for the user's first request.`
         this.messages.push({ role: "assistant", content: JSON.stringify(parsed) });
         this.steps.push(step);
         await this.checkpoint(handlers);
-        for (const call of parsed.toolCalls) {
+        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(
@@ -15527,24 +16042,33 @@ 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);
+            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);
-            continue;
           }
-          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;
+          }
         }
         if (handlers.signal?.aborted) {
           stopReason = "aborted";
@@ -15604,7 +16128,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 } : {}
         }
       );
@@ -15751,6 +16275,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.
@@ -15803,6 +16328,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
@@ -15844,6 +16370,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 ?? "";
@@ -15871,6 +16398,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();
@@ -15931,6 +16469,7 @@ ${context}`
     try {
       await handlers.onCheckpoint(this.toSession());
     } catch {
+      diagnosticEvent("session.checkpoint", { outcome: "failed", path: "interactive" });
     }
   }
   appendQueuedMessages(handlers) {
@@ -15969,6 +16508,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;
@@ -16029,13 +16573,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(
@@ -16045,27 +16590,37 @@ ${context}`
               )
             };
             if (authorization.permission) handlers.onToolDenied?.(displayCall, authorization.permission);
-            step.toolResults.push({ call: displayCall, result: result2 });
-            this.pushToolResult(call, result2);
+            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);
-            continue;
           }
-          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);
-          await this.checkpoint(handlers);
+            break;
+          }
         }
         if (handlers.signal?.aborted) {
           stopReason = "aborted";
@@ -16121,7 +16676,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 } : {}
         }
       );
@@ -16285,6 +16840,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.
@@ -16308,6 +16864,152 @@ function noteNativeCompactionFallback(reason) {
   );
 }
 
+// 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, startStep = 0) {
+  const hash = createHash7("sha256");
+  let completedTools = 0;
+  hash.update(session.finalMessage ?? "");
+  for (const step of (session.steps ?? []).slice(startStep)) {
+    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 lastSessionId;
+  let lastStepCount = 0;
+  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 stepCount = session.steps?.length ?? 0;
+      const startStep = session.id === lastSessionId && stepCount > lastStepCount ? lastStepCount : 0;
+      const current = progress(session, startStep);
+      lastSessionId = session.id;
+      lastStepCount = stepCount;
+      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/session-checkpoint.ts
 var SESSION_CHECKPOINT_FAILURE_WARNING = "Warning: the latest session checkpoint could not be saved; progress since the previous checkpoint may be lost.";
 function createSessionCheckpointWriter(workspace, onFailure) {
@@ -16335,6 +17037,16 @@ 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 chalk8 from "chalk";
 var stopReasonDetail = {
@@ -16348,15 +17060,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(chalk8.gray(`step ${step.index + 1}:`), step.parsed.message);
     }
     for (const toolResult of step.toolResults) {
       const status = toolResult.result.ok ? chalk8.green("ok") : chalk8.red("failed");
-      console.log(chalk8.cyan(toolResult.call.tool), status);
-      console.log(chalk8.gray(indent2(toolResult.result.content)));
+      console.log(chalk8.white(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) {
@@ -16375,279 +17087,92 @@ function printTools(tools) {
   for (const tool of tools) {
     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.white(tool.name)}${permissionText}${optionalText}`);
     console.log(chalk8.gray(indent2(tool.description)));
   }
 }
-function printToolResult(result) {
+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(result.content)));
+  console.log(`${chalk8.white(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 = [
-  "usage",
-  "max-steps",
-  "resume",
-  "deny",
-  "plan",
-  "review",
-  "coding",
-  "status",
-  "context",
-  "compact",
-  "diff",
-  "sessions",
-  "save",
-  "test",
-  "init",
-  "new",
-  "allow",
-  "clear",
-  "exit",
-  "help",
-  "memory",
-  "mode",
-  "model",
-  "permissions",
-  "quit",
-  "skills",
-  "tools",
-  "whoami"
-];
-var COMMAND_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var MAX_COMMAND_LENGTH = 64;
-function parseSlashInput(input) {
-  const trimmed = input.trim();
-  if (!trimmed.startsWith("/")) return null;
-  const rest = trimmed.slice(1);
-  const match = rest.match(/^(\S+)(?:\s+([\s\S]*))?$/);
-  if (!match) return null;
-  return { command: match[1], args: (match[2] ?? "").trim() };
+// src/ui/progress.ts
+import { stdout as stdout3 } from "process";
+import chalk9 from "chalk";
+var PENDING_GLYPH = "\u25CB";
+var DONE_GLYPH = "\u25CF";
+var REPAINT_MS = 100;
+function formatTokens(tokens) {
+  if (!Number.isFinite(tokens) || tokens <= 0) return "0";
+  if (tokens < 1e3) return String(Math.floor(tokens));
+  if (tokens < 1e6) {
+    const tenths2 = Math.floor(tokens / 100);
+    return `${Math.floor(tenths2 / 10)}.${tenths2 % 10}k`;
+  }
+  const tenths = Math.floor(tokens / 1e5);
+  return `${Math.floor(tenths / 10)}.${tenths % 10}M`;
 }
-function isBuiltinSlashCommand(command) {
-  return BUILTIN_SLASH_COMMANDS.includes(command.toLowerCase());
+function formatElapsed(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) return "0s";
+  const totalSeconds = Math.floor(ms / 1e3);
+  const seconds = totalSeconds % 60;
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  const minutes = totalMinutes % 60;
+  const hours = Math.floor(totalMinutes / 60);
+  if (totalMinutes === 0) return `${seconds}s`;
+  if (hours === 0) return `${minutes}m ${seconds}s`;
+  return `${hours}h ${String(minutes).padStart(2, "0")}m`;
 }
-function normalizeCommandName(value) {
-  const candidate = value.trim().replace(/^\/+/, "").trim();
-  if (!candidate) {
-    throw new Error("Slash command name is empty; expected kebab-case, for example: open-pr.");
+function formatProgressLine(snapshot) {
+  const finished = snapshot.done >= snapshot.total;
+  const glyph = finished ? chalk9.green(DONE_GLYPH) : chalk9.white(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) => chalk9.dim(stat11)).join(chalk9.dim(" \xB7 "));
+  return `  ${glyph} ${chalk9.white(snapshot.label)}  ${snapshot.description}  ${rendered}`;
+}
+var ProgressLine = class {
+  constructor(label, description, total) {
+    this.label = label;
+    this.description = description;
+    this.total = total;
   }
-  if (candidate.length > MAX_COMMAND_LENGTH) {
-    throw new Error(
-      `Slash command name "${candidate}" is longer than ${MAX_COMMAND_LENGTH} characters.`
-    );
+  label;
+  description;
+  total;
+  timer;
+  startedAt;
+  doneCount = 0;
+  tokens;
+  /** True only while this instance owns a painted line it still has to release. */
+  live = false;
+  start() {
+    if (this.startedAt !== void 0) return;
+    this.startedAt = Date.now();
+    if (!stdout3.isTTY) return;
+    this.live = true;
+    this.render();
+    this.timer = setInterval(() => this.render(), REPAINT_MS);
   }
-  if (!COMMAND_NAME_RE.test(candidate)) {
-    throw new Error(
-      `Invalid slash command name "${candidate}": use kebab-case - lowercase letters, digits, and single hyphens, no spaces or slashes (for example: open-pr).`
-    );
-  }
-  return candidate;
-}
-async function collectEntries(workspace) {
-  const skills = await discoverSkills(workspace);
-  const claimed = /* @__PURE__ */ new Map();
-  const conflicts = [];
-  for (const skill of skills) {
-    let declaration;
-    try {
-      declaration = skill.command ?? null;
-    } catch (error) {
-      conflicts.push({
-        command: "",
-        skillName: skill.name,
-        scope: skill.scope,
-        path: skill.path,
-        reason: "invalid",
-        message: `Skill "${skill.name}" (${skill.scope}) was skipped: ${error instanceof Error ? error.message : String(error)}`
-      });
-      continue;
-    }
-    if (!declaration) continue;
-    let command;
-    try {
-      command = normalizeCommandName(declaration.raw);
-    } catch (error) {
-      conflicts.push({
-        command: declaration.raw,
-        skillName: skill.name,
-        scope: skill.scope,
-        path: skill.path,
-        reason: "invalid",
-        message: `Skill "${skill.name}" (${skill.scope}) declares a malformed command: ${error instanceof Error ? error.message : String(error)}`
-      });
-      continue;
-    }
-    if (isBuiltinSlashCommand(command)) {
-      conflicts.push({
-        command,
-        skillName: skill.name,
-        scope: skill.scope,
-        path: skill.path,
-        reason: "builtin",
-        message: `Skill "${skill.name}" (${skill.scope}) declares /${command}, which is a built-in command. Built-ins always win - rename the command: key in ${skill.path}.`
-      });
-      continue;
-    }
-    const entry = {
-      skill,
-      command: {
-        command,
-        skillName: skill.name,
-        description: skill.description,
-        argumentHint: declaration.argumentHint,
-        scope: skill.scope,
-        path: skill.path
-      }
-    };
-    const existing = claimed.get(command);
-    if (!existing) {
-      claimed.set(command, entry);
-      continue;
-    }
-    const winner = existing.skill.scope === "global" && skill.scope === "project" ? entry : existing;
-    const loser = winner === entry ? existing : entry;
-    claimed.set(command, winner);
-    conflicts.push({
-      command,
-      skillName: loser.skill.name,
-      scope: loser.skill.scope,
-      path: loser.skill.path,
-      reason: "duplicate",
-      message: `/${command} is declared by both "${winner.skill.name}" (${winner.skill.scope}) and "${loser.skill.name}" (${loser.skill.scope}). "${winner.skill.name}" wins; rename the command: key in ${loser.skill.path}.`
-    });
-  }
-  const entries = [...claimed.values()].sort((a, b) => a.command.command.localeCompare(b.command.command));
-  return { entries, conflicts };
-}
-async function listSkillCommands(workspace) {
-  const { entries, conflicts } = await collectEntries(workspace);
-  return { commands: entries.map((entry) => entry.command), conflicts };
-}
-function buildSkillCommandPrompt(skill, command, args) {
-  const argumentLine = command.argumentHint ? `Arguments (${command.argumentHint}): ${args || "(none provided)"}` : `Arguments: ${args || "(none provided)"}`;
-  const header = [
-    `The user ran the /${command.command} slash command, which runs the "${skill.name}" skill (${skill.scope}).`,
-    skill.description ? `Description: ${skill.description}` : void 0,
-    argumentLine,
-    skill.permissions.length ? `Permissions needed: ${skill.permissions.join(", ")}` : void 0,
-    "Follow the instructions below now, applying the arguments where they are relevant."
-  ].filter(Boolean).join("\n");
-  return `${header}
-
---- instructions ---
-${skill.body}`;
-}
-async function resolveSkillCommand(workspace, input) {
-  const parsed = parseSlashInput(input);
-  if (!parsed) return { status: "not-a-command" };
-  const command = parsed.command.toLowerCase();
-  if (isBuiltinSlashCommand(command)) {
-    return { status: "builtin", command };
-  }
-  const { entries, conflicts } = await collectEntries(workspace);
-  const match = entries.find((entry) => entry.command.command === command);
-  if (!match) {
-    const related = conflicts.filter((conflict) => conflict.command === command);
-    if (related.length) {
-      return {
-        status: "conflict",
-        command,
-        message: related.map((conflict) => conflict.message).join("\n"),
-        conflicts: related
-      };
-    }
-    return {
-      status: "unknown",
-      command,
-      available: entries.map((entry) => entry.command.command)
-    };
-  }
-  return {
-    status: "ok",
-    command: match.command,
-    skill: match.skill,
-    args: parsed.args,
-    prompt: buildSkillCommandPrompt(match.skill, match.command, parsed.args)
-  };
-}
-function formatSkillCommandHelp(index) {
-  if (!index.commands.length) return "";
-  const lines = index.commands.map((command) => {
-    const invocation = command.argumentHint ? `/${command.command} ${command.argumentHint}` : `/${command.command}`;
-    const description = command.description || `Run the ${command.skillName} skill`;
-    return `  ${invocation.padEnd(22)}${description} (skill: ${command.skillName})`;
-  });
-  return ["Skill commands:", ...lines].join("\n");
-}
-
-// src/ui/progress.ts
-import { stdout as stdout3 } from "process";
-import chalk9 from "chalk";
-var PENDING_GLYPH = "\u25CB";
-var DONE_GLYPH = "\u25CF";
-var REPAINT_MS = 100;
-function formatTokens(tokens) {
-  if (!Number.isFinite(tokens) || tokens <= 0) return "0";
-  if (tokens < 1e3) return String(Math.floor(tokens));
-  if (tokens < 1e6) {
-    const tenths2 = Math.floor(tokens / 100);
-    return `${Math.floor(tenths2 / 10)}.${tenths2 % 10}k`;
-  }
-  const tenths = Math.floor(tokens / 1e5);
-  return `${Math.floor(tenths / 10)}.${tenths % 10}M`;
-}
-function formatElapsed(ms) {
-  if (!Number.isFinite(ms) || ms <= 0) return "0s";
-  const totalSeconds = Math.floor(ms / 1e3);
-  const seconds = totalSeconds % 60;
-  const totalMinutes = Math.floor(totalSeconds / 60);
-  const minutes = totalMinutes % 60;
-  const hours = Math.floor(totalMinutes / 60);
-  if (totalMinutes === 0) return `${seconds}s`;
-  if (hours === 0) return `${minutes}m ${seconds}s`;
-  return `${hours}h ${String(minutes).padStart(2, "0")}m`;
-}
-function formatProgressLine(snapshot) {
-  const finished = snapshot.done >= snapshot.total;
-  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) => chalk9.dim(stat11)).join(chalk9.dim(" \xB7 "));
-  return `  ${glyph} ${chalk9.cyan(snapshot.label)}  ${snapshot.description}  ${rendered}`;
-}
-var ProgressLine = class {
-  constructor(label, description, total) {
-    this.label = label;
-    this.description = description;
-    this.total = total;
-  }
-  label;
-  description;
-  total;
-  timer;
-  startedAt;
-  doneCount = 0;
-  tokens;
-  /** True only while this instance owns a painted line it still has to release. */
-  live = false;
-  start() {
-    if (this.startedAt !== void 0) return;
-    this.startedAt = Date.now();
-    if (!stdout3.isTTY) return;
-    this.live = true;
-    this.render();
-    this.timer = setInterval(() => this.render(), REPAINT_MS);
-  }
-  /** One agent finished. */
-  complete() {
-    if (this.doneCount < this.total) this.doneCount += 1;
+  /** One agent finished. */
+  complete() {
+    if (this.doneCount < this.total) this.doneCount += 1;
   }
   addTokens(tokens) {
     if (!Number.isFinite(tokens)) return;
@@ -16756,7 +17281,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);
@@ -16775,6 +17303,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);
@@ -16853,6 +17390,682 @@ function humanize(value) {
   return words ? `${words[0].toUpperCase()}${words.slice(1)}` : "Tool";
 }
 
+// src/ui/interactive-choice.ts
+var MOUSE_ON = "\x1B[?1006h\x1B[?1000h";
+var MOUSE_OFF = "\x1B[?1000l\x1B[?1006l";
+function displayLabel(value, width2) {
+  const clean = value.replace(/\x1b(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1b\\)|.)/g, "").replace(/[\x00-\x1f\x7f-\x9f]/g, " ");
+  let result = "";
+  let used = 0;
+  for (const character of clean) {
+    const size = /[\p{Mark}\u200d\ufe0e\ufe0f]/u.test(character) ? 0 : character.codePointAt(0) < 128 ? 1 : 2;
+    if (used + size > width2 - 1) return `${result}\u2026`;
+    result += character;
+    used += size;
+  }
+  return result;
+}
+function attachInteractiveChoices(readline, options, settings = {}) {
+  const rl = readline;
+  const output = settings.output ?? rl.output;
+  const prompt = settings.prompt ?? "  \u203A ";
+  let resolveReady;
+  const ready = new Promise((resolve15) => {
+    resolveReady = resolve15;
+  });
+  const original = rl._ttyWrite;
+  const priorPrompt = rl.getPrompt();
+  const priorLine = rl.line;
+  const priorCursor = rl.cursor;
+  const priorHistory = rl.history?.slice();
+  let injected = false;
+  let selected = 0;
+  let disposed = false;
+  let mouse = false;
+  let optionRow = null;
+  let reportPending = false;
+  let reportTimer;
+  let sequenceTimer;
+  let sequence = "";
+  const maxRow = () => settings.maxRow?.() ?? output?.rows ?? 1e4;
+  const columns = () => Math.max(16, output?.columns ?? 80);
+  const write = (text) => {
+    output?.write(text);
+  };
+  const labels = () => options.map((option, index) => {
+    const prefix = `  ${selected === index ? "\u203A" : " "} ${index + 1}. `;
+    const text = `${prefix}${displayLabel(option, columns() - 9)}`;
+    return selected === index ? `\x1B[7m${text}\x1B[0m` : text;
+  });
+  const restoreLine = () => {
+    if (!original || !rl.terminal || rl.closed) return;
+    if (rl.line) {
+      original.call(rl, void 0, { name: "end" });
+      original.call(rl, void 0, { name: "u", ctrl: true });
+    }
+    if (priorLine) {
+      original.call(rl, priorLine, {});
+      for (const _character of Array.from(priorLine.slice(priorCursor))) original.call(rl, void 0, { name: "left" });
+    }
+  };
+  const cleanup = () => {
+    if (disposed) return;
+    disposed = true;
+    clearTimeout(reportTimer);
+    clearTimeout(sequenceTimer);
+    if (rl._ttyWrite === intercept) rl._ttyWrite = original;
+    rl.off("line", onLine);
+    rl.off("close", cleanup);
+    output?.off("resize", onResize);
+    output?.off("error", cleanup);
+    settings.signal?.removeEventListener("abort", cleanup);
+    try {
+      if (mouse) write(MOUSE_OFF);
+    } catch {
+    }
+    mouse = false;
+    rl.setPrompt(priorPrompt);
+    if (injected && priorHistory && rl.history) rl.history.splice(0, rl.history.length, ...priorHistory);
+    try {
+      restoreLine();
+    } catch {
+    }
+    resolveReady(false);
+  };
+  function onLine() {
+    cleanup();
+  }
+  function redraw() {
+    if (disposed || rl.line || options.length + 2 > maxRow()) return;
+    write("\x1B7");
+    if (optionRow !== null) write(`\x1B[${optionRow};1H`);
+    else write(`\x1B[${options.length + 1}A\r`);
+    for (const label of labels()) write(`\x1B[2K${label}
+\r`);
+    write("\x1B8");
+  }
+  function choose(index) {
+    if (disposed || !original || index < 0 || index >= options.length) return;
+    selected = index;
+    injected = true;
+    if (rl.line) {
+      original.call(rl, void 0, { name: "end" });
+      original.call(rl, void 0, { name: "u", ctrl: true });
+    }
+    original.call(rl, String(index + 1), {});
+    original.call(rl, "\r", { name: "return", sequence: "\r" });
+  }
+  function requestPosition() {
+    if (disposed) return;
+    optionRow = null;
+    reportPending = true;
+    clearTimeout(reportTimer);
+    write("\x1B[6n");
+    reportTimer = setTimeout(() => {
+      reportPending = false;
+      resolveReady(false);
+    }, Math.max(1, settings.cursorReportTimeoutMs ?? 250));
+  }
+  function onResize() {
+    if (disposed) return;
+    if (mouse) write(MOUSE_OFF);
+    mouse = false;
+    optionRow = null;
+    requestPosition();
+  }
+  function consumeControl(value) {
+    const position = /^\x1b\[(\d+);(\d+)R$/.exec(value);
+    if (position) {
+      const row = Number(position[1]);
+      const column = Number(position[2]);
+      if (reportPending && row > options.length + 1 && row <= maxRow() && column >= 1 && column <= columns()) {
+        optionRow = row - options.length - 1;
+        reportPending = false;
+        clearTimeout(reportTimer);
+        write(MOUSE_ON);
+        mouse = true;
+        resolveReady(true);
+      }
+      return true;
+    }
+    const click = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/.exec(value);
+    if (click) {
+      const button = Number(click[1]);
+      const x = Number(click[2]);
+      const y = Number(click[3]);
+      if (mouse && optionRow !== null && click[4] === "M" && button < 32 && (button & 3) === 0 && x >= 1 && x <= columns() && y <= maxRow()) choose(y - optionRow);
+      return true;
+    }
+    return false;
+  }
+  function intercept(text, key) {
+    if (disposed) {
+      original?.call(rl, text, key);
+      return;
+    }
+    const value = key?.sequence ?? text ?? "";
+    if (sequence || value.startsWith("\x1B[<") || /^\x1b\[\d/.test(value)) {
+      sequence += value;
+      clearTimeout(sequenceTimer);
+      if (consumeControl(sequence)) {
+        sequence = "";
+        return;
+      }
+      if (/^\x1b\[(?:<[0-9;]*|[0-9;]*)$/.test(sequence) && sequence.length < 64) {
+        sequenceTimer = setTimeout(() => {
+          sequence = "";
+        }, 250);
+        return;
+      }
+      const unrecognized = sequence;
+      sequence = "";
+      original?.call(rl, unrecognized, key);
+      return;
+    }
+    if (!rl.line && (key?.name === "up" || key?.name === "down")) {
+      selected = (selected + (key.name === "down" ? 1 : options.length - 1)) % options.length;
+      redraw();
+      return;
+    }
+    if (!rl.line && (key?.name === "return" || key?.name === "enter")) {
+      choose(selected);
+      return;
+    }
+    if (key?.ctrl && key.name === "c") cleanup();
+    if (key?.ctrl && key.name === "d" && !rl.line) {
+      original?.call(rl, text, key);
+      cleanup();
+      return;
+    }
+    original?.call(rl, text, key);
+  }
+  if (settings.signal?.aborted) {
+    disposed = true;
+    resolveReady(false);
+    return { cleanup, ready };
+  }
+  if (!output || !rl.terminal || !output.isTTY || process.env.TERM === "dumb" || !original || !options.length) {
+    options.forEach((option, index) => write(`  ${index + 1}. ${displayLabel(option, columns() - 6)}
+`));
+    write(prompt);
+    resolveReady(false);
+    disposed = true;
+    return { cleanup, ready };
+  }
+  try {
+    if (priorLine) {
+      original.call(rl, void 0, { name: "end" });
+      original.call(rl, void 0, { name: "u", ctrl: true });
+    }
+    rl.setPrompt(prompt);
+    rl._ttyWrite = intercept;
+    rl.once("line", onLine);
+    rl.once("close", cleanup);
+    output.on("resize", onResize);
+    output.on("error", cleanup);
+    settings.signal?.addEventListener("abort", cleanup, { once: true });
+    for (const label of labels()) write(`${label}\r
+`);
+    write("  \u2191/\u2193 and Enter, a number, or your own answer.\r\n");
+    rl.prompt();
+    requestPosition();
+  } catch (error) {
+    cleanup();
+    throw error;
+  }
+  return { cleanup, ready };
+}
+
+// src/ui/slash-completion.ts
+function attachSlashCompletion(readline, loadEntries, render, initialEntries = []) {
+  const rl = readline;
+  const original = rl._ttyWrite;
+  let entries = [...initialEntries];
+  let matches = [];
+  let selected = 0;
+  let disposed = false;
+  let suppressed = false;
+  let opened = false;
+  let epoch = 0;
+  let handledEscape = false;
+  const clear = () => {
+    matches = [];
+    selected = 0;
+    render([], 0);
+  };
+  const refresh = () => {
+    if (disposed || suppressed) return;
+    const line = rl.line;
+    const skillPrefix = /^\/skill\s+([a-z0-9-]*)$/i.exec(line);
+    if (!/^\/[a-z0-9-]*$/i.test(line) && !skillPrefix) {
+      opened = false;
+      epoch += 1;
+      clear();
+      return;
+    }
+    if (!opened) {
+      opened = true;
+      const request = ++epoch;
+      void loadEntries().then((items) => {
+        if (disposed || request !== epoch || !opened) return;
+        entries = items;
+        refresh();
+      }).catch(() => {
+        if (!disposed && request === epoch) clear();
+      });
+    }
+    const query = (skillPrefix?.[1] ?? line.slice(1)).toLowerCase();
+    matches = entries.filter((entry) => (!skillPrefix || entry.skill) && (entry.text.toLowerCase().includes(query) || entry.label.toLowerCase().includes(query)));
+    selected = Math.min(selected, Math.max(0, matches.length - 1));
+    render(matches.map((entry) => `${entry.label}${entry.description ? `  ${entry.description}` : ""}`.replace(/[\x00-\x1f\x7f]/g, " ")), selected);
+  };
+  const wrapper = function(text, key) {
+    if (!suppressed && matches.length) {
+      if (key?.name === "escape") {
+        handledEscape = true;
+        setTimeout(() => {
+          handledEscape = false;
+        }, 0);
+        opened = false;
+        epoch += 1;
+        clear();
+        return;
+      }
+      if (key?.name === "up" || key?.name === "down") {
+        selected = (selected + (key.name === "up" ? -1 : 1) + matches.length) % matches.length;
+        render(matches.map((entry) => `${entry.label}${entry.description ? `  ${entry.description}` : ""}`.replace(/[\x00-\x1f\x7f]/g, " ")), selected);
+        return;
+      }
+      if (key?.name === "tab" || key?.name === "return" || key?.name === "enter") {
+        const choice = matches[selected];
+        suppressed = true;
+        try {
+          rl.write(null, { ctrl: true, name: "u" });
+          rl.write(`${choice.text} `);
+        } finally {
+          suppressed = false;
+          opened = false;
+          epoch += 1;
+          clear();
+        }
+        return;
+      }
+    }
+    original.call(this, text, key);
+    refresh();
+  };
+  rl._ttyWrite = wrapper;
+  return {
+    handledEscape: () => handledEscape,
+    suspend: () => {
+      suppressed = true;
+      opened = false;
+      epoch += 1;
+      clear();
+    },
+    resume: () => {
+      suppressed = false;
+      refresh();
+    },
+    cleanup: () => {
+      disposed = true;
+      epoch += 1;
+      clear();
+      if (rl._ttyWrite === wrapper) rl._ttyWrite = original;
+    }
+  };
+}
+
+// src/ui/terminal-layout.ts
+import { Writable } from "stream";
+import { stripVTControlCharacters } from "util";
+var CSI = "\x1B[";
+var RESET_REGION = `${CSI}r`;
+var MOUSE_OFF2 = `${CSI}?1000l${CSI}?1002l${CSI}?1003l${CSI}?1006l`;
+var BASE_FOOTER_ROWS = 5;
+var segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+var cells = (value) => [...segmenter.segment(value)].map(({ segment }) => {
+  const code = segment.codePointAt(0) ?? 0;
+  const wide = /\p{Extended_Pictographic}/u.test(segment) || code >= 4352 && (code <= 4447 || code === 9001 || code === 9002 || code >= 11904 && code <= 42191 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65040 && code <= 65135 || code >= 65281 && code <= 65376 || code >= 65504 && code <= 65510 || code >= 131072);
+  return { text: segment, width: /^\p{Mark}+$/u.test(segment) ? 0 : wide ? 2 : 1 };
+});
+var width = (text) => cells(text).reduce((sum, cell) => sum + cell.width, 0);
+function plain(value) {
+  return stripVTControlCharacters(value).replace(/[\x00-\x1f\x7f]/g, " ");
+}
+function fit(text, columns) {
+  if (columns <= 0) return "";
+  let result = "";
+  let used = 0;
+  for (const cell of cells(plain(text))) {
+    if (used + cell.width > columns) break;
+    result += cell.text;
+    used += cell.width;
+  }
+  return result;
+}
+var cup = (row, column = 1) => `${CSI}${row};${column}H`;
+var count3 = (value) => value !== void 0 && Number.isFinite(value) && value >= 0 ? Math.floor(value).toLocaleString("en-US") : "unknown";
+var ComposerOutput = class extends Writable {
+  constructor(layout) {
+    super();
+    this.layout = layout;
+  }
+  layout;
+  get isTTY() {
+    return this.layout.enabled;
+  }
+  get columns() {
+    return this.layout.columns;
+  }
+  get rows() {
+    return this.layout.rows;
+  }
+  _write(chunk, _encoding, callback) {
+    try {
+      this.layout.writeComposer(chunk);
+      callback();
+    } catch (error) {
+      callback(error instanceof Error ? error : new Error("Terminal output failed"));
+    }
+  }
+};
+var TerminalLayout = class {
+  outputProxy;
+  enabled;
+  output;
+  errorOutput;
+  originalWrite;
+  originalErrorWrite;
+  rawWrite;
+  details;
+  rl;
+  prompt = "\u203A ";
+  transcriptRow = 1;
+  transcriptColumn = 1;
+  wrapPending = false;
+  savedTranscript;
+  lastFooterTop = 0;
+  suggestions = [];
+  selected = 0;
+  installed = false;
+  closed = false;
+  suspended = 0;
+  paintQueued = false;
+  bindSignals;
+  resize = () => {
+    if (this.closed || !this.enabled) return;
+    this.clearPreviousFooter();
+    this.transcriptRow = Math.min(this.transcriptRow, this.contentRows);
+    this.transcriptColumn = Math.min(this.transcriptColumn, this.columns);
+    this.rawWrite(`${CSI}1;${this.contentRows}r`);
+    this.outputProxy.emit("resize");
+    this.paintFooter();
+  };
+  exit = () => {
+    this.close();
+  };
+  constructor(options) {
+    this.output = options.output;
+    this.errorOutput = options.errorOutput;
+    this.details = { ...options.details };
+    this.bindSignals = options.bindSignals !== false;
+    this.originalWrite = options.output.write;
+    this.rawWrite = options.output.write.bind(options.output);
+    this.originalErrorWrite = options.errorOutput?.write;
+    this.enabled = Boolean(options.output.isTTY && (options.output.columns ?? 80) >= 12 && (options.output.rows ?? 24) >= 7);
+    this.outputProxy = new ComposerOutput(this);
+  }
+  get columns() {
+    return Math.max(12, this.output.columns ?? 80);
+  }
+  get rows() {
+    return Math.max(7, this.output.rows ?? 24);
+  }
+  get suggestionRows() {
+    return Math.min(8, this.suggestions.length, Math.max(0, this.rows - BASE_FOOTER_ROWS - 2));
+  }
+  get contentRows() {
+    return this.rows - BASE_FOOTER_ROWS - this.suggestionRows;
+  }
+  get inputRow() {
+    return this.rows - 3;
+  }
+  install() {
+    if (this.installed || this.closed || !this.enabled) return this;
+    this.installed = true;
+    this.output.write = ((chunk, encoding, callback) => this.writeTranscript(chunk, encoding, callback));
+    if (this.errorOutput && this.errorOutput !== this.output) this.errorOutput.write = this.output.write;
+    this.output.on("resize", this.resize);
+    this.output.on("error", this.exit);
+    if (this.errorOutput !== this.output) this.errorOutput?.on("error", this.exit);
+    process.once("exit", this.exit);
+    if (this.bindSignals) {
+      process.once("SIGINT", this.exit);
+      process.once("SIGTERM", this.exit);
+    }
+    this.rawWrite(`${CSI}2J${cup(1)}${CSI}1;${this.contentRows}r`);
+    this.paintFooter();
+    return this;
+  }
+  attachReadline(rl) {
+    this.rl = rl;
+    rl.setPrompt(this.prompt);
+    this.paintFooter();
+  }
+  setPrompt(prompt) {
+    this.prompt = prompt;
+    this.rl?.setPrompt(prompt);
+    this.paintFooter();
+  }
+  updateDetails(details) {
+    this.details = { ...this.details, ...details };
+    this.paintFooter();
+  }
+  setSuggestions(items, selectedIndex = 0) {
+    if (this.enabled && this.installed && !this.closed) this.clearPreviousFooter();
+    this.suggestions = [...items];
+    this.selected = Math.max(0, Math.min(items.length - 1, selectedIndex));
+    if (this.enabled && this.installed && !this.closed) {
+      this.transcriptRow = Math.min(this.transcriptRow, this.contentRows);
+      this.rawWrite(`${CSI}1;${this.contentRows}r`);
+      this.paintFooter();
+    }
+  }
+  /** Freeze the footer and focus choices in the transcript; its reserved rows stay visible. */
+  suspend() {
+    if (this.closed || !this.enabled) return;
+    this.suspended += 1;
+    this.rawWrite(cup(this.transcriptRow, this.transcriptColumn));
+  }
+  resume() {
+    if (this.suspended > 0) this.suspended -= 1;
+    if (!this.suspended) this.paintFooter();
+  }
+  writeComposer(chunk) {
+    if (this.closed || !this.enabled || !this.installed) {
+      this.rawWrite(chunk);
+      return;
+    }
+    if (this.suspended) {
+      this.writeTranscript(chunk);
+      return;
+    }
+    if (!this.paintQueued) {
+      this.paintQueued = true;
+      queueMicrotask(() => {
+        this.paintQueued = false;
+        if (!this.closed && !this.suspended) this.paintFooter();
+      });
+    }
+  }
+  writeTranscript(chunk, encoding, callback) {
+    if (this.closed || !this.enabled || !this.installed) return this.rawWrite(chunk, encoding, callback);
+    const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString(typeof encoding === "string" ? encoding : "utf8");
+    const formatted = text.replace(/(?<!\r)\n/g, "\r\n").replace(/\x1b\[([012]?)J/g, (_escape, mode) => {
+      const saved = cup(this.transcriptRow, this.transcriptColumn);
+      const first = mode === "2" || mode === "1" ? 1 : this.transcriptRow;
+      const last = mode === "1" ? this.transcriptRow : this.contentRows;
+      let erased = "";
+      for (let row = first; row <= last; row += 1) erased += `${cup(row)}${CSI}2K`;
+      return erased + saved;
+    });
+    if (this.wrapPending && !/^[\r\n]/.test(stripVTControlCharacters(formatted))) {
+      this.rawWrite(`${cup(this.transcriptRow, this.columns)}\r
+`);
+      this.transcriptRow = Math.min(this.contentRows, this.transcriptRow + 1);
+      this.transcriptColumn = 1;
+      this.wrapPending = false;
+    }
+    this.rawWrite(cup(this.transcriptRow, this.transcriptColumn));
+    const accepted = this.rawWrite(
+      formatted,
+      typeof encoding === "string" ? encoding : void 0,
+      typeof encoding === "function" ? encoding : callback
+    );
+    this.trackTranscript(formatted);
+    if (!this.suspended) this.placeInputCursor();
+    return accepted;
+  }
+  trackTranscript(text) {
+    const parts = text.split(/(\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07]*(?:\x07|\x1b\\)|\x1b.)/g);
+    for (const part of parts) {
+      if (part === "\x1B7") {
+        this.savedTranscript = { row: this.transcriptRow, column: this.transcriptColumn, wrapPending: this.wrapPending };
+      } else if (part === "\x1B8") {
+        if (this.savedTranscript) {
+          this.transcriptRow = this.savedTranscript.row;
+          this.transcriptColumn = this.savedTranscript.column;
+          this.wrapPending = this.savedTranscript.wrapPending;
+        }
+      } else if (part.startsWith("\x1B[")) {
+        const match = /^\x1b\[([\d;]*)([A-GHf])$/.exec(part);
+        if (!match) continue;
+        const values = match[1].split(";").map((value) => Number(value) || 1);
+        const n = values[0];
+        this.wrapPending = false;
+        if (match[2] === "A") this.transcriptRow -= n;
+        else if (match[2] === "B") this.transcriptRow += n;
+        else if (match[2] === "C") this.transcriptColumn += n;
+        else if (match[2] === "D") this.transcriptColumn -= n;
+        else if (match[2] === "G") this.transcriptColumn = n;
+        else if (match[2] === "H" || match[2] === "f") {
+          this.transcriptRow = n;
+          this.transcriptColumn = values[1] ?? 1;
+        }
+      } else if (!part.startsWith("\x1B")) {
+        for (const cell of cells(part)) {
+          if (cell.text === "\r" || cell.text === "\r\n") {
+            this.wrapPending = false;
+            this.transcriptColumn = 1;
+            if (cell.text === "\r\n") this.transcriptRow += 1;
+          } else if (cell.text === "\n") {
+            this.wrapPending = false;
+            this.transcriptColumn = 1;
+            this.transcriptRow += 1;
+          } else if (cell.text === "\b") this.transcriptColumn -= 1;
+          else if (cell.text === "	") this.transcriptColumn += 8 - (this.transcriptColumn - 1) % 8;
+          else {
+            if (this.wrapPending || this.transcriptColumn + cell.width - 1 > this.columns) {
+              this.transcriptColumn = 1;
+              this.transcriptRow += 1;
+              this.wrapPending = false;
+            }
+            this.transcriptColumn += cell.width;
+            if (this.transcriptColumn > this.columns) {
+              this.transcriptColumn = this.columns;
+              this.wrapPending = true;
+            }
+          }
+          this.transcriptRow = Math.min(this.contentRows, this.transcriptRow);
+        }
+      }
+      this.transcriptRow = Math.max(1, Math.min(this.contentRows, this.transcriptRow));
+      this.transcriptColumn = Math.max(1, Math.min(this.columns, this.transcriptColumn));
+    }
+  }
+  composer() {
+    const available = this.columns - 4;
+    const prompt = fit(this.rl?.getPrompt() ?? this.prompt, Math.min(24, Math.max(2, Math.floor(available / 3))));
+    const input = plain(this.rl?.line ?? "");
+    const cursor = width(plain((this.rl?.line ?? "").slice(0, this.rl?.cursor ?? 0)));
+    const capacity = Math.max(1, available - width(prompt));
+    const offset = Math.max(0, cursor - capacity + 1);
+    let visible = "";
+    let used = 0;
+    let skipped = 0;
+    for (const cell of cells(input)) {
+      if (skipped + cell.width <= offset) {
+        skipped += cell.width;
+        continue;
+      }
+      if (used + cell.width > capacity) break;
+      visible += cell.text;
+      used += cell.width;
+    }
+    return { text: `${prompt}${visible}`, column: Math.min(this.columns - 1, 3 + width(prompt) + cursor - skipped) };
+  }
+  placeInputCursor() {
+    const composer = this.composer();
+    this.rawWrite(`${cup(this.inputRow, composer.column)}${CSI}?25h`);
+  }
+  clearPreviousFooter() {
+    if (!this.lastFooterTop) return;
+    let clear = "";
+    for (let row = this.lastFooterTop; row <= this.rows; row += 1) clear += `${cup(row)}${CSI}2K`;
+    this.rawWrite(clear);
+  }
+  paintFooter() {
+    if (!this.enabled || !this.installed || this.closed || this.suspended) return;
+    this.lastFooterTop = this.contentRows + 1;
+    const inner = this.columns - 2;
+    const border = "\u2500".repeat(inner);
+    const composer = this.composer();
+    const status = this.details.status ? `${plain(this.details.status)} \xB7 ` : "";
+    const modelRoom = Math.max(6, this.columns - width(`${status}${this.details.provider} \xB7  \xB7 ${this.details.mode}`));
+    const metadata = `${status}${this.details.provider} \xB7 ${fit(this.details.model, modelRoom)} \xB7 ${this.details.mode}`;
+    const usage = `${count3(this.details.tokens)} reported tokens \xB7 ${count3(this.details.steps)} steps \xB7 est ctx ${count3(this.details.contextUsed)}/${count3(this.details.contextMax)}`;
+    let frame = "";
+    const suggestions = this.suggestionRows;
+    const first = Math.max(0, Math.min(this.selected - Math.floor(suggestions / 2), this.suggestions.length - suggestions));
+    for (let i = 0; i < suggestions; i += 1) {
+      const index = first + i;
+      const selected = index === this.selected;
+      frame += `${cup(this.contentRows + 1 + i)}${CSI}2K${selected ? `${CSI}7m` : ""}${fit(`${selected ? "\u203A" : " "} ${this.suggestions[index] ?? ""}`, this.columns)}${CSI}0m`;
+    }
+    const inputText = fit(composer.text, this.columns - 4);
+    const paddedInput = inputText + " ".repeat(Math.max(0, this.columns - 4 - width(inputText)));
+    const lines = [`\u250C${border}\u2510`, `\u2502 ${paddedInput} \u2502`, `\u2514${border}\u2518`, fit(metadata, this.columns), fit(usage, this.columns)];
+    lines.forEach((line, index) => {
+      frame += `${cup(this.rows - 4 + index)}${CSI}2K${line}`;
+    });
+    this.rawWrite(`${frame}${cup(this.inputRow, composer.column)}${CSI}?25h`);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (!this.installed) return;
+    this.output.write = this.originalWrite;
+    if (this.errorOutput && this.errorOutput !== this.output && this.originalErrorWrite) this.errorOutput.write = this.originalErrorWrite;
+    this.output.off("resize", this.resize);
+    this.output.off("error", this.exit);
+    if (this.errorOutput !== this.output) this.errorOutput?.off("error", this.exit);
+    process.off("exit", this.exit);
+    process.off("SIGINT", this.exit);
+    process.off("SIGTERM", this.exit);
+    try {
+      this.rawWrite(`${RESET_REGION}${MOUSE_OFF2}${CSI}?25h`);
+      this.clearPreviousFooter();
+      this.rawWrite(`${cup(this.transcriptRow, this.transcriptColumn)}\r
+`);
+    } catch {
+    }
+  }
+};
+function createTerminalLayout(options) {
+  return new TerminalLayout(options).install();
+}
+
 // src/ui/welcome.ts
 import chalk10, { Chalk } from "chalk";
 var LOGO = [
@@ -16866,76 +18079,75 @@ var LOGO = [
 function renderWelcome(info, options = {}) {
   const columns = normalizeColumns(options.columns);
   const paint = new Chalk({ level: options.color === false ? 0 : chalk10.level });
-  const cardWidth = Math.min(88, Math.max(42, columns));
+  const cardWidth = columns;
   const innerWidth = cardWidth - 4;
   const wide = columns >= 64;
   const lines = [];
   if (wide) {
     lines.push("");
     for (let index = 0; index < LOGO.length; index += 1) {
-      const color = index < 2 ? paint.hex("#38BDF8") : index < 4 ? paint.hex("#22D3EE") : paint.hex("#A78BFA");
-      lines.push(`  ${color(LOGO[index])}`);
+      lines.push(`  ${paint.bold.white(LOGO[index])}`);
     }
   } else {
-    lines.push("", `  ${paint.bold.hex("#22D3EE")("ULTRAC")} ${paint.gray(`v${info.version}`)}`);
+    lines.push("", `  ${paint.bold.white("ULTRAC")} ${paint.gray(`v${info.version}`)}`);
   }
   const topLabel = wide ? ` ultrac v${info.version} ` : " session ";
   const topFill = Math.max(0, cardWidth - topLabel.length - 2);
-  lines.push(paint.cyan(`\u256D${topLabel}${"\u2500".repeat(topFill)}\u256E`));
+  lines.push(paint.gray(`\u256D${topLabel}${"\u2500".repeat(topFill)}\u256E`));
   lines.push(cardLine(`${info.model} via ${info.providerName}`, innerWidth, paint.bold));
   lines.push(cardLine(`${info.mode} \xB7 ${info.protocol}`, innerWidth, paint.white));
   lines.push(cardLine(shortenMiddle(info.workspace, innerWidth), innerWidth, paint.gray));
-  lines.push(paint.cyan(`\u251C${"\u2500".repeat(cardWidth - 2)}\u2524`));
+  lines.push(paint.gray(`\u251C${"\u2500".repeat(cardWidth - 2)}\u2524`));
   lines.push(cardLine(info.budget, innerWidth, paint.gray));
   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(paint.gray(`\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 ? chalk10.level : 0 });
-  const width = Math.min(88, Math.max(28, normalizeColumns(columns)));
+  const width2 = normalizeColumns(columns);
   const label = " message ";
-  const fill = Math.max(1, width - label.length - 2);
+  const fill = Math.max(1, width2 - label.length - 2);
   return {
     frame: `
-${paint.cyan(`\u256D\u2500${label}${"\u2500".repeat(fill)}`)}
-${paint.cyan("\u2502")}`,
-    prompt: paint.bold.hex("#22D3EE")("\u2570\u2500\u276F ")
+${paint.gray(`\u256D\u2500${label}${"\u2500".repeat(fill)}`)}
+${paint.gray("\u2502")}`,
+    prompt: paint.bold.white("\u2570\u2500\u276F ")
   };
 }
-function cardLine(value, width, style) {
-  const clipped = truncate3(value, width);
-  return `\u2502 ${style(clipped)}${" ".repeat(Math.max(0, width - clipped.length))} \u2502`;
+function cardLine(value, width2, style) {
+  const clipped = truncate3(value, width2);
+  return `\u2502 ${style(clipped)}${" ".repeat(Math.max(0, width2 - clipped.length))} \u2502`;
 }
 function normalizeColumns(columns) {
-  return Number.isFinite(columns) ? Math.max(28, Math.floor(columns)) : 80;
+  return Number.isFinite(columns) ? Math.max(16, Math.floor(columns)) : 80;
 }
-function truncate3(value, width) {
-  if (value.length <= width) return value;
-  if (width <= 1) return "\u2026";
-  return `${value.slice(0, width - 1)}\u2026`;
+function truncate3(value, width2) {
+  if (value.length <= width2) return value;
+  if (width2 <= 1) return "\u2026";
+  return `${value.slice(0, width2 - 1)}\u2026`;
 }
-function shortenMiddle(value, width) {
-  if (value.length <= width) return value;
-  if (width < 9) return truncate3(value, width);
-  const side = Math.floor((width - 1) / 2);
-  return `${value.slice(0, side)}\u2026${value.slice(value.length - (width - side - 1))}`;
+function shortenMiddle(value, width2) {
+  if (value.length <= width2) return value;
+  if (width2 < 9) return truncate3(value, width2);
+  const side = Math.floor((width2 - 1) / 2);
+  return `${value.slice(0, side)}\u2026${value.slice(value.length - (width2 - side - 1))}`;
 }
 
 // src/update/check.ts
 import { spawn as spawn4 } from "child_process";
 import { randomBytes as randomBytes4 } from "crypto";
-import { readFile as readFile13, rename as rename2, unlink as unlink3, writeFile as writeFile12 } from "fs/promises";
-import { join as join13 } 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 ?? join13(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) {
@@ -17019,9 +18231,9 @@ async function writeCache(path, cache) {
   try {
     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) {
@@ -17057,6 +18269,10 @@ async function runNpm(args, options) {
 // src/commands/repl.ts
 var HELP = `Commands:
   /help                 Show this help
+  /doctor               Check local setup
+  /mcp                  Show connected MCP servers
+  /continue [focus]     Continue unfinished work
+  /autonomous [on|off|status]  Continue step-limited turns (up to five rounds)
   /model [name]         Show or set the model
   /mode [name]          Show or set the agent mode (${agentModeNames.join(", ")})
   /permissions [readonly|workspace|full]  Show or set permissions
@@ -17079,11 +18295,19 @@ 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
+  /skill <name> [args]  Run an installed skill
   /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;
@@ -17175,7 +18399,7 @@ async function runRepl(options, initialTask = "") {
   const hasFallbackChain = Boolean(config.fallback?.chain?.length);
   if (providerName === "ultrac" && !hasFallbackChain && !await resolveUltracCredentials()) {
     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")}.`);
+    console.log(`Run ${chalk11.white("ultrac login")} first, or start with ${chalk11.white("--provider echo")}.`);
     process.exitCode = EXIT_REPL_NOT_STARTED;
     return;
   }
@@ -17237,10 +18461,37 @@ async function runRepl(options, initialTask = "") {
     mode,
     permissions: basePermissions
   });
+  const layout = stdin5.isTTY && stdout5.isTTY && process.env.TERM !== "dumb" ? createTerminalLayout({
+    output: stdout5,
+    errorOutput: stderr,
+    bindSignals: false,
+    details: { provider: provider.name, model: session.model, mode: session.mode, status: "Idle" }
+  }) : void 0;
+  const refreshDetails = () => {
+    if (!layout?.enabled) return;
+    const steps = session.toSession().steps;
+    const sum = (key) => {
+      const values = steps.flatMap((step) => typeof step.usage?.[key] === "number" ? [step.usage[key]] : []);
+      return values.length ? values.reduce((a, b) => a + b, 0) : void 0;
+    };
+    const context = session.contextStatus();
+    layout.updateDetails({
+      contextUsed: context.estimatedPromptTokens,
+      contextMax: context.contextTokens,
+      provider: provider.name,
+      model: session.model,
+      mode: session.mode,
+      tokens: sum("totalTokens"),
+      inputTokens: sum("inputTokens"),
+      outputTokens: sum("outputTokens"),
+      steps: steps.length
+    });
+  };
   const writeCheckpoint = createSessionCheckpointWriter(workspace, (message) => {
     console.error(chalk11.yellow(message));
   });
   const persistSession = async (target = session) => {
+    refreshDetails();
     const snapshot = target.toSession();
     if (!hasSavedSessionContent(snapshot)) return null;
     return writeCheckpoint(snapshot);
@@ -17262,6 +18513,7 @@ async function runRepl(options, initialTask = "") {
   try {
     await session.start();
   } catch (error) {
+    layout?.close();
     throw new Error(`Could not start the session: ${errorMessage2(error)}`, { cause: error });
   }
   const update = await updateCheck;
@@ -17270,21 +18522,58 @@ async function runRepl(options, initialTask = "") {
   \u2191 Update available: ${update.currentVersion} \u2192 ${update.latestVersion}`));
     console.log(chalk11.gray("    Run `ultrac update` after this session."));
   }
-  const rl = createInterface3({ input: stdin5, output: stdout5 });
+  const rl = createInterface3({ input: stdin5, output: layout?.enabled ? layout.outputProxy : stdout5 });
+  layout?.attachReadline(rl);
+  refreshDetails();
+  const builtinEntries = BUILTIN_SLASH_COMMANDS.map((command) => ({ text: `/${command}`, label: `/${command}` }));
+  const slashCompletion = layout?.enabled ? attachSlashCompletion(rl, async () => {
+    const [commands, skills] = await Promise.all([listSkillCommands(workspace), listSkills(workspace)]);
+    const declared = new Set(commands.commands.map((command) => command.skillName));
+    return [
+      ...builtinEntries,
+      ...commands.commands.map((command) => ({ text: `/${command.command}`, label: `/${command.command}`, description: command.description, skill: true })),
+      ...skills.filter((skill) => !declared.has(skill.name)).map((skill) => ({ text: `/skill ${skill.name}`, label: `/skill ${skill.name}`, description: skill.description, skill: true }))
+    ];
+  }, (rows, index) => layout.setSuggestions(rows, index), builtinEntries) : void 0;
   const reader = new LineReader(rl);
   const question = async (prompt, signal) => {
-    stdout5.write(prompt);
-    return reader.nextFresh(signal);
+    slashCompletion?.suspend();
+    try {
+      if (layout?.enabled) {
+        console.log(prompt);
+        layout.setPrompt("\u203A ");
+      } else stdout5.write(prompt);
+      return await reader.nextFresh(signal);
+    } finally {
+      layout?.setPrompt("\u203A ");
+      slashCompletion?.resume();
+    }
   };
   const drainQueuedMessages = () => reader.drainQueuedMessages();
+  let autonomousRounds = 1;
   setAskUserRuntime(async (text, options2, signal) => {
-    console.log(chalk11.cyan(`
+    console.log(chalk11.white(`
   ? ${text}`));
-    if (options2?.length) {
-      options2.forEach((option, index) => console.log(chalk11.gray(`     ${index + 1}. ${option}`)));
-      console.log(chalk11.gray("     (type a number, or answer in your own words)"));
+    let rawAnswer;
+    if (options2?.length && layout?.enabled) {
+      slashCompletion?.suspend();
+      layout.setPrompt("\u203A ");
+      let choices;
+      try {
+        choices = attachInteractiveChoices(rl, options2, { signal, output: stdout5, prompt: "\u203A ", maxRow: () => layout.contentRows });
+        rawAnswer = await reader.nextFresh(signal);
+      } finally {
+        choices?.cleanup();
+        layout.setPrompt("\u203A ");
+        slashCompletion?.resume();
+      }
+    } else {
+      if (options2?.length) {
+        options2.forEach((option, index) => console.log(chalk11.gray(`     ${index + 1}. ${option}`)));
+        console.log(chalk11.gray("     (type a number, or answer in your own words)"));
+      }
+      rawAnswer = await question(chalk11.white("  \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);
@@ -17295,42 +18584,65 @@ 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(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;
+    if (!slashCompletion?.handledEscape()) handleReplEscape(turnAbort);
+  };
+  if (stdin5.isTTY) {
+    emitKeypressEvents(stdin5, rl);
+    stdin5.on("keypress", onKeypress);
+  }
   const terminate = () => {
     running = false;
     turnAbort?.abort();
     rl.close();
   };
   process.on("SIGTERM", terminate);
+  let turnStartedAt;
+  const footerTimer = setInterval(() => {
+    const seconds = turnStartedAt === void 0 ? void 0 : Math.floor((Date.now() - turnStartedAt) / 1e3);
+    layout?.updateDetails({ status: seconds === void 0 ? "Idle" : `Running ${Math.floor(seconds / 60).toString().padStart(2, "0")}:${(seconds % 60).toString().padStart(2, "0")}` });
+  }, 1e3);
+  footerTimer.unref();
   const withInterrupt = async (run) => {
     turnAbort = new AbortController();
+    turnStartedAt = Date.now();
+    layout?.updateDetails({ status: "Running 00:00" });
     try {
       return await run(turnAbort.signal);
     } finally {
       turnAbort = void 0;
+      turnStartedAt = void 0;
+      refreshDetails();
+      layout?.updateDetails({ status: "Idle" });
     }
   };
   try {
     if (initialTask) {
-      console.log(chalk11.cyan(`
+      console.log(chalk11.white(`
 \u203A ${initialTask}`));
-      await withInterrupt((signal) => runAndCheckpointTurn(session, initialTask, question, signal, persistSession, drainQueuedMessages));
+      await withInterrupt((signal) => runAndCheckpointTurn(session, initialTask, question, signal, persistSession, drainQueuedMessages, () => reader.composing, autonomousRounds));
     }
     while (running) {
-      if (stdout5.isTTY) {
+      if (layout?.enabled) {
+        layout.setPrompt("\u203A ");
+      } else if (stdout5.isTTY) {
         const composer = renderComposer(stdout5.columns, true);
         console.log(composer.frame);
         stdout5.write(composer.prompt);
       } else {
-        stdout5.write(chalk11.cyan("\n\u203A "));
+        stdout5.write(chalk11.white("\n\u203A "));
       }
       const line = await reader.next();
       if (line === null) break;
+      if (layout?.enabled && line.trim()) console.log(`\u203A ${line.replace(/[\x00-\x1f\x7f]/g, " ")}`);
       const raw = line.trim();
       if (!raw) continue;
       if (raw.startsWith("/")) {
@@ -17346,7 +18658,7 @@ async function runRepl(options, initialTask = "") {
             resetContextBudgetNotices();
             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, autonomousRounds);
           }, signal, async (id) => {
             const lineage = await loadSessionLineage(workspace, id);
             const restored = createSession({ model: session.model, mode: session.mode, permissions: session.currentPermissions });
@@ -17355,7 +18667,11 @@ async function runRepl(options, initialTask = "") {
             session = restored;
             resetContextBudgetNotices();
             console.log(`Restored ${lineage.sessions.length} saved session(s). Permissions were kept from the current session.`);
-          });
+          }, { mcpStatus: () => mcpRuntime?.statuses ?? [], autonomous: (setting) => {
+            if (setting === "on") autonomousRounds = 5;
+            if (setting === "off") autonomousRounds = 1;
+            return autonomousRounds;
+          } });
         });
         if (handled === "exit") {
           running = false;
@@ -17364,7 +18680,9 @@ async function runRepl(options, initialTask = "") {
         setSubagentRuntime({ provider, model: session.model, mode: session.mode, registry });
         if (handled === "unhandled") {
           try {
-            await runSkillCommand(session, raw, workspace, question);
+            await withInterrupt((signal) => runSkillCommand(session, raw, workspace, question, async (prompt) => {
+              await runAndCheckpointTurn(session, prompt, question, signal, persistSession, drainQueuedMessages, () => reader.composing, autonomousRounds);
+            }));
           } finally {
             await persistSession();
           }
@@ -17375,20 +18693,29 @@ 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, autonomousRounds));
     }
   } finally {
+    clearInterval(footerTimer);
+    slashCompletion?.cleanup();
     process.off("SIGTERM", terminate);
+    if (stdin5.isTTY) stdin5.off("keypress", onKeypress);
     setAskUserRuntime(void 0);
     rl.close();
-    await saveTranscript(session, writeCheckpoint);
-    mcpRuntime?.close();
+    try {
+      await saveTranscript(session, writeCheckpoint);
+    } finally {
+      mcpRuntime?.close();
+      layout?.close();
+    }
   }
   console.log(chalk11.gray("Goodbye."));
 }
-async function runTurn(session, input, question, signal, drainQueuedMessages, persist) {
+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, {
@@ -17404,11 +18731,11 @@ async function runTurn(session, input, question, signal, drainQueuedMessages, pe
       },
       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) => {
@@ -17418,14 +18745,14 @@ ${message.trim()}`);
         }
       },
       onToolStart: (call) => {
-        console.log(chalk11.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(chalk11.dim("  Queued message added to the current turn."));
+          console.log(chalk11.dim(`  Queued for after the current tool: ${message}`));
         }
       } : {},
       onToolDenied: (call, permission) => {
@@ -17470,9 +18797,26 @@ ${message.trim()}`);
     detachProgress();
   }
 }
-async function runAndCheckpointTurn(session, input, question, signal, persist, drainQueuedMessages) {
+async function runAndCheckpointTurn(session, input, question, signal, persist, drainQueuedMessages, isComposing, maxRounds = 1) {
   try {
-    return await runTurn(session, input, question, signal, drainQueuedMessages, persist);
+    if (maxRounds === 1) return await runTurn(session, input, question, signal, drainQueuedMessages, persist, isComposing);
+    let successful = true;
+    const result = await runAutonomousLoop({
+      maxRounds,
+      signal,
+      classifyFailure: () => ({ kind: "unknown", retryable: false, failoverable: false, reason: "Interactive provider retries already exhausted." }),
+      runRound: async (round, _previous, roundSignal) => {
+        successful = await runTurn(session, round === 1 ? input : AUTONOMOUS_CONTINUE_TASK, question, roundSignal, drainQueuedMessages, persist, isComposing);
+        await persist(session);
+        const snapshot = session.toSession();
+        return successful ? snapshot : { ...snapshot, stopReason: roundSignal.aborted ? "aborted" : "error" };
+      },
+      onRoundEnd: (round, _snapshot, willResume) => {
+        if (willResume) console.log(chalk11.gray(`Continuing unfinished work: round ${round + 1}/${maxRounds}.`));
+      }
+    });
+    if (result.haltReason !== "completed" && result.haltReason !== "aborted") console.log(chalk11.gray(`Automatic continuation stopped: ${result.haltReason}. Session preserved.`));
+    return successful;
   } finally {
     await persist(session);
   }
@@ -17539,11 +18883,56 @@ function slashCommandChangesSession(raw) {
 function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
-async function handleSlashCommand(raw, session, providerName, workspace, onClear, runPrompt, signal, resume) {
+async function handleSlashCommand(raw, session, providerName, workspace, onClear, runPrompt, signal, resume, services) {
   const [name, ...rest] = raw.slice(1).split(/\s+/);
   const command = (name ?? "").toLowerCase();
   const argument = rest.join(" ").trim();
   switch (command) {
+    case "doctor":
+      await runDoctor(workspace, false, false);
+      return "ok";
+    case "mcp": {
+      const statuses = services?.mcpStatus?.() ?? [];
+      console.log(statuses.length ? renderMcpStatuses(statuses) : "No connected MCP servers. Configure with ultrac mcp add, approve with ultrac trust, then restart the session.");
+      return "ok";
+    }
+    case "autonomous": {
+      const setting = argument || "status";
+      if (setting !== "on" && setting !== "off" && setting !== "status") {
+        console.log("Usage: /autonomous on|off|status");
+        return "ok";
+      }
+      if (!services?.autonomous) {
+        console.log("Automatic continuation is available in the interactive session.");
+        return "ok";
+      }
+      const rounds = services.autonomous(setting);
+      console.log(`Automatic continuation ${rounds > 1 ? "on" : "off"}: up to ${rounds} round(s), with checkpoint, elapsed and stall limits.`);
+      return "ok";
+    }
+    case "continue": {
+      if (!runPrompt || !hasSavedSessionContent(session.toSession())) {
+        console.log("No current task to continue. Start a task or use /resume <id>.");
+        return "ok";
+      }
+      await runPrompt(`${AUTONOMOUS_CONTINUE_TASK}${argument ? ` Focus: ${argument}` : ""}`);
+      return "ok";
+    }
+    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);
@@ -17611,7 +19000,7 @@ ${extra}`);
       else {
         for (const field of ["inputTokens", "outputTokens", "totalTokens"]) {
           const counts = reported.flatMap((step) => typeof step.usage?.[field] === "number" ? [step.usage[field]] : []);
-          console.log(`${field}: ${counts.length ? counts.reduce((sum, count3) => sum + count3, 0) : "not reported"}`);
+          console.log(`${field}: ${counts.length ? counts.reduce((sum, count4) => sum + count4, 0) : "not reported"}`);
         }
         console.log(`Counts cover ${reported.length}/${steps.length} agent steps in this session. Compaction calls and ancestor sessions are excluded. Card charges are not inferred from tokens.`);
       }
@@ -17721,6 +19110,27 @@ ${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(", ")}`);
@@ -17742,6 +19152,20 @@ ${extra}`);
       }
       return "ok";
     }
+    case "skill": {
+      const [skillName, ...args] = argument.split(/\s+/);
+      if (!skillName || !runPrompt) {
+        console.log("Usage: /skill <name> [args]");
+        return "ok";
+      }
+      const skill = await readSkill(workspace, skillName);
+      if (!skill) {
+        console.log(`No available skill named ${skillName}. Use /skills to list them.`);
+        return "ok";
+      }
+      await runPrompt(buildSkillCommandPrompt(skill, { command: "skill", skillName: skill.name, description: skill.description, scope: skill.scope, path: skill.path }, args.join(" ")));
+      return "ok";
+    }
     case "skills": {
       const skills = await listSkills(workspace);
       if (!skills.length) {
@@ -17774,13 +19198,14 @@ ${extra}`);
       return "unhandled";
   }
 }
-async function runSkillCommand(session, raw, workspace, question) {
+async function runSkillCommand(session, raw, workspace, question, runPrompt) {
   const resolved = await resolveSkillCommand(workspace, raw);
   if (resolved.status === "ok") {
     console.log(
       chalk11.gray(`  /${resolved.command.command} \u2192 skill ${resolved.command.skillName} (${resolved.command.scope})`)
     );
-    await runTurn(session, resolved.prompt, question);
+    if (runPrompt) await runPrompt(resolved.prompt);
+    else await runTurn(session, resolved.prompt, question);
     return;
   }
   if (resolved.status === "conflict") {
@@ -17801,10 +19226,8 @@ async function runSkillCommand(session, raw, workspace, question) {
   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) {
@@ -17820,6 +19243,10 @@ var LineReader = class {
       }
     });
   }
+  rl;
+  queue = [];
+  waiters = [];
+  closed = false;
   next(signal) {
     return this.waitForLine(signal, true);
   }
@@ -17830,6 +19257,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
@@ -17875,11 +19306,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) {
@@ -17944,29 +19379,6 @@ function indent3(value) {
 // src/commands/run.ts
 import { basename as basename3 } from "path";
 import chalk12 from "chalk";
-
-// src/core/autonomous.ts
-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;
-function shouldResume(stopReason) {
-  return stopReason === "max-steps" || stopReason === "error";
-}
-async function runAutonomousLoop(options) {
-  if (!Number.isInteger(options.maxRounds) || options.maxRounds < 1) {
-    throw new Error("maxRounds must be a positive integer.");
-  }
-  let previous;
-  for (let round = 1; ; round += 1) {
-    const session = await options.runRound(round, previous);
-    const willResume = shouldResume(session.stopReason) && round < options.maxRounds && !options.signal?.aborted;
-    await options.onRoundEnd?.(round, session, willResume);
-    if (!willResume) return { session, rounds: round };
-    previous = session;
-  }
-}
-
-// src/commands/run.ts
 function parsePositiveInt(value, flag) {
   const parsed = Number.parseInt(value, 10);
   if (!Number.isInteger(parsed) || parsed < 1 || String(parsed) !== value.trim()) {
@@ -17975,7 +19387,6 @@ function parsePositiveInt(value, flag) {
   return parsed;
 }
 var EXIT_INCOMPLETE_RUN = 2;
-var AUTONOMOUS_ERROR_BACKOFF_MS = 15e3;
 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(
@@ -17986,7 +19397,7 @@ function registerRunCommand(program2) {
     "--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("--json", "Print the session JSON", false).action(async (taskParts, options) => {
+  ).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.");
@@ -18100,14 +19511,17 @@ function registerRunCommand(program2) {
         shell: options.allowShell || config.permissions.shell,
         network: options.allowNetwork || config.permissions.network
       };
+      const roundFailures = /* @__PURE__ */ new Map();
       let result;
       try {
         result = await runAutonomousLoop({
           maxRounds,
           signal: controller.signal,
-          runRound: async (round, previous) => {
+          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,
@@ -18121,22 +19535,30 @@ function registerRunCommand(program2) {
                 previousSessionLineage: lineage,
                 ...toolSelection ? { tools: toolSelection } : {},
                 permissions,
-                signal: controller.signal,
+                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) => {
-                  lastCheckpoint = session2;
-                  await writeCheckpoint(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 || controller.signal.aborted) throw 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: ${error.message}. Resuming from its last checkpoint.`)
+                chalk12.yellow(`Round ${round} failed (${classification.kind}). The latest checkpoint is saved.`)
               );
               return { ...lastCheckpoint, stopReason: "error" };
             }
@@ -18149,7 +19571,6 @@ function registerRunCommand(program2) {
                 `Round ${round} stopped (${session.stopReason}); resuming in round ${round + 1} of ${maxRounds}.`
               )
             );
-            if (session.stopReason === "error") await sleep(AUTONOMOUS_ERROR_BACKOFF_MS, controller.signal);
           }
         });
       } catch (error) {
@@ -18170,16 +19591,19 @@ 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(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"})`;
@@ -18433,17 +19857,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) => {
@@ -19188,8 +20620,8 @@ Leaving run ${runId} as it is.
     case "succeeded":
       finishHuman(result.text);
       if (result.toolCalls.length && !result.text) {
-        const count3 = result.toolCalls.length;
-        r.err(chalk13.gray(`Done with ${count3} tool call${count3 === 1 ? "" : "s"} and no text.
+        const count4 = result.toolCalls.length;
+        r.err(chalk13.gray(`Done with ${count4} tool call${count4 === 1 ? "" : "s"} and no text.
 `));
       }
       return result.outputSource === "incomplete" ? EXIT_FAILED : EXIT_DONE;
@@ -19384,7 +20816,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 },
@@ -19400,7 +20832,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;