@ikarmic/forge-core 4.5.0 → 5.1.0

package/dist/agent/background.js

@@ -0,0 +1,139 @@
+/** More than this at once costs more than anyone meant to spend. */
+export const MAX_RUNNING_BACKGROUND = 4;
+export class BackgroundAgents {
+    entries = new Map();
+    listeners = new Set();
+    counter = 0;
+    start(options) {
+        const running = [...this.entries.values()].filter((e) => e.state === 'running').length;
+        if (running >= MAX_RUNNING_BACKGROUND) {
+            throw new Error(`At most ${MAX_RUNNING_BACKGROUND} background agents can run at once; wait for one to finish or stop one.`);
+        }
+        this.counter += 1;
+        const controller = new AbortController();
+        const entry = {
+            id: `bg-${this.counter}`,
+            task: options.task,
+            ...(options.agent ? { agent: options.agent } : {}),
+            state: 'running',
+            startedAt: Date.now(),
+            controller,
+            finished: Promise.resolve(),
+            delivered: false,
+        };
+        entry.finished = options.run(controller.signal).then((result) => {
+            entry.result = result;
+            // A stop makes the child return with reason "aborted": that is a stopped run, not a finished one.
+            entry.state = controller.signal.aborted || result.reason === 'aborted' ? 'stopped' : 'done';
+            entry.endedAt = Date.now();
+            this.changed();
+        }, (err) => {
+            entry.error = err?.message ?? String(err);
+            entry.state = controller.signal.aborted ? 'stopped' : 'failed';
+            entry.endedAt = Date.now();
+            this.changed();
+        });
+        this.entries.set(entry.id, entry);
+        this.changed();
+        return this.view(entry);
+    }
+    list() {
+        return [...this.entries.values()].map((e) => this.view(e));
+    }
+    get(id) {
+        const e = this.entries.get(id);
+        return e ? this.view(e) : undefined;
+    }
+    stop(id) {
+        const e = this.entries.get(id);
+        if (e?.state === 'running')
+            e.controller.abort();
+    }
+    stopAll() {
+        for (const e of this.entries.values())
+            if (e.state === 'running')
+                e.controller.abort();
+    }
+    /** Stop everything and forget it all (a new chat starts with none). */
+    clear() {
+        this.stopAll();
+        this.entries.clear();
+        this.changed();
+    }
+    /** Remove a finished entry from the list. A running one must be stopped first. */
+    dismiss(id) {
+        const e = this.entries.get(id);
+        if (!e || e.state === 'running')
+            return false;
+        this.entries.delete(id);
+        this.changed();
+        return true;
+    }
+    /**
+     * Wait until the named runs (default: all that are running) have finished, or the timeout passes. Never throws:
+     * the answer is the current state of each run.
+     */
+    async wait(ids, options = {}) {
+        const chosen = ids ? ids.map((id) => this.entries.get(id)).filter((e) => e !== undefined) : [...this.entries.values()].filter((e) => e.state === 'running');
+        const all = Promise.all(chosen.map((e) => e.finished));
+        const races = [all];
+        let timer;
+        if (options.timeoutMs !== undefined)
+            races.push(new Promise((resolve) => (timer = setTimeout(resolve, options.timeoutMs))));
+        if (options.signal) {
+            const signal = options.signal;
+            races.push(new Promise((resolve) => (signal.aborted ? resolve(undefined) : signal.addEventListener('abort', () => resolve(undefined), { once: true }))));
+        }
+        await Promise.race(races);
+        if (timer)
+            clearTimeout(timer);
+        return chosen.map((e) => this.view(e));
+    }
+    /** Finished runs the model has not been told about yet; each is returned once. */
+    takeUndelivered() {
+        const out = [];
+        for (const e of this.entries.values()) {
+            if (e.state !== 'running' && !e.delivered) {
+                e.delivered = true;
+                out.push(this.view(e));
+            }
+        }
+        return out;
+    }
+    /** Mark runs as already known to the model (a `sub_agent_wait` answered for them). */
+    markDelivered(ids) {
+        for (const id of ids) {
+            const e = this.entries.get(id);
+            if (e && e.state !== 'running')
+                e.delivered = true;
+        }
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    changed() {
+        for (const l of this.listeners) {
+            try {
+                l();
+            }
+            catch {
+                // a listener that throws must not stop the run bookkeeping
+            }
+        }
+    }
+    view(e) {
+        const { controller: _c, finished: _f, delivered: _d, ...rest } = e;
+        return { ...rest };
+    }
+}
+/** The model-facing text for finished runs: what each was asked and what it answered. */
+export function backgroundResultsBlock(finished) {
+    if (finished.length === 0)
+        return '';
+    const parts = finished.map((a) => {
+        const body = a.state === 'done' ? (a.result?.finalText ?? '').trim() || '(no text)' : a.state === 'failed' ? `failed: ${a.error ?? 'unknown error'}` : `stopped by the user${a.result?.finalText ? `; it had said: ${a.result.finalText.trim()}` : ''}`;
+        return `<background-agent id="${a.id}" state="${a.state}" task="${a.task.replace(/"/g, "'").slice(0, 200)}">\n${body}\n</background-agent>`;
+    });
+    return `<background-agents>\n${parts.join('\n')}\n</background-agents>`;
+}

package/dist/agent/cache-hints.d.ts

@@ -13,4 +13,3 @@ import type { ModelMessage } from 'ai';
 import type { ModelConfig } from '../types.js';
 export declare function supportsCacheHints(model: ModelConfig): boolean;
 export declare function applyCacheHints(messages: ModelMessage[], model: ModelConfig): ModelMessage[];
-//# sourceMappingURL=cache-hints.d.ts.map

package/dist/agent/cache-hints.js

@@ -28,4 +28,3 @@ export function applyCacheHints(messages, model) {
         out[last] = withHint(out[last], hint);
     return out;
 }
-//# sourceMappingURL=cache-hints.js.map

package/dist/agent/cost-router.d.ts

@@ -9,4 +9,3 @@ export declare function createExploreEditRouter(models: {
     strong: ModelConfig;
     cheap: ModelConfig;
 }): ModelRouter;
-//# sourceMappingURL=cost-router.d.ts.map

package/dist/agent/cost-router.js

@@ -18,4 +18,3 @@ export function createExploreEditRouter(models) {
         return lastToolNames.every((n) => READ_ONLY_TOOLS.has(n)) ? models.cheap : models.strong;
     };
 }
