@swifty.js/swifty 0.0.27 → 0.0.28

package/dist/lib/chunk-RKJYTYQM.js

@@ -1,1285 +0,0 @@
-import {
-  AutoCompactTrackingState,
-  forceCompact,
-  getSessionFilePath,
-  manageContext,
-  saveMessage,
-  toolResultsToRecords,
-  toolUsesToRecords
-} from "./chunk-2QILP24G.js";
-import {
-  ContextTooLongError,
-  REJECTED_TOOL_RESULT,
-  RateLimitError
-} from "./chunk-OO2CLOEE.js";
-import {
-  asErrorString,
-  asRecord,
-  createChildLogger,
-  isObject,
-  strArg
-} from "./chunk-EY7HE52Q.js";
-
-// src/compact/recovery.ts
-var RECOVERY_FILE_LIMIT = 5;
-var RECOVERY_TOKENS_PER_FILE = 5e3;
-var RECOVERY_SKILLS_BUDGET = 25e3;
-var RECOVERY_TOKENS_PER_SKILL = 5e3;
-var RECOVERY_CHARS_PER_TOKEN = 3.5;
-function approxTokens(s) {
-  if (!s) {
-    return 0;
-  }
-  return Math.floor(s.length / RECOVERY_CHARS_PER_TOKEN);
-}
-function truncateByTokens(s, tokenBudget) {
-  if (tokenBudget <= 0 || !s) {
-    return s;
-  }
-  if (approxTokens(s) <= tokenBudget) {
-    return s;
-  }
-  const maxChars = Math.floor(tokenBudget * RECOVERY_CHARS_PER_TOKEN);
-  if (maxChars <= 0 || maxChars >= s.length) {
-    return s;
-  }
-  const suffix = "\n\u2026 (content truncated)";
-  if (maxChars <= suffix.length) {
-    return suffix.slice(0, maxChars);
-  }
-  return s.slice(0, maxChars - suffix.length) + suffix;
-}
-var RecoveryState = class {
-  files = /* @__PURE__ */ new Map();
-  skills = /* @__PURE__ */ new Map();
-  recordFileRead(path, content) {
-    this.files.delete(path);
-    this.files.set(path, {
-      path,
-      content: truncateByTokens(content, RECOVERY_TOKENS_PER_FILE),
-      timestamp: Date.now()
-    });
-    while (this.files.size > RECOVERY_FILE_LIMIT) {
-      const oldestPath = this.files.keys().next().value;
-      if (typeof oldestPath !== "string") {
-        break;
-      }
-      this.files.delete(oldestPath);
-    }
-  }
-  recordSkillInvocation(name, body) {
-    this.skills.set(name, { name, body, timestamp: Date.now() });
-  }
-  snapshotFiles(limit = RECOVERY_FILE_LIMIT) {
-    const sorted = [...this.files.values()].sort((a, b) => b.timestamp - a.timestamp);
-    return sorted.slice(0, limit);
-  }
-  snapshotSkills() {
-    return [...this.skills.values()].sort((a, b) => b.timestamp - a.timestamp);
-  }
-  buildRecoveryAttachment(toolSchemaNames) {
-    const sections = [];
-    const recentFiles = this.snapshotFiles();
-    if (recentFiles.length > 0) {
-      sections.push("## Recently read files\n");
-      sections.push(
-        "These snapshots are what the file-reading tool last returned. Re-open with the tool if you need the current bytes.\n"
-      );
-      for (const f of recentFiles) {
-        const content = truncateByTokens(f.content, RECOVERY_TOKENS_PER_FILE);
-        const ts = new Date(f.timestamp).toISOString().replace(/\.\d{3}Z$/, "Z");
-        sections.push(
-          `### ${f.path}  (read ${ts})
-
-\`\`\`
-${content}${content.endsWith("\n") ? "" : "\n"}\`\`\``
-        );
-      }
-    }
-    const skills = this.snapshotSkills();
-    if (skills.length > 0) {
-      let used = 0;
-      const skillParts = [];
-      skillParts.push("## Active skills\n");
-      skillParts.push(
-        "These skills were invoked earlier in the session. Continue to follow each SOP when its triggering condition applies.\n"
-      );
-      let emitted = false;
-      for (const sk of skills) {
-        const body = truncateByTokens(sk.body, RECOVERY_TOKENS_PER_SKILL);
-        const tokens = approxTokens(body) + approxTokens(sk.name) + 8;
-        if (used + tokens > RECOVERY_SKILLS_BUDGET) {
-          break;
-        }
-        used += tokens;
-        skillParts.push(`### ${sk.name}
-
-${body}`);
-        emitted = true;
-      }
-      if (emitted) {
-        sections.push(skillParts.join("\n\n"));
-      }
-    }
-    if (toolSchemaNames.length > 0) {
-      sections.push(
-        "## Available tools\n\nYou still have access to the following tools \u2014 call them directly when the task needs one:\n\n" + toolSchemaNames.map((n) => `- ${n}`).join("\n")
-      );
-    }
-    if (sections.length === 0) {
-      return "";
-    }
-    sections.push(
-      "## Note\n\nEverything above the divider is reconstructed context. For exact code, error strings, or user-typed text, re-read the source rather than guess from the summary."
-    );
-    return sections.join("\n\n");
-  }
-};
-
-// src/plan-file/plan-file.ts
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-import { join, resolve } from "path";
-var log = createChildLogger({ module: "plan-file" });
-var ADJECTIVES = [
-  "brave",
-  "calm",
-  "dark",
-  "eager",
-  "fair",
-  "gentle",
-  "happy",
-  "kind",
-  "lively",
-  "mighty",
-  "noble",
-  "proud",
-  "quiet",
-  "swift",
-  "warm",
-  "wise"
-];
-var NOUNS = [
-  "crystal",
-  "dragon",
-  "eagle",
-  "falcon",
-  "flame",
-  "forest",
-  "frost",
-  "mountain",
-  "ocean",
-  "phoenix",
-  "river",
-  "shadow",
-  "thunder",
-  "tiger"
-];
-function generateSlug() {
-  const adj = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
-  const noun = NOUNS[Math.floor(Math.random() * NOUNS.length)];
-  const ts = Date.now().toString(36).slice(-4);
-  return `${adj}-${noun}-${ts}`;
-}
-var currentPlanPath = null;
-function isPlanUnderWorkDir(planPath, workDir) {
-  const plansDir = resolve(workDir, ".swifty", "plans");
-  const resolved = resolve(planPath);
-  return resolved.startsWith(plansDir + "/");
-}
-function getOrCreatePlanPath(workDir) {
-  if (currentPlanPath && existsSync(currentPlanPath)) {
-    if (!isPlanUnderWorkDir(currentPlanPath, workDir)) {
-      log.warn({ planPath: currentPlanPath, workDir }, "current plan path is not under work dir");
-    } else {
-      return currentPlanPath;
-    }
-  }
-  const dir = join(workDir, ".swifty", "plans");
-  mkdirSync(dir, { recursive: true });
-  const slug = generateSlug();
-  currentPlanPath = join(dir, `${slug}.md`);
-  writeFileSync(currentPlanPath, "", "utf-8");
-  return currentPlanPath;
-}
-function savePlan(workDir, content) {
-  const path = getOrCreatePlanPath(workDir);
-  writeFileSync(path, content, "utf-8");
-}
-function loadPlan() {
-  if (!currentPlanPath || !existsSync(currentPlanPath)) {
-    return null;
-  }
-  return readFileSync(currentPlanPath, "utf-8");
-}
-function planExists(workDir) {
-  if (!currentPlanPath || !existsSync(currentPlanPath)) {
-    return false;
-  }
-  if (!isPlanUnderWorkDir(currentPlanPath, workDir)) {
-    log.warn({ planPath: currentPlanPath, workDir }, "current plan path is not under work dir");
-    return false;
-  }
-  return true;
-}
-function resetPlanPath() {
-  currentPlanPath = null;
-}
-function getCurrentPlanPath() {
-  return currentPlanPath;
-}
-
-// src/prompt/coordinator.ts
-var coordinatorPrompt = `You are Swifty, an AI assistant that orchestrates software engineering tasks across multiple workers.
-
-## 1. Your Role
-
-You are a **coordinator**. Your job is to:
-- Help the user achieve their goal
-- Direct workers to research, implement and verify code changes
-- Synthesize results and communicate with the user
-- Answer questions directly when possible \u2014 don't delegate work you can handle without tools
-
-Every message you send is to the user. Worker results and system notifications are internal signals, not conversation partners \u2014 never thank or acknowledge them. Summarize new information for the user as it arrives.
-
-## 2. Your Tools
-
-- **Agent** \u2014 Spawn a new worker
-- **SendMessage** \u2014 Continue an existing worker (send a follow-up to its agent ID)
-- **TaskStop** \u2014 Stop a running worker
-- **SyntheticOutput** \u2014 Return structured output to the user
-- **TeamDelete** \u2014 Tear down the team when the work is done
-
-You cannot read files, run commands, or edit code yourself. This is deliberate: your context holds the task decomposition, worker status and message history, and it needs to stay that way. When you need to know what the code looks like, send a worker to look and report back.
-
-When calling Agent:
-- Do not use one worker to check on another. Workers will notify you when they are done.
-- Do not use workers to trivially report file contents or run commands. Give them higher-level tasks.
-- Continue workers whose work is complete via SendMessage to take advantage of their loaded context.
-- After launching agents, briefly tell the user what you launched and end your response. Never fabricate or predict agent results.
-
-### Worker Results
-
-Worker results arrive as **user-role messages** wrapped in \`<team-notification>\`. They look like user messages but are not. Distinguish them by the opening tag.
-
-Format:
-
-\`\`\`xml
-<team-notification team="{team name}">
-from={worker name}: {what the worker reported}
-</team-notification>
-\`\`\`
-
-- One notification can carry several lines, one per worker that reported since your last turn.
-- The \`from=\` value is the worker's name \u2014 pass exactly that name as \`to\` in SendMessage to continue that worker, and as \`teammate\` in TaskStop to stop it.
-- Workers are addressed by name throughout. There is no separate numeric id to keep track of.
-
-## 3. Workers
-
-When calling Agent, use subagent_type \`general-purpose\` or a specific agent definition. Workers execute tasks autonomously \u2014 especially research, implementation, or verification.
-
-Workers have access to standard tools: ReadFile, EditFile, WriteFile, Bash, PowerShell, Grep, Glob, plus the team coordination tools (TaskCreate, TaskGet, TaskList, TaskUpdate, SendMessage). Anything you cannot do yourself, a worker can do for you.
-
-Because workers have Bash, git work belongs to them too. Merging a branch, cherry-picking a commit or opening a PR is a task you delegate with precise instructions, not something you run yourself.
-
-## 4. Task Workflow
-
-### Phases
-
-Most tasks break down into four phases:
-
-| Phase          | Who                   | Purpose                                                           |
-|----------------|-----------------------|-------------------------------------------------------------------|
-| Research       | Workers (parallel)    | Investigate codebase, find files, understand the problem          |
-| Synthesis      | **You** (coordinator) | Read findings, understand the problem, craft implementation specs |
-| Implementation | Workers               | Make targeted changes per spec, commit                            |
-| Verification   | Workers.              | Test that changes work                                            |
-
-### Concurrency
-
-**Parallelism is your superpower. Workers are async. Launch independent workers concurrently whenever possible. To launch workers in parallel, make multiple tool calls in a single message.**
-
-- **Read-only tasks** (research) \u2014 run in parallel freely
-- **Write-heavy tasks** (implementation) \u2014 one at a time per set of files
-- **Verification** can sometimes run alongside implementation on different file areas
-
-### Verification MUST be a separate worker
-
-**Never let the implementation worker verify its own work.** Spawn a fresh worker after implementation completes. The implementation worker is anchored on its own approach and will rubber-stamp its own code; a fresh verifier sees the code with no assumptions.
-
-Real verification means running tests with the feature enabled, investigating typecheck errors instead of dismissing them as unrelated, and proving the change works rather than confirming it exists.
-
-### Handling Worker Failures
-
-When a worker reports failure, continue that same worker with SendMessage \u2014 it has the full error context. If a correction attempt fails, try a different approach or report to the user.
-
-### Stopping Workers
-
-Use TaskStop on a worker you sent in the wrong direction, for example when the user changes requirements after you launched it. Stopped workers can be continued later with SendMessage.
-
-## 5. Writing Worker Prompts
-
-**Workers can't see your conversation.** Every prompt must be self-contained.
-
-### Always synthesize \u2014 your most important job
-
-When workers report research findings, you must understand them before directing follow-up work. Read the findings, identify the approach, then write a prompt that proves you understood it by naming specific file paths, line numbers, and exactly what to change.
-
-Never write "based on your findings" or "based on the research". These phrases hand your understanding off to a worker, which is the one thing you must not delegate.
-
-\`\`\`
-// Anti-pattern \u2014 lazy delegation
-Agent(prompt="Based on your findings, fix the auth bug")
-
-// Good \u2014 synthesized spec
-Agent(prompt="Fix the null pointer in src/auth/validate.ts:42. The user field on Session is undefined when the session expires but the token is still cached. Add a null check before accessing user.id \u2014 if null, return 401 with 'Session expired'. Commit and report the hash.")
-\`\`\`
-
-### Add a purpose statement
-
-Include a brief purpose so workers can calibrate depth and emphasis:
-- "This research will inform a PR description \u2014 focus on user-facing changes."
-- "I need this to plan an implementation \u2014 report file paths, line numbers, and type signatures."
-- "This is a quick check before we merge \u2014 just verify the happy path."
-
-### Choose continue vs. spawn by context overlap
-
-| Situation                                             | Mechanism                  | Why                                          |
-|-------------------------------------------------------|----------------------------|----------------------------------------------|
-| Research explored exactly the files that need editing | **Continue** (SendMessage) | Worker already has the files in context      |
-| Research was broad but implementation is narrow       | **Spawn fresh** (Agent)    | Avoid dragging along exploration noise       |
-| Correcting a failure or extending recent work         | **Continue**               | Worker has the error context                 |
-| Verifying code a different worker just wrote          | **Spawn fresh**            | Verifier should see the code with fresh eyes |
-| First attempt used the wrong approach entirely        | **Spawn fresh**            | Wrong-approach context pollutes the retry    |
-
-### Prompt tips
-
-- Include file paths, line numbers and error messages \u2014 workers start fresh and need complete context
-- State what "done" looks like
-- For implementation: "Run relevant tests, then commit and report the hash"
-- For research: "Report findings \u2014 do not modify files"
-- Be precise about git operations: name the branch, the commit hash, draft vs ready
-- For verification: "Prove the code works, don't just confirm it exists"
-
-## 6. Example Session
-
-User: "There's a null pointer in the auth module. Can you fix it?"
-
-You:
-  Let me investigate first.
-
-  Agent({ description: "Investigate auth bug", subagent_type: "general-purpose", prompt: "Investigate the auth module in src/auth/. Find where null pointer errors could occur around session handling and token validation. Report specific file paths, line numbers, and types involved. Do not modify files." })
-  Agent({ description: "Research auth tests", subagent_type: "general-purpose", prompt: "Find all test files related to src/auth/. Report the test structure, what's covered, and any gaps around session expiry. Do not modify files." })
-
-  Investigating from two angles \u2014 I'll report back with findings.
-
-User:
-  <team-notification team="auth-fix">
-  from=investigator: Found null pointer in src/auth/validate.ts:42. The user field on Session is undefined when the session expires but the token is still cached.
-  </team-notification>
-
-You:
-  Found the bug \u2014 null pointer in validate.ts:42.
-
-  SendMessage({ to: "investigator", message: "Fix the null pointer in src/auth/validate.ts:42. Add a null check before accessing user.id \u2014 if null, return 401. Commit and report the hash." })
-
-  Fix is in progress.`;
-var coordinatorSparseReminder = `Coordinator mode still active (see full instructions earlier in conversation). You cannot read files, run commands, or edit code \u2014 send a worker instead. Tools: Agent, SendMessage, TaskStop, SyntheticOutput, TeamDelete. Address workers by the name in the from= field of a team-notification. Synthesize worker findings yourself before directing follow-up work.`;
-var REMINDER_INTERVAL = 5;
-function coordinatorReminder(iteration = 1) {
-  if (iteration <= 1 || (iteration - 1) % REMINDER_INTERVAL === 0) {
-    return coordinatorPrompt;
-  }
-  return coordinatorSparseReminder;
-}
-
-// src/prompt/plan-mode.ts
-var planModeFullReminder = `Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits (with the exception of the plan file mentioned below), run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supersedes any other instructions you have received.
-
-## Plan File Info:
-
-%PLAN_FILE_INFO%
-You should build your plan incrementally by writing to or editing this file. NOTE that this is the only file you are allowed to edit - other than this you are only allowed to take READ-ONLY actions.
-
-## Plan Workflow
-
-### Phase 1: Initial Understanding
-
-Goal: Gain a comprehensive understanding of the user's request by reading through code and asking them questions. Critical: In this phase you should use the Agent tool with subagent_type="explore".
-
-1. Focus on understanding the user's request and the code associated with their request. Actively search for existing functions, utilities, and patterns that can be reused \u2014 avoid proposing new code when suitable implementations already exist.
-
-2. **Call the Agent tool with subagent_type="explore" to explore the codebase.** You can launch up to 3 explore agents IN PARALLEL by making multiple Agent tool calls in a single response.
-
-### Phase 2: Design
-
-Goal: Design an implementation approach.
-
-Call the Agent tool with subagent_type="plan" to design the implementation based on the user's intent and your exploration results from Phase 1.
-
-### Phase 3: Review
-
-Goal: Review the plan(s) from Phase 2 and ensure alignment with the user's intentions.
-
-1. Read the critical files identified by agents to deepen your understanding
-2. Ensure that the plans align with the user's original request
-3. Use AskUserQuestion to clarify any remaining questions with the user.
-
-### Phase 4: Final Plan
-
-Goal: Write your final plan to the plan file (the only file you can edit).
-
-- Begin with a **Context** section
-- Include only your recommended approach
-- Include the paths of critical files to be modified
-- Include a verification section
-
-### Phase 5: Call ExitPlanMode
-
-At the very end of your turn, once you have asked the user questions and are happy with your final plan file - you should always call ExitPlanMode.
-`;
-var planModeSparseReminder = `Plan mode still active (see full instructions earlier in conversation). Read-only except plan file (%PLAN_PATH%). Follow 5-phase workflow. End turns with AskUserQuestion (for clarifications) or ExitPlanMode (for plan approval). Never ask about plan approval via text or AskUserQuestion.`;
-var planModeExitTemplate = `## Exited Plan Mode
-
-You have exited plan mode. You can now make edits, run tools, and take actions.%EXTRA%`;
-var planModeReentryTemplate = `You have re-entered plan mode. Your previous plan file is at %PLAN_PATH%. Review it and continue from where you left off. You can update, refine, or restart the plan as needed. Follow the same 5-phase workflow as before.`;
-var reminderInterval = 5;
-function buildPlanModeReminder(planPath, planExist, iteration) {
-  let planFileInfo = `Plan file: ${planPath}`;
-  if (planExist) {
-    planFileInfo += `
-A plan file already exists at ${planPath}. You can read it and make incremental edits using the EditFile tool.`;
-  } else {
-    planFileInfo += `
-No plan file exists yet. You should create your plan at ${planPath} using the WriteFile tool.`;
-  }
-  if ((iteration - 1) % reminderInterval === 0) {
-    return planModeFullReminder.replace("%PLAN_FILE_INFO%", planFileInfo);
-  }
-  return planModeSparseReminder.replace("%PLAN_PATH%", planPath);
-}
-function buildPlanModeExitReminder(planPath, planExists2) {
-  let extra = "";
-  if (planExists2) {
-    extra = ` The plan file is located at ${planPath} if you need to reference it.`;
-  }
-  return planModeExitTemplate.replace("%EXTRA%", extra);
-}
-function buildPlanModeReentryReminder(planPath, planFileExists) {
-  if (!planFileExists) {
-    return "";
-  }
-  return planModeReentryTemplate.replace("%PLAN_PATH%", planPath);
-}
-
-// src/tool-result/budget.ts
-import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2, resolve as resolve2 } from "path";
-var log2 = createChildLogger({ module: "tool-result" });
-var MESSAGE_AGGREGATE_LIMIT = 2e5;
-var TOOL_RESULT_PREVIEW_CHARS = 2e3;
-function spillDir(workDir, sessionId) {
-  const id = sessionId || "default";
-  return join2(workDir, ".swifty", "sessions", id, "tool-results");
-}
-function writeSpill(workDir, sessionId, toolUseId, content) {
-  const dir = spillDir(workDir, sessionId);
-  mkdirSync2(dir, { recursive: true });
-  const path = join2(dir, toolUseId + ".txt");
-  try {
-    writeFileSync2(path, content, { encoding: "utf-8", flag: "wx" });
-  } catch (err) {
-    log2.error({ err }, "tool-result operation failed");
-    if (isObject(err) && "code" in err && err.code !== "EEXIST") {
-      throw err;
-    }
-  }
-  return path;
-}
-function toDisplayPreview(content) {
-  if (content.length <= TOOL_RESULT_PREVIEW_CHARS) {
-    return content;
-  }
-  return content.slice(0, TOOL_RESULT_PREVIEW_CHARS) + `
-\u2026 ${String(content.length - TOOL_RESULT_PREVIEW_CHARS)} chars omitted from transcript`;
-}
-function replaceToolResultContent(result, content) {
-  result.content = content;
-  if (result.contentBlocks?.length) {
-    result.contentBlocks = [
-      { type: "text", text: content },
-      ...result.contentBlocks.filter((block) => block.type !== "text")
-    ];
-  }
-}
-function buildSpillPreview(content, spillPath) {
-  const sizeKB = Math.floor(content.length / 1024);
-  const preview = content.slice(0, TOOL_RESULT_PREVIEW_CHARS);
-  const hasMore = content.length > TOOL_RESULT_PREVIEW_CHARS;
-  let msg = `<persisted-output>
-`;
-  msg += `Output too large (${String(sizeKB)}KB). Full content saved to:
-${spillPath}
-
-`;
-  msg += `Preview (first 2KB):
-${preview}`;
-  if (hasMore) {
-    msg += "\n...";
-  }
-  msg += "\n</persisted-output>";
-  return msg;
-}
-function isSpillReadback(toolName, args, workDir, sessionId) {
-  if (toolName !== "ReadFile" || !args) {
-    return false;
-  }
-  const raw = args.file_path;
-  if (typeof raw !== "string" || !raw) {
-    return false;
-  }
-  return resolve2(raw).startsWith(resolve2(spillDir(workDir, sessionId)));
-}
-function applyBudget(toolResults, workDir, sessionId, exemptIds) {
-  let total = toolResults.reduce((sum, result) => sum + result.content.length, 0);
-  if (total <= MESSAGE_AGGREGATE_LIMIT) {
-    return;
-  }
-  const sorted = toolResults.toSorted((a, b) => b.content.length - a.content.length);
-  for (const r of sorted) {
-    if (total <= MESSAGE_AGGREGATE_LIMIT) {
-      break;
-    }
-    if (exemptIds?.has(r.toolUseId)) {
-      continue;
-    }
-    const content = r.content;
-    if (content.length <= TOOL_RESULT_PREVIEW_CHARS) {
-      continue;
-    }
-    let spillPath;
-    try {
-      spillPath = writeSpill(workDir, sessionId, r.toolUseId, content);
-    } catch {
-      continue;
-    }
-    const replacement = buildSpillPreview(content, spillPath);
-    total -= content.length - replacement.length;
-    replaceToolResultContent(r, replacement);
-  }
-}
-function persistLargeResult(workDir, sessionId, toolUseId, content) {
-  let path;
-  try {
-    path = writeSpill(workDir, sessionId, toolUseId, content);
-  } catch {
-    return content;
-  }
-  return buildSpillPreview(content, path);
-}
-
-// src/agent/streaming-executor.ts
-var log3 = createChildLogger({ module: "agent" });
-var StreamingExecutor = class {
-  pending = [];
-  registry;
-  ctx;
-  constructor(registry, ctx) {
-    this.registry = registry;
-    this.ctx = ctx;
-  }
-  submit(toolId, toolName, args) {
-    this.pending.push({ toolId, toolName, arguments: args });
-  }
-  async collectResults() {
-    const calls = [...this.pending];
-    this.pending = [];
-    const promises = calls.map(async (call) => {
-      const tool = this.registry.get(call.toolName);
-      const start = Date.now();
-      if (!tool) {
-        return {
-          toolId: call.toolId,
-          toolName: call.toolName,
-          result: {
-            output: `Error: unknown tool '${call.toolName}'`,
-            isError: true
-          },
-          elapsed: 0
-        };
-      }
-      try {
-        const result = await tool.execute(this.ctx, call.arguments);
-        return {
-          toolId: call.toolId,
-          toolName: call.toolName,
-          result,
-          elapsed: (Date.now() - start) / 1e3
-        };
-      } catch (err) {
-        log3.error({ err }, "agent operation failed");
-        return {
-          toolId: call.toolId,
-          toolName: call.toolName,
-          result: {
-            output: `Error executing ${call.toolName}: ${asErrorString(err)}`,
-            isError: true
-          },
-          elapsed: (Date.now() - start) / 1e3
-        };
-      }
-    });
-    return Promise.all(promises);
-  }
-  hasPending() {
-    return this.pending.length > 0;
-  }
-};
-
-// src/agent/agent.ts
-var MAX_TOKENS_CEILING = 64e3;
-var MAX_OUTPUT_TOKENS_RECOVERIES = 3;
-var MAX_OUTPUT_CHARS = 5e4;
-var DEFERRED_REMINDER_MARKER = "The following deferred tools are available via ToolSearch.";
-var Agent = class {
-  // Deferred tool names announced to the model last time, in lexicographic order.
-  // Compared against the current pool to skip re-injection when nothing changed.
-  announcedDeferred = [];
-  client;
-  registry;
-  checker;
-  conversation;
-  workDir;
-  sessionId;
-  sessionFilePath;
-  hookEngine;
-  fileHistory;
-  fileStateCache;
-  abortSignal;
-  contextWindow;
-  maxOutput;
-  recoveryState;
-  maxIterations;
-  notificationFn;
-  onLoopComplete;
-  compactTracking = new AutoCompactTrackingState();
-  onPermissionRequest;
-  toolFilter;
-  coordinatorActiveFn;
-  activeSkills;
-  instructions;
-  memoryContent;
-  skillSection;
-  skillDeltaFn;
-  memoryRecallPromise;
-  memoryRecallConsumed = false;
-  /** Whether the prefetch has settled, and its result. The main loop checks this flag without awaiting. */
-  memoryRecallSettled = false;
-  memoryRecallValue;
-  onMemoriesSurfaced;
-  constructor(config) {
-    this.client = config.client;
-    this.registry = config.registry;
-    this.checker = config.checker;
-    this.conversation = config.conversation;
-    this.workDir = config.workDir;
-    this.sessionId = config.sessionId ?? "";
-    this.sessionFilePath = config.sessionId ? getSessionFilePath(config.workDir, config.sessionId) : "";
-    this.hookEngine = config.hookEngine;
-    this.fileHistory = config.fileHistory;
-    this.fileStateCache = config.fileStateCache;
-    this.abortSignal = config.abortSignal;
-    this.contextWindow = config.contextWindow ?? 2e5;
-    this.maxOutput = config.maxOutput ?? 8192;
-    this.recoveryState = config.recoveryState ?? new RecoveryState();
-    this.maxIterations = config.maxIterations ?? 0;
-    this.notificationFn = config.notificationFn;
-    this.onLoopComplete = config.onLoopComplete;
-    this.onPermissionRequest = config.onPermissionRequest;
-    this.activeSkills = config.activeSkills ?? /* @__PURE__ */ new Map();
-    this.toolFilter = config.toolFilter;
-    this.coordinatorActiveFn = config.coordinatorActiveFn;
-    this.instructions = config.instructions ?? "";
-    this.memoryContent = config.memoryContent ?? "";
-    this.skillSection = config.skillSection ?? "";
-    this.skillDeltaFn = config.skillDeltaFn;
-    this.memoryRecallPromise = config.memoryRecallPromise;
-    this.onMemoriesSurfaced = config.onMemoriesSurfaced;
-    void this.memoryRecallPromise?.then(
-      (r) => {
-        this.memoryRecallValue = r;
-        this.memoryRecallSettled = true;
-      },
-      () => {
-        this.memoryRecallSettled = true;
-      }
-    );
-  }
-  async *run() {
-    let toolSchemas = this.registry.getAllSchemas();
-    if (this.toolFilter) {
-      toolSchemas = toolSchemas.filter((s) => this.toolFilter?.(s.name));
-    }
-    const toolSchemaNames = this.registry.listTools().map((t) => t.name);
-    let maxTokensEscalated = false;
-    let outputRecoveries = 0;
-    let iteration = 0;
-    await this.fireLifecycle("session_start");
-    try {
-      let looping = true;
-      while (looping) {
-        iteration++;
-        if (this.maxIterations > 0 && iteration > this.maxIterations) {
-          yield {
-            type: "error",
-            error: new Error(`Agent reached maximum iterations (${String(this.maxIterations)})`)
-          };
-          return;
-        }
-        let fullText = "";
-        const thinkingBlocks = [];
-        const toolUses = [];
-        let stopReason = "end_turn";
-        let lastUsage = null;
-        if (this.checker.mode === "plan") {
-          const planPath = getOrCreatePlanPath(this.workDir);
-          this.checker.planFilePath = planPath;
-          this.conversation.addSystemReminder(
-            buildPlanModeReminder(planPath, planExists(this.workDir), iteration)
-          );
-        }
-        if (this.coordinatorActiveFn?.()) {
-          this.conversation.addSystemReminder(coordinatorReminder(iteration));
-        }
-        const deferredNames = this.registry.getDeferredToolNames();
-        if (deferredNames.length > 0) {
-          const poolChanged = deferredNames.length !== this.announcedDeferred.length || deferredNames.some((n, i) => n !== this.announcedDeferred[i]);
-          if (poolChanged || !this.conversation.hasReminderContaining(DEFERRED_REMINDER_MARKER)) {
-            let reminder = DEFERRED_REMINDER_MARKER + ' Their schemas are NOT loaded - use ToolSearch with query "select:<name>[,<name>...]" to load tool schemas';
-            reminder += this.registry.mcpLoadingMode === "dispatch" ? ", then invoke them with the mcp_call tool" : " before calling them";
-            this.conversation.addSystemReminder(reminder + ":\n" + deferredNames.join("\n"));
-            this.announcedDeferred = deferredNames;
-          }
-        }
-        if (this.hookEngine) {
-          for (const note of this.hookEngine.drainNotifications()) {
-            this.conversation.addSystemReminder(note);
-          }
-        }
-        if (this.notificationFn) {
-          for (const note of this.notificationFn()) {
-            this.conversation.addSystemReminder(note);
-          }
-        }
-        if (this.skillDeltaFn) {
-          const delta = this.skillDeltaFn();
-          if (delta) {
-            this.conversation.addSystemReminder("The following skills became available:\n" + delta);
-          }
-        }
-        await this.fireLifecycle("turn_start");
-        await this.fireLifecycle("pre_send");
-        const mc = await manageContext(
-          this.conversation,
-          this.client,
-          this.contextWindow,
-          this.maxOutput,
-          this.compactTracking,
-          this.recoveryState,
-          toolSchemaNames,
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          toolSchemas,
-          this.sessionFilePath
-        );
-        if (mc.message) {
-          yield { type: "compact", message: mc.message, boundary: mc.boundary };
-        }
-        if (mc.compacted) {
-          this.conversation.injectLongTermMemory(
-            this.instructions,
-            this.memoryContent,
-            this.skillSection
-          );
-        }
-        try {
-          const stream = this.client.stream(
-            this.conversation,
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            toolSchemas,
-            this.abortSignal
-          );
-          for await (const event of stream) {
-            if (this.abortSignal?.aborted) {
-              looping = false;
-              break;
-            }
-            switch (event.type) {
-              case "text_delta":
-                fullText += event.text;
-                yield { type: "stream_text", text: event.text };
-                break;
-              case "thinking_delta":
-                yield { type: "thinking_text", text: event.text };
-                break;
-              case "thinking_complete":
-                thinkingBlocks.push({
-                  thinking: event.thinking,
-                  signature: event.signature
-                });
-                yield {
-                  type: "thinking_complete",
-                  thinking: event.thinking,
-                  signature: event.signature
-                };
-                break;
-              case "tool_call_start":
-                break;
-              case "tool_call_complete":
-                toolUses.push({
-                  toolUseId: event.toolId,
-                  toolName: event.toolName,
-                  arguments: event.arguments
-                });
-                yield {
-                  type: "tool_use",
-                  toolName: event.toolName,
-                  toolId: event.toolId,
-                  args: event.arguments
-                };
-                break;
-              case "stream_end":
-                stopReason = event.stopReason;
-                lastUsage = event.usage;
-                yield { type: "usage", usage: event.usage };
-                break;
-            }
-          }
-        } catch (err) {
-          if (this.abortSignal?.aborted) {
-            yield { type: "loop_complete", stopReason: "interrupted" };
-            return;
-          }
-          if (err instanceof ContextTooLongError) {
-            try {
-              const result = await forceCompact(
-                this.conversation,
-                this.client,
-                this.recoveryState,
-                toolSchemaNames,
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                toolSchemas,
-                this.sessionFilePath
-              );
-              this.conversation.clearUsageAnchor();
-              this.conversation.injectLongTermMemory(
-                this.instructions,
-                this.memoryContent,
-                this.skillSection
-              );
-              yield {
-                type: "compact",
-                message: "Auto-compacted due to context length: " + result.message,
-                boundary: result.boundary
-              };
-              continue;
-            } catch {
-              yield { type: "error", error: err };
-              return;
-            }
-          }
-          if (err instanceof RateLimitError) {
-            const waitMs = parseRetryAfter(strArg(asRecord(err), "retryAfter"));
-            yield { type: "retry", reason: "rate limited", delay: waitMs };
-            if (await this.interruptibleSleep(waitMs)) {
-              yield { type: "loop_complete", stopReason: "interrupted" };
-              return;
-            }
-            continue;
-          }
-          yield {
-            type: "error",
-            error: err instanceof Error ? err : new Error(JSON.stringify(err))
-          };
-          return;
-        }
-        if (this.abortSignal?.aborted) {
-          if (fullText) {
-            this.conversation.addAssistantFull(fullText, thinkingBlocks, []);
-            this.persistLastMessage();
-          }
-          yield { type: "loop_complete", stopReason: "interrupted" };
-          return;
-        }
-        await this.fireLifecycle("post_receive", fullText);
-        if (stopReason === "max_tokens") {
-          if (!maxTokensEscalated) {
-            this.client.setMaxOutputTokens?.(MAX_TOKENS_CEILING);
-            maxTokensEscalated = true;
-            if (fullText) {
-              this.conversation.addAssistantFull(fullText, thinkingBlocks, []);
-              this.persistLastMessage();
-              if (lastUsage) {
-                this.conversation.recordUsageAnchor(
-                  lastUsage.inputTokens,
-                  lastUsage.outputTokens,
-                  lastUsage.cacheReadInputTokens,
-                  lastUsage.cacheCreationInputTokens
-                );
-              }
-              this.conversation.addUserMessage(
-                "Output token limit hit. Resume directly from where you stopped. Do not apologize or repeat previous content. Pick up mid-thought if needed."
-              );
-            }
-            yield { type: "retry", reason: "max_tokens escalation", delay: 0 };
-            continue;
-          } else if (outputRecoveries < MAX_OUTPUT_TOKENS_RECOVERIES) {
-            outputRecoveries++;
-            this.conversation.addAssistantFull(fullText, thinkingBlocks, []);
-            this.persistLastMessage();
-            if (lastUsage) {
-              this.conversation.recordUsageAnchor(
-                lastUsage.inputTokens,
-                lastUsage.outputTokens,
-                lastUsage.cacheReadInputTokens,
-                lastUsage.cacheCreationInputTokens
-              );
-            }
-            this.conversation.addUserMessage(
-              "Output token limit hit. Resume directly from where you stopped. Break remaining work into smaller pieces."
-            );
-            yield {
-              type: "retry",
-              reason: `max_tokens recovery ${String(outputRecoveries)}/${String(MAX_OUTPUT_TOKENS_RECOVERIES)}`,
-              delay: 0
-            };
-            continue;
-          }
-        } else {
-          outputRecoveries = 0;
-        }
-        this.conversation.addAssistantFull(fullText, thinkingBlocks, toolUses);
-        this.persistLastMessage();
-        if (lastUsage) {
-          this.conversation.recordUsageAnchor(
-            lastUsage.inputTokens,
-            lastUsage.outputTokens,
-            lastUsage.cacheReadInputTokens,
-            lastUsage.cacheCreationInputTokens
-          );
-        }
-        if (toolUses.length > 0) {
-          const results = await this.executeTools(toolUses);
-          for (const r of results) {
-            yield r;
-          }
-          const exemptIds = /* @__PURE__ */ new Set();
-          for (const tu of toolUses) {
-            if (isSpillReadback(tu.toolName, tu.arguments, this.workDir, this.sessionId)) {
-              exemptIds.add(tu.toolUseId);
-            }
-          }
-          const toolResults = [];
-          for (const r of results) {
-            if (r.type === "tool_result") {
-              const toolResult = {
-                toolUseId: r.toolId,
-                content: r.output,
-                ...r.contentBlocks?.length ? { contentBlocks: r.contentBlocks } : {},
-                isError: r.isError
-              };
-              if (toolResult.content.length > MAX_OUTPUT_CHARS && !exemptIds.has(r.toolId)) {
-                const replacement = persistLargeResult(
-                  this.workDir,
-                  this.sessionId,
-                  r.toolId,
-                  toolResult.content
-                );
-                if (replacement !== toolResult.content) {
-                  replaceToolResultContent(toolResult, replacement);
-                }
-                exemptIds.add(r.toolId);
-              }
-              toolResults.push(toolResult);
-            }
-          }
-          applyBudget(toolResults, this.workDir, this.sessionId, exemptIds);
-          const exitPlanSucceeded = toolUses.some((tu) => {
-            if (tu.toolName !== "ExitPlanMode") {
-              return false;
-            }
-            const result = results.find(
-              (r) => r.type === "tool_result" && r.toolId === tu.toolUseId
-            );
-            return result?.type === "tool_result" && !result.isError;
-          });
-          this.conversation.addToolResultsMessage(toolResults);
-          this.persistLastMessage();
-          if (this.abortSignal?.aborted) {
-            yield { type: "turn_complete" };
-            yield { type: "loop_complete", stopReason: "interrupted" };
-            return;
-          }
-          if (this.memoryRecallPromise && !this.memoryRecallConsumed && this.memoryRecallSettled) {
-            const recall = this.memoryRecallValue;
-            if (recall?.reminder) {
-              this.conversation.addSystemReminder(recall.reminder);
-              this.onMemoriesSurfaced?.(recall.paths);
-            }
-            this.memoryRecallConsumed = true;
-          }
-          if (exitPlanSucceeded) {
-            yield { type: "turn_complete" };
-            yield { type: "loop_complete", stopReason: "end_turn" };
-            return;
-          }
-          yield { type: "turn_complete" };
-          await this.fireLifecycle("turn_end");
-        } else {
-          looping = false;
-          if (this.fileHistory) {
-            const summary = fullText.length > 60 ? fullText.slice(0, 60) + "..." : fullText;
-            this.fileHistory.makeSnapshot(this.conversation.len(), summary);
-          }
-          yield { type: "loop_complete", stopReason };
-          if (this.onLoopComplete) {
-            try {
-              this.onLoopComplete(this.conversation);
-            } catch {
-            }
-          }
-        }
-      }
-    } finally {
-      await this.fireLifecycle("session_end");
-    }
-  }
-  // Fire a lifecycle hook event and queue any non-empty hook output as a
-  // notification to be surfaced on the next turn. No-op without a HookEngine.
-  async fireLifecycle(event, message) {
-    if (!this.hookEngine) {
-      return;
-    }
-    const results = await this.hookEngine.fire(event, { event, message });
-    for (const r of results) {
-      if (r.output) {
-        this.hookEngine.recordNotification(r.output);
-      }
-    }
-  }
-  // Sleep for ms, resolving early with `true` if the abort signal fires during
-  // the wait (ctx-aware). Resolves `false` on timeout.
-  interruptibleSleep(ms) {
-    return new Promise((resolve3) => {
-      if (this.abortSignal?.aborted) {
-        resolve3(true);
-        return;
-      }
-      const onAbort = () => {
-        clearTimeout(timer);
-        resolve3(true);
-      };
-      const timer = setTimeout(() => {
-        this.abortSignal?.removeEventListener("abort", onAbort);
-        resolve3(false);
-      }, ms);
-      this.abortSignal?.addEventListener("abort", onAbort, { once: true });
-    });
-  }
-  async executeTools(toolUses) {
-    const events = [];
-    const batches = this.partitionToolCalls(toolUses);
-    for (const batch of batches) {
-      const batchEvents = await this.executeBatch(
-        batch.blocks,
-        batch.concurrent && batch.blocks.length > 1
-      );
-      events.push(...batchEvents);
-    }
-    return events;
-  }
-  partitionToolCalls(toolUses) {
-    const batches = [];
-    for (const tu of toolUses) {
-      const tool = this.registry.get(tu.toolName);
-      const safe = tool ? tool.isConcurrencySafe?.(tu.arguments ?? {}) ?? tool.category === "read" : false;
-      if (safe && batches.length > 0 && batches[batches.length - 1].concurrent) {
-        batches[batches.length - 1].blocks.push(tu);
-      } else {
-        batches.push({ concurrent: safe, blocks: [tu] });
-      }
-    }
-    return batches;
-  }
-  // executeBatch runs a set of tool calls through permission checks, hooks,
-  // and the streaming executor. When parallel is true all calls run
-  // concurrently; otherwise they run one at a time.
-  async executeBatch(toolUses, parallel) {
-    const events = [];
-    const executor = new StreamingExecutor(this.registry, {
-      workDir: this.workDir,
-      abortSignal: this.abortSignal,
-      fileHistory: this.fileHistory,
-      fileStateCache: this.fileStateCache
-    });
-    for (const tu of toolUses) {
-      if (this.abortSignal?.aborted) {
-        events.push({
-          type: "tool_result",
-          toolName: tu.toolName,
-          toolId: tu.toolUseId,
-          output: "Error: command interrupted",
-          isError: true,
-          elapsed: 0
-        });
-        continue;
-      }
-      if (this.hookEngine) {
-        const hookResult = await this.hookEngine.firePreToolHooks(tu.toolName, tu.arguments);
-        if (hookResult.rejected) {
-          events.push({
-            type: "tool_result",
-            toolName: tu.toolName,
-            toolId: tu.toolUseId,
-            output: `Rejected by hook: ${hookResult.reason}`,
-            isError: true,
-            elapsed: 0
-          });
-          continue;
-        }
-      }
-      const tool = this.registry.get(tu.toolName);
-      const category = tool?.category ?? "command";
-      const decision = this.checker.check(tu.toolName, category, tu.arguments);
-      if (decision.effect === "deny") {
-        events.push({
-          type: "tool_result",
-          toolName: tu.toolName,
-          toolId: tu.toolUseId,
-          output: `Permission denied: ${decision.reason}. This operation has been blocked by the security policy. Inform the user that the command was denied; do not describe what the command would do.`,
-          isError: true,
-          elapsed: 0
-        });
-        continue;
-      }
-      if (decision.effect === "ask" && this.onPermissionRequest) {
-        const response = await this.onPermissionRequest(tu.toolName, tu.arguments, decision);
-        if (response === "deny") {
-          events.push({
-            type: "tool_result",
-            toolName: tu.toolName,
-            toolId: tu.toolUseId,
-            output: REJECTED_TOOL_RESULT,
-            isError: true,
-            elapsed: 0
-          });
-          continue;
-        }
-        if (response === "allowAlways") {
-          this.checker.allowAlways(tu.toolName, tu.arguments);
-        }
-      }
-      executor.submit(tu.toolUseId, tu.toolName, tu.arguments);
-      if (!parallel) {
-        const batchResults = await executor.collectResults();
-        for (const r of batchResults) {
-          await this.processToolResult(r, toolUses, events);
-        }
-      }
-    }
-    if (parallel) {
-      const batchResults = await executor.collectResults();
-      for (const r of batchResults) {
-        await this.processToolResult(r, toolUses, events);
-      }
-    }
-    return events;
-  }
-  // processToolResult handles a single executor result: records file-read
-  // snapshots, emits the tool_result event, and fires post-tool hooks.
-  async processToolResult(r, toolUses, events) {
-    if (!r.result.isError && r.toolName === "ReadFile" && !r.result.contentBlocks?.length) {
-      const tu = toolUses.find((t) => t.toolUseId === r.toolId);
-      const p = strArg(tu?.arguments ?? {}, "file_path");
-      if (p) {
-        this.recoveryState.recordFileRead(p, r.result.output);
-      }
-    }
-    events.push({
-      type: "tool_result",
-      toolName: r.toolName,
-      toolId: r.toolId,
-      output: r.result.output,
-      ...r.result.contentBlocks?.length ? { contentBlocks: r.result.contentBlocks } : {},
-      isError: r.result.isError,
-      elapsed: r.elapsed
-    });
-    if (this.hookEngine) {
-      const hookResults = await this.hookEngine.fire("post_tool_use", {
-        event: "post_tool_use",
-        toolName: r.toolName,
-        message: r.result.output
-      });
-      for (const hr of hookResults) {
-        if (hr.output) {
-          this.hookEngine.recordNotification(hr.output);
-        }
-      }
-    }
-  }
-  /**
-   * Persist the most recently appended conversation message to the session log.
-   *
-   * Persistence lives in the main loop rather than in individual frontends: both
-   * the TUI and Web share the same recording path, ensuring intermediate assistant
-   * text and complete tool-call chains are captured for session restoration.
-   * Skipped when sessionId is empty (one-shot invocations, sub-agents).
-   */
-  persistLastMessage() {
-    if (!this.workDir || !this.sessionId) {
-      return;
-    }
-    const msgs = this.conversation.getMessages();
-    if (msgs.length === 0) {
-      return;
-    }
-    const last = msgs[msgs.length - 1];
-    saveMessage(this.workDir, this.sessionId, {
-      role: last.role,
-      content: last.content,
-      timestamp: Math.floor(Date.now() / 1e3),
-      ...last.toolUses?.length ? { tool_uses: toolUsesToRecords(last.toolUses) } : {},
-      ...last.toolResults?.length ? { tool_results: toolResultsToRecords(last.toolResults) } : {}
-    });
-  }
-};
-function parseRetryAfter(header) {
-  if (!header) {
-    return 5e3;
-  }
-  const secs = parseInt(header, 10);
-  if (!Number.isNaN(secs)) {
-    return secs * 1e3;
-  }
-  return 5e3;
-}
-
-export {
-  RecoveryState,
-  getOrCreatePlanPath,
-  savePlan,
-  loadPlan,
-  planExists,
-  resetPlanPath,
-  getCurrentPlanPath,
-  coordinatorReminder,
-  buildPlanModeReminder,
-  buildPlanModeExitReminder,
-  buildPlanModeReentryReminder,
-  TOOL_RESULT_PREVIEW_CHARS,
-  toDisplayPreview,
-  replaceToolResultContent,
-  isSpillReadback,
-  applyBudget,
-  persistLargeResult,
-  StreamingExecutor,
-  Agent
-};