steward-cli 0.11.0 → 0.13.0

package/dist/cli.js

@@ -44696,15 +44696,6 @@ function wrapVisualLineWithCursor(text, maxCols, targetCharOffset, hangingIndent
   }
   function emitCurrentLine() {
     const activeStyles = getActiveStyleCodes();
-    if (activeBg && currentWidth < maxCols) {
-      const remainingCols = maxCols - currentWidth;
-      currentTokens.push({
-        type: "char",
-        value: " ".repeat(remainingCols),
-        width: remainingCols
-      });
-      currentWidth = maxCols;
-    }
     let lineStr = currentTokens.map((t) => t.value).join("");
     if (activeStyles.length > 0 && !lineStr.endsWith("\x1B[0m")) {
       lineStr += "\x1B[0m";
@@ -52404,6 +52395,8 @@ function formatToolStatus(options) {
   let mainLine = `${bullet} ${dispName}`;
   if (truncatedArg) {
     mainLine += `${source_default.dim("(")}${source_default.dim(truncatedArg)}${source_default.dim(")")}`;
+  } else {
+    mainLine += `${source_default.dim("()")}`;
   }
   const lines = [mainLine];
   if (status === "completed" && options.toolOutput) {
@@ -52415,23 +52408,12 @@ function formatToolStatus(options) {
       const maxOutLen = Math.max(10, fullTermWidth - 6);
       const truncatedSummary = summaryText.length > maxOutLen ? `${summaryText.slice(0, maxOutLen - 1)}…` : summaryText;
       lines.push(`  ${source_default.dim("└ ")}${source_default.white(truncatedSummary)}`);
-      const diffDeleteBg = themeBgColor(theme.diffDeleteBG);
-      const diffAddBg = themeBgColor(theme.diffAddBG);
-      const rawDiffDelBg = theme.diffDeleteBG;
-      const rawDiffAddBg = theme.diffAddBG;
+      const maxContentWidth = Math.max(30, Math.min(fullTermWidth - 4, Math.floor(fullTermWidth * 0.85)));
       for (let i = 1;i < outputLines.length; i++) {
-        const line = outputLines[i] ?? "";
-        const plain = stripAnsi(line);
-        const isDelete = line.includes(rawDiffDelBg) || /\d+\s+-/.test(plain) || plain.startsWith("-");
-        const isAdd = line.includes(rawDiffAddBg) || /\d+\s+\+/.test(plain) || plain.startsWith("+");
-        if (isDelete || isAdd) {
-          const bgFn = isDelete ? diffDeleteBg : diffAddBg;
-          const visLen = 3 + stringWidth(plain);
-          const padLen = Math.max(0, fullTermWidth - visLen);
-          lines.push(bgFn(`   ${line}${" ".repeat(padLen)}`));
-        } else {
-          lines.push(`   ${line}`);
-        }
+        const rawLine = outputLines[i] ?? "";
+        const prefixed = `   ${rawLine}`;
+        const wrapped = wrapVisualLine(prefixed, maxContentWidth, "     ");
+        lines.push(...wrapped);
       }
     }
   }
@@ -52991,7 +52973,7 @@ class TerminalEngine {
 }
 
 // src/engine/agent-session.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 // src/session/helpers.ts
 function formatToolOutputSummary(res, isError = false) {
   if (isError || res === undefined || res === null) {
@@ -70973,7 +70955,6 @@ class ToolCatalog {
     for (const [name, def] of this.tools.entries()) {
       aiTools[name] = tool({
         description: def.description,
-        inputSchema: def.parameters,
         parameters: def.parameters,
         execute: async (args) => {
           return def.execute(args, context);
@@ -71099,7 +71080,8 @@ var writeFileTool = {
   summarize: (args, result) => {
     const lines = result?.linesWritten ?? 0;
     const filePath = args.file_path;
-    const summary = `Wrote ${lines} line${lines === 1 ? "" : "s"} to ${filePath}`;
+    const isNew = result?.isNew ?? true;
+    const summary = isNew ? `Created ${filePath} (${lines} line${lines === 1 ? "" : "s"})` : `Wrote ${lines} line${lines === 1 ? "" : "s"} to ${filePath}`;
     const contentLines = args.content.split(/\r?\n/);
     if (contentLines.length === 0 || contentLines.length === 1 && !contentLines[0]) {
       return summary;
@@ -71107,7 +71089,7 @@ var writeFileTool = {
     const cap = 50;
     const shown = contentLines.slice(0, cap);
     const padWidth = String(contentLines.length).length;
-    const detail = shown.map((l, i) => `${String(i + 1).padStart(padWidth)}  ${l}`).join(`
+    const detail = shown.map((l, i) => `${source_default.dim(String(i + 1).padStart(padWidth))}  ${source_default.white(l)}`).join(`
 `);
     const overflow = contentLines.length > cap ? `
    … (${contentLines.length - cap} more lines)` : "";
@@ -71233,6 +71215,237 @@ import {
   writeSync as writeSync6
 } from "node:fs";
 import { dirname as dirname6, join as join8 } from "node:path";
+
+// src/utils/diff.ts
+function tokenizeLines(content) {
+  if (!content)
+    return [];
+  const tokens = [];
+  const regex = /([^\r\n]*)(\r?\n)?/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    if (match.index === content.length)
+      break;
+    const text = match[1] ?? "";
+    const ending = match[2] ?? "";
+    tokens.push({ text, ending });
+    if (!ending && match.index + text.length === content.length)
+      break;
+  }
+  return tokens;
+}
+function tokenizeWords(text) {
+  if (!text)
+    return [];
+  const matches = text.match(/[\w]+|[^\w\s]+|\s+/g);
+  return matches ?? [text];
+}
+function myersDiff(oldArr, newArr, equals = (a, b) => a === b) {
+  const n = oldArr.length;
+  const m = newArr.length;
+  if (n === 0 && m === 0)
+    return [];
+  if (n === 0)
+    return newArr.map((newItem, i) => ({ kind: "insert", newItem, newIndex: i }));
+  if (m === 0)
+    return oldArr.map((oldItem, i) => ({ kind: "delete", oldItem, oldIndex: i }));
+  const max = n + m;
+  const v = { 1: 0 };
+  const trace = [];
+  for (let d = 0;d <= max; d++) {
+    trace.push({ ...v });
+    for (let k = -d;k <= d; k += 2) {
+      let x = k === -d || k !== d && (v[k - 1] ?? -1) < (v[k + 1] ?? -1) ? v[k + 1] ?? 0 : (v[k - 1] ?? 0) + 1;
+      let y = x - k;
+      while (x < n && y < m && equals(oldArr[x], newArr[y])) {
+        x++;
+        y++;
+      }
+      v[k] = x;
+      if (x >= n && y >= m) {
+        const ops = [];
+        let cx = n;
+        let cy = m;
+        for (let cd = d;cd > 0; cd--) {
+          const prevV = trace[cd];
+          const pk = cx - cy;
+          const prevK = pk === -cd || pk !== cd && (prevV[pk - 1] ?? -1) < (prevV[pk + 1] ?? -1) ? pk + 1 : pk - 1;
+          const prevX = prevV[prevK] ?? 0;
+          const prevY = prevX - prevK;
+          while (cx > prevX + (prevK === pk + 1 ? 0 : 1) && cy > prevY + (prevK === pk + 1 ? 1 : 0)) {
+            cx--;
+            cy--;
+            ops.push({
+              kind: "equal",
+              oldItem: oldArr[cx],
+              newItem: newArr[cy],
+              oldIndex: cx,
+              newIndex: cy
+            });
+          }
+          if (prevK === pk + 1) {
+            cy--;
+            ops.push({ kind: "insert", newItem: newArr[cy], newIndex: cy });
+          } else {
+            cx--;
+            ops.push({ kind: "delete", oldItem: oldArr[cx], oldIndex: cx });
+          }
+        }
+        while (cx > 0 && cy > 0) {
+          cx--;
+          cy--;
+          ops.push({
+            kind: "equal",
+            oldItem: oldArr[cx],
+            newItem: newArr[cy],
+            oldIndex: cx,
+            newIndex: cy
+          });
+        }
+        ops.reverse();
+        return ops;
+      }
+    }
+  }
+  return [];
+}
+function computeWordDiff(oldLine, newLine) {
+  const oldWords = tokenizeWords(oldLine);
+  const newWords = tokenizeWords(newLine);
+  const ops = myersDiff(oldWords, newWords);
+  const oldSpans = [];
+  const newSpans = [];
+  for (const op of ops) {
+    if (op.kind === "equal") {
+      const text = op.oldItem ?? "";
+      oldSpans.push({ text, kind: "equal" });
+      newSpans.push({ text, kind: "equal" });
+    } else if (op.kind === "delete") {
+      oldSpans.push({ text: op.oldItem ?? "", kind: "deletion" });
+    } else if (op.kind === "insert") {
+      newSpans.push({ text: op.newItem ?? "", kind: "addition" });
+    }
+  }
+  return { oldSpans, newSpans };
+}
+function buildUnifiedDiff(before, after, contextLines = 3) {
+  const oldTokens = tokenizeLines(before);
+  const newTokens = tokenizeLines(after);
+  if (before === after) {
+    return { hunks: [], oldLineCount: oldTokens.length, newLineCount: newTokens.length };
+  }
+  const ops = myersDiff(oldTokens, newTokens, (a, b) => a.text === b.text && a.ending === b.ending);
+  const editIndices = ops.map((op, i) => op.kind !== "equal" ? i : -1).filter((i) => i !== -1);
+  if (editIndices.length === 0) {
+    return { hunks: [], oldLineCount: oldTokens.length, newLineCount: newTokens.length };
+  }
+  const hunkRanges = [];
+  let currentRange = {
+    startIdx: Math.max(0, editIndices[0] - contextLines),
+    endIdx: Math.min(ops.length - 1, editIndices[0] + contextLines)
+  };
+  for (let i = 1;i < editIndices.length; i++) {
+    const editIdx = editIndices[i];
+    const opStart = Math.max(0, editIdx - contextLines);
+    const opEnd = Math.min(ops.length - 1, editIdx + contextLines);
+    if (opStart <= currentRange.endIdx) {
+      currentRange.endIdx = Math.max(currentRange.endIdx, opEnd);
+    } else {
+      hunkRanges.push(currentRange);
+      currentRange = { startIdx: opStart, endIdx: opEnd };
+    }
+  }
+  hunkRanges.push(currentRange);
+  const hunks = [];
+  for (const range of hunkRanges) {
+    const lines = [];
+    let oldCount = 0;
+    let newCount = 0;
+    let oldStart = null;
+    let newStart = null;
+    for (let i = range.startIdx;i <= range.endIdx; i++) {
+      const op = ops[i];
+      if (op.kind === "equal") {
+        const oIdx = op.oldIndex + 1;
+        const nIdx = op.newIndex + 1;
+        if (oldStart === null)
+          oldStart = oIdx;
+        if (newStart === null)
+          newStart = nIdx;
+        lines.push({
+          kind: "context",
+          text: op.oldItem.text,
+          ending: op.oldItem.ending,
+          oldLineNumber: oIdx,
+          newLineNumber: nIdx
+        });
+        oldCount++;
+        newCount++;
+      } else if (op.kind === "delete") {
+        const oIdx = op.oldIndex + 1;
+        if (oldStart === null)
+          oldStart = oIdx;
+        lines.push({
+          kind: "deletion",
+          text: op.oldItem.text,
+          ending: op.oldItem.ending,
+          oldLineNumber: oIdx
+        });
+        oldCount++;
+      } else if (op.kind === "insert") {
+        const nIdx = op.newIndex + 1;
+        if (newStart === null)
+          newStart = nIdx;
+        lines.push({
+          kind: "addition",
+          text: op.newItem.text,
+          ending: op.newItem.ending,
+          newLineNumber: nIdx
+        });
+        newCount++;
+      }
+    }
+    let l = 0;
+    while (l < lines.length) {
+      if (lines[l]?.kind === "deletion") {
+        const delStart = l;
+        while (l < lines.length && lines[l]?.kind === "deletion")
+          l++;
+        const delEnd = l;
+        const addStart = l;
+        while (l < lines.length && lines[l]?.kind === "addition")
+          l++;
+        const addEnd = l;
+        const delCount = delEnd - delStart;
+        const addCount = addEnd - addStart;
+        const pairCount = Math.min(delCount, addCount);
+        for (let p = 0;p < pairCount; p++) {
+          const delLine = lines[delStart + p];
+          const addLine = lines[addStart + p];
+          const { oldSpans, newSpans } = computeWordDiff(delLine.text, addLine.text);
+          delLine.spans = oldSpans;
+          addLine.spans = newSpans;
+        }
+      } else {
+        l++;
+      }
+    }
+    hunks.push({
+      oldStart: oldStart ?? (oldTokens.length === 0 ? 0 : 1),
+      oldCount,
+      newStart: newStart ?? (newTokens.length === 0 ? 0 : 1),
+      newCount,
+      lines
+    });
+  }
+  return {
+    hunks,
+    oldLineCount: oldTokens.length,
+    newLineCount: newTokens.length
+  };
+}
+
+// src/tools/edit-file/index.ts
 var editFileInputSchema = object({
   file_path: string2().describe("The path of the file to edit (relative to current working directory or absolute inside trusted workspace)."),
   old_string: string2().describe("The exact string to find and replace in the file."),
@@ -71260,27 +71473,54 @@ var editFileTool = {
     const added = result?.addedLines ?? 0;
     const removed = result?.removedLines ?? 0;
     const summary = `Added ${added} line${added === 1 ? "" : "s"}, removed ${removed} line${removed === 1 ? "" : "s"}`;
-    const oldLines = args.old_string.split(/\r?\n/);
-    const newLines = args.new_string.split(/\r?\n/);
     if (added === 0 && removed === 0)
       return summary;
-    const cap = 30;
-    const padWidth = String(Math.max(oldLines.length, newLines.length)).length;
+    const diff = buildUnifiedDiff(args.old_string, args.new_string, 2);
     const theme = getTheme();
     const deleteStyle = (str) => themeBgColor(theme.diffDeleteBG)(themeColor2(theme.diffDeleteFG)(str));
     const addStyle = (str) => themeBgColor(theme.diffAddBG)(themeColor2(theme.diffAddFG)(str));
-    const removedDetail = oldLines.slice(0, cap).map((l, i) => deleteStyle(`${String(i + 1).padStart(padWidth)} -${l}`)).join(`
-`);
-    const addedDetail = newLines.slice(0, cap).map((l, i) => addStyle(`${String(i + 1).padStart(padWidth)} +${l}`)).join(`
-`);
-    const overflowOld = oldLines.length > cap ? `
-   … (${oldLines.length - cap} more removed)` : "";
-    const overflowNew = newLines.length > cap ? `
-   … (${newLines.length - cap} more added)` : "";
-    const diffBlock = [removedDetail + overflowOld, addedDetail + overflowNew].filter(Boolean).join(`
-`);
-    return `${summary}
-${diffBlock}`;
+    const contextStyle = (str) => source_default.dim(str);
+    let maxLineNum = 1;
+    for (const hunk of diff.hunks) {
+      for (const line of hunk.lines) {
+        if (line.oldLineNumber)
+          maxLineNum = Math.max(maxLineNum, line.oldLineNumber);
+        if (line.newLineNumber)
+          maxLineNum = Math.max(maxLineNum, line.newLineNumber);
+      }
+    }
+    const padWidth = Math.max(1, String(maxLineNum).length);
+    const diffLines = [];
+    const cap = 30;
+    let count = 0;
+    let overflow = 0;
+    for (const hunk of diff.hunks) {
+      for (const line of hunk.lines) {
+        if (count >= cap) {
+          overflow++;
+          continue;
+        }
+        count++;
+        if (line.kind === "deletion") {
+          const numStr = String(line.oldLineNumber ?? "").padStart(padWidth, " ");
+          const body = line.spans ? "-" + line.spans.map((s) => s.kind === "deletion" ? source_default.bold(s.text) : s.text).join("") : `-${line.text}`;
+          diffLines.push(deleteStyle(`${numStr} ${body}`));
+        } else if (line.kind === "addition") {
+          const numStr = String(line.newLineNumber ?? "").padStart(padWidth, " ");
+          const body = line.spans ? "+" + line.spans.map((s) => s.kind === "addition" ? source_default.bold(s.text) : s.text).join("") : `+${line.text}`;
+          diffLines.push(addStyle(`${numStr} ${body}`));
+        } else {
+          const numStr = String(line.newLineNumber ?? line.oldLineNumber ?? "").padStart(padWidth, " ");
+          diffLines.push(contextStyle(`${numStr}  ${line.text}`));
+        }
+      }
+    }
+    if (overflow > 0) {
+      diffLines.push(source_default.dim(`   … (${overflow} more lines)`));
+    }
+    return diffLines.length > 0 ? `${summary}
+${diffLines.join(`
+`)}` : summary;
   },
   execute: async (args, context) => {
     const { absolutePath: targetPath, relativePath } = resolveDirectMutationPath(context.cwd, args.file_path);
@@ -72295,15 +72535,23 @@ async function evaluateBashPermission(req, context) {
 
 // src/tools/bash/index.ts
 var bashInputSchema = object({
-  command: string2().min(1).describe("The command to execute in the system shell."),
-  explanation: string2().min(1).max(240).describe("Brief sentence explaining why this command is needed (displayed in permission prompt).")
+  command: string2({
+    required_error: "command is required"
+  }).min(1, "command cannot be empty").describe("The command to execute in the system shell."),
+  explanation: string2({
+    required_error: "An explanation is mandatory for running a bash command.",
+    invalid_type_error: "explanation must be a string."
+  }).min(1, "An explanation is mandatory for running a bash command.").max(240).describe("Mandatory brief sentence explaining why this command is needed and what it does (displayed in permission prompt).")
 });
 var bashTool = {
   name: "bash",
   displayName: "Bash",
-  description: "Executes a command in the platform shell. Commands that exceed the foreground limit (~12s) automatically continue as background shell tasks. Use task_read, task_send_input, and task_kill to manage background tasks. Note: Bash commands are NOT tracked by the file checkpoint system (/rewind).",
+  description: "Executes a command in the platform shell. An explanation of what the command does and why it is needed is MANDATORY. Commands that exceed the foreground limit (~12s) automatically continue as background shell tasks. Use task_read, task_send_input, and task_kill to manage background tasks. Note: Bash commands are NOT tracked by the file checkpoint system (/rewind).",
   parameters: bashInputSchema,
   confirmationPolicy: "never",
+  summarizeArgs: (args) => {
+    return args.command ?? "";
+  },
   summarize: (_args, result) => {
     if (result && "status" in result && result.status === "backgrounded") {
       return `Moved to background · task id: ${result.taskId}`;
@@ -72312,10 +72560,13 @@ var bashTool = {
     return `Ran successfully · exit code: ${code}`;
   },
   execute: async (args, context) => {
-    const command = args.command.trim();
-    const explanation = args.explanation.trim();
+    const command = typeof args?.command === "string" ? args.command.trim() : "";
+    if (!command) {
+      throw new Error("Command is required and cannot be empty.");
+    }
+    const explanation = typeof args?.explanation === "string" ? args.explanation.trim() : "";
     if (!explanation) {
-      throw new Error("An explanation is required for running a bash command.");
+      throw new Error("An explanation is mandatory for running a bash command.");
     }
     const perm = await evaluateBashPermission({ command, explanation }, context);
     if (!perm.allowed) {
@@ -72440,7 +72691,7 @@ var taskKillTool = {
 // package.json
 var package_default = {
   name: "steward-cli",
-  version: "0.11.0",
+  version: "0.13.0",
   description: "Interactive AI engineering assistant for the terminal with human-in-the-loop control across local and frontier models.",
   author: "sapirrior",
   license: "MIT",
@@ -72657,6 +72908,727 @@ var webSearchTool = {
     };
   }
 };
+// src/services/todos/store.ts
+import {
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync12,
+  renameSync as renameSync7,
+  unlinkSync as unlinkSync7,
+  writeFileSync as writeFileSync3,
+  openSync as openSync8,
+  fsyncSync as fsyncSync7,
+  closeSync as closeSync8
+} from "node:fs";
+import { join as join13 } from "node:path";
+import { randomUUID as randomUUID7 } from "node:crypto";
+
+// src/config/env.ts
+var ALL_PROVIDER_NAMES = [
+  "gemini",
+  "anthropic",
+  "openai",
+  "xai",
+  "mistral",
+  "deepseek",
+  "openrouter",
+  "custom"
+];
+function getEnvConfig() {
+  const geminiApiKey = process.env["GEMINI_API_KEY"]?.trim() || process.env["GOOGLE_GENERATIVE_AI_API_KEY"]?.trim() || undefined;
+  const anthropicApiKey = process.env["ANTHROPIC_API_KEY"]?.trim() || undefined;
+  const openaiApiKey = process.env["OPENAI_API_KEY"]?.trim() || undefined;
+  const xaiApiKey = process.env["XAI_API_KEY"]?.trim() || undefined;
+  const mistralApiKey = process.env["MISTRAL_API_KEY"]?.trim() || undefined;
+  const deepseekApiKey = process.env["DEEPSEEK_API_KEY"]?.trim() || undefined;
+  const openrouterApiKey = process.env["OPENROUTER_API_KEY"]?.trim() || undefined;
+  const customApiKey = process.env["CUSTOM_API_KEY"]?.trim() || undefined;
+  const customApiModelName = process.env["CUSTOM_API_MODEL_NAME"]?.trim() || undefined;
+  const customApiUrl = process.env["CUSTOM_API_URL"]?.trim() || undefined;
+  return {
+    geminiApiKey,
+    anthropicApiKey,
+    openaiApiKey,
+    xaiApiKey,
+    mistralApiKey,
+    deepseekApiKey,
+    openrouterApiKey,
+    custom: {
+      apiKey: customApiKey,
+      modelName: customApiModelName,
+      baseURL: customApiUrl
+    }
+  };
+}
+function hasProviderConfig(provider, config = getEnvConfig()) {
+  switch (provider) {
+    case "gemini":
+      return Boolean(config.geminiApiKey);
+    case "anthropic":
+      return Boolean(config.anthropicApiKey);
+    case "openai":
+      return Boolean(config.openaiApiKey);
+    case "xai":
+      return Boolean(config.xaiApiKey);
+    case "mistral":
+      return Boolean(config.mistralApiKey);
+    case "deepseek":
+      return Boolean(config.deepseekApiKey);
+    case "openrouter":
+      return Boolean(config.openrouterApiKey);
+    case "custom":
+      return Boolean(config.custom.baseURL && config.custom.modelName);
+  }
+}
+function getAvailableProviders(config = getEnvConfig()) {
+  const providers = [];
+  if (hasProviderConfig("gemini", config))
+    providers.push("gemini");
+  if (hasProviderConfig("anthropic", config))
+    providers.push("anthropic");
+  if (hasProviderConfig("openai", config))
+    providers.push("openai");
+  if (hasProviderConfig("xai", config))
+    providers.push("xai");
+  if (hasProviderConfig("mistral", config))
+    providers.push("mistral");
+  if (hasProviderConfig("deepseek", config))
+    providers.push("deepseek");
+  if (hasProviderConfig("openrouter", config))
+    providers.push("openrouter");
+  if (hasProviderConfig("custom", config))
+    providers.push("custom");
+  return providers;
+}
+// src/services/todos/store.ts
+var VALID_STATUSES = [
+  "pending",
+  "in_progress",
+  "completed",
+  "cancelled",
+  "blocked"
+];
+var MIN_ITEMS = 2;
+var MAX_ITEMS = 10;
+
+class SessionLockQueue {
+  queues = new Map;
+  async runExclusive(sessionId, task) {
+    const prev = this.queues.get(sessionId) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    this.queues.set(sessionId, prev.then(() => current, () => current));
+    try {
+      await prev;
+      return await task();
+    } finally {
+      release();
+      if (this.queues.get(sessionId) === current) {
+        this.queues.delete(sessionId);
+      }
+    }
+  }
+}
+var sessionLocks = new SessionLockQueue;
+function sanitizeSessionId(sessionId) {
+  if (!sessionId || typeof sessionId !== "string") {
+    throw new Error("Invalid sessionId: must be a non-empty string");
+  }
+  const clean = sessionId.trim();
+  if (!clean || clean.includes("..") || clean.includes("/") || clean.includes("\\")) {
+    throw new Error(`Invalid sessionId for path resolution: "${sessionId}"`);
+  }
+  return clean;
+}
+function getSessionTodosDir(sessionId) {
+  const safeId = sanitizeSessionId(sessionId);
+  return join13(getSettingsDir(), "todos", safeId);
+}
+function getSessionTodosFilePath(sessionId) {
+  return join13(getSessionTodosDir(sessionId), "todos.json");
+}
+function validateTodoList(todos) {
+  if (!Array.isArray(todos)) {
+    throw new Error("Invalid todos format: expected an array of todo items");
+  }
+  if (todos.length < MIN_ITEMS || todos.length > MAX_ITEMS) {
+    throw new Error(`Todo list must contain between ${MIN_ITEMS} and ${MAX_ITEMS} items (received ${todos.length})`);
+  }
+  const seenIds = new Set;
+  let inProgressCount = 0;
+  const validated = [];
+  for (let i = 0;i < todos.length; i++) {
+    const item = todos[i];
+    if (!item || typeof item !== "object") {
+      throw new Error(`Invalid todo at index ${i}: item must be an object`);
+    }
+    const { id, description, status } = item;
+    if (typeof id !== "string" || !id.trim()) {
+      throw new Error(`Invalid todo at index ${i}: id must be a non-empty string`);
+    }
+    const trimmedId = id.trim();
+    if (seenIds.has(trimmedId)) {
+      throw new Error(`Duplicate todo id "${trimmedId}" at index ${i}`);
+    }
+    seenIds.add(trimmedId);
+    if (typeof description !== "string" || !description.trim()) {
+      throw new Error(`Invalid todo at index ${i} (${trimmedId}): description must be a non-empty string`);
+    }
+    if (typeof status !== "string" || !VALID_STATUSES.includes(status)) {
+      throw new Error(`Invalid todo at index ${i} (${trimmedId}): status must be one of ${VALID_STATUSES.join(", ")} (got "${status}")`);
+    }
+    if (status === "in_progress") {
+      inProgressCount++;
+    }
+    validated.push({
+      id: trimmedId,
+      description: description.trim(),
+      status
+    });
+  }
+  if (inProgressCount > 1) {
+    throw new Error(`At most 1 todo item can be 'in_progress' at any time (found ${inProgressCount} in_progress items)`);
+  }
+  return validated;
+}
+async function readTodoList(sessionId) {
+  const filePath = getSessionTodosFilePath(sessionId);
+  if (!existsSync12(filePath)) {
+    return null;
+  }
+  const raw = readFileSync12(filePath, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Corrupted todo state for session "${sessionId}": failed to parse JSON (${err instanceof Error ? err.message : String(err)})`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Corrupted todo state for session "${sessionId}": root must be an object`);
+  }
+  const record = parsed;
+  if (record.schemaVersion !== 1) {
+    throw new Error(`Unsupported todo schemaVersion "${record.schemaVersion}" (expected 1) for session "${sessionId}"`);
+  }
+  if (typeof record.sessionId !== "string") {
+    throw new Error(`Invalid todo state for session "${sessionId}": missing or invalid sessionId`);
+  }
+  const validatedTodos = validateTodoList(record.todos);
+  return {
+    schemaVersion: 1,
+    sessionId: record.sessionId,
+    updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : new Date().toISOString(),
+    todos: validatedTodos
+  };
+}
+async function writeTodoList(sessionId, todos) {
+  return sessionLocks.runExclusive(sessionId, async () => {
+    const validated = validateTodoList(todos);
+    const safeSessionId = sanitizeSessionId(sessionId);
+    const dir = getSessionTodosDir(safeSessionId);
+    if (!existsSync12(dir)) {
+      mkdirSync9(dir, { recursive: true, mode: 448 });
+    }
+    const payload = {
+      schemaVersion: 1,
+      sessionId: safeSessionId,
+      updatedAt: new Date().toISOString(),
+      todos: validated
+    };
+    const targetPath = getSessionTodosFilePath(safeSessionId);
+    const tempPath = join13(dir, `.todos.${randomUUID7()}.tmp`);
+    const jsonStr = JSON.stringify(payload, null, 2) + `
+`;
+    try {
+      writeFileSync3(tempPath, jsonStr, { encoding: "utf-8", mode: 384 });
+      const fd = openSync8(tempPath, "r");
+      try {
+        fsyncSync7(fd);
+      } finally {
+        closeSync8(fd);
+      }
+      renameSync7(tempPath, targetPath);
+    } catch (err) {
+      try {
+        if (existsSync12(tempPath)) {
+          unlinkSync7(tempPath);
+        }
+      } catch {}
+      throw err;
+    }
+    return payload;
+  });
+}
+async function updateTodoItem(sessionId, todoId, updates) {
+  return sessionLocks.runExclusive(sessionId, async () => {
+    if (!todoId || typeof todoId !== "string" || !todoId.trim()) {
+      throw new Error("todoId must be a non-empty string");
+    }
+    const targetId = todoId.trim();
+    const current = await readTodoList(sessionId);
+    if (!current) {
+      throw new Error(`No todo list found for session "${sessionId}". Create one first with TodoWrite.`);
+    }
+    const itemIndex = current.todos.findIndex((t) => t.id === targetId);
+    if (itemIndex === -1) {
+      throw new Error(`Todo item with id "${targetId}" not found in current session todo list`);
+    }
+    if (updates.status === undefined && updates.description === undefined) {
+      throw new Error("At least one of status or description must be provided for update");
+    }
+    const currentItem = current.todos[itemIndex];
+    const newStatus = updates.status !== undefined ? updates.status : currentItem.status;
+    const newDescription = updates.description !== undefined ? updates.description.trim() : currentItem.description;
+    if (!newDescription) {
+      throw new Error("Updated description cannot be empty");
+    }
+    const updatedTodos = current.todos.map((item, idx) => {
+      if (idx !== itemIndex) {
+        return item;
+      }
+      return {
+        ...item,
+        status: newStatus,
+        description: newDescription
+      };
+    });
+    const validated = validateTodoList(updatedTodos);
+    const safeSessionId = sanitizeSessionId(sessionId);
+    const dir = getSessionTodosDir(safeSessionId);
+    if (!existsSync12(dir)) {
+      mkdirSync9(dir, { recursive: true, mode: 448 });
+    }
+    const payload = {
+      schemaVersion: 1,
+      sessionId: safeSessionId,
+      updatedAt: new Date().toISOString(),
+      todos: validated
+    };
+    const targetPath = getSessionTodosFilePath(safeSessionId);
+    const tempPath = join13(dir, `.todos.${randomUUID7()}.tmp`);
+    const jsonStr = JSON.stringify(payload, null, 2) + `
+`;
+    try {
+      writeFileSync3(tempPath, jsonStr, { encoding: "utf-8", mode: 384 });
+      const fd = openSync8(tempPath, "r");
+      try {
+        fsyncSync7(fd);
+      } finally {
+        closeSync8(fd);
+      }
+      renameSync7(tempPath, targetPath);
+    } catch (err) {
+      try {
+        if (existsSync12(tempPath)) {
+          unlinkSync7(tempPath);
+        }
+      } catch {}
+      throw err;
+    }
+    return payload;
+  });
+}
+// src/tools/todo-write/index.ts
+var todoItemSchema = object({
+  id: string2().min(1, "id is required").describe("Unique identifier for the todo item"),
+  description: string2().min(1, "description is required").describe("Clear description of the task"),
+  status: _enum(["pending", "in_progress", "completed", "cancelled", "blocked"]).describe("Current status of the todo item")
+});
+var todoWriteParamsSchema = object({
+  todos: array(todoItemSchema).min(2, "Todo list must contain at least 2 items").max(10, "Todo list must contain at most 10 items").describe("Complete list of 2 to 10 todo items establishing the execution plan")
+});
+function formatTodoCheckbox(status) {
+  switch (status) {
+    case "completed":
+      return "[x]";
+    case "in_progress":
+      return `[${figures.sliderPointer}]`;
+    case "cancelled":
+      return `[${figures.cross}]`;
+    case "blocked":
+      return `[${figures.warning}]`;
+    case "pending":
+    default:
+      return "[ ]";
+  }
+}
+function formatTodoListSummary(todos, maxItems = 10) {
+  const visible = todos.slice(0, maxItems);
+  const hiddenCount = todos.length - visible.length;
+  const lines = visible.map((t, i) => `${i + 1}. ${formatTodoCheckbox(t.status)} ${t.description}`);
+  if (hiddenCount > 0) {
+    lines.push(`… and ${hiddenCount} more`);
+  }
+  return lines.join(`
+`);
+}
+var todoWriteTool = {
+  name: "TodoWrite",
+  displayName: "TodoWrite",
+  icon: "\uD83D\uDCDD",
+  description: "Initializes or replaces the current session todo list with 2 to 10 items. Use this to establish or replace the multi-step execution plan for the session.",
+  parameters: todoWriteParamsSchema,
+  summarizeArgs(args) {
+    if (!args.todos || args.todos.length === 0)
+      return "";
+    if (args.todos.length <= 2) {
+      return args.todos.map((t) => `"${t.description}"`).join(", ");
+    }
+    return `"${args.todos[0]?.description}", "${args.todos[1]?.description}", +${args.todos.length - 2} more`;
+  },
+  async execute(args, context) {
+    if (!context.sessionId) {
+      throw new Error("TodoWrite requires an active session ID in ToolContext");
+    }
+    return writeTodoList(context.sessionId, args.todos);
+  },
+  summarize(args, result) {
+    const list = result?.todos ?? args.todos;
+    const total = list.length;
+    const header = `Added ${total} todos`;
+    const details = formatTodoListSummary(list);
+    return `${header}
+${details}`;
+  }
+};
+
+// src/tools/todo-update/index.ts
+var todoUpdateParamsSchema = object({
+  id: string2().min(1, "id is required").describe("ID of the existing todo item to update"),
+  status: _enum(["pending", "in_progress", "completed", "cancelled", "blocked"]).optional().describe("New status for the todo item"),
+  description: string2().min(1).optional().describe("Updated description for the todo item")
+});
+function formatTodoCheckbox2(status) {
+  switch (status) {
+    case "completed":
+      return "[x]";
+    case "in_progress":
+      return `[${figures.sliderPointer}]`;
+    case "cancelled":
+      return `[${figures.cross}]`;
+    case "blocked":
+      return `[${figures.warning}]`;
+    case "pending":
+    default:
+      return "[ ]";
+  }
+}
+function formatTodoListSummary2(todos, maxItems = 10) {
+  const visible = todos.slice(0, maxItems);
+  const hiddenCount = todos.length - visible.length;
+  const lines = visible.map((t, i) => `${i + 1}. ${formatTodoCheckbox2(t.status)} ${t.description}`);
+  if (hiddenCount > 0) {
+    lines.push(`… and ${hiddenCount} more`);
+  }
+  return lines.join(`
+`);
+}
+var todoUpdateTool = {
+  name: "TodoUpdate",
+  displayName: "TodoUpdate",
+  icon: "✓",
+  description: "Updates a single todo item status or description in the current session. Cannot create new items or update multiple items at once.",
+  parameters: todoUpdateParamsSchema,
+  summarizeArgs(args) {
+    const parts = [`id: "${args.id}"`];
+    if (args.status)
+      parts.push(`status: "${args.status}"`);
+    if (args.description)
+      parts.push(`desc: "${args.description}"`);
+    return parts.join(", ");
+  },
+  async execute(args, context) {
+    if (!context.sessionId) {
+      throw new Error("TodoUpdate requires an active session ID in ToolContext");
+    }
+    return updateTodoItem(context.sessionId, args.id, {
+      status: args.status,
+      description: args.description
+    });
+  },
+  summarize(args, result) {
+    if (!result || !result.todos) {
+      return `Todo ${args.id} updated`;
+    }
+    const total = result.todos.length;
+    const completed = result.todos.filter((t) => t.status === "completed").length;
+    const updatedItem = result.todos.find((t) => t.id === args.id);
+    const statusText = updatedItem?.status ?? args.status ?? "updated";
+    const header = `Todo ${args.id} ${statusText} · ${completed}/${total} done`;
+    const details = formatTodoListSummary2(result.todos);
+    return `${header}
+${details}`;
+  }
+};
+
+// src/tools/todo-read/index.ts
+var todoReadParamsSchema = object({});
+function formatTodoCheckbox3(status) {
+  switch (status) {
+    case "completed":
+      return "[x]";
+    case "in_progress":
+      return `[${figures.sliderPointer}]`;
+    case "cancelled":
+      return `[${figures.cross}]`;
+    case "blocked":
+      return `[${figures.warning}]`;
+    case "pending":
+    default:
+      return "[ ]";
+  }
+}
+function formatTodoListSummary3(todos, maxItems = 10) {
+  const visible = todos.slice(0, maxItems);
+  const hiddenCount = todos.length - visible.length;
+  const lines = visible.map((t, i) => `${i + 1}. ${formatTodoCheckbox3(t.status)} ${t.description}`);
+  if (hiddenCount > 0) {
+    lines.push(`… and ${hiddenCount} more`);
+  }
+  return lines.join(`
+`);
+}
+var todoReadTool = {
+  name: "TodoRead",
+  displayName: "TodoRead",
+  icon: "\uD83D\uDCCB",
+  description: "Reads the current session todo list without modifying it. Returns an empty result if no todos have been established yet.",
+  parameters: todoReadParamsSchema,
+  summarizeArgs() {
+    return "";
+  },
+  async execute(_args, context) {
+    if (!context.sessionId) {
+      throw new Error("TodoRead requires an active session ID in ToolContext");
+    }
+    const list = await readTodoList(context.sessionId);
+    if (!list) {
+      return {
+        hasTodos: false,
+        todos: [],
+        message: "No todos currently established for this session."
+      };
+    }
+    return {
+      hasTodos: true,
+      todos: list.todos,
+      updatedAt: list.updatedAt
+    };
+  },
+  summarize(_args, result) {
+    if (!result || !result.hasTodos || result.todos.length === 0) {
+      return "No active todos";
+    }
+    const total = result.todos.length;
+    const completed = result.todos.filter((t) => t.status === "completed").length;
+    const active = result.todos.find((t) => t.status === "in_progress");
+    const header = active ? `Todos ${completed}/${total} done · ▶ ${active.description}` : `Todos ${completed}/${total} done`;
+    const details = formatTodoListSummary3(result.todos);
+    return `${header}
+${details}`;
+  }
+};
+// src/skills/discovery.ts
+import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync13, statSync as statSync6 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { isAbsolute as isAbsolute6, join as join14, normalize, resolve as resolve9, sep as sep3 } from "node:path";
+var MAX_SKILL_FILE_SIZE = 64 * 1024;
+function parseSkillFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match || !match[1]) {
+    return null;
+  }
+  const rawYaml = match[1];
+  const lines = rawYaml.split(/\r?\n/);
+  const result = {};
+  let currentKey = null;
+  let descriptionLines = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const keyMatch = line.match(/^([a-zA-Z0-9_-]+):\s*(.*)$/);
+    if (keyMatch && keyMatch[1]) {
+      const key = keyMatch[1].toLowerCase();
+      const val = (keyMatch[2] ?? "").trim();
+      if (key === "name") {
+        currentKey = "name";
+        result.name = unquote(val);
+      } else if (key === "description") {
+        currentKey = "description";
+        if (val === ">" || val === ">-" || val === "|" || val === "|-") {
+          descriptionLines = [];
+        } else if (val) {
+          descriptionLines = [unquote(val)];
+        } else {
+          descriptionLines = [];
+        }
+      } else {
+        currentKey = null;
+      }
+    } else if (currentKey === "description" && (line.startsWith("  ") || line.startsWith("\t"))) {
+      descriptionLines.push(trimmed);
+    }
+  }
+  if (descriptionLines.length > 0) {
+    result.description = descriptionLines.join(" ").trim();
+  }
+  return result;
+}
+function unquote(str) {
+  const trimmed = str.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function discoverSkills(cwd = process.cwd()) {
+  const targets = [
+    { dir: join14(cwd, ".agents", "skills"), source: "workspace" },
+    { dir: join14(homedir5(), ".agents", "skills"), source: "user-agents" },
+    { dir: join14(homedir5(), ".steward", "skills"), source: "user-steward" }
+  ];
+  const skillMap = new Map;
+  for (const target of targets) {
+    if (!existsSync13(target.dir)) {
+      continue;
+    }
+    try {
+      const entries = readdirSync5(target.dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory())
+          continue;
+        const skillDir = join14(target.dir, entry.name);
+        const skillMdPath = join14(skillDir, "SKILL.md");
+        const fallbackMdPath = join14(skillDir, "skill.md");
+        const resolvedFile = existsSync13(skillMdPath) ? skillMdPath : existsSync13(fallbackMdPath) ? fallbackMdPath : null;
+        if (!resolvedFile)
+          continue;
+        try {
+          const raw = readFileSync13(resolvedFile, "utf-8");
+          const frontmatter = parseSkillFrontmatter(raw);
+          const skillName = frontmatter?.name || entry.name;
+          const description = frontmatter?.description || "No description provided.";
+          if (!skillMap.has(skillName)) {
+            skillMap.set(skillName, {
+              name: skillName,
+              description,
+              filePath: resolvedFile,
+              dirPath: skillDir,
+              source: target.source
+            });
+          }
+        } catch {}
+      }
+    } catch {}
+  }
+  return Array.from(skillMap.values());
+}
+function getSkill(name, cwd = process.cwd()) {
+  const cleanName = name.trim();
+  const all = discoverSkills(cwd);
+  return all.find((s) => s.name.toLowerCase() === cleanName.toLowerCase()) ?? null;
+}
+function readSkillResource(name, relativePath, cwd = process.cwd(), maxBytes = MAX_SKILL_FILE_SIZE) {
+  const skill = getSkill(name, cwd);
+  if (!skill) {
+    throw new Error(`Skill "${name}" not found`);
+  }
+  let targetFilePath;
+  if (!relativePath || !relativePath.trim()) {
+    targetFilePath = skill.filePath;
+  } else {
+    const trimmedPath = relativePath.trim();
+    if (isAbsolute6(trimmedPath)) {
+      throw new Error(`Invalid skill resource path: absolute paths are not permitted (${trimmedPath})`);
+    }
+    const normalizedRelative = normalize(trimmedPath);
+    if (normalizedRelative.startsWith("..") || normalizedRelative.includes(`${sep3}..`)) {
+      throw new Error(`Invalid skill resource path: directory traversal ("..") is forbidden (${trimmedPath})`);
+    }
+    targetFilePath = resolve9(skill.dirPath, normalizedRelative);
+    const resolvedDir = resolve9(skill.dirPath);
+    if (!targetFilePath.startsWith(resolvedDir + sep3) && targetFilePath !== resolvedDir) {
+      throw new Error(`Resource "${trimmedPath}" resolves outside skill directory`);
+    }
+  }
+  if (!existsSync13(targetFilePath)) {
+    throw new Error(`Skill resource file "${targetFilePath}" does not exist`);
+  }
+  const stat = statSync6(targetFilePath);
+  if (!stat.isFile()) {
+    throw new Error(`Skill resource path "${targetFilePath}" is not a regular file`);
+  }
+  if (stat.size > maxBytes) {
+    throw new Error(`Skill resource file exceeds size limit of ${maxBytes} bytes (file is ${stat.size} bytes)`);
+  }
+  const content = readFileSync13(targetFilePath, "utf-8");
+  return {
+    name: skill.name,
+    description: skill.description,
+    source: skill.source,
+    resourcePath: targetFilePath,
+    content
+  };
+}
+// src/tools/skill-list/index.ts
+var skillListParamsSchema = object({});
+var skillListTool = {
+  name: "SkillList",
+  displayName: "SkillList",
+  icon: "\uD83D\uDCA1",
+  description: "Discovers and lists all available specialized skills and their descriptions. Use this when you need specialized domain knowledge or workflows.",
+  parameters: skillListParamsSchema,
+  summarizeArgs() {
+    return "";
+  },
+  async execute(_args, context) {
+    const cwd = context?.cwd ?? process.cwd();
+    const skills = discoverSkills(cwd);
+    return skills.map((s) => ({
+      name: s.name,
+      description: s.description,
+      source: s.source
+    })).sort((a, b) => a.name.localeCompare(b.name));
+  },
+  summarize(_args, result) {
+    const count = result?.length ?? 0;
+    if (count === 0) {
+      return "Discovered 0 skills";
+    }
+    return `Discovered ${count} skill${count === 1 ? "" : "s"}`;
+  }
+};
+
+// src/tools/skill-read/index.ts
+var skillReadParamsSchema = object({
+  name: string2().min(1, "Skill name is required"),
+  path: string2().optional()
+});
+var skillReadTool = {
+  name: "SkillRead",
+  displayName: "SkillRead",
+  icon: "\uD83D\uDCD6",
+  description: "Loads and reads the instructions (SKILL.md) or a relative resource file of a specialized skill by name. Use this when a task requires specialized guidelines.",
+  parameters: skillReadParamsSchema,
+  summarizeArgs(args) {
+    if (args.path) {
+      return `name="${args.name}" path="${args.path}"`;
+    }
+    return `name="${args.name}"`;
+  },
+  async execute(args, context) {
+    const cwd = context?.cwd ?? process.cwd();
+    return readSkillResource(args.name, args.path, cwd);
+  },
+  summarize(args, result) {
+    const target = args.path ? `${args.name}/${args.path}` : args.name;
+    const len = result?.content ? ` (${result.content.length} bytes)` : "";
+    return `SkillRead: ${target}${len}`;
+  }
+};
 
 // src/tools/index.ts
 var builtInTools = [
@@ -72672,7 +73644,12 @@ var builtInTools = [
   taskSendInputTool,
   taskKillTool,
   webFetchTool,
-  webSearchTool
+  webSearchTool,
+  todoWriteTool,
+  todoUpdateTool,
+  todoReadTool,
+  skillListTool,
+  skillReadTool
 ];
 for (const tool of builtInTools) {
   defaultToolCatalog.register(tool);
@@ -72879,84 +73856,6 @@ class ShellTaskManager {
     }
   }
 }
-
-// src/config/env.ts
-var ALL_PROVIDER_NAMES = [
-  "gemini",
-  "anthropic",
-  "openai",
-  "xai",
-  "mistral",
-  "deepseek",
-  "openrouter",
-  "custom"
-];
-function getEnvConfig() {
-  const geminiApiKey = process.env["GEMINI_API_KEY"]?.trim() || process.env["GOOGLE_GENERATIVE_AI_API_KEY"]?.trim() || undefined;
-  const anthropicApiKey = process.env["ANTHROPIC_API_KEY"]?.trim() || undefined;
-  const openaiApiKey = process.env["OPENAI_API_KEY"]?.trim() || undefined;
-  const xaiApiKey = process.env["XAI_API_KEY"]?.trim() || undefined;
-  const mistralApiKey = process.env["MISTRAL_API_KEY"]?.trim() || undefined;
-  const deepseekApiKey = process.env["DEEPSEEK_API_KEY"]?.trim() || undefined;
-  const openrouterApiKey = process.env["OPENROUTER_API_KEY"]?.trim() || undefined;
-  const customApiKey = process.env["CUSTOM_API_KEY"]?.trim() || undefined;
-  const customApiModelName = process.env["CUSTOM_API_MODEL_NAME"]?.trim() || undefined;
-  const customApiUrl = process.env["CUSTOM_API_URL"]?.trim() || undefined;
-  return {
-    geminiApiKey,
-    anthropicApiKey,
-    openaiApiKey,
-    xaiApiKey,
-    mistralApiKey,
-    deepseekApiKey,
-    openrouterApiKey,
-    custom: {
-      apiKey: customApiKey,
-      modelName: customApiModelName,
-      baseURL: customApiUrl
-    }
-  };
-}
-function hasProviderConfig(provider, config = getEnvConfig()) {
-  switch (provider) {
-    case "gemini":
-      return Boolean(config.geminiApiKey);
-    case "anthropic":
-      return Boolean(config.anthropicApiKey);
-    case "openai":
-      return Boolean(config.openaiApiKey);
-    case "xai":
-      return Boolean(config.xaiApiKey);
-    case "mistral":
-      return Boolean(config.mistralApiKey);
-    case "deepseek":
-      return Boolean(config.deepseekApiKey);
-    case "openrouter":
-      return Boolean(config.openrouterApiKey);
-    case "custom":
-      return Boolean(config.custom.baseURL && config.custom.modelName);
-  }
-}
-function getAvailableProviders(config = getEnvConfig()) {
-  const providers = [];
-  if (hasProviderConfig("gemini", config))
-    providers.push("gemini");
-  if (hasProviderConfig("anthropic", config))
-    providers.push("anthropic");
-  if (hasProviderConfig("openai", config))
-    providers.push("openai");
-  if (hasProviderConfig("xai", config))
-    providers.push("xai");
-  if (hasProviderConfig("mistral", config))
-    providers.push("mistral");
-  if (hasProviderConfig("deepseek", config))
-    providers.push("deepseek");
-  if (hasProviderConfig("openrouter", config))
-    providers.push("openrouter");
-  if (hasProviderConfig("custom", config))
-    providers.push("custom");
-  return providers;
-}
 // src/errors/classifier.ts
 function classifyError(error) {
   if (!error) {
@@ -73101,15 +74000,15 @@ function classifyError(error) {
   };
 }
 // src/errors/logger.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync12, mkdirSync as mkdirSync9, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { join as join13 } from "node:path";
+import { appendFileSync as appendFileSync3, existsSync as existsSync14, mkdirSync as mkdirSync10, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join15 } from "node:path";
 var SENSITIVE_KEY_REGEX = /api[_-]?key|token|secret|password|auth|credential|bearer/i;
 function getLogsRootDir() {
   if (process.env.STEWARD_LOGS_DIR) {
     return process.env.STEWARD_LOGS_DIR;
   }
-  return join13(homedir5(), ".steward", "logs");
+  return join15(homedir6(), ".steward", "logs");
 }
 function getLogDateTime(d = new Date) {
   const year = d.getFullYear();
@@ -73193,11 +74092,11 @@ function logError(error, contextInfo) {
   try {
     const rootDir = getLogsRootDir();
     const { date, time } = getLogDateTime();
-    const dateDir = join13(rootDir, date);
-    if (!existsSync12(dateDir)) {
-      mkdirSync9(dateDir, { recursive: true });
+    const dateDir = join15(rootDir, date);
+    if (!existsSync14(dateDir)) {
+      mkdirSync10(dateDir, { recursive: true });
     }
-    const logPath = join13(dateDir, `${time}.log`);
+    const logPath = join15(dateDir, `${time}.log`);
     const structured = classifyError(error);
     const mem = process.memoryUsage ? process.memoryUsage() : undefined;
     const logEntry = {
@@ -73223,10 +74122,10 @@ function logError(error, contextInfo) {
 ` + JSON.stringify(logEntry, null, 2) + `
 
 `;
-    if (existsSync12(logPath)) {
+    if (existsSync14(logPath)) {
       appendFileSync3(logPath, formatted, "utf-8");
     } else {
-      writeFileSync3(logPath, formatted, "utf-8");
+      writeFileSync4(logPath, formatted, "utf-8");
     }
     return logPath;
   } catch {
@@ -110884,7 +111783,7 @@ function createProviderExecutedToolFactory2({
     supportsDeferredResults
   });
 }
-async function resolve9(value) {
+async function resolve10(value) {
   if (typeof value === "function") {
     value = value();
   }
@@ -116110,7 +117009,7 @@ var XaiSpeechModel = class _XaiSpeechModel {
     const { requestBody, warnings, withTimestamps } = await this.getArgs(options);
     const { value, responseHeaders, rawValue } = await postJsonToApi4({
       url: `${this.config.baseURL}/tts`,
-      headers: combineHeaders4(this.config.headers ? await resolve9(this.config.headers) : undefined, options.headers),
+      headers: combineHeaders4(this.config.headers ? await resolve10(this.config.headers) : undefined, options.headers),
       body: requestBody,
       failedResponseHandler: xaiFailedResponseHandler,
       successfulResponseHandler: withTimestamps ? createJsonResponseHandler4(xaiSpeechTimestampsResponseSchema) : createBinaryResponseHandler2(),
@@ -116917,288 +117816,59 @@ function inferProviderFromModelId(modelId) {
   }
   return null;
 }
-// src/skills/discovery.ts
-import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync12 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { join as join14 } from "node:path";
-function parseSkillFrontmatter(content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match || !match[1]) {
-    return null;
-  }
-  const rawYaml = match[1];
-  const lines = rawYaml.split(/\r?\n/);
-  const result = {};
-  let currentKey = null;
-  let descriptionLines = [];
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#"))
-      continue;
-    const keyMatch = line.match(/^([a-zA-Z0-9_-]+):\s*(.*)$/);
-    if (keyMatch && keyMatch[1]) {
-      const key = keyMatch[1].toLowerCase();
-      const val = (keyMatch[2] ?? "").trim();
-      if (key === "name") {
-        currentKey = "name";
-        result.name = unquote(val);
-      } else if (key === "description") {
-        currentKey = "description";
-        if (val === ">" || val === ">-" || val === "|" || val === "|-") {
-          descriptionLines = [];
-        } else if (val) {
-          descriptionLines = [unquote(val)];
-        } else {
-          descriptionLines = [];
-        }
-      } else {
-        currentKey = null;
-      }
-    } else if (currentKey === "description" && (line.startsWith("  ") || line.startsWith("\t"))) {
-      descriptionLines.push(trimmed);
-    }
-  }
-  if (descriptionLines.length > 0) {
-    result.description = descriptionLines.join(" ").trim();
-  }
-  return result;
-}
-function unquote(str) {
-  const trimmed = str.trim();
-  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-    return trimmed.slice(1, -1);
-  }
-  return trimmed;
-}
-function discoverSkills(cwd = process.cwd()) {
-  const targets = [
-    { dir: join14(cwd, ".agents", "skills"), source: "workspace" },
-    { dir: join14(homedir6(), ".agents", "skills"), source: "user-agents" },
-    { dir: join14(homedir6(), ".steward", "skills"), source: "user-steward" }
-  ];
-  const skillMap = new Map;
-  for (const target of targets) {
-    if (!existsSync13(target.dir)) {
-      continue;
-    }
-    try {
-      const entries = readdirSync5(target.dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory())
-          continue;
-        const skillDir = join14(target.dir, entry.name);
-        const skillMdPath = join14(skillDir, "SKILL.md");
-        const fallbackMdPath = join14(skillDir, "skill.md");
-        const resolvedFile = existsSync13(skillMdPath) ? skillMdPath : existsSync13(fallbackMdPath) ? fallbackMdPath : null;
-        if (!resolvedFile)
-          continue;
-        try {
-          const raw = readFileSync12(resolvedFile, "utf-8");
-          const frontmatter = parseSkillFrontmatter(raw);
-          const skillName = frontmatter?.name || entry.name;
-          const description = frontmatter?.description || "No description provided.";
-          if (!skillMap.has(skillName)) {
-            skillMap.set(skillName, {
-              name: skillName,
-              description,
-              filePath: resolvedFile,
-              dirPath: skillDir,
-              source: target.source
-            });
-          }
-        } catch {}
-      }
-    } catch {}
-  }
-  return Array.from(skillMap.values());
-}
-function formatSkillsForSystemPrompt(skills) {
-  if (skills.length === 0)
-    return "";
-  const list = skills.map((s) => `- ${s.name} (${s.filePath}): ${s.description}`).join(`
-`);
-  return `<skills>
-You can use specialized 'skills' to help you with complex tasks.
-
-Skills are folders of instructions, scripts, and resources that extend your capabilities for specialized tasks. Each skill folder contains a SKILL.md file with YAML frontmatter and detailed markdown instructions.
 
-Available skills:
-${list}
-
-If a skill seems relevant to your current task, you MUST read its SKILL.md instructions using read_file before proceeding.
-</skills>`;
-}
 // src/engine/system-prompt.ts
 function buildSystemPrompt(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const platform = process.platform;
-  const skills = options.skills ?? discoverSkills(cwd);
   const dateUTC = new Date().toUTCString();
-  let isAGitREPO = "no";
-  try {
-    isAGitREPO = Bun.spawnSync(["git", "status"], { cwd, stdio: ["ignore", "ignore", "ignore"] }).exitCode === 0 ? "yes" : "no";
-  } catch {
-    isAGitREPO = "no";
-  }
-  let prompt = `
-    You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
-
-    IMPORTANT: Assist with defensive security tasks only. Refuse to create, modify, or improve code that may be used maliciously. Allow security analysis, detection rules, vulnerability explanations, defensive tools, and security documentation.
-    NOTE: - To give feedback, users should report the issue at https://github.com/sapirrior/steward/issues
-
-    NOTE: When the user directly asks about Steward (eg 'can Steward do...', 'does Steward have...') or asks in second person (eg 'are you able...', 'can you do...', 'will you be abel to do...'), response the USER to head over to the Open-Source repo of Steward (https://github.com/sapirrior/steward/) for information related to steward and its architecture
-
-    # Tone and style
-    You should be concise, direct, and to the point.
-    You MUST answer concisely with fewer than 4 lines (not including the tool use or code generation), unless the USER asks for detail.
-    Do not add additional code explanation summary unless requested by the USER. After working on a file, just stop, rather than providing an explanation of what you did.
-    IMPORTANT: You should minimize the output tokens as much as possible while maintaining appropriate helpfulness, quality, and accuracy. Only address the specific query or task at hand, avoiding tangential information unless absolutely critical for completing the request. If you can answer in 1-4 sentences or a short paragraph, please do.
-    IMPORTANT: You should NOT answer with unnecessary preamble or postamble (such as explaining your code or summarizing your action), unless the user asks you explicitly.
-    IMPORTANT: Keep your responses short, since they will be displayed on a command line interface.
-    Answer the user's question directly, without elaboration, explanation, or details. One word answers are best. Avoid introductions, conclusions, and explanations. You MUST avoid text before/after your response, such as "The answer is <answer>.", "Here is the content of the file..." or "Based on the information provided, the answer is..." or "Here is what I will do next...". Here are some examples to demonstrate appropriate verbosity:
-
-    <example>
-    user: what is 2 + 2
-    assistant: 4
-    </example>
-
-    <example>
-    user: 4 + 4
-    assistant: 8
-    </example>
-
-    <example>
-    user: what command should I run to read the content of a specific file?
-    assistant: cat
-    </example>
-
-    <example>
-    user: what command should I run to watch files in the current directory?
-    [assistant runs the ls command through tool call to list the files in the current directory, then read docs/commands in the relevant file to find out how to watch files]
-    assistant: npm run dev
-    </example>
-
-    <example>
-    user: can you find all the TODO comments in src/
-    [assistant runs search text tool call and sees TODO comment occurance in src/foo.c at line 11 src/boo.c at 180]
-    assistant: src/foo:11 and src/boo.c:180
-    </example>
+  let prompt = `You are Steward, an interactive software-engineering agent operating in a terminal workspace. Assist the user with building, refactoring, debugging, inspecting, and verifying software.
 
-    When you run a non-trivial bash command, you should explain what the command does and why you are running it, to make sure the USER understands what you are doing (this is especially very important when you are running a command that will make changes to the USER's system including file mutation).
-    Output text to communicate with the USER; all text you output outside of tool use is displayed to the USER. Only use tools to complete tasks. Never use tools like Bash or code comments as means to communicate with the USER during the session.
-    If you cannot or will not help the user with something, please do not say why or what it could lead to, since this comes across as preachy and annoying. Please offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences.
-    IMPORTANT: Only use emojis if the USER explicitly requests it. Avoid using emojis in all communication unless asked.
-    IMPORTANT: Keep your responses short, since they will be displayed on a command line interface.
+IMPORTANT: Assist with defensive security tasks only. Refuse to create, modify, or improve code intended for malicious use.
 
-    # Proactiveness
-    You are allowed to be proactive, but only when the USER asks you to do something. You should strive to strike a balance between:
-    - Doing the right thing when asked, including taking actions and follow-up actions
-    - Not surprising the USER with actions you take without asking
-    For example, if the USER asks you how to approach something, you should do your best to answer their question first, and not immediately jump into taking actions.
+# Operating Principles
+- Inspect before editing: investigate existing files, directories, and patterns before making changes.
+- Minimal and idiomatic: prefer the smallest correct change that aligns with existing repository architecture and conventions.
+- Never assume external dependencies or libraries exist; check project configuration files (e.g. package.json, Cargo.toml, pyproject.toml) first.
+- Security and secrets: never expose, commit, or log API keys, credentials, or secrets.
+- Verify your changes: run relevant project verification or tests after making non-trivial modifications.
+- Never commit git changes unless the user explicitly requests you to commit.
+- Provide direct, concise responses suitable for a terminal interface. Explain non-obvious failures or decisions clearly without unnecessary filler or commentary.
+- When referencing code locations, use the format: \`file_path:line_number\`.
+- Avoid adding redundant comments unless explaining non-obvious invariants or explicitly requested.
 
-    # Following conventions
-    When making changes to files, first understand the file's code conventions. Mimic code style, use existing libraries and utilities, and follow existing patterns.
-    - NEVER assume that a given library is available, even if it is well known or. Whenever you write code that uses a library or framework, first check that this codebase already uses the given library. For example, you might look at neighboring files, or check the package.json (or cargo.toml or pyproject.toml, and so on depending on the language).
-    - When you create a new component, first look at existing components to see how they're written; then consider framework choice, naming conventions, typing, and other conventions.
-    - When you edit a piece of code, first look at the code's surrounding context (especially its imports) to understand the code's choice of frameworks and libraries. Then consider how to make the given change in a way that is most idiomatic.
-    - Always follow security best practices. Never introduce code that exposes or logs secrets and keys. Never commit secrets or keys to the repository.
-    - Always read the AI Context File / Memory File / Contributing Guidelines / readme for better understanding of the codebase, code writing styles or conventions. For example (not limited to): AGENTS.md, IMPORTANT.md, CONTRIBUTING.md, readme.txt / README.md.
+# Tool Usage Policy
+- Investigation: use read_file, grep, list_dir, and glob to explore code before modifying it.
+- Mutations: use write_file and edit_file to apply changes. Respect user permission prompts.
+- Commands: when using bash, you MUST always provide a concise, non-empty 'explanation' parameter describing what the command does and why it is needed.
+- Background tasks: use task_read to check status/output, task_send_input to send standard input (with a trailing newline), and task_kill to terminate.
+- Web: use web_fetch and web_search when external documentation or live data is needed. If web_fetch indicates a redirect, follow up with the target URL.
 
-    # Code style
-   - IMPORTANT: DO NOT ADD **ANY** COMMENTS unless explicitly asked.
+# Task and Plan Management (Todos)
+- For multi-step, complex, or verification-heavy tasks, maintain operational state using session todos:
+  - TodoWrite: initialize or replace the session todo list (must contain 2 to 10 items).
+  - TodoUpdate: update exactly one todo item status or description as progress occurs.
+  - TodoRead: inspect current session todos when recovering or verifying progress.
+- Keep at most one item in 'in_progress' status at any time.
+- Mark todos completed immediately after completing each step; do not batch progress updates.
+- For simple, one-step queries or edits, do not create a todo list.
 
-   # Tool usage policy
-   - Use the edit file and write file tools for both normal code/file changes as well as making plans and todos.
-   - When WebFetch returns a message about a redirect to a different host, immediately make a new WebFetch request with the redirect URL provided in the response.
-   - When web search returns but does not contain enough data, use the URLs from the results and WebFetch them for more detailed information.
-   - When a command moves to the background as a shell task, use task_read to inspect its status/output, task_send_input to send standard input (always include a trailing '
-' to submit a line / press Enter), and task_kill to terminate it.
-
-   # Task Management (Planning)
-   You have access to the write file and edit file tools to help you manage and plan tasks alongside normal file/code creation. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
-   These tools are also EXTREMELY helpful for planning tasks and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks — and that is unacceptable.
-   IMPORTANT: Write plans/tasks in the codebase/repository's .steward/plans/ directory and write them in standard Markdown format. For example, a terminal TUI library plan: [project dir]/.steward/plans/tui_library_plan.md, an HTTP API server plan: [project dir]/.steward/plans/api_server_implementation_plan.md.
-   IMPORTANT: If the user asks to create the plan in a different directory than the standard [project dir]/.steward/plans/, proceed normally but warn the USER that it is not recommended to make plans outside the .steward/plans/ directory.
-   IMPORTANT: Always use proper names for the plan/task files (wrong: plan.md, plan_12.md, implementation.md; right: code_refactor_plan.md, codebase_migration_plan.md).
-   IMPORTANT: It is **VERY VERY IMPORTANT** to always put a todo list between the main title header and the content of the plan. It is critical that you mark todos as completed as soon as you are done with a task. **NEVER** batch up multiple tasks before marking them as completed.
-
-   <example>
-   user: Run the build and fix any type errors.
-   assistant: I'm going to use the TodoWrite tool to write the following items to the todo list:
-   - Run the build
-   - Fix any type errors
-   [assistant uses write_file to write the task todo/plan in [project dir]/.steward/plans/fixing_type_errors_plan.md]
-   assistant: I'm now going to run the build using Bash.
-   [assistant runs the build command and gets 10 type errors]
-   assistant: Looks like I found 10 type errors. I'm going to use the edit file tool to write 10 items to the todo list.
-   [assistant runs edit tool and puts 10 child todos under the 'figure out type error files' todo in [project dir]/.steward/plans/fixing_type_errors_plan.md]
-   assistant: Marking the first todo as in_progress.
-   [assistant uses the edit file to mark 'run build command to find type errors' todo]
-   Let me start working on the first item...
-   [assistant reads the first file, uses edit tool and fixes it]
-   The first item has been fixed, let me mark the first todo as completed, and move on to the second item...
-   [same as first one, assistant fixes all files]
-   </example>
-   In the above example, the assistant completes all the tasks, including the 10 error fixes and running the build to double-check the fixes.
-
-   <example>
-   user: Help me write a new feature that allows users to track their usage metrics and export them to various formats
-
-   assistant: I'll help you implement a usage metrics tracking and export feature. Let me first use the write file tool to plan this task.
-   Adding the following todos to the todo list:
-   1. Research existing metrics tracking in the codebase
-   2. Design the metrics collection system
-   3. Implement core metrics tracking functionality
-   4. Create export functionality for different formats
-   [assistant uses the write file to write the plan and its todos in [project dir]/.steward/plans/]
-   Let me start by researching the existing codebase to understand what metrics we might already be tracking and how we can build on that.
-   [assistant lists all files and reads all the relevant files step by step]
-   I'm going to search for any existing metrics or telemetry code in the project.
-   [assistant runs search text to find any existing telemetry code in the codebase]
-   I've found some existing telemetry code. Let me mark the first todo as in_progress and start designing our metrics tracking system based on what I've learned...
-   [assistant continues implementing the feature step by step, marking todos as completed as they go]
-   </example>
-
-   IMPORTANT: Completed todo: marked with ◉ beside the todo text and * beside the current working todo.
-
-   # Doing tasks
-   The user will primarily request you perform software engineering tasks. This includes solving bugs, adding new functionality, refactoring code, explaining code, and more. For these tasks the following steps are recommended:
-   - Use the write file tool to plan the task if required.
-   - Use the available search tools to understand the codebase and the user's query. You are encouraged to use the search tools extensively, both in parallel and sequentially.
-   - Implement the solution using all tools available to you.
-   - Verify the solution if possible with tests. NEVER assume a specific test framework or test script. Check the README or search the codebase to determine the testing approach.
-   - VERY IMPORTANT: When you have completed a task, you MUST run the lint and typecheck commands (e.g. npm run lint, npm run typecheck, ruff, etc.) with Bash if they were provided to you to ensure your code is correct. If you are unable to find the correct command, ask the user for the command to run and if they supply it, proactively suggest writing it to AGENTS.md so that you will know to run it next time.
-   NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTANT to only commit when explicitly asked, otherwise the user will feel that you are being too proactive.
-
-   Here is useful information about the environment you are running in:
-   <env>
-   Working directory: ${cwd}
-   Is directory a git repo: ${isAGitREPO}
-   Platform: ${platform}
-   Today's date: ${dateUTC}
-   </env>
-
-   # Code References
-   When referencing specific functions or pieces of code, include the pattern \`file_path:line_number\` to allow the user to easily navigate to the source code location.
-   
-   <example>
-   user: Where are errors from the client handled?
-   assistant: Clients are marked as failed in the \`connectToServer\` function in src/services/process.ts:712.
-   </example>`;
-  const skillsPrompt = formatSkillsForSystemPrompt(skills);
-  if (skillsPrompt) {
-    prompt += `
+# Specialized Skills Policy
+- Skills are discoverable on-demand packages of specialized instructions located in workspace or user configuration.
+- Use SkillList to discover available skills and their descriptions.
+- Use SkillRead to load a skill's instructions (SKILL.md) or relative resources only when a task requires specialized domain guidance.
+- Skill instructions are supplemental and must not override core safety rules, tool boundaries, or user permission constraints.
 
-${skillsPrompt}`;
-  }
+<env>
+Working directory: ${cwd}
+Platform: ${platform}
+Today's date: ${dateUTC}
+</env>`;
   if (options.userRules && options.userRules.length > 0) {
     prompt += `
 
 <user_defined_rules>
-The following rules are set by the user and MUST be followed without exception.
-They take precedence over all other style and behaviour guidelines above,
-except for the operating_principles and security sections.
-
+The following rules are configured by the user and must be followed:
 ${options.userRules.map((rule) => `- ${rule}`).join(`
 `)}
 </user_defined_rules>`;
@@ -117336,7 +118006,7 @@ class AgentSession {
     this.messages.push(userMessage);
     this.isGenerating = true;
     this.activeAbortController = new AbortController;
-    const turnId = randomUUID7();
+    const turnId = randomUUID8();
     const turnStartedAt = new Date().toISOString();
     const turnStartMonotonic = performance.now();
     const turnModel = this.getModel();
@@ -117362,6 +118032,7 @@ class AgentSession {
     await tracker.beginTurn(turnId, this.sessionData.turns.length + 1);
     const toolContext = {
       cwd,
+      sessionId: this.sessionData.id,
       abortSignal: this.activeAbortController.signal,
       checkpointTracker: tracker,
       mutationLocks: globalMutationLockManager,
@@ -117378,6 +118049,7 @@ class AgentSession {
       activeTools = defaultToolCatalog.toAISDKTools(toolContext);
     }
     const instructions = buildSystemPrompt({
+      cwd,
       extraInstructions: options.extraInstructions
     });
     const wrappedOnEvent = (event) => {
@@ -118829,6 +119501,7 @@ class StatusBar extends Component {
   clip = true;
   warningTimer = null;
   voiceTimer = null;
+  updateTimer = null;
   constructor(props) {
     super(props);
     this.state = {
@@ -118838,7 +119511,8 @@ class StatusBar extends Component {
       exitPending: props.exitPending,
       warning: props.warning,
       voiceState: props.voiceState ?? "idle",
-      voiceDurationSec: props.voiceDurationSec ?? 0
+      voiceDurationSec: props.voiceDurationSec ?? 0,
+      updateStatus: props.updateStatus
     };
   }
   update(partial) {
@@ -118861,6 +119535,21 @@ class StatusBar extends Component {
       });
     }
   }
+  setUpdateStatus(updateStatus, durationMs) {
+    if (this.updateTimer) {
+      clearTimeout(this.updateTimer);
+      this.updateTimer = null;
+    }
+    this.setState({ updateStatus });
+    if (updateStatus && durationMs && durationMs > 0) {
+      this.updateTimer = setTimeout(() => {
+        this.updateTimer = null;
+        if (this.state.updateStatus === updateStatus) {
+          this.setState({ updateStatus: undefined });
+        }
+      }, durationMs);
+    }
+  }
   showWarning(warningText, durationMs = 4000) {
     if (this.warningTimer) {
       clearTimeout(this.warningTimer);
@@ -118883,12 +119572,25 @@ class StatusBar extends Component {
       clearInterval(this.voiceTimer);
       this.voiceTimer = null;
     }
+    if (this.updateTimer) {
+      clearTimeout(this.updateTimer);
+      this.updateTimer = null;
+    }
   }
   render(width) {
     const theme = getTheme();
     const termWidth = width ?? process.stdout.columns ?? 80;
     const maxCols = Math.max(1, termWidth);
-    const { model, usage, isBusy, exitPending, warning, voiceState, voiceDurationSec } = this.state;
+    const {
+      model,
+      usage,
+      isBusy,
+      exitPending,
+      warning,
+      voiceState,
+      voiceDurationSec,
+      updateStatus
+    } = this.state;
     let left = "";
     if (warning) {
       left = themeColor2(theme.warning)(warning);
@@ -118904,6 +119606,20 @@ class StatusBar extends Component {
     } else if (exitPending) {
       const errColor = themeColor2(theme.error);
       left = `${errColor("▸ ")}${source_default.dim("Press ")}${errColor("Ctrl+C")}${source_default.dim(" again to exit")}`;
+    } else if (updateStatus && updateStatus.state !== "idle") {
+      if (updateStatus.state === "checking") {
+        left = source_default.white(updateStatus.message ?? "Checking for updates...");
+      } else if (updateStatus.state === "available") {
+        left = source_default.white(updateStatus.message ?? `Update v${updateStatus.version ?? ""} is available`);
+      } else if (updateStatus.state === "no-updates") {
+        left = source_default.white(updateStatus.message ?? "Steward is up to date");
+      } else if (updateStatus.state === "error" && updateStatus.message) {
+        left = themeColor2(theme.error)(updateStatus.message);
+      } else if (isBusy) {
+        left = source_default.dim("esc to interrupt");
+      } else {
+        left = source_default.dim("? for shortcuts");
+      }
     } else if (isBusy) {
       left = source_default.dim("esc to interrupt");
     } else {
@@ -119037,6 +119753,8 @@ class StreamingView extends Component {
         const maxArgLen = Math.max(10, maxCols - toolName.length - 8);
         const truncatedArg = targetArg.length > maxArgLen ? truncateMiddle(targetArg, maxArgLen) : targetArg;
         line += `${source_default.dim("(")}${source_default.dim(truncatedArg)}${source_default.dim(")")}`;
+      } else {
+        line += `${source_default.dim("()")}`;
       }
       lines.push(line);
       if (activeTool.recentLines && activeTool.recentLines.length > 0) {
@@ -120545,235 +121263,6 @@ class BashPermissionDock extends Component {
   }
 }
 
-// src/utils/diff.ts
-function tokenizeLines(content) {
-  if (!content)
-    return [];
-  const tokens = [];
-  const regex = /([^\r\n]*)(\r?\n)?/g;
-  let match;
-  while ((match = regex.exec(content)) !== null) {
-    if (match.index === content.length)
-      break;
-    const text = match[1] ?? "";
-    const ending = match[2] ?? "";
-    tokens.push({ text, ending });
-    if (!ending && match.index + text.length === content.length)
-      break;
-  }
-  return tokens;
-}
-function tokenizeWords(text) {
-  if (!text)
-    return [];
-  const matches = text.match(/[\w]+|[^\w\s]+|\s+/g);
-  return matches ?? [text];
-}
-function myersDiff(oldArr, newArr, equals = (a, b) => a === b) {
-  const n = oldArr.length;
-  const m = newArr.length;
-  if (n === 0 && m === 0)
-    return [];
-  if (n === 0)
-    return newArr.map((newItem, i) => ({ kind: "insert", newItem, newIndex: i }));
-  if (m === 0)
-    return oldArr.map((oldItem, i) => ({ kind: "delete", oldItem, oldIndex: i }));
-  const max = n + m;
-  const v = { 1: 0 };
-  const trace = [];
-  for (let d = 0;d <= max; d++) {
-    trace.push({ ...v });
-    for (let k = -d;k <= d; k += 2) {
-      let x = k === -d || k !== d && (v[k - 1] ?? -1) < (v[k + 1] ?? -1) ? v[k + 1] ?? 0 : (v[k - 1] ?? 0) + 1;
-      let y = x - k;
-      while (x < n && y < m && equals(oldArr[x], newArr[y])) {
-        x++;
-        y++;
-      }
-      v[k] = x;
-      if (x >= n && y >= m) {
-        const ops = [];
-        let cx = n;
-        let cy = m;
-        for (let cd = d;cd > 0; cd--) {
-          const prevV = trace[cd];
-          const pk = cx - cy;
-          const prevK = pk === -cd || pk !== cd && (prevV[pk - 1] ?? -1) < (prevV[pk + 1] ?? -1) ? pk + 1 : pk - 1;
-          const prevX = prevV[prevK] ?? 0;
-          const prevY = prevX - prevK;
-          while (cx > prevX + (prevK === pk + 1 ? 0 : 1) && cy > prevY + (prevK === pk + 1 ? 1 : 0)) {
-            cx--;
-            cy--;
-            ops.push({
-              kind: "equal",
-              oldItem: oldArr[cx],
-              newItem: newArr[cy],
-              oldIndex: cx,
-              newIndex: cy
-            });
-          }
-          if (prevK === pk + 1) {
-            cy--;
-            ops.push({ kind: "insert", newItem: newArr[cy], newIndex: cy });
-          } else {
-            cx--;
-            ops.push({ kind: "delete", oldItem: oldArr[cx], oldIndex: cx });
-          }
-        }
-        while (cx > 0 && cy > 0) {
-          cx--;
-          cy--;
-          ops.push({
-            kind: "equal",
-            oldItem: oldArr[cx],
-            newItem: newArr[cy],
-            oldIndex: cx,
-            newIndex: cy
-          });
-        }
-        ops.reverse();
-        return ops;
-      }
-    }
-  }
-  return [];
-}
-function computeWordDiff(oldLine, newLine) {
-  const oldWords = tokenizeWords(oldLine);
-  const newWords = tokenizeWords(newLine);
-  const ops = myersDiff(oldWords, newWords);
-  const oldSpans = [];
-  const newSpans = [];
-  for (const op of ops) {
-    if (op.kind === "equal") {
-      const text = op.oldItem ?? "";
-      oldSpans.push({ text, kind: "equal" });
-      newSpans.push({ text, kind: "equal" });
-    } else if (op.kind === "delete") {
-      oldSpans.push({ text: op.oldItem ?? "", kind: "deletion" });
-    } else if (op.kind === "insert") {
-      newSpans.push({ text: op.newItem ?? "", kind: "addition" });
-    }
-  }
-  return { oldSpans, newSpans };
-}
-function buildUnifiedDiff(before, after, contextLines = 3) {
-  const oldTokens = tokenizeLines(before);
-  const newTokens = tokenizeLines(after);
-  if (before === after) {
-    return { hunks: [], oldLineCount: oldTokens.length, newLineCount: newTokens.length };
-  }
-  const ops = myersDiff(oldTokens, newTokens, (a, b) => a.text === b.text && a.ending === b.ending);
-  const editIndices = ops.map((op, i) => op.kind !== "equal" ? i : -1).filter((i) => i !== -1);
-  if (editIndices.length === 0) {
-    return { hunks: [], oldLineCount: oldTokens.length, newLineCount: newTokens.length };
-  }
-  const hunkRanges = [];
-  let currentRange = {
-    startIdx: Math.max(0, editIndices[0] - contextLines),
-    endIdx: Math.min(ops.length - 1, editIndices[0] + contextLines)
-  };
-  for (let i = 1;i < editIndices.length; i++) {
-    const editIdx = editIndices[i];
-    const opStart = Math.max(0, editIdx - contextLines);
-    const opEnd = Math.min(ops.length - 1, editIdx + contextLines);
-    if (opStart <= currentRange.endIdx) {
-      currentRange.endIdx = Math.max(currentRange.endIdx, opEnd);
-    } else {
-      hunkRanges.push(currentRange);
-      currentRange = { startIdx: opStart, endIdx: opEnd };
-    }
-  }
-  hunkRanges.push(currentRange);
-  const hunks = [];
-  for (const range of hunkRanges) {
-    const lines = [];
-    let oldCount = 0;
-    let newCount = 0;
-    let oldStart = null;
-    let newStart = null;
-    for (let i = range.startIdx;i <= range.endIdx; i++) {
-      const op = ops[i];
-      if (op.kind === "equal") {
-        const oIdx = op.oldIndex + 1;
-        const nIdx = op.newIndex + 1;
-        if (oldStart === null)
-          oldStart = oIdx;
-        if (newStart === null)
-          newStart = nIdx;
-        lines.push({
-          kind: "context",
-          text: op.oldItem.text,
-          ending: op.oldItem.ending,
-          oldLineNumber: oIdx,
-          newLineNumber: nIdx
-        });
-        oldCount++;
-        newCount++;
-      } else if (op.kind === "delete") {
-        const oIdx = op.oldIndex + 1;
-        if (oldStart === null)
-          oldStart = oIdx;
-        lines.push({
-          kind: "deletion",
-          text: op.oldItem.text,
-          ending: op.oldItem.ending,
-          oldLineNumber: oIdx
-        });
-        oldCount++;
-      } else if (op.kind === "insert") {
-        const nIdx = op.newIndex + 1;
-        if (newStart === null)
-          newStart = nIdx;
-        lines.push({
-          kind: "addition",
-          text: op.newItem.text,
-          ending: op.newItem.ending,
-          newLineNumber: nIdx
-        });
-        newCount++;
-      }
-    }
-    let l = 0;
-    while (l < lines.length) {
-      if (lines[l]?.kind === "deletion") {
-        const delStart = l;
-        while (l < lines.length && lines[l]?.kind === "deletion")
-          l++;
-        const delEnd = l;
-        const addStart = l;
-        while (l < lines.length && lines[l]?.kind === "addition")
-          l++;
-        const addEnd = l;
-        const delCount = delEnd - delStart;
-        const addCount = addEnd - addStart;
-        const pairCount = Math.min(delCount, addCount);
-        for (let p = 0;p < pairCount; p++) {
-          const delLine = lines[delStart + p];
-          const addLine = lines[addStart + p];
-          const { oldSpans, newSpans } = computeWordDiff(delLine.text, addLine.text);
-          delLine.spans = oldSpans;
-          addLine.spans = newSpans;
-        }
-      } else {
-        l++;
-      }
-    }
-    hunks.push({
-      oldStart: oldStart ?? (oldTokens.length === 0 ? 0 : 1),
-      oldCount,
-      newStart: newStart ?? (newTokens.length === 0 ? 0 : 1),
-      newCount,
-      lines
-    });
-  }
-  return {
-    hunks,
-    oldLineCount: oldTokens.length,
-    newLineCount: newTokens.length
-  };
-}
-
 // src/tui/components/docks/FilePermissionDock.tsx
 class FilePermissionDock extends Component {
   wrap = true;
@@ -120903,8 +121392,7 @@ class FilePermissionDock extends Component {
           const wrapped = prefixedBlock(firstPrefix, bodyText, {
             continuationPrefix: contPrefix,
             width: maxCols,
-            bg: diffDeleteBg,
-            padToWidth: true
+            bg: diffDeleteBg
           });
           renderedRows.push(...wrapped);
         } else if (line.kind === "addition") {
@@ -120915,8 +121403,7 @@ class FilePermissionDock extends Component {
           const wrapped = prefixedBlock(firstPrefix, bodyText, {
             continuationPrefix: contPrefix,
             width: maxCols,
-            bg: diffAddBg,
-            padToWidth: true
+            bg: diffAddBg
           });
           renderedRows.push(...wrapped);
         } else {
@@ -122049,6 +122536,163 @@ class VoiceController {
     this.setState("idle");
   }
 }
+// src/services/updater/service.ts
+var DEFAULT_REPO = "sapirrior/steward";
+function parseSemver(v) {
+  if (!v || typeof v !== "string") {
+    return [0, 0, 0];
+  }
+  const clean = v.replace(/^v/i, "").trim().split("-")[0] ?? "";
+  const parts = clean.split(".").map((p) => parseInt(p, 10) || 0);
+  return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
+}
+function isNewerVersion(current, latest) {
+  const [cMaj, cMin, cPat] = parseSemver(current);
+  const [lMaj, lMin, lPat] = parseSemver(latest);
+  if (lMaj > cMaj)
+    return true;
+  if (lMaj < cMaj)
+    return false;
+  if (lMin > cMin)
+    return true;
+  if (lMin < cMin)
+    return false;
+  return lPat > cPat;
+}
+
+class UpdateCheckerService {
+  currentVersion;
+  repo;
+  state = "idle";
+  options;
+  checkTimer = null;
+  resetTimer = null;
+  constructor(options = {}) {
+    this.options = options;
+    this.currentVersion = options.currentVersion || package_default.version || "0.0.0";
+    this.repo = options.repo || DEFAULT_REPO;
+  }
+  getState() {
+    return this.state;
+  }
+  getRepo() {
+    return this.repo;
+  }
+  getCurrentVersion() {
+    return this.currentVersion;
+  }
+  get rawPackageJsonUrl() {
+    return `https://raw.githubusercontent.com/${this.repo}/main/package.json`;
+  }
+  setState(state, info) {
+    this.state = state;
+    this.options.onStatusChange?.(state, info);
+  }
+  async checkForUpdates() {
+    if (process.env.STEWARD_NO_UPDATE_CHECK === "1" || process.env.STEWARD_NO_UPDATE_CHECK === "true") {
+      return null;
+    }
+    if (this.resetTimer) {
+      clearTimeout(this.resetTimer);
+      this.resetTimer = null;
+    }
+    try {
+      this.setState("checking", { message: "Checking for updates..." });
+      const checkStartTime = Date.now();
+      const controller = new AbortController;
+      const timeout = setTimeout(() => controller.abort(), this.options.timeoutMs ?? 1e4);
+      const response = await fetch(this.rawPackageJsonUrl, {
+        headers: {
+          "User-Agent": `steward-cli/${this.currentVersion}`,
+          Accept: "application/json"
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      const elapsed = Date.now() - checkStartTime;
+      const targetMinDisplay = this.options.minDisplayMs !== undefined ? this.options.minDisplayMs : 1000;
+      const minDisplayDelay = Math.max(0, targetMinDisplay - elapsed);
+      if (minDisplayDelay > 0) {
+        await new Promise((resolve) => setTimeout(resolve, minDisplayDelay));
+      }
+      if (!response.ok) {
+        this.setState("error", { message: "Failed to check for updates" });
+        this.resetTimer = setTimeout(() => {
+          if (this.state === "error")
+            this.setState("idle");
+        }, 3000);
+        return null;
+      }
+      const data = await response.json();
+      if (!data || typeof data !== "object" || typeof data.version !== "string") {
+        this.setState("error", { message: "Invalid upstream version response" });
+        this.resetTimer = setTimeout(() => {
+          if (this.state === "error")
+            this.setState("idle");
+        }, 3000);
+        return null;
+      }
+      const latestVersion = data.version.replace(/^v/i, "").trim();
+      if (!latestVersion) {
+        this.setState("error", { message: "Empty upstream version response" });
+        this.resetTimer = setTimeout(() => {
+          if (this.state === "error")
+            this.setState("idle");
+        }, 3000);
+        return null;
+      }
+      const hasUpdate = isNewerVersion(this.currentVersion, latestVersion);
+      const updateInfo = {
+        currentVersion: this.currentVersion,
+        latestVersion,
+        hasUpdate
+      };
+      if (hasUpdate) {
+        this.setState("available", {
+          version: latestVersion,
+          message: `Update v${latestVersion} is available`
+        });
+      } else {
+        this.setState("no-updates", {
+          version: this.currentVersion,
+          message: `Steward is up to date (v${this.currentVersion})`
+        });
+        this.resetTimer = setTimeout(() => {
+          if (this.state === "no-updates")
+            this.setState("idle");
+        }, 3500);
+      }
+      return updateInfo;
+    } catch (err) {
+      logError(err, { component: "UpdateCheckerService", method: "checkForUpdates" });
+      this.setState("error", { message: "Failed to check for updates" });
+      this.resetTimer = setTimeout(() => {
+        if (this.state === "error")
+          this.setState("idle");
+      }, 3000);
+      return null;
+    }
+  }
+  startBackgroundCheck(initialDelayMs = 2000) {
+    if (this.checkTimer) {
+      clearTimeout(this.checkTimer);
+    }
+    this.checkTimer = setTimeout(async () => {
+      this.checkTimer = null;
+      await this.checkForUpdates();
+    }, initialDelayMs);
+  }
+  dispose() {
+    if (this.checkTimer) {
+      clearTimeout(this.checkTimer);
+      this.checkTimer = null;
+    }
+    if (this.resetTimer) {
+      clearTimeout(this.resetTimer);
+      this.resetTimer = null;
+    }
+  }
+}
 // src/tui/app.ts
 class TUIApp {
   engine;
@@ -122064,6 +122708,7 @@ class TUIApp {
   ctrlCTimer = null;
   isBusy = false;
   voiceController;
+  updateChecker;
   permissionQueue;
   constructor(options = {}) {
     this.cwd = options.cwd ?? process.cwd();
@@ -122126,6 +122771,32 @@ class TUIApp {
         this.statusBar.showWarning(warning);
       }
     });
+    this.updateChecker = new UpdateCheckerService({
+      currentVersion: options.version,
+      onStatusChange: (state, info) => {
+        if (state === "idle") {
+          this.statusBar.setUpdateStatus(undefined);
+        } else if (state === "available") {
+          this.statusBar.setUpdateStatus({
+            state,
+            version: info?.version,
+            message: info?.message
+          }, 8000);
+        } else if (state === "error") {
+          this.statusBar.setUpdateStatus({
+            state,
+            version: info?.version,
+            message: info?.message
+          }, 4000);
+        } else {
+          this.statusBar.setUpdateStatus({
+            state,
+            version: info?.version,
+            message: info?.message
+          });
+        }
+      }
+    });
     this.permissionQueue = new PermissionQueue({
       onShow: (item) => {
         if (this.activeModal)
@@ -122222,6 +122893,7 @@ class TUIApp {
     this.engine.mount(this.streamingView, { kind: "custom" });
     this.engine.mount(this.promptInput, { keepCursorVisible: true, kind: "input" });
     this.engine.mount(this.statusBar, { kind: "custom" });
+    this.updateChecker.startBackgroundCheck(3000);
     this.engine.addInputListener((chunk) => {
       const action = parseKeyInput(chunk);
       if (this.voiceController.isActive) {
@@ -122657,6 +123329,7 @@ class TUIApp {
     this.permissionQueue.clear();
     this.session.shutdown().catch(() => {});
     this.voiceController.dispose();
+    this.updateChecker.dispose();
     this.engine.cleanupSync();
     if (this.onExitCallback) {
       this.onExitCallback();