-//# sourceMappingURL=cost-router.js.map

package/dist/agent/enhance-prompt.d.ts

@@ -0,0 +1,9 @@
+import type { LanguageModel } from 'ai';
+import type { ModelConfig } from '../types.js';
+/** The prompt for rewriting `input`: the user's own instruction when given (a blank one is ignored), else the built-in. */
+export declare function enhanceRequestPrompt(input: string, instruction?: string): string;
+/**
+ * Rewrite a draft chat message into a clearer request using `model` (typically the cheap model).
+ * Never throws: an empty input, a missing model, a model error or an empty reply all return `input` unchanged.
+ */
+export declare function enhancePrompt(input: string, model: ModelConfig | undefined, modelFactory?: (cfg: ModelConfig) => LanguageModel, instruction?: string): Promise<string>;

package/dist/agent/enhance-prompt.js

@@ -0,0 +1,34 @@
+import { generateText } from 'ai';
+import { createLanguageModel } from '../providers.js';
+import { stripThinkTags } from './think-tags.js';
+const ENHANCE_INSTRUCTIONS = 'Rewrite the request below so a coding agent can act on it: say what to change and where, name the expected result, and keep every file, symbol and constraint the user mentioned. ' +
+    'Do not invent requirements or add steps the user did not ask for. Reply with the rewritten request only, no quotes, no code fences, no preface.';
+/** The prompt for rewriting `input`: the user's own instruction when given (a blank one is ignored), else the built-in. */
+export function enhanceRequestPrompt(input, instruction) {
+    return `${instruction?.trim() || ENHANCE_INSTRUCTIONS}\n\nRequest:\n${input}`;
+}
+/**
+ * Rewrite a draft chat message into a clearer request using `model` (typically the cheap model).
+ * Never throws: an empty input, a missing model, a model error or an empty reply all return `input` unchanged.
+ */
+export async function enhancePrompt(input, model, modelFactory = createLanguageModel, instruction) {
+    if (!model || !input.trim())
+        return input;
+    try {
+        const result = await generateText({ model: modelFactory(model), prompt: enhanceRequestPrompt(input, instruction) });
+        return clean(result.text) || input;
+    }
+    catch {
+        return input;
+    }
+}
+function clean(text) {
+    // Reasoning models put an inline <think> block in the reply; only what follows it is the rewrite.
+    return stripThinkTags(text)
+        .trim()
+        .replace(/^```[a-z]*\s*\n?/i, '')
+        .replace(/\n?```$/, '')
+        .trim()
+        .replace(/^["'“”](.*)["'“”]$/s, '$1')
+        .trim();
+}

package/dist/agent/goal.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+/**
+ * Session goals: one objective kept in focus across turns. Pure state machine plus the `goal_report` tool the
+ * model uses to say it is done or stuck. The loop that runs the turns lives in the surface (VS Code chat).
+ */
+export type GoalStatus = 'active' | 'paused' | 'blocked' | 'complete';
+export interface GoalState {
+    objective: string;
+    status: GoalStatus;
+    /** The model's own closing report (complete or blocked); not independently verified. */
+    report?: string;
+    /** Turns used so far. */
+    turns: number;
+}
+export interface GoalReport {
+    kind: 'complete' | 'blocked';
+    reason: string;
+}
+export interface TurnOutcome {
+    /** Tool calls the turn made; zero with no report means the model made no progress. */
+    toolCalls: number;
+    error?: boolean;
+    stopped?: boolean;
+    report?: GoalReport;
+    /** A permission request or tool call was rejected. */
+    rejected?: boolean;
+}
+export declare const MAX_OBJECTIVE_CHARS = 10000;
+export declare function startGoal(objective: string): GoalState;
+/**
+ * The goal after one turn. Stop, an error, no progress or an exhausted turn budget pause it; a rejection or a
+ * `blocked` report blocks it; a `complete` report finishes it. A report counts only when the turn ended cleanly.
+ */
+export declare function applyTurnOutcome(g: GoalState, o: TurnOutcome, maxTurns: number): GoalState;
+export declare function pauseGoal(g: GoalState): GoalState;
+/** Paused and blocked goals continue; a complete one restarts from zero turns. */
+export declare function resumeGoal(g: GoalState): GoalState;
+/** The message that drives one goal turn. */
+export declare function goalPrompt(g: GoalState): string;
+declare const reportParams: z.ZodObject<{
+    kind: z.ZodEnum<["complete", "blocked"]>;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "blocked" | "complete";
+    reason: string;
+}, {
+    kind: "blocked" | "complete";
+    reason: string;
+}>;
+export declare function createGoalReportTool(onReport: (r: GoalReport) => void): ToolDefinition<z.infer<typeof reportParams>, {
+    recorded: true;
+}>;
+export {};

package/dist/agent/goal.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+export const MAX_OBJECTIVE_CHARS = 10_000;
+export function startGoal(objective) {
+    const text = objective.trim();
+    if (!text)
+        throw new Error('A goal needs an objective.');
+    if (text.length > MAX_OBJECTIVE_CHARS)
+        throw new Error('A goal objective can be at most 10,000 characters.');
+    return { objective: text, status: 'active', turns: 0 };
+}
+/**
+ * The goal after one turn. Stop, an error, no progress or an exhausted turn budget pause it; a rejection or a
+ * `blocked` report blocks it; a `complete` report finishes it. A report counts only when the turn ended cleanly.
+ */
+export function applyTurnOutcome(g, o, maxTurns) {
+    const turns = g.turns + 1;
+    const { report: _previous, ...rest } = g;
+    if (o.stopped || o.error)
+        return { ...rest, status: 'paused', turns };
+    if (o.rejected)
+        return { ...rest, status: 'blocked', turns, ...(o.report ? { report: o.report.reason } : {}) };
+    if (o.report) {
+        return { ...rest, status: o.report.kind === 'complete' ? 'complete' : 'blocked', turns, report: o.report.reason };
+    }
+    if (o.toolCalls === 0)
+        return { ...rest, status: 'paused', turns };
+    if (turns >= maxTurns)
+        return { ...rest, status: 'paused', turns };
+    return { ...rest, status: 'active', turns };
+}
+export function pauseGoal(g) {
+    return g.status === 'active' ? { ...g, status: 'paused' } : g;
+}
+/** Paused and blocked goals continue; a complete one restarts from zero turns. */
+export function resumeGoal(g) {
+    if (g.status === 'complete')
+        return { objective: g.objective, status: 'active', turns: 0 };
+    const { report: _report, ...rest } = g;
+    return { ...rest, status: 'active' };
+}
+/** The message that drives one goal turn. */
+export function goalPrompt(g) {
+    return [
+        `Goal: ${g.objective}`,
+        '',
+        'Keep working toward this goal. Make the next concrete step with your tools; do not stop to ask questions, choose safe, reversible options instead.',
+        'When the goal is met, call goal_report with kind "complete" and what you did. If you cannot continue safely, call goal_report with kind "blocked" and why.',
+    ].join('\n');
+}
+const reportParams = z.object({
+    kind: z.enum(['complete', 'blocked']).describe('complete when the goal is met; blocked when something prevents safe progress.'),
+    reason: z.string().min(1).max(2000).describe('What was done, or what is blocking.'),
+});
+export function createGoalReportTool(onReport) {
+    return {
+        name: 'goal_report',
+        description: 'Report the outcome of the current goal: complete when the objective is met, blocked when you cannot continue safely.',
+        parameters: reportParams,
+        noApproval: true,
+        execute: async (args) => {
+            onReport({ kind: args.kind, reason: args.reason });
+            return { recorded: true };
+        },
+    };
+}

package/dist/agent/index.d.ts

@@ -1,3 +1,2 @@
 export { Agent } from './agent.js';
 export { DEFAULT_SYSTEM_PROMPT } from './prompts.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/agent/index.js

@@ -1,3 +1,2 @@
 export { Agent } from './agent.js';
 export { DEFAULT_SYSTEM_PROMPT } from './prompts.js';
-//# sourceMappingURL=index.js.map

package/dist/agent/loop-guard.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Detects a run that is stuck repeating one tool call. A call counts as a repeat only when the tool
+ * name, the arguments (key order ignored) and the result all match the previous call, so re-reading
+ * a file after an edit changed it never trips the guard.
+ */
+export declare class LoopGuard {
+    private lastKey;
+    private count;
+    private readonly threshold;
+    /**
+     * `threshold` identical calls in a row trip the guard; 0 turns it off. A threshold of 1 would stop
+     * every run at its first call, so it counts as 2.
+     */
+    constructor(threshold: number);
+    /** Length of the current run of identical calls. */
+    get streak(): number;
+    /** Record a finished call. Returns true when the streak has reached the threshold. */
+    record(toolName: string, args: unknown, resultKey: string): boolean;
+}
+/** A short stable key for a tool result, so the guard never holds large outputs in memory. */
+export declare function resultKeyOf(value: unknown): string;

package/dist/agent/loop-guard.js

@@ -0,0 +1,41 @@
+import { createHash } from 'node:crypto';
+/**
+ * Detects a run that is stuck repeating one tool call. A call counts as a repeat only when the tool
+ * name, the arguments (key order ignored) and the result all match the previous call, so re-reading
+ * a file after an edit changed it never trips the guard.
+ */
+export class LoopGuard {
+    lastKey;
+    count = 0;
+    threshold;
+    /**
+     * `threshold` identical calls in a row trip the guard; 0 turns it off. A threshold of 1 would stop
+     * every run at its first call, so it counts as 2.
+     */
+    constructor(threshold) {
+        this.threshold = threshold >= 1 ? Math.max(2, threshold) : 0;
+    }
+    /** Length of the current run of identical calls. */
+    get streak() {
+        return this.count;
+    }
+    /** Record a finished call. Returns true when the streak has reached the threshold. */
+    record(toolName, args, resultKey) {
+        if (this.threshold <= 0)
+            return false;
+        const key = `${toolName}\u0000${canonical(args)}\u0000${resultKey}`;
+        this.count = key === this.lastKey ? this.count + 1 : 1;
+        this.lastKey = key;
+        return this.count >= this.threshold;
+    }
+}
+/** A short stable key for a tool result, so the guard never holds large outputs in memory. */
+export function resultKeyOf(value) {
+    const text = typeof value === 'string' ? value : (JSON.stringify(value) ?? '');
+    return createHash('sha1').update(text).digest('hex');
+}
+function canonical(value) {
+    return JSON.stringify(value, (_k, v) => v !== null && typeof v === 'object' && !Array.isArray(v)
+        ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)))
+        : v);
+}

