@cryer/star-cli 0.1.3 → 0.2.1

package/dist/chunk-MJ2O7NWI.js

@@ -0,0 +1,2469 @@
+#!/usr/bin/env node
+
+// src/agent/loop.ts
+import { tool as aiTool } from "ai";
+
+// src/context/compaction.ts
+import { generateText } from "ai";
+
+// src/context/tokens.ts
+var CHARS_PER_TOKEN = 4;
+var MESSAGE_OVERHEAD = 4;
+var IMAGE_PART_TOKENS = 1024;
+var CJK_RE = /[\u3000-\u30FF\u3400-\u4DBF\u4E00-\u9FFF\uF900-\uFAFF\uFF00-\uFFEF]/;
+function textWeight(text) {
+  let cjk = 0;
+  for (const ch of text) {
+    if (CJK_RE.test(ch)) cjk++;
+  }
+  return text.length + cjk * (CHARS_PER_TOKEN - 1);
+}
+function contentCharLength(message) {
+  if (message.role === "tool") {
+    let chars2 = 0;
+    for (const part of message.content) {
+      chars2 += textWeight(JSON.stringify(part.result ?? null));
+    }
+    return chars2;
+  }
+  if (typeof message.content === "string") {
+    return textWeight(message.content);
+  }
+  let chars = 0;
+  for (const part of message.content) {
+    if (part.type === "text" || part.type === "reasoning") {
+      chars += textWeight(part.text);
+    } else if (part.type === "tool-call") {
+      chars += textWeight(part.toolName) + textWeight(JSON.stringify(part.args ?? null));
+    }
+  }
+  return chars;
+}
+function imagePartCount(message) {
+  if (typeof message.content === "string" || message.role === "tool") return 0;
+  return message.content.filter((part) => part.type === "image" || part.type === "file").length;
+}
+function estimateMessageTokens(message) {
+  return Math.ceil(contentCharLength(message) / CHARS_PER_TOKEN) + MESSAGE_OVERHEAD + imagePartCount(message) * IMAGE_PART_TOKENS;
+}
+function estimateTokens(messages) {
+  return messages.reduce((total, message) => total + estimateMessageTokens(message), 0);
+}
+
+// src/context/compaction.ts
+var MIN_KEPT_MESSAGES = 4;
+function placeholderMessage(droppedCount) {
+  return {
+    role: "user",
+    content: `[context compacted: ${droppedCount} earlier messages dropped]`
+  };
+}
+var SUMMARY_SYSTEM_PROMPT = [
+  "You are summarizing an AI coding agent's conversation for context compaction.",
+  "Write a concise summary that preserves:",
+  "- the user's goals and requests",
+  "- decisions made and their rationale",
+  "- files and code touched (paths, key changes)",
+  "- tool results that matter (errors, key outputs)",
+  "- outstanding TODOs and next steps",
+  "Output only the summary, no preamble."
+].join("\n");
+function serializeMessage(message) {
+  if (typeof message.content === "string") {
+    return `${message.role}: ${message.content}`;
+  }
+  const parts = message.content.map((part) => {
+    if (part.type === "text") return part.text;
+    if (part.type === "tool-call")
+      return `[tool-call ${part.toolName}] ${JSON.stringify(part.args)}`;
+    if (part.type === "tool-result")
+      return `[tool-result ${part.toolName}] ${JSON.stringify(part.result)}`;
+    return `[${part.type}]`;
+  });
+  return `${message.role}: ${parts.join("\n")}`;
+}
+async function summarizeMessages(messages, model) {
+  const transcript = messages.map(serializeMessage).join("\n");
+  const { text } = await generateText({
+    model,
+    system: SUMMARY_SYSTEM_PROMPT,
+    prompt: `Summarize this conversation so far:
+
+${transcript}`
+  });
+  return text.trim();
+}
+function compactMessages(messages, maxTokens) {
+  if (estimateTokens(messages) <= maxTokens) {
+    return { messages, compacted: false, droppedCount: 0 };
+  }
+  const first = messages[0];
+  const hasSystem = first?.role === "system";
+  const head = hasSystem && first ? [first] : [];
+  const rest = hasSystem ? messages.slice(1) : messages.slice();
+  const turns = [];
+  for (const message of rest) {
+    const current = turns[turns.length - 1];
+    if (message.role === "user" || !current) {
+      turns.push([message]);
+    } else {
+      current.push(message);
+    }
+  }
+  let droppedCount = 0;
+  let turnIndex = 0;
+  while (turnIndex < turns.length) {
+    const turn = turns[turnIndex];
+    if (rest.length - droppedCount - turn.length < MIN_KEPT_MESSAGES) {
+      break;
+    }
+    droppedCount += turn.length;
+    turnIndex += 1;
+    const candidate = [...head, placeholderMessage(droppedCount), ...rest.slice(droppedCount)];
+    if (estimateTokens(candidate) <= maxTokens) {
+      break;
+    }
+  }
+  if (droppedCount === 0) {
+    return { messages, compacted: false, droppedCount: 0 };
+  }
+  return {
+    messages: [...head, placeholderMessage(droppedCount), ...rest.slice(droppedCount)],
+    compacted: true,
+    droppedCount
+  };
+}
+
+// src/core/git.ts
+import { execFileSync } from "child_process";
+var GIT_TIMEOUT_MS = 2e3;
+var GIT_MAX_BUFFER = 8 * 1024 * 1024;
+var COMMIT_DIFF_MAX_LINES = 2e3;
+var WORKING_DIFF_MAX_LINES = 2e3;
+function runGit(args, cwd) {
+  try {
+    const out = execFileSync("git", args, {
+      cwd,
+      timeout: GIT_TIMEOUT_MS,
+      encoding: "utf8",
+      maxBuffer: GIT_MAX_BUFFER,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return out.replace(/\n$/, "");
+  } catch {
+    return null;
+  }
+}
+function isGitRepo(cwd) {
+  return runGit(["rev-parse", "--is-inside-work-tree"], cwd) === "true";
+}
+function getGitSummary(cwd) {
+  const branch = runGit(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+  if (branch === null) return null;
+  const status = runGit(["status", "--porcelain"], cwd) ?? "";
+  const dirtyCount = status === "" ? 0 : status.split("\n").length;
+  const log = runGit(["log", "--oneline", "-3"], cwd) ?? "";
+  return { branch, dirtyCount, recentCommits: log === "" ? [] : log.split("\n") };
+}
+function formatGitSummary(summary) {
+  const lines = [
+    "Git context for the working directory (refreshed each turn):",
+    `Branch: ${summary.branch}`,
+    summary.dirtyCount === 0 ? "Working tree: clean" : `Working tree: ${summary.dirtyCount} file(s) with uncommitted changes`
+  ];
+  if (summary.recentCommits.length > 0) {
+    lines.push("Recent commits:", ...summary.recentCommits);
+  }
+  return lines.join("\n");
+}
+function truncateLines(text, maxLines) {
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) return { text, truncated: false };
+  return { text: lines.slice(0, maxLines).join("\n"), truncated: true };
+}
+function collectDiffs(cwd) {
+  return {
+    staged: runGit(["diff", "--cached"], cwd) ?? "",
+    unstaged: runGit(["diff"], cwd) ?? ""
+  };
+}
+function collectCommitContext(cwd) {
+  if (!isGitRepo(cwd)) return null;
+  const status = runGit(["status", "--short"], cwd) ?? "";
+  const { staged, unstaged } = collectDiffs(cwd);
+  if (status === "" && staged === "" && unstaged === "") return null;
+  const rawDiff = [staged, unstaged].filter((part) => part !== "").join("\n");
+  const { text: diff, truncated } = truncateLines(rawDiff, COMMIT_DIFF_MAX_LINES);
+  const recentLog = runGit(["log", "--oneline", "-5"], cwd) ?? "";
+  return { status, diff, diffTruncated: truncated, recentLog };
+}
+function buildCommitPrompt(context, instructions = "") {
+  const parts = [
+    "Analyze the uncommitted git changes below and create a commit for them.",
+    "",
+    "Requirements:",
+    "- Draft a commit message in Conventional Commits style (e.g. `feat(scope): summary`), consistent with the repository's recent commit history.",
+    "- Stage the relevant files and create the commit with the bash tool (`git add` + `git commit`), through the normal permission flow.",
+    "- Do not push and do not amend existing commits.",
+    "- After committing, briefly report the commit hash and message."
+  ];
+  if (instructions) {
+    parts.push("", `Additional instructions from the user: ${instructions}`);
+  }
+  parts.push("", "## git status --short", "```", context.status || "(clean)", "```");
+  if (context.recentLog) {
+    parts.push("", "## recent commits (git log --oneline -5)", "```", context.recentLog, "```");
+  }
+  if (context.diff) {
+    parts.push("", "## git diff (staged + unstaged)", "```diff", context.diff, "```");
+    if (context.diffTruncated) {
+      parts.push(`(diff truncated to ${COMMIT_DIFF_MAX_LINES} lines)`);
+    }
+  }
+  return parts.join("\n");
+}
+function collectWorkingDiff(cwd) {
+  if (!isGitRepo(cwd)) return null;
+  const status = runGit(["status", "--short"], cwd) ?? "";
+  const { staged, unstaged } = collectDiffs(cwd);
+  const sections = [];
+  if (staged) sections.push(`# Staged changes
+${staged}`);
+  if (unstaged) sections.push(`# Unstaged changes
+${unstaged}`);
+  const { text, truncated } = truncateLines(sections.join("\n"), WORKING_DIFF_MAX_LINES);
+  return { status, diff: text, truncated };
+}
+
+// src/core/messages.ts
+var MISSING_TOOL_RESULT_TEXT = "tool result missing (session was interrupted)";
+function reconcileToolCalls(messages) {
+  const result = [];
+  let pending = [];
+  const flushPending = () => {
+    for (const call of pending) {
+      result.push({
+        role: "tool",
+        content: [
+          {
+            type: "tool-result",
+            toolCallId: call.toolCallId,
+            toolName: call.toolName,
+            result: MISSING_TOOL_RESULT_TEXT
+          }
+        ]
+      });
+    }
+    pending = [];
+  };
+  for (const message of messages) {
+    if (message.role === "assistant" && Array.isArray(message.content)) {
+      flushPending();
+      pending = message.content.filter((part) => part.type === "tool-call").map((part) => ({ toolCallId: part.toolCallId, toolName: part.toolName }));
+    } else if (message.role === "tool" && Array.isArray(message.content) && pending.length > 0) {
+      const answered = new Set(message.content.map((part) => part.toolCallId));
+      pending = pending.filter((call) => !answered.has(call.toolCallId));
+    } else {
+      flushPending();
+    }
+    result.push(message);
+  }
+  flushPending();
+  return result;
+}
+function retractLastTurn(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.role === "user") {
+      return { messages: messages.slice(0, i), removed: messages.length - i };
+    }
+  }
+  return { messages, removed: 0 };
+}
+
+// src/hooks/runner.ts
+import { spawn } from "child_process";
+var STDERR_LIMIT = 2e3;
+var STDERR_CAPTURE_LIMIT = 64 * 1024;
+function truncate(text) {
+  const trimmed = text.trim();
+  return trimmed.length > STDERR_LIMIT ? `${trimmed.slice(0, STDERR_LIMIT)}\u2026` : trimmed;
+}
+function killTree(pid) {
+  if (pid === void 0) return;
+  if (process.platform === "win32") {
+    spawn("taskkill", ["/pid", String(pid), "/T", "/F"], { windowsHide: true }).on(
+      "error",
+      () => {
+      }
+    );
+  } else {
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+  }
+}
+function runCommand(hook, event, ctx) {
+  const env = {
+    ...process.env,
+    STAR_HOOK_EVENT: event,
+    STAR_CWD: ctx.cwd,
+    STAR_SESSION_ID: ctx.sessionId ?? ""
+  };
+  if (ctx.toolName !== void 0) env.STAR_TOOL_NAME = ctx.toolName;
+  if (ctx.toolInput !== void 0) env.STAR_TOOL_INPUT = JSON.stringify(ctx.toolInput);
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(hook.command, [], {
+        shell: true,
+        cwd: ctx.cwd,
+        env,
+        windowsHide: true,
+        detached: process.platform !== "win32"
+      });
+    } catch (error) {
+      resolve({
+        code: 1,
+        stderr: "",
+        timedOut: false,
+        spawnError: error instanceof Error ? error.message : String(error)
+      });
+      return;
+    }
+    let stderr = "";
+    let timedOut = false;
+    let settled = false;
+    const finish = (outcome) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      clearTimeout(fallback);
+      resolve(outcome);
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      killTree(child.pid);
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      fallback = setTimeout(() => {
+        finish({ code: 1, stderr, timedOut: true });
+      }, 2e3);
+      fallback.unref?.();
+    }, hook.timeoutSec * 1e3);
+    let fallback;
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < STDERR_CAPTURE_LIMIT) stderr += chunk.toString("utf8");
+    });
+    child.stdout?.resume();
+    child.on("error", (error) => {
+      finish({ code: 1, stderr, timedOut, spawnError: error.message });
+    });
+    child.on("close", (code) => {
+      finish({ code: code ?? 1, stderr, timedOut });
+    });
+  });
+}
+function hookMatches(hook, event, toolName) {
+  if (hook.event !== event) return false;
+  if (event === "Stop" || !hook.matcher) return true;
+  if (toolName === void 0) return false;
+  try {
+    return new RegExp(hook.matcher).test(toolName);
+  } catch {
+    return false;
+  }
+}
+async function runHooks(event, hooks2, ctx) {
+  const result = { blocked: false, warnings: [] };
+  for (const hook of hooks2) {
+    if (!hookMatches(hook, event, ctx.toolName)) continue;
+    let outcome;
+    try {
+      outcome = await runCommand(hook, event, ctx);
+    } catch (error) {
+      result.warnings.push(
+        `Hook "${hook.command}" (${event}) failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+      continue;
+    }
+    if (outcome.code === 0) continue;
+    const stderr = truncate(outcome.stderr);
+    if (event === "PreToolUse" && outcome.code === 2 && !outcome.timedOut) {
+      result.blocked = true;
+      result.reason = stderr || `hook "${hook.command}" exited with code 2`;
+      return result;
+    }
+    const detail = outcome.timedOut ? `timed out after ${hook.timeoutSec}s` : outcome.spawnError ? `failed to start: ${outcome.spawnError}` : `exited with code ${outcome.code}`;
+    result.warnings.push(
+      `Hook "${hook.command}" (${event}) ${detail}${stderr ? `: ${stderr}` : ""}`
+    );
+  }
+  return result;
+}
+
+// src/permissions/gate.ts
+import path from "path";
+
+// src/permissions/allow.ts
+function parseAllowRule(rule) {
+  const match = /^([\w-]+)(?:\((.*)\))?$/.exec(rule.trim());
+  if (!match) return null;
+  return { toolName: match[1], pattern: match[2] };
+}
+function globMatch(pattern, value) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`).test(value);
+}
+function requestTarget(req) {
+  if (typeof req.args !== "object" || req.args === null) return void 0;
+  const args = req.args;
+  const key = req.toolName === "bash" ? "command" : "path";
+  const value = args[key];
+  return typeof value === "string" ? value : void 0;
+}
+function matchAllowRule(rule, req) {
+  if (rule.toolName !== req.toolName) return false;
+  if (rule.pattern === void 0) return true;
+  const target = requestTarget(req);
+  return target !== void 0 && globMatch(rule.pattern, target);
+}
+function isAllowedByRules(rules, req) {
+  return rules.some((raw) => {
+    const rule = parseAllowRule(raw);
+    return rule !== null && matchAllowRule(rule, req);
+  });
+}
+function buildAllowRule(req) {
+  const target = requestTarget(req);
+  return target !== void 0 ? `${req.toolName}(${target})` : req.toolName;
+}
+
+// src/permissions/gate.ts
+var FILE_TOOLS = /* @__PURE__ */ new Set(["write_file", "edit_file", "read_file"]);
+var DANGEROUS_COMMAND_PATTERNS = [
+  /rm\s+-rf\s+\/(?:\s|$|;|&)/i,
+  /rm\s+-rf\s+~(?:\s|\/|$|;|&)/i,
+  /:\(\)\s*\{\s*:\|:&\s*\}\s*;:/,
+  /\bmkfs\b/i,
+  /dd\s+[^|;]*\bif=/i,
+  />\s*\/dev\/sd[a-z]/i,
+  /\bshutdown\b/i,
+  /\breboot\b/i,
+  /\bpoweroff\b/i
+];
+function isDangerousCommand(command) {
+  return DANGEROUS_COMMAND_PATTERNS.some((pattern) => pattern.test(command));
+}
+function getStringArg(args, key) {
+  if (typeof args === "object" && args !== null) {
+    const value = args[key];
+    if (typeof value === "string") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function normalizeAbsolute(p, cwd) {
+  const abs = path.isAbsolute(p) ? path.normalize(p) : path.resolve(cwd, p);
+  return abs.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}
+function isOutsideCwd(p, cwd) {
+  const abs = normalizeAbsolute(p, cwd);
+  const base = normalizeAbsolute(cwd, cwd);
+  return abs !== base && !abs.startsWith(`${base}/`);
+}
+function isSensitivePath(p) {
+  const base = p.replace(/\\/g, "/").split("/").pop()?.toLowerCase() ?? "";
+  if (base === ".env.example" || base === ".env.sample" || base === ".env.template") {
+    return false;
+  }
+  return base === ".env" || base.startsWith(".env.") || base === "id_rsa" || base.endsWith(".pem");
+}
+function checkPermission(mode, req, ctx, allowRules = []) {
+  if (mode === "yolo") {
+    return "allow";
+  }
+  const command = getStringArg(req.args, "command");
+  const filePath = getStringArg(req.args, "path");
+  if (req.toolName === "bash" && command !== void 0 && isDangerousCommand(command)) {
+    return "deny";
+  }
+  if (FILE_TOOLS.has(req.toolName) && filePath !== void 0) {
+    if ((req.toolName === "write_file" || req.toolName === "edit_file") && isSensitivePath(filePath)) {
+      return "deny";
+    }
+    if (isOutsideCwd(filePath, ctx.cwd)) {
+      if (mode === "ask" && req.level === "read") {
+        return "ask";
+      }
+      return "deny";
+    }
+  }
+  if (mode === "auto") {
+    return "allow";
+  }
+  if (mode === "readonly") {
+    return req.level === "read" ? "allow" : "deny";
+  }
+  if (mode === "plan") {
+    return req.level === "read" ? "allow" : "deny";
+  }
+  if (isAllowedByRules(allowRules, req)) {
+    return "allow";
+  }
+  return req.level === "read" ? "allow" : "ask";
+}
+
+// src/session/title.ts
+import { generateText as generateText2 } from "ai";
+var TITLE_MAX_CHARS = 50;
+var TITLE_INPUT_MAX_CHARS = 1e3;
+var TITLE_MAX_TOKENS = 20;
+var TITLE_TIMEOUT_MS = 15e3;
+var TITLE_SYSTEM_PROMPT = [
+  "You write short titles for conversations.",
+  "Summarize the user's first message into a single concise title:",
+  "- at most 50 characters",
+  "- no surrounding quotes, no trailing punctuation",
+  "- same language as the user's message",
+  "Output only the title, nothing else."
+].join("\n");
+function sanitizeTitle(raw) {
+  let title = raw.trim().split("\n")[0]?.trim() ?? "";
+  let previous;
+  do {
+    previous = title;
+    title = title.replace(/^["'“”‘’「」『』\s]+|["'“”‘’「」『』\s]+$/g, "").replace(/[。．.!！?？…:：;；,，、\s]+$/u, "");
+  } while (title !== previous);
+  return title.slice(0, TITLE_MAX_CHARS).trim();
+}
+async function generateSessionTitle(userText, model) {
+  const { text } = await generateText2({
+    model,
+    system: TITLE_SYSTEM_PROMPT,
+    prompt: userText.slice(0, TITLE_INPUT_MAX_CHARS),
+    maxTokens: TITLE_MAX_TOKENS,
+    abortSignal: AbortSignal.timeout(TITLE_TIMEOUT_MS)
+  });
+  return sanitizeTitle(text);
+}
+function scheduleSessionTitle(store, userText, model) {
+  void (async () => {
+    const meta = await store.meta();
+    if (meta.title) return;
+    const title = await generateSessionTitle(userText, model);
+    if (!title) return;
+    const current = await store.meta();
+    if (current.title) return;
+    await store.setTitle(title);
+  })().catch(() => {
+  });
+}
+
+// src/tools/fs/snapshots.ts
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import path2 from "path";
+var MAX_SNAPSHOTS = 50;
+var stack = [];
+var activeTurn = 0;
+var activeTurnMessageIndex = -1;
+var checkpointSeq = 0;
+var hooks = null;
+function setSnapshotHooks(next) {
+  hooks = next;
+}
+function nextSnapshotId() {
+  return ++checkpointSeq;
+}
+function beginTurn(messageIndex = -1) {
+  activeTurnMessageIndex = messageIndex;
+  return ++activeTurn;
+}
+function currentTurnSeq() {
+  return activeTurn;
+}
+function currentTurnMessageIndex() {
+  return activeTurnMessageIndex;
+}
+async function captureSnapshot(filePath, toolName) {
+  let content = null;
+  let existed = false;
+  try {
+    content = await readFile(filePath, "utf8");
+    existed = true;
+  } catch {
+  }
+  return {
+    id: nextSnapshotId(),
+    path: filePath,
+    existed,
+    content,
+    toolName,
+    timestamp: Date.now(),
+    turn: activeTurn,
+    messageIndex: activeTurnMessageIndex
+  };
+}
+async function pushSnapshot(snapshot) {
+  stack.push(snapshot);
+  await hooks?.onPush?.(snapshot);
+  if (stack.length > MAX_SNAPSHOTS) {
+    const evicted = stack.splice(0, stack.length - MAX_SNAPSHOTS);
+    await removeFromStore(evicted.map((s) => s.id));
+  }
+}
+async function removeFromStore(ids) {
+  if (ids.length > 0) await hooks?.onRemove?.(ids);
+}
+function listSnapshots() {
+  return [...stack];
+}
+function clearSnapshots() {
+  stack.length = 0;
+}
+function hydrateSnapshots(snapshots) {
+  stack.length = 0;
+  stack.push(...snapshots.slice(-MAX_SNAPSHOTS));
+  for (const snapshot of stack) {
+    if (snapshot.id > checkpointSeq) checkpointSeq = snapshot.id;
+  }
+}
+async function resolveContent(snapshot) {
+  if (snapshot.content !== null) return snapshot.content;
+  if (!snapshot.contentFile) return null;
+  try {
+    return await readFile(snapshot.contentFile, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function revert(snapshot) {
+  if (snapshot.existed) {
+    const content = await resolveContent(snapshot);
+    if (content === null) {
+      return `Skipped ${snapshot.path}: the snapshot content is no longer available.`;
+    }
+    await mkdir(path2.dirname(snapshot.path), { recursive: true });
+    await writeFile(snapshot.path, content, "utf8");
+    return `Restored ${snapshot.path} to its state before ${snapshot.toolName}.`;
+  }
+  await rm(snapshot.path, { force: true });
+  return `Deleted ${snapshot.path} (it did not exist before ${snapshot.toolName}).`;
+}
+async function undoTurnSnapshots(turn) {
+  const matches = [];
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const snapshot = stack[i];
+    if (snapshot && snapshot.turn === turn) {
+      matches.push(snapshot);
+      stack.splice(i, 1);
+    }
+  }
+  await removeFromStore(matches.map((s) => s.id));
+  const messages = [];
+  for (const snapshot of matches) {
+    messages.push(await revert(snapshot));
+  }
+  return messages;
+}
+async function rewindToSnapshot(id) {
+  if (!stack.some((snapshot) => snapshot.id === id)) return null;
+  const matches = [];
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const snapshot = stack[i];
+    if (snapshot && snapshot.id >= id) {
+      matches.push(snapshot);
+      stack.splice(i, 1);
+    }
+  }
+  await removeFromStore(matches.map((s) => s.id));
+  const reverted = [];
+  let messageIndex = null;
+  for (const snapshot of matches) {
+    reverted.push(await revert(snapshot));
+    if (snapshot.messageIndex >= 0) {
+      messageIndex = messageIndex === null ? snapshot.messageIndex : Math.min(messageIndex, snapshot.messageIndex);
+    }
+  }
+  return { reverted, messageIndex };
+}
+
+// src/agent/project-memory.ts
+import { readFileSync, statSync } from "fs";
+import path3 from "path";
+var PROJECT_MEMORY_FILE = "AGENTS.md";
+var PROJECT_MEMORY_MAX_CHARS = 32 * 1024;
+var cache = /* @__PURE__ */ new Map();
+function readProjectMemory(cwd) {
+  const file = path3.join(cwd, PROJECT_MEMORY_FILE);
+  let mtimeMs;
+  try {
+    mtimeMs = statSync(file).mtimeMs;
+  } catch {
+    return null;
+  }
+  const hit = cache.get(file);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.block;
+  let block = null;
+  try {
+    let body = readFileSync(file, "utf8").trim();
+    if (body) {
+      if (body.length > PROJECT_MEMORY_MAX_CHARS) {
+        body = `${body.slice(0, PROJECT_MEMORY_MAX_CHARS)}
+
+[AGENTS.md truncated to ${PROJECT_MEMORY_MAX_CHARS} characters]`;
+      }
+      block = `# Project instructions (AGENTS.md)
+${body}`;
+    }
+  } catch {
+    block = null;
+  }
+  cache.set(file, { mtimeMs, block });
+  return block;
+}
+
+// src/agent/skills.ts
+import { readFileSync as readFileSync2, readdirSync, statSync as statSync2 } from "fs";
+import path5 from "path";
+import { z } from "zod";
+
+// src/config/paths.ts
+import os from "os";
+import path4 from "path";
+function starHome() {
+  return process.env.STAR_HOME ?? path4.join(os.homedir(), ".star-cli");
+}
+function globalConfigPath() {
+  return path4.join(starHome(), "config.toml");
+}
+function sessionsDir() {
+  return path4.join(starHome(), "sessions");
+}
+function projectConfigPath(cwd) {
+  return path4.join(cwd, ".star", "config.toml");
+}
+
+// src/agent/skills.ts
+var SKILL_FILE = "SKILL.md";
+var SKILL_MAX_CHARS = 32 * 1024;
+var NAME_PATTERN = /^[a-z0-9-]+$/;
+function parseFrontmatter(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  if (!match) return null;
+  const meta = {};
+  for (const line of (match[1] ?? "").split(/\r?\n/)) {
+    const kv = line.match(/^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/);
+    if (kv?.[1]) meta[kv[1]] = (kv[2] ?? "").trim();
+  }
+  return { meta, body: raw.slice(match[0].length).trim() };
+}
+var cache2 = /* @__PURE__ */ new Map();
+function parseSkillFile(filePath, dirName, scope) {
+  let mtimeMs;
+  try {
+    mtimeMs = statSync2(filePath).mtimeMs;
+  } catch {
+    return null;
+  }
+  const hit = cache2.get(filePath);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.skill;
+  let skill = null;
+  try {
+    const parsed = parseFrontmatter(readFileSync2(filePath, "utf8"));
+    const name = parsed?.meta.name || dirName;
+    const description = parsed?.meta.description;
+    if (parsed && NAME_PATTERN.test(name) && description) {
+      skill = { name, description, filePath, dir: path5.dirname(filePath), scope };
+    }
+  } catch {
+    skill = null;
+  }
+  cache2.set(filePath, { mtimeMs, skill });
+  return skill;
+}
+function scanDir(base, scope, into) {
+  let entries;
+  try {
+    entries = readdirSync(base);
+  } catch {
+    return;
+  }
+  for (const entry of entries.sort()) {
+    if (!NAME_PATTERN.test(entry)) continue;
+    const parsed = parseSkillFile(path5.join(base, entry, SKILL_FILE), entry, scope);
+    if (parsed) into.set(parsed.name, parsed);
+  }
+}
+function discoverSkills(cwd, home = starHome()) {
+  const byName = /* @__PURE__ */ new Map();
+  scanDir(path5.join(home, "skills"), "user", byName);
+  scanDir(path5.join(cwd, ".star", "skills"), "project", byName);
+  return [...byName.values()];
+}
+function formatSkillsBlock(skills) {
+  const lines = skills.map((s) => `- ${s.name}: ${s.description}`);
+  return [
+    "# Available skills",
+    "When the user's request matches one of these skills, call the skill tool with its name to load the full instructions before proceeding:",
+    ...lines
+  ].join("\n");
+}
+function loadSkillBody(skill) {
+  let parsed = null;
+  try {
+    parsed = parseFrontmatter(readFileSync2(skill.filePath, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!parsed?.body) return null;
+  if (parsed.body.length > SKILL_MAX_CHARS) {
+    return `${parsed.body.slice(0, SKILL_MAX_CHARS)}
+
+[skill truncated to ${SKILL_MAX_CHARS} characters]`;
+  }
+  return parsed.body;
+}
+function createSkillTool(deps) {
+  return {
+    name: "skill",
+    description: "Load the full instructions of a skill by name. Available skills are listed in the system prompt when present; call this before starting work that matches one of them.",
+    permission: "read",
+    parameters: z.object({
+      name: z.string().describe("Name of the skill to load, as listed in the system prompt.")
+    }),
+    async execute(args) {
+      const skills = discoverSkills(deps.cwd, deps.home);
+      const skill = skills.find((s) => s.name === args.name);
+      if (!skill) {
+        const available = skills.map((s) => s.name).join(", ") || "none";
+        return {
+          content: `Unknown skill: "${args.name}". Available skills: ${available}`,
+          isError: true
+        };
+      }
+      const body = loadSkillBody(skill);
+      if (!body) {
+        return { content: `Skill "${skill.name}" is empty or unreadable.`, isError: true };
+      }
+      return {
+        content: [
+          `# Skill: ${skill.name}`,
+          "",
+          body,
+          "",
+          `Base directory for relative file references in this skill: ${skill.dir}`
+        ].join("\n")
+      };
+    }
+  };
+}
+
+// src/agent/subagent.ts
+import { z as z12 } from "zod";
+
+// src/tools/bash.ts
+import { spawn as spawn3 } from "child_process";
+import { existsSync } from "fs";
+import path6 from "path";
+import { z as z2 } from "zod";
+
+// src/tasks/manager.ts
+import { spawn as spawn2 } from "child_process";
+import { EventEmitter } from "events";
+var MAX_TASK_OUTPUT = 1e5;
+var DEFAULT_TASK_TIMEOUT = 3600;
+var TRUNCATED_PREFIX = "[... earlier output truncated ...]\n";
+var TaskManager = class extends EventEmitter {
+  records = /* @__PURE__ */ new Map();
+  seq = 0;
+  start(opts) {
+    const id = `task-${++this.seq}`;
+    const spec = resolveShell();
+    const child = spawn2(spec.shell, spec.wrap(opts.command), {
+      cwd: opts.cwd,
+      windowsHide: true
+    });
+    const rec = {
+      id,
+      command: opts.command,
+      description: opts.description,
+      status: "running",
+      startedAt: Date.now(),
+      output: "",
+      truncated: false,
+      child
+    };
+    this.records.set(id, rec);
+    const append = (d) => {
+      rec.output += d.toString("utf8");
+      if (rec.output.length > MAX_TASK_OUTPUT) {
+        rec.output = rec.output.slice(-MAX_TASK_OUTPUT);
+        rec.truncated = true;
+      }
+    };
+    child.stdout.on("data", append);
+    child.stderr.on("data", append);
+    child.on("error", (err) => {
+      append(Buffer.from(`Failed to start shell '${spec.label}': ${err.message}
+`));
+      if (rec.status === "running") {
+        this.finish(rec, "failed", null);
+      }
+    });
+    child.on("close", (code) => {
+      if (rec.status !== "running") return;
+      this.finish(rec, code === 0 ? "completed" : "failed", code);
+    });
+    const timeoutSeconds = opts.timeoutSeconds ?? DEFAULT_TASK_TIMEOUT;
+    rec.timer = setTimeout(() => this.terminate(rec, "timed_out"), timeoutSeconds * 1e3);
+    rec.timer.unref();
+    this.emitUpdate(rec);
+    return this.snapshot(rec);
+  }
+  get(id) {
+    const rec = this.records.get(id);
+    return rec ? this.snapshot(rec) : void 0;
+  }
+  list() {
+    return [...this.records.values()].map((rec) => this.snapshot(rec));
+  }
+  runningCount() {
+    let count = 0;
+    for (const rec of this.records.values()) {
+      if (rec.status === "running") count += 1;
+    }
+    return count;
+  }
+  kill(id) {
+    const rec = this.records.get(id);
+    if (!rec || rec.status !== "running") return void 0;
+    this.terminate(rec, "stopped");
+    return this.snapshot(rec);
+  }
+  cleanup() {
+    const killed = [];
+    for (const rec of this.records.values()) {
+      if (rec.status === "running") {
+        this.terminate(rec, "stopped");
+        killed.push(this.snapshot(rec));
+      }
+    }
+    return killed;
+  }
+  terminate(rec, status) {
+    killTree2(rec.child);
+    this.finish(rec, status, null);
+  }
+  finish(rec, status, exitCode) {
+    if (rec.timer) clearTimeout(rec.timer);
+    rec.status = status;
+    rec.exitCode = exitCode;
+    rec.endedAt = Date.now();
+    this.emitUpdate(rec);
+  }
+  emitUpdate(rec) {
+    this.emit("update", this.snapshot(rec));
+  }
+  snapshot(rec) {
+    return {
+      id: rec.id,
+      command: rec.command,
+      description: rec.description,
+      status: rec.status,
+      startedAt: rec.startedAt,
+      endedAt: rec.endedAt,
+      exitCode: rec.exitCode,
+      output: rec.truncated ? TRUNCATED_PREFIX + rec.output : rec.output
+    };
+  }
+};
+var defaultTaskManager = new TaskManager();
+
+// src/tools/bash.ts
+var MAX_OUTPUT = 3e4;
+var DEFAULT_TIMEOUT = 120;
+var MAX_TIMEOUT = 600;
+function findOnPath(exe, exclude) {
+  for (const dir of (process.env.PATH ?? "").split(path6.delimiter)) {
+    if (!dir || exclude?.(dir)) {
+      continue;
+    }
+    const full = path6.join(dir, exe);
+    if (existsSync(full)) {
+      return full;
+    }
+  }
+  return null;
+}
+function resolveShell() {
+  if (process.platform !== "win32") {
+    return { shell: "sh", wrap: (c) => ["-c", c], label: "sh" };
+  }
+  const isWslStub = (dir) => /\\(system32|windowsapps)\\?$/i.test(dir.trim());
+  const fromPath = findOnPath("bash.exe", isWslStub);
+  if (fromPath) {
+    return { shell: fromPath, wrap: (c) => ["-c", c], label: "bash" };
+  }
+  const gitExe = findOnPath("git.exe");
+  if (gitExe) {
+    const sibling = path6.join(path6.dirname(path6.dirname(gitExe)), "bin", "bash.exe");
+    if (existsSync(sibling)) {
+      return { shell: sibling, wrap: (c) => ["-c", c], label: "bash" };
+    }
+  }
+  for (const candidate of [
+    "C:\\Program Files\\Git\\bin\\bash.exe",
+    "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
+    "D:\\Git\\bin\\bash.exe"
+  ]) {
+    if (existsSync(candidate)) {
+      return { shell: candidate, wrap: (c) => ["-c", c], label: "bash" };
+    }
+  }
+  const comspec = process.env.ComSpec ?? "cmd.exe";
+  return { shell: comspec, wrap: (c) => ["/d", "/s", "/c", c], label: "cmd" };
+}
+var schema = z2.object({
+  command: z2.string().describe("Shell command to execute"),
+  timeout: z2.number().positive().max(MAX_TIMEOUT).optional().describe("Timeout in seconds (default 120, max 600)"),
+  description: z2.string().optional().describe("Short description of what the command does"),
+  run_in_background: z2.boolean().optional().describe(
+    "Run the command in the background and return a task id immediately (default false). Use task_output/task_kill to inspect or stop it."
+  )
+});
+function killTree2(child) {
+  if (process.platform === "win32" && child.pid) {
+    spawn3("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
+      windowsHide: true,
+      stdio: "ignore"
+    }).unref();
+    return;
+  }
+  child.kill("SIGKILL");
+}
+function truncateMiddle(s) {
+  if (s.length <= MAX_OUTPUT) {
+    return s;
+  }
+  const half = Math.floor(MAX_OUTPUT / 2);
+  const head = s.slice(0, half);
+  const tail = s.slice(-half);
+  return `${head}
+... [${s.length - MAX_OUTPUT} characters truncated] ...
+${tail}`;
+}
+var bashTool = {
+  name: "bash",
+  description: "Execute a shell command (Git Bash on Windows when available, otherwise cmd; sh elsewhere). Stdout and stderr are merged. Output is truncated to 30000 characters. Set run_in_background for long-running commands; it returns a task id for task_list/task_output/task_kill.",
+  permission: "exec",
+  parameters: schema,
+  execute(args, ctx) {
+    if (args.run_in_background) {
+      const task = defaultTaskManager.start({
+        command: args.command,
+        description: args.description,
+        cwd: ctx.cwd,
+        timeoutSeconds: args.timeout
+      });
+      return Promise.resolve({
+        content: `Background task started: ${task.id}
+command: ${args.command}
+description: ${args.description ?? "(none)"}`
+      });
+    }
+    const timeoutSeconds = Math.min(args.timeout ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
+    const spec = resolveShell();
+    return new Promise((resolve) => {
+      const child = spawn3(spec.shell, spec.wrap(args.command), {
+        cwd: ctx.cwd,
+        windowsHide: true
+      });
+      let output = "";
+      let settled = false;
+      const finish = (result) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        ctx.abortSignal?.removeEventListener("abort", onAbort);
+        resolve(result);
+      };
+      const onAbort = () => {
+        killTree2(child);
+        finish({ content: `${truncateMiddle(output)}
+Command aborted`, isError: true });
+      };
+      const timer = setTimeout(() => {
+        killTree2(child);
+        finish({
+          content: `${truncateMiddle(output)}
+Command timed out after ${timeoutSeconds}s`,
+          isError: true
+        });
+      }, timeoutSeconds * 1e3);
+      child.stdout.on("data", (d) => {
+        output += d.toString("utf8");
+      });
+      child.stderr.on("data", (d) => {
+        output += d.toString("utf8");
+      });
+      child.on("error", (err) => {
+        finish({ content: `Failed to start shell '${spec.label}': ${err.message}`, isError: true });
+      });
+      ctx.abortSignal?.addEventListener("abort", onAbort);
+      child.on("close", (code) => {
+        const trimmed = output.replace(/\s+$/, "");
+        if (code === 0) {
+          finish({ content: truncateMiddle(trimmed) || "(no output)" });
+          return;
+        }
+        const body = truncateMiddle(trimmed);
+        finish({
+          content: `${body}${body ? "\n" : ""}Exit code: ${code ?? "unknown"}`,
+          isError: true
+        });
+      });
+    });
+  }
+};
+
+// src/tools/fs/edit.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path7 from "path";
+import { z as z3 } from "zod";
+var schema2 = z3.object({
+  path: z3.string().describe("File path, absolute or relative to the working directory"),
+  old_string: z3.string().min(1).describe("Exact text to replace"),
+  new_string: z3.string().describe("Replacement text"),
+  replace_all: z3.boolean().optional().describe("Replace every occurrence instead of requiring a unique match")
+});
+var editFileTool = {
+  name: "edit_file",
+  description: "Replace an exact string in a file. Fails if old_string is not found or matches multiple locations unless replace_all is set.",
+  permission: "write",
+  parameters: schema2,
+  async execute(args, ctx) {
+    const filePath = path7.resolve(ctx.cwd, args.path);
+    let content;
+    try {
+      content = await readFile2(filePath, "utf8");
+    } catch (err) {
+      return { content: `Failed to read ${args.path}: ${err.message}`, isError: true };
+    }
+    let count = 0;
+    let idx = content.indexOf(args.old_string);
+    while (idx !== -1) {
+      count += 1;
+      idx = content.indexOf(args.old_string, idx + args.old_string.length);
+    }
+    if (count === 0) {
+      return { content: `old_string not found in ${args.path}`, isError: true };
+    }
+    if (count > 1 && !args.replace_all) {
+      return {
+        content: `old_string matches ${count} locations in ${args.path}; provide more surrounding context or set replace_all`,
+        isError: true
+      };
+    }
+    const updated = args.replace_all ? content.split(args.old_string).join(args.new_string) : content.replace(args.old_string, args.new_string);
+    try {
+      await writeFile2(filePath, updated, "utf8");
+    } catch (err) {
+      return { content: `Failed to write ${args.path}: ${err.message}`, isError: true };
+    }
+    await pushSnapshot({
+      id: nextSnapshotId(),
+      path: filePath,
+      existed: true,
+      content,
+      toolName: "edit_file",
+      timestamp: Date.now(),
+      turn: currentTurnSeq(),
+      messageIndex: currentTurnMessageIndex()
+    });
+    return { content: `Edited ${args.path}: ${count} replacement${count > 1 ? "s" : ""}` };
+  }
+};
+
+// src/tools/fs/glob.ts
+import path9 from "path";
+import { z as z4 } from "zod";
+
+// src/tools/fs/util.ts
+import { readdir, stat } from "fs/promises";
+import path8 from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
+async function walkFiles(root, skipDirs = SKIP_DIRS) {
+  const out = [];
+  async function walk(dir, relBase) {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => null);
+    if (!entries) {
+      return;
+    }
+    for (const entry of entries) {
+      const abs = path8.join(dir, entry.name);
+      const rel = relBase ? `${relBase}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        if (!skipDirs.has(entry.name)) {
+          await walk(abs, rel);
+        }
+      } else if (entry.isFile()) {
+        try {
+          const st = await stat(abs);
+          out.push({ abs, rel, mtimeMs: st.mtimeMs });
+        } catch {
+        }
+      }
+    }
+  }
+  await walk(root, "");
+  return out;
+}
+var REGEX_SPECIALS = /[.+^${}()|[\]\\]/g;
+function globToRegExp(pattern) {
+  let re = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern.charAt(i);
+    if (c === "*") {
+      if (pattern.charAt(i + 1) === "*") {
+        i += 2;
+        if (pattern.charAt(i) === "/") {
+          i += 1;
+          re += "(?:[^/]+/)*";
+        } else {
+          re += ".*";
+        }
+      } else {
+        re += "[^/]*";
+        i += 1;
+      }
+    } else if (c === "?") {
+      re += "[^/]";
+      i += 1;
+    } else {
+      re += c.replace(REGEX_SPECIALS, "\\$&");
+      i += 1;
+    }
+  }
+  return new RegExp(`^${re}$`);
+}
+function matchesGlob(pattern, relPath) {
+  const normalized = pattern.replace(/\\/g, "/");
+  if (!normalized.includes("/")) {
+    const base = relPath.split("/").pop() ?? relPath;
+    return globToRegExp(normalized).test(base);
+  }
+  return globToRegExp(normalized).test(relPath);
+}
+function isSensitivePath2(filePath) {
+  const base = path8.basename(filePath);
+  if (base === ".env.example" || base === ".env.sample" || base === ".env.template") {
+    return false;
+  }
+  if (base === ".env" || base.startsWith(".env.")) {
+    return true;
+  }
+  if (base === "id_rsa" || base.endsWith(".pem")) {
+    return true;
+  }
+  return false;
+}
+
+// src/tools/fs/glob.ts
+var MAX_RESULTS = 100;
+var schema3 = z4.object({
+  pattern: z4.string().describe(
+    "Glob pattern, e.g. 'src/**/*.ts'. Supports **, * and ?. A bare pattern like '*.ts' matches basenames recursively."
+  ),
+  path: z4.string().optional().describe("Directory to search, defaults to the working directory")
+});
+var globTool = {
+  name: "glob",
+  description: "Find files by glob pattern. Skips node_modules, .git and dist. Returns paths sorted by modification time, newest first, up to 100 results.",
+  permission: "read",
+  parameters: schema3,
+  async execute(args, ctx) {
+    const root = path9.resolve(ctx.cwd, args.path ?? ".");
+    const files = await walkFiles(root);
+    const matched = files.filter((f) => matchesGlob(args.pattern, f.rel)).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, MAX_RESULTS);
+    if (matched.length === 0) {
+      return { content: `No files matched pattern: ${args.pattern}` };
+    }
+    return { content: matched.map((f) => f.rel).join("\n") };
+  }
+};
+
+// src/tools/fs/grep.ts
+import { readFile as readFile3, stat as stat2 } from "fs/promises";
+import path10 from "path";
+import { z as z5 } from "zod";
+var MAX_MATCHES = 250;
+var schema4 = z5.object({
+  pattern: z5.string().describe("Regular expression to search for"),
+  path: z5.string().optional().describe("File or directory to search, defaults to the working directory"),
+  glob: z5.string().optional().describe("Glob pattern to filter which files are searched, e.g. '*.ts'"),
+  ignoreCase: z5.boolean().optional().describe("Case-insensitive matching")
+});
+var grepTool = {
+  name: "grep",
+  description: "Search file contents with a regular expression. Outputs 'file:line:content', up to 250 matches. Skips binary files, node_modules and .git.",
+  permission: "read",
+  parameters: schema4,
+  async execute(args, ctx) {
+    let re;
+    try {
+      re = new RegExp(args.pattern, args.ignoreCase ? "i" : "");
+    } catch (err) {
+      return { content: `Invalid regular expression: ${err.message}`, isError: true };
+    }
+    const root = path10.resolve(ctx.cwd, args.path ?? ".");
+    let files;
+    try {
+      const st = await stat2(root);
+      if (st.isFile()) {
+        files = [{ abs: root, rel: path10.basename(root), mtimeMs: st.mtimeMs }];
+      } else {
+        files = await walkFiles(root);
+      }
+    } catch {
+      return { content: `Path not found: ${args.path ?? "."}`, isError: true };
+    }
+    if (args.glob) {
+      const glob = args.glob;
+      files = files.filter((f) => matchesGlob(glob, f.rel));
+    }
+    const out = [];
+    let truncated = false;
+    outer: for (const file of files) {
+      let buf;
+      try {
+        buf = await readFile3(file.abs);
+      } catch {
+        continue;
+      }
+      if (buf.includes(0)) {
+        continue;
+      }
+      const lines = buf.toString("utf8").split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        if (re.test(line)) {
+          out.push(`${file.rel}:${i + 1}:${line}`);
+          if (out.length >= MAX_MATCHES) {
+            truncated = true;
+            break outer;
+          }
+        }
+      }
+    }
+    if (out.length === 0) {
+      return { content: `No matches for pattern: ${args.pattern}` };
+    }
+    if (truncated) {
+      out.push(`... (truncated: more than ${MAX_MATCHES} matches)`);
+    }
+    return { content: out.join("\n") };
+  }
+};
+
+// src/tools/fs/read.ts
+import { readFile as readFile4, stat as stat3 } from "fs/promises";
+import path11 from "path";
+import { z as z6 } from "zod";
+var DEFAULT_LIMIT = 2e3;
+var MAX_CHARS = 100 * 1024;
+var schema5 = z6.object({
+  path: z6.string().describe("File path, absolute or relative to the working directory"),
+  offset: z6.number().int().positive().optional().describe("1-based line number to start reading from"),
+  limit: z6.number().int().positive().optional().describe("Maximum number of lines to read (default 2000)")
+});
+var readFileTool = {
+  name: "read_file",
+  description: "Read a text file and return its contents with line numbers. Output is truncated to 2000 lines or 100KB by default.",
+  permission: "read",
+  parameters: schema5,
+  async execute(args, ctx) {
+    const filePath = path11.resolve(ctx.cwd, args.path);
+    if (isSensitivePath2(filePath)) {
+      return { content: `Refused to read sensitive file: ${args.path}`, isError: true };
+    }
+    const st = await stat3(filePath).catch(() => null);
+    if (!st) {
+      return { content: `File not found: ${args.path}`, isError: true };
+    }
+    if (st.isDirectory()) {
+      return { content: `Path is a directory, not a file: ${args.path}`, isError: true };
+    }
+    const raw = await readFile4(filePath, "utf8");
+    const lines = raw.split("\n");
+    const start = args.offset ?? 1;
+    const limit = args.limit ?? DEFAULT_LIMIT;
+    const end = Math.min(lines.length, start - 1 + limit);
+    const out = [];
+    let size = 0;
+    let truncatedBySize = false;
+    for (let i = start - 1; i < end; i++) {
+      const line = lines[i];
+      if (line === void 0) {
+        break;
+      }
+      const numbered = `${i + 1}	${line}`;
+      if (size + numbered.length > MAX_CHARS) {
+        truncatedBySize = true;
+        break;
+      }
+      out.push(numbered);
+      size += numbered.length;
+    }
+    const lastShown = start - 1 + out.length;
+    if (truncatedBySize) {
+      out.push(
+        `... (truncated: output exceeds 100KB, showing lines ${start}-${lastShown} of ${lines.length})`
+      );
+    } else if (end < lines.length) {
+      out.push(`... (truncated: showing lines ${start}-${end} of ${lines.length})`);
+    }
+    return { content: out.join("\n") };
+  }
+};
+
+// src/tools/fs/write.ts
+import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
+import path12 from "path";
+import { z as z7 } from "zod";
+var schema6 = z7.object({
+  path: z7.string().describe("File path, absolute or relative to the working directory"),
+  content: z7.string().describe("Full content to write to the file")
+});
+var writeFileTool = {
+  name: "write_file",
+  description: "Write content to a file, creating parent directories as needed. Overwrites existing files.",
+  permission: "write",
+  parameters: schema6,
+  async execute(args, ctx) {
+    const filePath = path12.resolve(ctx.cwd, args.path);
+    const snapshot = await captureSnapshot(filePath, "write_file");
+    try {
+      await mkdir2(path12.dirname(filePath), { recursive: true });
+      await writeFile3(filePath, args.content, "utf8");
+    } catch (err) {
+      return { content: `Failed to write ${args.path}: ${err.message}`, isError: true };
+    }
+    await pushSnapshot(snapshot);
+    return { content: `Wrote ${Buffer.byteLength(args.content, "utf8")} bytes to ${args.path}` };
+  }
+};
+
+// src/tools/tasks.ts
+import { z as z8 } from "zod";
+
+// src/tasks/format.ts
+function formatDuration(startedAt, endedAt) {
+  const seconds = Math.max(0, Math.round(((endedAt ?? Date.now()) - startedAt) / 1e3));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m${seconds % 60}s`;
+  return `${Math.floor(minutes / 60)}h${minutes % 60}m`;
+}
+function formatStatus(task) {
+  const duration = formatDuration(task.startedAt, task.endedAt);
+  if (task.status === "running") return `running ${duration}`;
+  const exit = task.exitCode === null || task.exitCode === void 0 ? "" : `, exit ${task.exitCode}`;
+  return `${task.status}${exit} after ${duration}`;
+}
+function formatTaskLine(task) {
+  const label = task.description ? `${task.description} (${task.command})` : task.command;
+  return `${task.id} [${formatStatus(task)}] ${label}`;
+}
+function formatTaskList(tasks) {
+  if (tasks.length === 0) return "No background tasks.";
+  return `Background tasks:
+${tasks.map(formatTaskLine).join("\n")}`;
+}
+function formatTaskStarted(task) {
+  const label = task.description ? `${task.description} (${task.command})` : task.command;
+  return `Background task ${task.id} started: ${label}`;
+}
+function formatTaskFinished(task) {
+  const exit = task.exitCode === null || task.exitCode === void 0 ? "" : ` (exit ${task.exitCode})`;
+  switch (task.status) {
+    case "completed":
+      return `Background task ${task.id} finished${exit}: ${task.command}`;
+    case "failed":
+      return `Background task ${task.id} failed${exit}: ${task.command}`;
+    case "timed_out":
+      return `Background task ${task.id} timed out: ${task.command}`;
+    case "stopped":
+      return `Background task ${task.id} stopped: ${task.command}`;
+    default:
+      return `Background task ${task.id}: ${task.command}`;
+  }
+}
+
+// src/tools/tasks.ts
+var idSchema = z8.object({
+  id: z8.string().describe("Task id, e.g. task-1")
+});
+var taskListTool = {
+  name: "task_list",
+  description: "List background shell tasks with status, runtime, and exit code.",
+  permission: "read",
+  parameters: z8.object({}),
+  execute() {
+    return Promise.resolve({ content: formatTaskList(defaultTaskManager.list()) });
+  }
+};
+var taskOutputTool = {
+  name: "task_output",
+  description: "Read the current output of a background shell task (works while still running).",
+  permission: "read",
+  parameters: idSchema,
+  execute(args) {
+    const task = defaultTaskManager.get(args.id);
+    if (!task) {
+      return Promise.resolve({ content: `Unknown task: ${args.id}`, isError: true });
+    }
+    const body = task.output.replace(/\s+$/, "") || "(no output yet)";
+    return Promise.resolve({ content: `${formatTaskLine(task)}
+${body}` });
+  }
+};
+var taskKillTool = {
+  name: "task_kill",
+  description: "Stop a running background shell task (kills the whole process tree).",
+  permission: "exec",
+  parameters: idSchema,
+  execute(args) {
+    const task = defaultTaskManager.get(args.id);
+    if (!task) {
+      return Promise.resolve({ content: `Unknown task: ${args.id}`, isError: true });
+    }
+    if (task.status !== "running") {
+      return Promise.resolve({
+        content: `Task ${args.id} is not running (status: ${task.status}).`,
+        isError: true
+      });
+    }
+    defaultTaskManager.kill(args.id);
+    return Promise.resolve({ content: `Task ${args.id} stopped.` });
+  }
+};
+
+// src/tools/todo.ts
+import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import path13 from "path";
+import { z as z9 } from "zod";
+var todoItemSchema = z9.object({
+  id: z9.number().int(),
+  title: z9.string(),
+  status: z9.enum(["pending", "in_progress", "done"])
+});
+var writeSchema = z9.object({
+  todos: z9.array(todoItemSchema).describe("The full todo list, replacing the current one")
+});
+var readSchema = z9.object({});
+function fileFor(cwd) {
+  return path13.join(cwd, ".star", "todos.json");
+}
+var TodoStore = class {
+  items = /* @__PURE__ */ new Map();
+  list() {
+    return [...this.items.values()];
+  }
+  replace(items) {
+    this.items.clear();
+    for (const item of items) {
+      this.items.set(item.id, item);
+    }
+  }
+  async load(cwd) {
+    let raw;
+    try {
+      raw = await readFile5(fileFor(cwd), "utf8");
+    } catch {
+      return;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        this.replace(parsed.filter((it) => todoItemSchema.safeParse(it).success));
+      }
+    } catch {
+    }
+  }
+  async save(cwd) {
+    await mkdir3(path13.join(cwd, ".star"), { recursive: true });
+    await writeFile4(fileFor(cwd), `${JSON.stringify(this.list(), null, 2)}
+`);
+  }
+};
+var SYMBOLS = {
+  pending: "[ ]",
+  in_progress: "[~]",
+  done: "[x]"
+};
+function formatTodos(items) {
+  if (items.length === 0) {
+    return "No todos.";
+  }
+  const lines = items.map((it) => `${SYMBOLS[it.status]} ${it.id}. ${it.title}`);
+  const width = Math.max(...lines.map((l) => l.length));
+  return lines.map((line, i) => {
+    const status = items[i]?.status;
+    return status === "pending" ? line : `${line.padEnd(width + 4)}(${status})`;
+  }).join("\n");
+}
+var defaultStore = new TodoStore();
+function createTodoTools(store = defaultStore) {
+  const todoWrite = {
+    name: "todo_write",
+    description: "Replace the current todo list with the given items. Each item has an id, title, and status (pending, in_progress, done).",
+    permission: "read",
+    parameters: writeSchema,
+    async execute(args, ctx) {
+      const parsed = writeSchema.safeParse(args);
+      if (!parsed.success) {
+        return { content: `Invalid todos: ${parsed.error.message}`, isError: true };
+      }
+      await store.load(ctx.cwd);
+      store.replace(parsed.data.todos);
+      await store.save(ctx.cwd);
+      return { content: formatTodos(store.list()) };
+    }
+  };
+  const todoRead = {
+    name: "todo_read",
+    description: "Read the current todo list.",
+    permission: "read",
+    parameters: readSchema,
+    async execute(_args, ctx) {
+      await store.load(ctx.cwd);
+      return { content: formatTodos(store.list()) };
+    }
+  };
+  return [todoWrite, todoRead];
+}
+
+// src/tools/web/fetch.ts
+import { z as z10 } from "zod";
+var DEFAULT_MAX_CHARS = 2e4;
+var MAX_BYTES = 2 * 1024 * 1024;
+var TIMEOUT_MS = 3e4;
+var schema7 = z10.object({
+  url: z10.string().describe("The http(s) URL to fetch"),
+  maxChars: z10.number().int().positive().optional().describe("Maximum characters of text to return (default 20000)")
+});
+function decodeEntities(s) {
+  return s.replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n))).replace(/&#x([0-9a-fA-F]+);/gi, (_, n) => String.fromCodePoint(Number.parseInt(n, 16))).replace(/&(quot|lt|gt|nbsp);/g, (m) => {
+    switch (m) {
+      case "&quot;":
+        return '"';
+      case "&lt;":
+        return "<";
+      case "&gt;":
+        return ">";
+      case "&nbsp;":
+        return " ";
+      default:
+        return m;
+    }
+  }).replace(/&amp;/g, "&");
+}
+function htmlToText(html) {
+  const noBlocks = html.replace(/<(script|style|noscript|template)\b[^>]*>[\s\S]*?<\/\1>/gi, " ");
+  const withBreaks = noBlocks.replace(
+    /<br\s*\/?>|<\/(p|div|li|tr|h[1-6]|section|article|header|footer|blockquote|pre)>/gi,
+    "\n"
+  );
+  const stripped = decodeEntities(withBreaks.replace(/<[^>]+>/g, " "));
+  return stripped.split("\n").map((line) => line.replace(/\s+/g, " ").trim()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+async function readBody(res, maxChars) {
+  if (!res.body) {
+    return "";
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let bytes = 0;
+  let text = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      bytes += value.byteLength;
+      text += decoder.decode(value, { stream: true });
+      if (bytes >= MAX_BYTES || text.length >= maxChars * 2) {
+        break;
+      }
+    }
+    text += decoder.decode();
+  } finally {
+    reader.cancel().catch(() => {
+    });
+  }
+  return text;
+}
+function truncate2(s, maxChars) {
+  if (s.length <= maxChars) {
+    return s;
+  }
+  return `${s.slice(0, maxChars)}
+[truncated, showing first ${maxChars} of ${s.length} chars]`;
+}
+var webFetchTool = {
+  name: "web_fetch",
+  description: "Fetch a URL over http(s) and return its contents as readable text. HTML pages are converted to plain text (tags, scripts and styles removed). Output is truncated to maxChars (default 20000).",
+  permission: "read",
+  parameters: schema7,
+  async execute(args, ctx) {
+    let url;
+    try {
+      url = new URL(args.url);
+    } catch {
+      return { content: `ERROR: invalid URL: ${args.url}`, isError: true };
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      return {
+        content: `ERROR: only http(s) URLs are supported, got: ${url.protocol}`,
+        isError: true
+      };
+    }
+    const maxChars = args.maxChars ?? DEFAULT_MAX_CHARS;
+    const timeoutSignal = AbortSignal.timeout(TIMEOUT_MS);
+    const signal = ctx.abortSignal ? AbortSignal.any([timeoutSignal, ctx.abortSignal]) : timeoutSignal;
+    let res;
+    try {
+      res = await fetch(url, { signal, redirect: "follow" });
+    } catch (err) {
+      if (ctx.abortSignal?.aborted) {
+        return { content: "ERROR: request aborted", isError: true };
+      }
+      if (timeoutSignal.aborted) {
+        return { content: `ERROR: request timed out after ${TIMEOUT_MS / 1e3}s`, isError: true };
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `ERROR: failed to fetch ${args.url}: ${message}`, isError: true };
+    }
+    if (!res.ok) {
+      await res.body?.cancel().catch(() => {
+      });
+      return {
+        content: `ERROR: HTTP ${res.status} ${res.statusText} for ${args.url}`,
+        isError: true
+      };
+    }
+    const [rawType = ""] = (res.headers.get("content-type") ?? "text/plain").split(";");
+    const contentType = rawType.trim().toLowerCase();
+    const isHtml = contentType === "text/html" || contentType === "application/xhtml+xml";
+    const isText = contentType.startsWith("text/") || contentType === "application/json" || contentType === "application/xml" || contentType.endsWith("+json") || contentType.endsWith("+xml");
+    if (!isHtml && !isText) {
+      await res.body?.cancel().catch(() => {
+      });
+      return {
+        content: `ERROR: unsupported content type: ${contentType} (${args.url})`,
+        isError: true
+      };
+    }
+    let body;
+    try {
+      body = await readBody(res, maxChars);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `ERROR: failed to read response body: ${message}`, isError: true };
+    }
+    const text = isHtml ? htmlToText(body) : body;
+    return { content: truncate2(text, maxChars) };
+  }
+};
+
+// src/tools/web/search.ts
+import { z as z11 } from "zod";
+var TIMEOUT_MS2 = 15e3;
+var DEFAULT_MAX_RESULTS = 5;
+var MAX_RESULTS_LIMIT = 10;
+var SEARCH_URL = "https://html.duckduckgo.com/html/?q=";
+var USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
+var schema8 = z11.object({
+  query: z11.string().min(1).describe("The search query"),
+  maxResults: z11.number().int().min(1).max(MAX_RESULTS_LIMIT).optional().describe(
+    `Maximum number of results to return (default ${DEFAULT_MAX_RESULTS}, max ${MAX_RESULTS_LIMIT})`
+  )
+});
+function stripTags(s) {
+  return decodeEntities(s.replace(/<[^>]+>/g, " ")).replace(/\s+/g, " ").trim();
+}
+function normalizeUrl(href) {
+  const decoded = decodeEntities(href);
+  const uddg = decoded.match(/[?&]uddg=([^&]+)/);
+  if (uddg?.[1]) {
+    try {
+      return decodeURIComponent(uddg[1]);
+    } catch {
+      return decoded;
+    }
+  }
+  if (decoded.startsWith("//")) {
+    return `https:${decoded}`;
+  }
+  return decoded;
+}
+function parseResults(html) {
+  const results = [];
+  const anchorRe = /<a\b[^>]*\bclass\s*=\s*"[^"]*\bresult__a\b[^"]*"[^>]*>[\s\S]*?<\/a>/gi;
+  const anchors = [...html.matchAll(anchorRe)];
+  for (const [i, anchor] of anchors.entries()) {
+    const full = anchor[0];
+    const hrefMatch = full.match(/href\s*=\s*"([^"]*)"/i);
+    if (!hrefMatch?.[1]) {
+      continue;
+    }
+    const url = normalizeUrl(hrefMatch[1]);
+    const title = stripTags(full.replace(/^<a\b[^>]*>/i, "").replace(/<\/a>\s*$/i, ""));
+    const blockStart = (anchor.index ?? 0) + full.length;
+    const blockEnd = i + 1 < anchors.length ? anchors[i + 1]?.index ?? html.length : html.length;
+    const block = html.slice(blockStart, blockEnd);
+    const snippetMatch = block.match(
+      /<(?:a|div)\b[^>]*\bclass\s*=\s*"[^"]*\bresult__snippet\b[^"]*"[^>]*>([\s\S]*?)<\/(?:a|div)>/i
+    );
+    const snippet = snippetMatch?.[1] ? stripTags(snippetMatch[1]) : "";
+    if (title && url) {
+      results.push({ title, url, snippet });
+    }
+  }
+  return results;
+}
+var webSearchTool = {
+  name: "web_search",
+  description: "Search the web using DuckDuckGo and return a numbered list of results with title, URL and snippet. No API key required. Use web_fetch to read a result's full page.",
+  permission: "read",
+  parameters: schema8,
+  async execute(args, ctx) {
+    const maxResults = Math.min(args.maxResults ?? DEFAULT_MAX_RESULTS, MAX_RESULTS_LIMIT);
+    const url = `${SEARCH_URL}${encodeURIComponent(args.query)}`;
+    const timeoutSignal = AbortSignal.timeout(TIMEOUT_MS2);
+    const signal = ctx.abortSignal ? AbortSignal.any([timeoutSignal, ctx.abortSignal]) : timeoutSignal;
+    let res;
+    try {
+      res = await fetch(url, {
+        signal,
+        redirect: "follow",
+        headers: { "user-agent": USER_AGENT, accept: "text/html" }
+      });
+    } catch (err) {
+      if (ctx.abortSignal?.aborted) {
+        return { content: "ERROR: request aborted", isError: true };
+      }
+      const name = err instanceof Error ? err.name : "";
+      if (timeoutSignal.aborted || name === "TimeoutError") {
+        return { content: `ERROR: search timed out after ${TIMEOUT_MS2 / 1e3}s`, isError: true };
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `ERROR: search request failed: ${message}`, isError: true };
+    }
+    if (!res.ok) {
+      await res.body?.cancel().catch(() => {
+      });
+      return {
+        content: `ERROR: HTTP ${res.status} ${res.statusText} from DuckDuckGo`,
+        isError: true
+      };
+    }
+    let html;
+    try {
+      html = await res.text();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `ERROR: failed to read search response: ${message}`, isError: true };
+    }
+    const results = parseResults(html).slice(0, maxResults);
+    if (results.length === 0) {
+      return {
+        content: `ERROR: no results found for "${args.query}" (the response may have been blocked or the page layout changed)`,
+        isError: true
+      };
+    }
+    const lines = results.map(
+      (r, i) => `${i + 1}. ${r.title}
+   ${r.url}${r.snippet ? `
+   ${r.snippet}` : ""}`
+    );
+    return { content: lines.join("\n") };
+  }
+};
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  constructor() {
+    for (const tool of [
+      readFileTool,
+      writeFileTool,
+      editFileTool,
+      globTool,
+      grepTool,
+      bashTool,
+      webFetchTool,
+      webSearchTool,
+      taskListTool,
+      taskOutputTool,
+      taskKillTool,
+      ...createTodoTools()
+    ]) {
+      this.register(tool);
+    }
+  }
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  list() {
+    return [...this.tools.values()];
+  }
+  names() {
+    return [...this.tools.keys()];
+  }
+};
+
+// src/tools/index.ts
+function createDefaultRegistry() {
+  const registry = new ToolRegistry();
+  for (const tool of createTodoTools()) {
+    registry.register(tool);
+  }
+  return registry;
+}
+
+// src/agent/subagent.ts
+var MAX_SUBAGENT_DEPTH = 1;
+var MAX_REPORT_CHARS = 2e4;
+var SUBAGENT_PROMPT = "You are a subagent spawned to handle a focused subtask on behalf of the main agent. Work autonomously with the tools available to you, then finish with a concise report of what you found or did. Your final text is returned to the main agent as the tool result \u2014 make it self-contained.";
+function createSubagentTool(deps) {
+  return {
+    name: "subagent",
+    description: "Spawn a subagent with its own agent loop to handle a focused subtask (research, exploration, or an isolated change). The subagent has the same tools but cannot spawn further subagents. Returns the subagent's final report. Prefer this for self-contained work that would otherwise clutter the main conversation.",
+    permission: "exec",
+    parameters: z12.object({
+      prompt: z12.string().describe("Complete, self-contained instructions for the subagent."),
+      description: z12.string().optional().describe("Short label for the subtask, shown in the result header.")
+    }),
+    async execute(args, ctx) {
+      const { AgentLoop: AgentLoop2 } = await import("./loop-R3RQCNFT.js");
+      const child = new AgentLoop2({
+        model: deps.model,
+        registry: createDefaultRegistry(),
+        config: deps.config,
+        cwd: ctx.cwd,
+        system: deps.system ? `${deps.system}
+
+${SUBAGENT_PROMPT}` : SUBAGENT_PROMPT,
+        subagentDepth: deps.depth + 1
+      });
+      const confirmHandler = deps.getConfirmHandler?.();
+      if (confirmHandler) child.confirmHandler = confirmHandler;
+      const signal = ctx.abortSignal ?? new AbortController().signal;
+      let toolCalls = 0;
+      let error = null;
+      try {
+        for await (const event of child.stream(args.prompt, signal)) {
+          if (event.type === "tool-result") {
+            toolCalls++;
+          } else if (event.type === "error") {
+            error = event.error.message;
+            break;
+          }
+        }
+      } catch (e) {
+        error = e instanceof Error ? e.message : String(e);
+      }
+      let report = "";
+      const messages = child.getMessages();
+      for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message?.role !== "assistant" || !Array.isArray(message.content)) continue;
+        const text = message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+        if (text) {
+          report = text;
+          break;
+        }
+      }
+      if (report.length > MAX_REPORT_CHARS) {
+        report = `${report.slice(0, MAX_REPORT_CHARS)}
+... (truncated)`;
+      }
+      const label = args.description ? ` "${args.description}"` : "";
+      const stats = `[subagent${label}: ${toolCalls} tool call(s)]`;
+      if (error) {
+        return {
+          content: [`Subagent failed: ${error}`, stats, report].filter(Boolean).join("\n"),
+          isError: true
+        };
+      }
+      return { content: `${stats}
+${report || "(subagent produced no text output)"}` };
+    }
+  };
+}
+
+// src/agent/loop.ts
+var PLAN_MODE_PROMPT = "\n\nYou are currently in PLAN MODE. Research the task using only the read-only tools available to you, then present a concrete, step-by-step implementation plan as your final answer. You must not modify files, run shell commands, or otherwise change the system \u2014 write/exec tools are unavailable in this mode. Do not ask the user to run commands for you; note manual steps in the plan instead. The user will review your plan and approve it before any execution begins.";
+var AgentLoop = class {
+  messages = [];
+  opts;
+  // Seq + user-message index of each turn started via stream(); lets /undo
+  // match a retracted turn to the file snapshots it produced. Cleared when
+  // history is replaced wholesale (resume/compact), because indices no longer
+  // line up — in that case /undo only retracts messages, never wrong files.
+  turnMarkers = [];
+  titleScheduled = false;
+  confirmHandler;
+  // Hook failures never block the turn (except an explicit PreToolUse block);
+  // their stderr surfaces through this callback (REPL system message / stderr
+  // in print mode).
+  onHookWarning;
+  constructor(opts) {
+    this.opts = opts;
+    if (opts.system) {
+      this.messages.push({ role: "system", content: opts.system });
+    }
+    if (opts.sessionStore) {
+      this.bindSnapshotHooks(opts.sessionStore);
+    }
+    opts.registry?.register(createSkillTool({ cwd: opts.cwd }));
+    const depth = opts.subagentDepth ?? 0;
+    if (opts.registry && depth < MAX_SUBAGENT_DEPTH) {
+      opts.registry.register(
+        createSubagentTool({
+          model: opts.model,
+          config: opts.config,
+          cwd: opts.cwd,
+          system: opts.system,
+          depth,
+          getConfirmHandler: () => this.confirmHandler
+        })
+      );
+    }
+  }
+  getMessages() {
+    return this.messages;
+  }
+  // Swaps the persistence target (/new starts a fresh session mid-REPL).
+  // Title generation is re-armed so the new session gets one after its first
+  // turn, and snapshot checkpoints now flow to the new store.
+  setSessionStore(store) {
+    this.opts.sessionStore = store;
+    this.titleScheduled = false;
+    if (store) this.bindSnapshotHooks(store);
+  }
+  bindSnapshotHooks(store) {
+    setSnapshotHooks({
+      onPush: (snapshot) => store.appendCheckpoint(
+        {
+          id: snapshot.id,
+          timestamp: snapshot.timestamp,
+          path: snapshot.path,
+          existed: snapshot.existed,
+          toolName: snapshot.toolName,
+          turn: snapshot.turn,
+          messageIndex: snapshot.messageIndex
+        },
+        snapshot.content
+      ),
+      onRemove: (ids) => store.removeCheckpoints(ids)
+    });
+  }
+  async loadMessages(messages) {
+    this.messages = reconcileToolCalls(messages);
+    this.turnMarkers = [];
+  }
+  // Drops the final user message and everything after it, and persists the
+  // trimmed history so a later /resume does not bring the turn back.
+  // `turn` is the retracted turn's snapshot seq when it could be verified
+  // against the marker recorded at turn start — undefined means the caller
+  // must not revert any file snapshots.
+  async retractLastTurn() {
+    const result = retractLastTurn([...this.messages]);
+    if (result.removed === 0) return { removed: 0 };
+    const userIndex = result.messages.length;
+    this.messages = result.messages;
+    await this.opts.sessionStore?.replaceMessages([...this.messages]);
+    const last = this.turnMarkers[this.turnMarkers.length - 1];
+    let turn;
+    if (last && last.userIndex === userIndex) {
+      turn = last.seq;
+      this.turnMarkers.pop();
+    }
+    return { removed: result.removed, turn };
+  }
+  // Cut point for a rewind: messages[index] should be the user message that
+  // started the rewound turn, but compaction may have shifted indices, so
+  // walk back to the nearest user message. Never touches a leading system
+  // message.
+  retractionCut(index) {
+    const clamped = Math.max(0, Math.min(index, this.messages.length - 1));
+    for (let i = clamped; i >= 0; i--) {
+      if (this.messages[i]?.role === "user") return i;
+    }
+    return this.messages[0]?.role === "system" ? 1 : 0;
+  }
+  countRetraction(index) {
+    return this.messages.length - this.retractionCut(index);
+  }
+  // Truncates the history back to the given message index (the user message
+  // at that index and everything after it is dropped) and persists the
+  // trimmed history, so /rewind stays consistent across resume.
+  async retractFromIndex(index) {
+    const cut = this.retractionCut(index);
+    const removed = this.messages.length - cut;
+    if (removed === 0) return 0;
+    this.messages = this.messages.slice(0, cut);
+    await this.opts.sessionStore?.replaceMessages([...this.messages]);
+    this.turnMarkers = this.turnMarkers.filter((m) => m.userIndex < cut);
+    return removed;
+  }
+  async appendContextMessage(text, role = "user") {
+    const message = { role, content: text };
+    this.messages.push(message);
+    await this.persist(message);
+  }
+  async persist(message) {
+    await this.opts.sessionStore?.append(message);
+  }
+  // After the first assistant reply, kick off background title generation
+  // for the session. Runs once per loop; the store-level title check makes
+  // resumed sessions that already have a title a no-op.
+  maybeScheduleTitle(input) {
+    if (this.titleScheduled) return;
+    const store = this.opts.sessionStore;
+    if (!store) return;
+    this.titleScheduled = true;
+    scheduleSessionTitle(store, input, this.opts.model);
+  }
+  async *stream(input, signal, opts) {
+    this.syncSystemMessage();
+    const text = typeof input === "string" ? input : input.text;
+    const images = typeof input === "string" ? [] : input.images;
+    const userMessage = images.length > 0 ? {
+      role: "user",
+      content: [
+        ...images.map((img) => ({
+          type: "image",
+          image: img.data,
+          mimeType: img.mimeType
+        })),
+        { type: "text", text }
+      ]
+    } : { role: "user", content: text };
+    this.messages.push(userMessage);
+    const seq = (this.opts.subagentDepth ?? 0) === 0 ? beginTurn(this.messages.length - 1) : currentTurnSeq();
+    this.turnMarkers.push({ seq, userIndex: this.messages.length - 1 });
+    await this.persist(
+      opts?.persistAs !== void 0 ? { role: "user", content: opts.persistAs } : userMessage
+    );
+    const { config, registry, cwd } = this.opts;
+    const aiTools = this.buildAiTools();
+    for (let step = 0; step < config.maxSteps; step++) {
+      const maxTokens = this.opts.contextMaxTokens ?? config.contextMaxTokens;
+      const compacted = compactMessages([...this.messages], maxTokens);
+      if (compacted.compacted) {
+        this.messages = await this.applyCompactionSummary(compacted);
+      }
+      let text2 = "";
+      const toolCalls = [];
+      let failed = false;
+      try {
+        for await (const event of this.streamOnce(aiTools, signal)) {
+          if (event.type === "text-delta") {
+            text2 += event.text;
+            yield event;
+          } else if (event.type === "reasoning") {
+            yield event;
+          } else if (event.type === "tool-call") {
+            toolCalls.push({ id: event.id, name: event.name, args: event.args });
+            yield event;
+          } else if (event.type === "error") {
+            failed = true;
+            yield event;
+          } else {
+            yield event;
+          }
+        }
+      } catch (error) {
+        if (signal.aborted) return;
+        yield { type: "error", error: error instanceof Error ? error : new Error(String(error)) };
+        return;
+      }
+      if (failed) return;
+      const assistantMessage = {
+        role: "assistant",
+        content: [
+          ...text2 ? [{ type: "text", text: text2 }] : [],
+          ...toolCalls.map((call) => ({
+            type: "tool-call",
+            toolCallId: call.id,
+            toolName: call.name,
+            args: call.args
+          }))
+        ]
+      };
+      this.messages.push(assistantMessage);
+      await this.persist(assistantMessage);
+      this.maybeScheduleTitle(text2);
+      if (toolCalls.length === 0) {
+        await this.runEventHooks("Stop");
+        return;
+      }
+      const answered = /* @__PURE__ */ new Set();
+      try {
+        for (const call of toolCalls) {
+          if (signal.aborted) break;
+          const result = await this.executeTool(call, signal);
+          const toolMessage = {
+            role: "tool",
+            content: [
+              {
+                type: "tool-result",
+                toolCallId: call.id,
+                toolName: call.name,
+                result: result.content
+              }
+            ]
+          };
+          this.messages.push(toolMessage);
+          await this.persist(toolMessage);
+          answered.add(call.id);
+          yield {
+            type: "tool-result",
+            id: call.id,
+            name: call.name,
+            content: result.content,
+            isError: result.isError
+          };
+        }
+      } finally {
+        for (const call of toolCalls) {
+          if (answered.has(call.id)) continue;
+          const content = signal.aborted ? "Tool execution interrupted by user." : "Tool execution interrupted before a result was produced.";
+          const synthetic = {
+            role: "tool",
+            content: [
+              {
+                type: "tool-result",
+                toolCallId: call.id,
+                toolName: call.name,
+                result: content
+              }
+            ]
+          };
+          this.messages.push(synthetic);
+          await this.persist(synthetic).catch(() => {
+          });
+          yield { type: "tool-result", id: call.id, name: call.name, content, isError: true };
+        }
+      }
+      if (signal.aborted) return;
+    }
+    yield {
+      type: "error",
+      error: new Error(`Max steps (${config.maxSteps}) reached, stopping.`)
+    };
+  }
+  // The permission mode can change at runtime, so the system message is
+  // recomputed at the start of every turn instead of being frozen by the
+  // constructor. Also restores a system message after loadMessages() (resume,
+  // /model switch) replaced the history with one that has none. Git context
+  // (branch, dirty count, recent commits) is refreshed here too, so the model
+  // always sees the current repo state; any git failure is silently skipped.
+  // Project memory (AGENTS.md in the cwd) is appended as a delimited block;
+  // readProjectMemory caches by mtime, so this stays cheap per turn. The
+  // skills listing is refreshed here as well, so skills added mid-session
+  // show up in the next turn's system prompt.
+  syncSystemMessage() {
+    const base = this.opts.system;
+    const plan = this.opts.config.permissionMode === "plan";
+    const parts = [];
+    if (base) parts.push(base);
+    if (plan) parts.push(PLAN_MODE_PROMPT.trim());
+    const memory = readProjectMemory(this.opts.cwd);
+    if (memory) parts.push(memory);
+    const skills = discoverSkills(this.opts.cwd);
+    if (skills.length > 0) parts.push(formatSkillsBlock(skills));
+    const git = getGitSummary(this.opts.cwd);
+    if (git) parts.push(formatGitSummary(git));
+    if (parts.length === 0) return;
+    const content = parts.join("\n\n");
+    const head = this.messages[0];
+    if (head?.role === "system" && typeof head.content === "string") {
+      if (head.content !== content) head.content = content;
+    } else if (head?.role !== "system") {
+      this.messages.unshift({ role: "system", content });
+    }
+  }
+  async applyCompactionSummary(compacted) {
+    const { config, model } = this.opts;
+    if (config.contextCompaction !== "summary" || !model) {
+      return compacted.messages;
+    }
+    const headCount = compacted.messages[0]?.role === "system" ? 1 : 0;
+    const dropped = this.messages.slice(headCount, headCount + compacted.droppedCount);
+    try {
+      const summary = await summarizeMessages(dropped, model);
+      const messages = compacted.messages.slice();
+      messages[headCount] = {
+        role: "user",
+        content: `[earlier conversation summarized]
+${summary}`
+      };
+      return messages;
+    } catch {
+      return compacted.messages;
+    }
+  }
+  async *streamOnce(aiTools, signal) {
+    const { streamChat } = await import("./stream-Y55NRF2S.js");
+    yield* streamChat({
+      model: this.opts.model,
+      messages: this.messages,
+      tools: aiTools,
+      abortSignal: signal,
+      idleTimeoutMs: this.opts.config.streamIdleTimeoutSec * 1e3
+    });
+  }
+  buildAiTools() {
+    const plan = this.opts.config.permissionMode === "plan";
+    const tools = {};
+    for (const t of this.opts.registry.list()) {
+      if (plan && t.permission !== "read") continue;
+      tools[t.name] = aiTool({
+        description: t.description,
+        parameters: t.parameters
+      });
+    }
+    return tools;
+  }
+  async runEventHooks(event, toolName, toolInput) {
+    const empty = { blocked: false, warnings: [] };
+    if (this.opts.config.hooks.length === 0) return empty;
+    try {
+      const result = await runHooks(event, this.opts.config.hooks, {
+        cwd: this.opts.cwd,
+        sessionId: this.opts.sessionStore?.id,
+        toolName,
+        toolInput
+      });
+      for (const warning of result.warnings) this.onHookWarning?.(warning);
+      return result;
+    } catch {
+      return empty;
+    }
+  }
+  async executeTool(call, signal) {
+    const { registry, config, cwd } = this.opts;
+    const tool = registry.get(call.name);
+    if (!tool) {
+      return { content: `Unknown tool: ${call.name}`, isError: true };
+    }
+    const decision = checkPermission(
+      config.permissionMode,
+      { toolName: call.name, args: call.args, level: tool.permission },
+      { cwd },
+      config.permissions.allow
+    );
+    if (decision === "deny") {
+      return { content: `Permission denied for tool "${call.name}".`, isError: true };
+    }
+    if (decision === "ask") {
+      let approved = false;
+      try {
+        approved = this.confirmHandler ? await this.confirmHandler({
+          toolName: call.name,
+          args: call.args,
+          level: tool.permission
+        }) : false;
+      } catch {
+        approved = false;
+      }
+      if (!approved) {
+        return { content: `User rejected tool "${call.name}".`, isError: true };
+      }
+    }
+    const parsed = tool.parameters.safeParse(call.args);
+    if (!parsed.success) {
+      return { content: `Invalid arguments: ${parsed.error.message}`, isError: true };
+    }
+    const pre = await this.runEventHooks("PreToolUse", call.name, call.args);
+    if (pre.blocked) {
+      return {
+        content: `Tool "${call.name}" blocked by a PreToolUse hook: ${pre.reason}`,
+        isError: true
+      };
+    }
+    let result;
+    try {
+      result = await tool.execute(parsed.data, { cwd, abortSignal: signal });
+    } catch (error) {
+      if (signal.aborted) {
+        return { content: "Tool execution aborted.", isError: true };
+      }
+      return {
+        content: `Tool error: ${error instanceof Error ? error.message : String(error)}`,
+        isError: true
+      };
+    }
+    if (!result.isError) {
+      await this.runEventHooks("PostToolUse", call.name, call.args);
+    }
+    return result;
+  }
+};
+
+export {
+  estimateTokens,
+  summarizeMessages,
+  compactMessages,
+  WORKING_DIFF_MAX_LINES,
+  isGitRepo,
+  getGitSummary,
+  collectCommitContext,
+  buildCommitPrompt,
+  collectWorkingDiff,
+  reconcileToolCalls,
+  isAllowedByRules,
+  buildAllowRule,
+  isDangerousCommand,
+  listSnapshots,
+  clearSnapshots,
+  hydrateSnapshots,
+  undoTurnSnapshots,
+  rewindToSnapshot,
+  starHome,
+  globalConfigPath,
+  sessionsDir,
+  projectConfigPath,
+  discoverSkills,
+  defaultTaskManager,
+  resolveShell,
+  bashTool,
+  SKIP_DIRS,
+  isSensitivePath2 as isSensitivePath,
+  formatTaskList,
+  formatTaskStarted,
+  formatTaskFinished,
+  TodoStore,
+  formatTodos,
+  createDefaultRegistry,
+  PLAN_MODE_PROMPT,
+  AgentLoop
+};
+//# sourceMappingURL=chunk-MJ2O7NWI.js.map