@ikarmic/forge-core 5.1.0 → 5.2.0

package/dist/specs/generate.js

@@ -9,6 +9,7 @@
  * order) into the three separate document bodies `SpecStore.approve`
  * writes to disk.
  */
+import { convertToCheckboxes, parseTasks } from './tasks-parser.js';
 /** Read-only tools exposed to the model during spec-mode generation. */
 export const SPEC_READONLY_TOOLS = [
     'read_file',
@@ -23,37 +24,87 @@ const SECTION_MATCHES = [
     { key: 'design', header: 'design.md' },
     { key: 'tasks', header: 'tasks.md' },
 ];
+/** Where a section body ends: the next `## ` heading. */
+const STRICT_STOP = /^##\s+\S/m;
+/** Stage replies: a level-1 or level-2 heading, or any named section heading at level 1 to 3. */
+const LENIENT_STOP = /^(?:#{1,2}[ \t]+\S|#{1,3}[ \t]*`?(?:requirements|design|tasks)\.md`?[ \t]*$)/im;
+/** A line that is nothing but a code fence. */
+const FENCE_ONLY_LINE = /\n[ \t]*(?:```|~~~)[ \t]*$/;
+const FENCE_LINE_ANYWHERE = /^[ \t]*(?:```|~~~)/gm;
 /**
- * Split a spec-mode run's final text into its three sections. Each
- * section is introduced by a `## <file>.md` markdown heading (case-
- * insensitive, arbitrary surrounding whitespace); the body runs until
- * the next matching heading or end of text. Section order in `raw`
- * does not matter.
+ * Drop the closing fence a model leaves behind when it wrapped the whole reply
+ * in a code block: the opening fence sits before the first heading, so the last
+ * section ends with an unmatched closing one.
  *
- * Throws when any of the three expected headings is missing: callers
- * should surface this as a generation failure rather than write partial
- * or malformed files.
+ * Only when the count is odd. A `tasks.md` that legitimately *ends* with a
+ * fenced code block has a balanced pair, and stripping that would eat the real
+ * document — which is what the existing one-shot test caught on the first run.
  */
-export function splitSpecSections(raw) {
+function dropUnmatchedTrailingFence(body) {
+    const fences = body.match(FENCE_LINE_ANYWHERE)?.length ?? 0;
+    if (fences % 2 === 0)
+        return body;
+    // `$` without /m anchors at the very end of the string, not before a trailing
+    // newline, so the trailing whitespace has to go before the fence can match.
+    return body.trimEnd().replace(FENCE_ONLY_LINE, '');
+}
+/**
+ * Find every section the text contains, validating nothing. Callers decide
+ * which they require, so the one-shot path can keep demanding all three while
+ * the journey's Spec stage asks for two and its ImplPlan stage for one.
+ *
+ * A section's body runs to the next `## ` heading or the end of the text, so an
+ * unrelated heading the model wrote between two sections ends only its own
+ * section. Text before the first heading is never part of a body, which is what
+ * makes a preamble harmless.
+ *
+ * `lenient` is for the journey's stage replies and is opt-in; the one-shot
+ * `splitSpecSections` passes false and reads exactly as it always has. Lenient
+ * does two things:
+ *
+ * - It strips the closing fence a wrapped reply leaves behind. This once ran for
+ *   both paths, which quietly changed what `/spec` persists (a wrapped reply
+ *   lost its closing fence, and a tilde block holding a bare backtick line lost
+ *   its own) and contradicted the plan's "nothing existing changes behaviour".
+ * - It accepts a section heading at level 1 to 3, optionally in backticks. A live
+ *   MiniMax-M3 run answered with `# tasks.md` and the strict parser threw "got:
+ *   none" although the model had done the work. Once a section may be headed
+ *   `###`, a body cannot end at "any `##` line" or the first section would
+ *   swallow the second, so it ends at a level-1/2 heading *or* at any named
+ *   section heading; a level-3 subsection inside a document stays inside it.
+ *
+ * The one-shot flaws are real and recorded in RB-31; they are not fixed here.
+ */
+function splitSections(raw, lenient) {
     const found = {};
     const foundHeaders = [];
     for (const { key, header } of SECTION_MATCHES) {
-        const re = new RegExp(`^##\\s*${escapeRegExp(header)}\\s*$`, 'im');
+        const re = lenient
+            ? new RegExp(`^#{1,3}[ \\t]*\`?${escapeRegExp(header)}\`?[ \\t]*$`, 'im')
+            : new RegExp(`^##\\s*${escapeRegExp(header)}\\s*$`, 'im');
         const match = re.exec(raw);
         if (!match)
             continue;
         const start = match.index + match[0].length;
         const rest = raw.slice(start);
         // Body runs until the next `## ...` heading line, or end of text.
-        const nextHeadingRe = /^##\s+\S/m;
-        const nextMatch = nextHeadingRe.exec(rest);
-        const body = nextMatch ? rest.slice(0, nextMatch.index) : rest;
+        const nextMatch = (lenient ? LENIENT_STOP : STRICT_STOP).exec(rest);
+        const slice = nextMatch ? rest.slice(0, nextMatch.index) : rest;
+        const body = lenient ? dropUnmatchedTrailingFence(slice) : slice;
         found[key] = key === 'tasks' ? splitInlineSubtasks(body.trim()) : body.trim();
         foundHeaders.push(header);
     }
+    return { found, foundHeaders };
+}
+function describeFound(foundHeaders) {
+    return foundHeaders.length > 0 ? foundHeaders.join(', ') : 'none';
+}
+export function splitSpecSections(raw) {
+    const { found, foundHeaders } = splitSections(raw, false);
+    // Strict on purpose: see `splitSections`. The one-shot path reads exactly as it always has.
     const missing = SECTION_MATCHES.filter((s) => found[s.key] === undefined);
     if (missing.length > 0) {
-        throw new Error(`Spec generation did not include all three sections (requirements.md/design.md/tasks.md): got: ${foundHeaders.length > 0 ? foundHeaders.join(', ') : 'none'}`);
+        throw new Error(`Spec generation did not include all three sections (requirements.md/design.md/tasks.md): got: ${describeFound(foundHeaders)}`);
     }
     return {
         requirements: found.requirements,
@@ -61,6 +112,115 @@ export function splitSpecSections(raw) {
         tasks: found.tasks,
     };
 }
+/**
+ * The Spec stage's two documents. Returns **only** those two keys: a model that
+ * volunteers a `## tasks.md` section despite being told not to must not be able
+ * to smuggle it into a draft, because the person has not reached the
+ * implementation-plan gate yet.
+ */
+export function splitRequirementsDesign(raw) {
+    const { found, foundHeaders } = splitSections(raw, true);
+    const missing = ['requirements', 'design'].filter((k) => found[k] === undefined);
+    if (missing.length > 0) {
+        throw new Error(`Spec generation did not include ${missing.map((k) => `${k}.md`).join(' and ')}: got: ${describeFound(foundHeaders)}`);
+    }
+    return { requirements: found.requirements, design: found.design };
+}
+const CHECKBOX_LINE = /^\s*[-*+]\s+\[[ xX]\]\s+\S/;
+const FENCE_START = /^\s*(?:```|~~~)/;
+/** `_Requirements: 2_`, `*Requirements: 2*`, `**Requirements:** 1.1`: the footer under a task, however the model dressed it. */
+const REQUIREMENTS_FOOTER = /^\s*[_*]{1,2}Requirements\b.*$/i;
+/** A line that belongs to the task above it: indented, or its requirements footer. */
+function continuesTask(line) {
+    return /^\s+\S/.test(line) || REQUIREMENTS_FOOTER.test(line);
+}
+/**
+ * Cut a closing summary off the end of a task list.
+ *
+ * Nothing ends the *last* section of a reply, so a model that finishes with
+ * "Notes on two judgment calls… Plan is complete, next step would be executing
+ * task 1" has that text written into the persisted `tasks.md`. A live
+ * MiniMax-M3 run did exactly that. The checklist is the anchor: the document
+ * ends where the last checkbox's own block ends.
+ *
+ * That block is the task's indented lines and its requirements footer, and it
+ * may contain blank lines, so a blank run is looked *through* and kept when what
+ * follows still belongs to the task. A fenced block under the last task is part
+ * of it and is kept whole; an *unclosed* fence is trailer, because keeping it
+ * would persist a document that ends inside a code block. The anchor itself is
+ * the last checkbox `parseTasks` would see, so one inside a fenced example does
+ * not count.
+ *
+ * With no checkbox at all (a prose or numbered list) there is nothing to anchor
+ * on, so the text is returned as it is and approval converts it to checkboxes
+ * the way the one-shot path always has.
+ */
+function dropClosingSummary(tasks) {
+    const lines = tasks.split('\n');
+    let last = -1;
+    let inFence = false;
+    lines.forEach((line, i) => {
+        if (FENCE_START.test(line)) {
+            inFence = !inFence;
+            return;
+        }
+        if (!inFence && CHECKBOX_LINE.test(line))
+            last = i;
+    });
+    if (last === -1)
+        return tasks;
+    let end = last;
+    let i = last + 1;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line.trim() === '') {
+            let next = i + 1;
+            while (next < lines.length && lines[next].trim() === '')
+                next += 1;
+            const rest = lines[next];
+            if (rest !== undefined && (continuesTask(rest) || FENCE_START.test(rest))) {
+                i = next;
+                continue;
+            }
+            break;
+        }
+        if (FENCE_START.test(line)) {
+            let close = i + 1;
+            while (close < lines.length && !FENCE_START.test(lines[close]))
+                close += 1;
+            if (close >= lines.length)
+                break;
+            end = close;
+            i = close + 1;
+            continue;
+        }
+        if (!continuesTask(line))
+            break;
+        end = i;
+        i += 1;
+    }
+    return lines.slice(0, end + 1).join('\n').trimEnd();
+}
+/**
+ * The ImplPlan stage's single document.
+ *
+ * Throws when the reply holds no task at all: an empty body or a prose-only
+ * "Plan is complete." would otherwise be written by `writeDraftTasks` and then
+ * approved, because `approveDraft` only checks that the file exists — leaving a
+ * spec with nothing to run, which is the very outcome that guard exists to
+ * prevent. Failing generation here sends the journey back to "Revise".
+ */
+export function splitTasksSection(raw) {
+    const { found, foundHeaders } = splitSections(raw, true);
+    if (found.tasks === undefined) {
+        throw new Error(`Spec generation did not include tasks.md: got: ${describeFound(foundHeaders)}`);
+    }
+    const tasks = dropClosingSummary(found.tasks);
+    if (parseTasks(convertToCheckboxes(tasks)).length === 0) {
+        throw new Error(`Spec generation produced a tasks.md with no tasks in it: got: ${describeFound(foundHeaders)}`);
+    }
+    return tasks;
+}
 // A task line with a numbered subtask glued on after it: "- [ ] 1. Title - [ ] 1.1 Sub".
 const INLINE_SUBTASK_RE = /^(\s*)([-*+]\s+\[[ xX]\]\s+.+?)\s+[-*+]\s+(\[[ xX]\]\s+\d.*)$/;
 /**

package/dist/specs/index.d.ts

@@ -6,8 +6,8 @@
  * `./generate.js`, added in a later task.
  */
 export { SpecStore, isSafeSpecId, runKey, slugifyTaskForSpecId } from './store.js';
-export type { SpecDraft, SpecRunRecord, SpecRuns, SpecSections, SpecSummary } from './types.js';
-export { SPEC_READONLY_TOOLS, splitSpecSections } from './generate.js';
+export type { SpecDraft, SpecDraftSections, SpecRunRecord, SpecRuns, SpecSections, SpecSummary } from './types.js';
+export { SPEC_READONLY_TOOLS, splitRequirementsDesign, splitSpecSections, splitTasksSection } from './generate.js';
 export { convertToCheckboxes, parseTasks, setTaskDone } from './tasks-parser.js';
 export type { SpecTask } from './tasks-parser.js';
 export { changedSince, changeSize, keepDoneTasks, referencedPaths, specDrift, syncSpecTask } from './sync.js';

package/dist/specs/index.js

@@ -6,6 +6,6 @@
  * `./generate.js`, added in a later task.
  */
 export { SpecStore, isSafeSpecId, runKey, slugifyTaskForSpecId } from './store.js';
-export { SPEC_READONLY_TOOLS, splitSpecSections } from './generate.js';
+export { SPEC_READONLY_TOOLS, splitRequirementsDesign, splitSpecSections, splitTasksSection } from './generate.js';
 export { convertToCheckboxes, parseTasks, setTaskDone } from './tasks-parser.js';
 export { changedSince, changeSize, keepDoneTasks, referencedPaths, specDrift, syncSpecTask } from './sync.js';

package/dist/specs/store.d.ts

@@ -7,7 +7,7 @@
  * generation happens entirely in memory (in the CLI/REPL layer), so a
  * cancelled review leaves no trace here.
  */
-import type { SpecDraft, SpecRunRecord, SpecRuns, SpecSections, SpecSummary } from './types.js';
+import type { SpecDraft, SpecDraftSections, SpecRunRecord, SpecRuns, SpecSections, SpecSummary } from './types.js';
 /** Spec ids become path segments; the leading-alphanumeric rule also rejects `.drafts`, `.` and `..`. */
 export declare function isSafeSpecId(id: string): boolean;
 /** Key for a task's run history: a reordered or renamed task stops matching old runs. */
@@ -33,7 +33,19 @@ export declare class SpecStore {
     /** Delete an approved spec's directory. Returns false when it didn't exist. */
     delete(id: string): Promise<boolean>;
     private draftDir;
-    createDraft(id: string, task: string, sections: SpecSections): Promise<SpecDraft>;
+    /**
+     * A draft may be created before its tasks exist: the journey's Spec stage
+     * writes requirements and design, and `tasks.md` arrives from the ImplPlan
+     * stage behind its own gate (`writeDraftTasks`). The one-shot `/spec` path
+     * passes all three and is unaffected.
+     */
+    createDraft(id: string, task: string, sections: SpecDraftSections): Promise<SpecDraft>;
+    /**
+     * Write (or replace) a draft's `tasks.md`, which is the ImplPlan stage's
+     * artefact. `writeFile` truncates, so running the stage again after the person
+     * chose "Revise them" replaces the list rather than appending to it.
+     */
+    writeDraftTasks(id: string, tasks: string): Promise<void>;
     getDraft(id: string): Promise<SpecDraft | null>;
     listDrafts(): Promise<SpecDraft[]>;
     /** Approve what is on disk now (the user may have edited it), converting tasks.md to checkboxes if needed. */

package/dist/specs/store.js

@@ -134,6 +134,12 @@ export class SpecStore {
     draftDir(id) {
         return path.join(this.root, DRAFTS_DIR, id);
     }
+    /**
+     * A draft may be created before its tasks exist: the journey's Spec stage
+     * writes requirements and design, and `tasks.md` arrives from the ImplPlan
+     * stage behind its own gate (`writeDraftTasks`). The one-shot `/spec` path
+     * passes all three and is unaffected.
+     */
     async createDraft(id, task, sections) {
         assertSafeSpecId(id);
         const dir = this.draftDir(id);
@@ -142,11 +148,24 @@ export class SpecStore {
         await mkdir(dir, { recursive: true });
         await writeFile(path.join(dir, 'requirements.md'), sections.requirements, 'utf8');
         await writeFile(path.join(dir, 'design.md'), sections.design, 'utf8');
-        await writeFile(path.join(dir, 'tasks.md'), sections.tasks, 'utf8');
+        if (sections.tasks !== undefined)
+            await writeFile(path.join(dir, 'tasks.md'), sections.tasks, 'utf8');
         const createdAt = new Date().toISOString();
         await writeFile(path.join(dir, DRAFT_FILENAME), JSON.stringify({ id, task, createdAt }, null, 2), 'utf8');
         return { id, task, createdAt, dir };
     }
+    /**
+     * Write (or replace) a draft's `tasks.md`, which is the ImplPlan stage's
+     * artefact. `writeFile` truncates, so running the stage again after the person
+     * chose "Revise them" replaces the list rather than appending to it.
+     */
+    async writeDraftTasks(id, tasks) {
+        assertSafeSpecId(id);
+        const draft = await this.getDraft(id);
+        if (!draft)
+            throw new Error(`no draft ${id}`);
+        await writeFile(path.join(draft.dir, 'tasks.md'), tasks, 'utf8');
+    }
     async getDraft(id) {
         if (!isSafeSpecId(id))
             return null;
@@ -187,6 +206,12 @@ export class SpecStore {
         // Finish the spec inside the draft folder, then move it into place with one rename,
         // so a spec directory never exists half-written.
         const tasksPath = path.join(draft.dir, 'tasks.md');
+        // A journey draft has no tasks until the ImplPlan stage has run. Approving
+        // then would produce a spec the Specs tree shows with nothing to run, so say
+        // what is missing instead.
+        if (!existsSync(tasksPath)) {
+            throw new Error(`draft ${id} has no tasks.md: the implementation plan stage has not run yet`);
+        }
         await writeFile(tasksPath, convertToCheckboxes(await readFile(tasksPath, 'utf8')), 'utf8');
         const summary = { id, task: draft.task, approvedAt: new Date().toISOString(), dir: specDir };
         await writeFile(path.join(draft.dir, MANIFEST_FILENAME), JSON.stringify(summary, null, 2), 'utf8');

package/dist/specs/types.d.ts

@@ -4,6 +4,17 @@ export interface SpecSections {
     design: string;
     tasks: string;
 }
+/**
+ * A draft mid-journey. The Spec stage writes requirements and design; `tasks`
+ * arrives later, from the ImplPlan stage, behind its own gate. `SpecSections`
+ * deliberately stays all-required: the one-shot `/spec` path produces all three
+ * at once and nothing about it changes.
+ */
+export interface SpecDraftSections {
+    requirements: string;
+    design: string;
+    tasks?: string;
+}
 /** An unapproved spec in `.forge/specs/.drafts/<id>/`. */
 export interface SpecDraft {
     id: string;

package/dist/structured/schema.js

@@ -258,36 +258,33 @@ export function formatZodError(err) {
     return err.issues
         .map((issue) => {
         const pathStr = issue.path.length > 0 ? issue.path.join('.') : '(root)';
-        const expected = issueCode(issue.code);
+        const expected = issueCode(issue);
         const received = describeReceived(issue);
         return `${pathStr}: ${issue.message}${expected ? ` (expected ${expected}${received ? `, got ${received}` : ''})` : ''}`;
     })
         .join('\n');
 }
-function issueCode(code) {
-    switch (code) {
+function issueCode(issue) {
+    switch (issue.code) {
         case 'invalid_type':
             return 'correct type';
-        case 'invalid_string':
+        case 'invalid_format':
             return 'string matching format';
         case 'too_small':
             return 'value >= min';
         case 'too_big':
             return 'value <= max';
-        case 'invalid_enum_value':
-            return 'one of the allowed values';
+        case 'invalid_value':
+            return issue.values.length === 1 ? 'the literal value' : 'one of the allowed values';
         case 'unrecognized_keys':
             return 'no extra keys';
         case 'invalid_union':
             return 'one of the union variants';
-        case 'invalid_literal':
-            return 'the literal value';
         default:
             return '';
     }
 }
-function describeReceived(issue) {
-    if (issue.code !== 'invalid_type')
-        return '';
-    return JSON.stringify(issue.received);
+// Zod 4 dropped `received` from the issue; its message already says "received <type>".
+function describeReceived(_issue) {
+    return '';
 }

package/dist/tools/apply-patch.d.ts

@@ -2,11 +2,7 @@ import { z } from 'zod';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     patch: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    patch: string;
-}, {
-    patch: string;
-}>;
+}, z.core.$strip>;
 export type PatchOp = {
     kind: 'add';
     path: string;

package/dist/tools/ask-user.d.ts

@@ -7,17 +7,9 @@ import type { ToolDefinition } from '../types.js';
  */
 declare const params: z.ZodObject<{
     question: z.ZodString;
-    options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
     allowCustom: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    question: string;
-    options?: string[] | undefined;
-    allowCustom?: boolean | undefined;
-}, {
-    question: string;
-    options?: string[] | undefined;
-    allowCustom?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export interface AskUserResult {
     answer: string;
     unavailable?: boolean;

package/dist/tools/ask-user.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { raceAbort } from '../agent/race-abort.js';
 /**
  * Ask the person a question with optional choices. The agent only offers this tool when a surface can answer
  * (AgentConfig.askUser) and the run is not autonomous; if it is called anyway, or the run is stopped while the
@@ -14,6 +15,18 @@ const UNAVAILABLE = {
     unavailable: true,
     note: 'No user is available. Choose the safest reasonable option and say what you assumed.',
 };
+/**
+ * A guided journey asks at most four questions. The budget is enforced here
+ * rather than in prompt text for the same reason stage gates live in the tool
+ * sandbox: a limit the model is merely told about is a limit it will exceed,
+ * and one bad extra question is what makes an interview feel like an
+ * interrogation (spec anti-goal 3).
+ */
+const BUDGET_SPENT = {
+    answer: '',
+    unavailable: true,
+    note: 'The question budget for this journey is spent: no more questions. Proceed with what you have and say what you assumed.',
+};
 export const askUserTool = {
     name: 'ask_user',
     description: 'Ask the user a clarifying question when you cannot proceed safely without their answer. Give a few options when you can. Do not ask for permission to run tools; approvals are handled separately.',
@@ -25,8 +38,31 @@ export const askUserTool = {
         const signal = ctx.abortSignal;
         if (signal?.aborted)
             return UNAVAILABLE;
-        const answered = ctx.askUser(args, signal).then((answer) => ({ answer }));
-        const aborted = new Promise((resolve) => signal?.addEventListener('abort', () => resolve(UNAVAILABLE), { once: true }));
-        return Promise.race([answered, aborted]);
+        // Counted only once the question is actually put to a surface, so a refused
+        // or impossible question never spends part of the budget.
+        if (ctx.askBudget) {
+            if (ctx.askBudget.used >= ctx.askBudget.max)
+                return BUDGET_SPENT;
+            ctx.askBudget.used += 1;
+        }
+        const budget = ctx.askBudget;
+        const refund = () => {
+            if (budget)
+                budget.used = Math.max(0, budget.used - 1);
+        };
+        const answered = ctx.askUser(args, signal).then((answer) => {
+            // A question the person dismissed resolves to an empty answer and must not
+            // cost part of the budget: four dismissals would otherwise end an interview
+            // without a single question being answered. Refunding keeps the budget a
+            // count of questions actually answered.
+            if (answer.trim() === '')
+                refund();
+            return { answer };
+        }, (err) => {
+            // A surface that failed never showed the question, so it costs nothing either.
+            refund();
+            throw err;
+        });
+        return raceAbort(answered, signal, UNAVAILABLE);
     },
 };

package/dist/tools/browser-tools.d.ts

@@ -4,15 +4,15 @@ import type { ToolContext, ToolDefinition } from '../types.js';
 /** Throws unless `rawUrl` is an http(s) URL the browser may visit. */
 export declare function assertBrowsableUrl(rawUrl: string, policy: ToolContext['policy']): Promise<void>;
 declare const observeParams: z.ZodObject<{
-    action: z.ZodEnum<["open", "screenshot", "text", "console", "close"]>;
+    action: z.ZodEnum<{
+        close: "close";
+        text: "text";
+        open: "open";
+        screenshot: "screenshot";
+        console: "console";
+    }>;
     url: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    action: "close" | "text" | "open" | "screenshot" | "console";
-    url?: string | undefined;
-}, {
-    action: "close" | "text" | "open" | "screenshot" | "console";
-    url?: string | undefined;
-}>;
+}, z.core.$strip>;
 export type BrowserResult = {
     action: 'open';
     url: string;
@@ -48,30 +48,14 @@ export declare function createBrowserTools(session: BrowserSession): [
         note?: string;
     }>
 ];
-declare const actParams: z.ZodEffects<z.ZodObject<{
-    action: z.ZodEnum<["click", "type", "evaluate"]>;
+declare const actParams: z.ZodObject<{
+    action: z.ZodEnum<{
+        type: "type";
+        click: "click";
+        evaluate: "evaluate";
+    }>;
     selector: z.ZodOptional<z.ZodString>;
     text: z.ZodOptional<z.ZodString>;
     expression: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    action: "type" | "click" | "evaluate";
-    text?: string | undefined;
-    expression?: string | undefined;
-    selector?: string | undefined;
-}, {
-    action: "type" | "click" | "evaluate";
-    text?: string | undefined;
-    expression?: string | undefined;
-    selector?: string | undefined;
-}>, {
-    action: "type" | "click" | "evaluate";
-    text?: string | undefined;
-    expression?: string | undefined;
-    selector?: string | undefined;
-}, {
-    action: "type" | "click" | "evaluate";
-    text?: string | undefined;
-    expression?: string | undefined;
-    selector?: string | undefined;
-}>;
+}, z.core.$strip>;
 export {};

package/dist/tools/codebase-search.d.ts

@@ -5,13 +5,7 @@ import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     query: z.ZodString;
     limit: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    query: string;
-    limit?: number | undefined;
-}, {
-    query: string;
-    limit?: number | undefined;
-}>;
+}, z.core.$strip>;
 export interface CodebaseSearchResult {
     query: string;
     embedder: string;

package/dist/tools/dependency-audit.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+export declare const AUDIT_TIMEOUT_MS = 60000;
+export declare const MAX_AUDIT_CHARS = 60000;
+export interface AuditFinding {
+    package: string;
+    installed?: string;
+    advisory: string;
+    severity: string;
+    fixedIn?: string;
+}
+export interface AuditorPlan {
+    ecosystem: 'npm' | 'pnpm' | 'yarn' | 'python' | 'cargo' | 'go';
+    program: string;
+    args: string[];
+    lockfile: string;
+}
+/** The auditors for the lockfiles at the workspace root, in a fixed order. */
+export declare function pickAuditors(cwd: string): AuditorPlan[];
+/** npm 7+ (`auditReportVersion: 2`): one finding per package with its own advisory; entries that only inherit one are skipped. */
+export declare function parseNpmAudit(text: string): AuditFinding[];
+/** pnpm (npm 6 format): `advisories` keyed by id. */
+export declare function parsePnpmAudit(text: string): AuditFinding[];
+/** pip-audit `-f json`: `{ dependencies: [...] }` (older versions print the list itself). pip-audit reports no severity. */
+export declare function parsePipAudit(text: string): AuditFinding[];
+/** cargo-audit `--json`: `vulnerabilities.list`. */
+export declare function parseCargoAudit(text: string): AuditFinding[];
+declare const params: z.ZodObject<{}, z.core.$strip>;
+export declare const dependencyAuditTool: ToolDefinition<z.infer<typeof params>, string>;
+export {};