package/dist/agent/prompts.d.ts

@@ -22,4 +22,3 @@ export declare const DEFAULT_SPEC_MODE_SUFFIX = "\n\nSPEC MODE \u2014 IMPORTANT:
 export declare const CONTINUE_PROMPT = "Continue exactly where you stopped. Do not repeat anything you already wrote.";
 /** Spec-mode prompt override for architect phase 1 (see agent/architect.ts). */
 export declare const ARCHITECT_PROMPT = "\n\nYou are the ARCHITECT. Explore the codebase with your read-only tools, then\nreply with a precise change plan for a separate editor model to apply. Do not\nwrite code outside the plan. Your final message must contain only:\n\n1. Files to change \u2014 for each file, the exact edits (what to find, what to\n   replace it with, or the new code to add and where).\n2. New files \u2014 path and full contents.\n3. Verification \u2014 the commands to run to check the change.\n\nBe exact: the editor applies your plan literally and cannot ask questions.\n";
-//# sourceMappingURL=prompts.d.ts.map

package/dist/agent/prompts.js

@@ -78,4 +78,3 @@ write code outside the plan. Your final message must contain only:
 
 Be exact: the editor applies your plan literally and cannot ask questions.
 `;
-//# sourceMappingURL=prompts.js.map

package/dist/agent/think-tags.d.ts

@@ -26,4 +26,3 @@ export declare class ThinkSplitter {
 }
 /** The visible answer: everything outside `<think>…</think>` (an unclosed block runs to the end). */
 export declare function stripThinkTags(text: string): string;
-//# sourceMappingURL=think-tags.d.ts.map

package/dist/agent/think-tags.js

@@ -81,4 +81,3 @@ export function stripThinkTags(text) {
         .replace(/<think>[\s\S]*$/, '')
         .trim();
 }
-//# sourceMappingURL=think-tags.js.map

package/dist/agent/verify.d.ts

@@ -14,4 +14,3 @@ export interface VerifyOutcome {
 export declare function runVerification(config: VerifyConfig, ctx: ToolContext, editedFiles?: string[]): Promise<VerifyOutcome>;
 /** The message shown to the model after a failed verification. */
 export declare function failureMessage(failures: VerifyFailure[]): string;
-//# sourceMappingURL=verify.d.ts.map

package/dist/agent/verify.js

@@ -53,4 +53,3 @@ export function failureMessage(failures) {
 function tail(text) {
     return text.length <= MAX_FAILURE_CHARS ? text : `...\n${text.slice(text.length - MAX_FAILURE_CHARS)}`;
 }
-//# sourceMappingURL=verify.js.map

package/dist/agents/agent-files.d.ts

@@ -0,0 +1,43 @@
+import type { SpecialistConfig } from '../orchestrator/types.js';
+/**
+ * An agent defined as a Markdown file: front matter for settings, the body as the system prompt.
+ * `~/.forge/agents/*.md` (yours) and `<workspace>/.forge/agents/*.md` (the project's); the file name is the agent name.
+ */
+export interface AgentDef {
+    name: string;
+    description: string;
+    /** `subagent` runs only when delegated to, `primary` only as the chat's agent, `all` both. */
+    mode: 'subagent' | 'primary' | 'all';
+    model?: string;
+    /** Iteration cap. */
+    steps?: number;
+    temperature?: number;
+    color?: string;
+    /** Tools it may call; empty = every built-in tool except the denied ones. */
+    tools: string[];
+    /** Tools it may never call. Always contains `sub_agent`. */
+    deny: string[];
+    /** Left out of menus and the picker; still reachable by name. */
+    hidden: boolean;
+    /** Set by `disable: true`; a disabled file removes the agent of that name from the result. */
+    disabled?: boolean;
+    prompt: string;
+}
+export declare function parseAgentFile(fileName: string, text: string): {
+    agent?: AgentDef;
+    problem?: string;
+};
+/** Load folders in order (user first, project last); a later agent replaces an earlier one of the same name. */
+export declare function loadAgentFiles(dirs: string[]): Promise<{
+    agents: AgentDef[];
+    problems: string[];
+}>;
+/**
+ * An agent file as a chat mode: modes are specialists, so a `primary` or `all` agent shows up in the mode switcher
+ * with its prompt, tools and step cap. No tools list = every tool in `allToolNames` except the denied ones.
+ */
+export declare function agentToSpecialist(def: AgentDef, allToolNames: readonly string[]): SpecialistConfig;
+/** The agents of the running host, so the `sub_agent` tool can find one by name. Hosts register at the start of every run. */
+export declare function registerAgentDefs(agents: AgentDef[]): void;
+export declare function registeredAgent(name: string): AgentDef | undefined;
+export declare function registeredAgents(): AgentDef[];

package/dist/agents/agent-files.js

@@ -0,0 +1,109 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { parseFrontmatter } from '../skills/parser.js';
+const NAME = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+const list = (v) => (v ?? '').split(',').map((s) => s.trim()).filter(Boolean);
+export function parseAgentFile(fileName, text) {
+    const name = basename(fileName).replace(/\.md$/i, '');
+    if (!NAME.test(name))
+        return { problem: `${fileName}: the file name "${name}" is not a valid agent name (lowercase letters, digits, - and _)` };
+    if (!text.startsWith('---'))
+        return { problem: `${fileName}: needs front matter (--- lines) with a description` };
+    const { fields, body } = parseFrontmatter(text.replace(/\r\n/g, '\n'));
+    const description = (fields.get('description') ?? '').trim();
+    if (!description)
+        return { problem: `${fileName}: description is required` };
+    const mode = fields.get('mode') ?? 'subagent';
+    if (mode !== 'subagent' && mode !== 'primary' && mode !== 'all')
+        return { problem: `${fileName}: mode must be subagent, primary or all` };
+    let steps;
+    if (fields.has('steps')) {
+        steps = Number(fields.get('steps'));
+        if (!Number.isInteger(steps) || steps < 1)
+            return { problem: `${fileName}: steps must be a positive whole number` };
+    }
+    let temperature;
+    if (fields.has('temperature')) {
+        temperature = Number(fields.get('temperature'));
+        if (!Number.isFinite(temperature) || temperature < 0 || temperature > 2)
+            return { problem: `${fileName}: temperature must be between 0 and 2` };
+    }
+    const tools = list(fields.get('tools')).filter((t) => t !== 'sub_agent');
+    const deny = [...new Set(['sub_agent', ...list(fields.get('deny'))])];
+    const model = fields.get('model')?.trim();
+    const color = fields.get('color')?.trim();
+    return {
+        agent: {
+            name,
+            description,
+            mode,
+            ...(model ? { model } : {}),
+            ...(steps !== undefined ? { steps } : {}),
+            ...(temperature !== undefined ? { temperature } : {}),
+            ...(color ? { color } : {}),
+            tools,
+            deny,
+            hidden: fields.get('hidden') === 'true',
+            ...(fields.get('disable') === 'true' ? { disabled: true } : {}),
+            prompt: body.trim(),
+        },
+    };
+}
+/** Load folders in order (user first, project last); a later agent replaces an earlier one of the same name. */
+export async function loadAgentFiles(dirs) {
+    const byName = new Map();
+    const problems = [];
+    for (const dir of dirs) {
+        let names;
+        try {
+            names = (await readdir(dir)).filter((n) => n.toLowerCase().endsWith('.md')).sort();
+        }
+        catch {
+            continue;
+        }
+        for (const n of names) {
+            let text;
+            try {
+                text = await readFile(join(dir, n), 'utf8');
+            }
+            catch (err) {
+                problems.push(`${n}: ${err.message}`);
+                continue;
+            }
+            const { agent, problem } = parseAgentFile(n, text);
+            if (problem)
+                problems.push(problem);
+            else if (agent)
+                byName.set(agent.name, agent);
+        }
+    }
+    return { agents: [...byName.values()].filter((a) => !a.disabled), problems };
+}
+/**
+ * An agent file as a chat mode: modes are specialists, so a `primary` or `all` agent shows up in the mode switcher
+ * with its prompt, tools and step cap. No tools list = every tool in `allToolNames` except the denied ones.
+ */
+export function agentToSpecialist(def, allToolNames) {
+    const denied = new Set(def.deny);
+    const allow = def.tools.length > 0 ? new Set(def.tools) : undefined;
+    return {
+        id: def.name,
+        description: def.description,
+        systemPrompt: def.prompt,
+        allowedTools: allToolNames.filter((n) => !denied.has(n) && (!allow || allow.has(n))),
+        forbiddenTools: [...denied],
+        ...(def.steps !== undefined ? { maxIterations: def.steps } : {}),
+        ...(def.model ? { model: def.model } : {}),
+    };
+}
+let registered = new Map();
+/** The agents of the running host, so the `sub_agent` tool can find one by name. Hosts register at the start of every run. */
+export function registerAgentDefs(agents) {
+    registered = new Map(agents.map((a) => [a.name, a]));
+}
+export function registeredAgent(name) {
+    return registered.get(name);
+}
+export function registeredAgents() {
+    return [...registered.values()];
+}

package/dist/ai-comments/index.d.ts

@@ -21,4 +21,3 @@ export interface AiCommentFile {
 }
 /** Build the agent task for the files that carry AI comments. */
 export declare function aiCommentTask(files: AiCommentFile[], action: 'change' | 'question'): string;
-//# sourceMappingURL=index.d.ts.map

package/dist/ai-comments/index.js

@@ -38,4 +38,3 @@ export function aiCommentTask(files, action) {
         ? `Apply the instructions left as AI comments in these files, then remove the AI comments you resolved:\n\n${body}`
         : `Answer the questions left as AI comments in these files. Do not edit any file:\n\n${body}`;
 }
-//# sourceMappingURL=index.js.map

package/dist/attachments.d.ts

@@ -44,4 +44,3 @@ export declare function attachmentParts(attachments: readonly Attachment[]): Arr
 export declare function mediaPartTokens(part: unknown): number;
 /** A short stand-in for a media part in transcripts (summaries, logs), never the bytes. */
 export declare function mediaPartLabel(part: unknown): string | null;
-//# sourceMappingURL=attachments.d.ts.map

package/dist/attachments.js

@@ -176,4 +176,3 @@ export function mediaPartLabel(part) {
     }
     return null;
 }
-//# sourceMappingURL=attachments.js.map

package/dist/browser/cdp.d.ts

@@ -29,4 +29,3 @@ export declare class CdpClient {
 /** Open a CDP connection to `wsUrl` using the runtime's global WebSocket. */
 export declare function connectWebSocket(wsUrl: string, timeoutMs?: number): Promise<CdpTransport>;
 export {};
-//# sourceMappingURL=cdp.d.ts.map

package/dist/browser/cdp.js

@@ -123,4 +123,3 @@ export function connectWebSocket(wsUrl, timeoutMs = 10_000) {
         });
     });
 }
-//# sourceMappingURL=cdp.js.map

package/dist/browser/chrome.d.ts

@@ -11,4 +11,3 @@ export declare function launchChrome(chromePath: string, options?: {
     headless?: boolean;
     timeoutMs?: number;
 }): Promise<LaunchedBrowser>;
-//# sourceMappingURL=chrome.d.ts.map

package/dist/browser/chrome.js

@@ -100,4 +100,3 @@ export async function launchChrome(chromePath, options = {}) {
     });
     return { port, kill: cleanup };
 }
-//# sourceMappingURL=chrome.js.map

package/dist/browser/session.d.ts

@@ -54,4 +54,3 @@ export declare class BrowserSession {
     get isOpen(): boolean;
     close(): Promise<void>;
 }
-//# sourceMappingURL=session.d.ts.map