@ikarmic/forge-core 5.1.1 → 5.2.0

package/dist/agent/agent.js

@@ -31,9 +31,11 @@ import { redact } from '../tools/redact.js';
 import { composeSkillsPrompt, selectSkills } from '../skills/activator.js';
 import { MAX_TOOL_INJECTIONS, selectAtStart, selectOnToolTouch, toWorkspaceRelative, wrapSteering } from '../steering/select.js';
 import { applyCacheHints } from './cache-hints.js';
+import { raceAbort } from './race-abort.js';
 import { attachmentParts, formatBytes, mediaPartTokens } from '../attachments.js';
 import { renderAnswersBlock } from '../journey/answers-block.js';
 import { CONTINUE_PROMPT, DEFAULT_PLAN_MODE_SUFFIX, DEFAULT_SPEC_MODE_SUFFIX, DEFAULT_SYSTEM_PROMPT, environmentBlock } from './prompts.js';
+import { detectStackFacts, stackBlock } from './stack-facts.js';
 /** Read-only tool names whose output flows through the redactor. */
 const DEFAULT_MAX_CONTINUATIONS = 3;
 export const DEFAULT_MAX_DURATION_MS = 10 * 60 * 1000;
@@ -1020,8 +1022,7 @@ export class Agent {
             if (abortSignal?.aborted)
                 return { approved: false };
             const answered = Promise.resolve(this.config.approve(request));
-            const aborted = new Promise((resolve) => abortSignal?.addEventListener('abort', () => resolve('aborted'), { once: true }));
-            const decision = await Promise.race([answered, aborted]);
+            const decision = await raceAbort(answered, abortSignal, 'aborted');
             if (decision === 'aborted')
                 return { approved: false };
             return typeof decision === 'boolean' ? { approved: decision } : decision;
@@ -1215,6 +1216,16 @@ async function buildInitialMessages(config, task, skills, steeringSystem = [], u
     // the first run: an answer that arrives on turn 3 can never enter the system
     // message, and a middle turn would be summarised away by compaction.
     const answersBlock = renderAnswersBlock(config.journeyAnswers ?? []);
+    // The versions the workspace's files state, so code is written for them and not for what training saw most.
+    let stackFactsBlock = '';
+    if (!config.disableStackFacts) {
+        try {
+            stackFactsBlock = stackBlock(await detectStackFacts(cwd));
+        }
+        catch {
+            // Skipped, never fatal.
+        }
+    }
     // Facts the model would otherwise have to guess: the platform decides
     // whether `cat` or `type` works, and it cannot see the date at all.
     const envBlock = environmentBlock({
@@ -1229,7 +1240,7 @@ async function buildInitialMessages(config, task, skills, steeringSystem = [], u
     // stable order so cache hits survive across runs that share state. The
     // environment block goes last: it is the part that varies per session.
     const steeringBlock = steeringSystem.map(wrapSteering).join('\n\n');
-    const blocks = [steeringBlock, instructionsBlock, extraInstructionsBlock, config.mcpInstructions ?? '', config.projectCommands ?? '', memoryBlock, skillsBlock, answersBlock, mapBlock, envBlock].filter((b) => b.length > 0);
+    const blocks = [steeringBlock, instructionsBlock, extraInstructionsBlock, config.mcpInstructions ?? '', config.projectCommands ?? '', memoryBlock, skillsBlock, answersBlock, mapBlock, stackFactsBlock, envBlock].filter((b) => b.length > 0);
     const systemContent = blocks.length > 0 ? `${basePrompt}\n\n${blocks.join('\n\n')}` : basePrompt;
     return [
         { role: 'system', content: systemContent },

package/dist/agent/goal.d.ts

@@ -39,15 +39,12 @@ 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"]>;
+    kind: z.ZodEnum<{
+        blocked: "blocked";
+        complete: "complete";
+    }>;
     reason: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    kind: "blocked" | "complete";
-    reason: string;
-}, {
-    kind: "blocked" | "complete";
-    reason: string;
-}>;
+}, z.core.$strip>;
 export declare function createGoalReportTool(onReport: (r: GoalReport) => void): ToolDefinition<z.infer<typeof reportParams>, {
     recorded: true;
 }>;

package/dist/agent/race-abort.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Race `work` against `signal`, resolving to `onAbort` if the signal fires first.
+ *
+ * The listener is removed once the race settles. A run's signal lives for the
+ * whole run, so a listener added per question or per approval and left behind
+ * keeps every one of those closures alive until the run ends.
+ */
+export declare function raceAbort<T, A>(work: Promise<T>, signal: AbortSignal | undefined, onAbort: A): Promise<T | A>;

package/dist/agent/race-abort.js

@@ -0,0 +1,24 @@
+/**
+ * Race `work` against `signal`, resolving to `onAbort` if the signal fires first.
+ *
+ * The listener is removed once the race settles. A run's signal lives for the
+ * whole run, so a listener added per question or per approval and left behind
+ * keeps every one of those closures alive until the run ends.
+ */
+export async function raceAbort(work, signal, onAbort) {
+    if (!signal)
+        return work;
+    if (signal.aborted)
+        return onAbort;
+    let listener;
+    const aborted = new Promise((resolve) => {
+        listener = () => resolve(onAbort);
+        signal.addEventListener('abort', listener, { once: true });
+    });
+    try {
+        return await Promise.race([work, aborted]);
+    }
+    finally {
+        signal.removeEventListener('abort', listener);
+    }
+}

package/dist/agent/stack-facts.d.ts

@@ -0,0 +1,23 @@
+export declare const MAX_STACK_LIBRARIES = 25;
+export interface StackFacts {
+    runtimes: {
+        name: string;
+        version: string;
+        source: string;
+    }[];
+    libraries: {
+        name: string;
+        version: string;
+        range: boolean;
+    }[];
+    tools: {
+        test?: string;
+        lint?: string;
+        format?: string;
+    };
+}
+/** JSON with comments and trailing commas (tsconfig.json): comments outside strings removed, then trailing commas. */
+export declare function parseJsonc(text: string): Record<string, unknown> | undefined;
+export declare function detectStackFacts(cwd: string): Promise<StackFacts>;
+/** The facts as a block for the system prompt; '' when there are none. */
+export declare function stackBlock(facts: StackFacts): string;

package/dist/agent/stack-facts.js

@@ -0,0 +1,150 @@
+/**
+ * The `<stack>` block: the language, runtime and library versions the workspace's own files state, so an
+ * agent writes code for the versions in use instead of the ones it saw most in training. File reads only,
+ * no model and no tree walk (the journey survey's rule: a missing fact costs less than a wrong one). Every
+ * source is read on its own; one that is missing or unreadable leaves its facts out and never fails a run.
+ * Only the workspace root's files are read.
+ */
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+export const MAX_STACK_LIBRARIES = 25;
+const TEST_TOOLS = { vitest: 'vitest', jest: 'jest', mocha: 'mocha', ava: 'ava', pytest: 'pytest' };
+const LINT_TOOLS = { eslint: 'eslint', '@biomejs/biome': 'biome', ruff: 'ruff', flake8: 'flake8', pylint: 'pylint' };
+const FORMAT_TOOLS = { prettier: 'prettier', '@biomejs/biome': 'biome', black: 'black', ruff: 'ruff' };
+async function read(cwd, rel) {
+    try {
+        return await readFile(path.join(cwd, rel), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function json(text) {
+    if (text === undefined)
+        return undefined;
+    try {
+        const v = JSON.parse(text);
+        return v && typeof v === 'object' && !Array.isArray(v) ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** JSON with comments and trailing commas (tsconfig.json): comments outside strings removed, then trailing commas. */
+export function parseJsonc(text) {
+    let out = '';
+    let inString = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (inString) {
+            out += c;
+            if (c === '\\')
+                out += text[++i] ?? '';
+            else if (c === '"')
+                inString = false;
+        }
+        else if (c === '"') {
+            inString = true;
+            out += c;
+        }
+        else if (c === '/' && text[i + 1] === '/') {
+            while (i < text.length && text[i] !== '\n')
+                i++;
+            out += '\n';
+        }
+        else if (c === '/' && text[i + 1] === '*') {
+            const end = text.indexOf('*/', i + 2);
+            i = end < 0 ? text.length : end + 1;
+        }
+        else
+            out += c;
+    }
+    return json(out.replace(/,(\s*[}\]])/g, '$1'));
+}
+const strings = (v) => Object.fromEntries(Object.entries(v && typeof v === 'object' ? v : {}).filter((e) => typeof e[1] === 'string'));
+async function installedVersion(cwd, name, lock) {
+    const own = json(await read(cwd, path.join('node_modules', name, 'package.json')));
+    if (typeof own?.version === 'string')
+        return own.version;
+    const entry = lock?.packages?.[`node_modules/${name}`];
+    if (typeof entry?.version === 'string')
+        return entry.version;
+    const legacy = lock?.dependencies?.[name];
+    return typeof legacy?.version === 'string' ? legacy.version : undefined;
+}
+function firstMatch(text, re) {
+    return text?.match(re)?.[1]?.trim() || undefined;
+}
+export async function detectStackFacts(cwd) {
+    const facts = { runtimes: [], libraries: [], tools: {} };
+    const runtime = (name, version, source) => {
+        if (version)
+            facts.runtimes.push({ name, version, source });
+    };
+    const noteTool = (dep) => {
+        facts.tools.test ??= TEST_TOOLS[dep];
+        facts.tools.lint ??= LINT_TOOLS[dep];
+        facts.tools.format ??= FORMAT_TOOLS[dep];
+    };
+    // Node and npm-style libraries.
+    const manifest = json(await read(cwd, 'package.json'));
+    const engines = strings(manifest?.engines);
+    runtime('node', engines.node, 'package.json engines');
+    runtime('node', firstMatch(await read(cwd, '.nvmrc'), /^\s*(\S+)/), '.nvmrc');
+    runtime('node', firstMatch(await read(cwd, '.node-version'), /^\s*(\S+)/), '.node-version');
+    if (manifest) {
+        const lock = json(await read(cwd, 'package-lock.json'));
+        const deps = Object.entries({ ...strings(manifest.dependencies) });
+        const dev = Object.entries(strings(manifest.devDependencies)).filter(([n]) => !deps.some(([d]) => d === n));
+        for (const [name] of [...deps, ...dev])
+            noteTool(name);
+        for (const [name, range] of [...deps, ...dev].slice(0, MAX_STACK_LIBRARIES)) {
+            const exact = await installedVersion(cwd, name, lock);
+            facts.libraries.push(exact ? { name, version: exact, range: false } : { name, version: range, range: true });
+        }
+    }
+    const tsconfig = await read(cwd, 'tsconfig.json');
+    const target = tsconfig === undefined ? undefined : parseJsonc(tsconfig)?.compilerOptions?.target;
+    if (typeof target === 'string')
+        runtime('tsconfig target', target, 'tsconfig.json');
+    // Python.
+    runtime('python', firstMatch(await read(cwd, 'pyproject.toml'), /^\s*requires-python\s*=\s*["']([^"']+)["']/m), 'pyproject.toml');
+    runtime('python', firstMatch(await read(cwd, '.python-version'), /^\s*(\S+)/), '.python-version');
+    const requirements = await read(cwd, 'requirements.txt');
+    for (const line of requirements?.split(/\r?\n/) ?? []) {
+        const m = line.match(/^\s*([A-Za-z0-9._-]+)\s*==\s*([^\s;#]+)/);
+        if (!m)
+            continue;
+        noteTool(m[1].toLowerCase());
+        if (facts.libraries.length < MAX_STACK_LIBRARIES)
+            facts.libraries.push({ name: m[1], version: m[2], range: false });
+    }
+    // Go, Rust, Java.
+    runtime('go', firstMatch(await read(cwd, 'go.mod'), /^\s*go\s+(\d[\w.]*)\s*$/m), 'go.mod');
+    runtime('rust edition', firstMatch(await read(cwd, 'Cargo.toml'), /^\s*edition\s*=\s*["']([^"']+)["']/m), 'Cargo.toml');
+    runtime('rust', firstMatch(await read(cwd, 'rust-toolchain.toml'), /^\s*channel\s*=\s*["']([^"']+)["']/m), 'rust-toolchain.toml');
+    runtime('rust', firstMatch(await read(cwd, 'rust-toolchain'), /^\s*(\S+)/), 'rust-toolchain');
+    const pom = await read(cwd, 'pom.xml');
+    runtime('java', firstMatch(pom, /<maven\.compiler\.release>\s*([^<\s]+)\s*</) ?? firstMatch(pom, /<java\.version>\s*([^<\s]+)\s*</), 'pom.xml');
+    for (const gradle of ['build.gradle.kts', 'build.gradle']) {
+        const text = await read(cwd, gradle);
+        runtime('java', firstMatch(text, /JavaLanguageVersion\.of\(\s*(\d+)\s*\)/) ?? firstMatch(text, /JavaVersion\.VERSION_(\d+(?:_\d+)?)/), gradle);
+    }
+    for (const k of Object.keys(facts.tools))
+        if (facts.tools[k] === undefined)
+            delete facts.tools[k];
+    return facts;
+}
+/** The facts as a block for the system prompt; '' when there are none. */
+export function stackBlock(facts) {
+    const lines = [
+        ...facts.runtimes.map((r) => `${r.name} ${r.version} (${r.source})`),
+        ...facts.libraries.map((l) => (l.range ? `${l.name} ${l.version} (range in the manifest; installed version unknown)` : `${l.name} ${l.version}`)),
+        ...(facts.tools.test ? [`test runner: ${facts.tools.test}`] : []),
+        ...(facts.tools.lint ? [`linter: ${facts.tools.lint}`] : []),
+        ...(facts.tools.format ? [`formatter: ${facts.tools.format}`] : []),
+    ];
+    if (lines.length === 0)
+        return '';
+    return ['<stack>', "Versions this workspace's files state (read from the files, not guessed):", ...lines, '</stack>'].join('\n');
+}

package/dist/code-index/parser.js

@@ -1,3 +1,4 @@
+import { existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import Parser from 'web-tree-sitter';
@@ -44,6 +45,47 @@ const KIND_BY_NODE_TYPE = {
     method_definition: 'method',
     method_signature: 'method',
 };
+/**
+ * The folder of a bundle that carries its wasm files beside it, or null. The VS Code extension's build copies the
+ * runtime and grammar wasm into `dist/` next to `extension.js`, and its VSIX has no node_modules to resolve from.
+ * `typeof` keeps this safe under real ESM, where `__dirname` is not defined.
+ */
+function bundledWasmDir() {
+    if (typeof __dirname !== 'string')
+        return null;
+    return existsSync(path.join(__dirname, 'tree-sitter.wasm')) ? __dirname : null;
+}
+/** web-tree-sitter's runtime wasm, beside the bundle or resolved from the package; throws when this build does not carry it. */
+function treeSitterWasm() {
+    const bundled = bundledWasmDir();
+    if (bundled)
+        return path.join(bundled, 'tree-sitter.wasm');
+    let file;
+    try {
+        file = path.join(path.dirname(getRequire().resolve('web-tree-sitter/package.json')), 'tree-sitter.wasm');
+    }
+    catch {
+        throw new Error('Symbol tools are not available in this build: tree-sitter (web-tree-sitter) is not installed. Use search_files instead.');
+    }
+    if (!existsSync(file)) {
+        throw new Error(`Symbol tools are not available in this build: ${file} is missing. Use search_files instead.`);
+    }
+    return file;
+}
+/** A grammar's wasm, beside the bundle or from `tree-sitter-wasms`; throws when this build does not carry it. */
+function grammarWasm(grammarFile) {
+    let file;
+    try {
+        file = path.join(bundledWasmDir() ?? path.join(path.dirname(getRequire().resolve('tree-sitter-wasms/package.json')), 'out'), grammarFile);
+    }
+    catch {
+        throw new Error('Symbol tools are not available in this build: tree-sitter grammars (tree-sitter-wasms) are not installed. Use search_files instead.');
+    }
+    if (!existsSync(file)) {
+        throw new Error(`Symbol tools are not available in this build: ${file} is missing. Use search_files instead.`);
+    }
+    return file;
+}
 let parserInitialized = false;
 const languageCache = new Map();
 async function loadLanguage(ext) {
@@ -54,11 +96,14 @@ async function loadLanguage(ext) {
     if (cached)
         return cached;
     if (!parserInitialized) {
-        await Parser.init();
+        // Point web-tree-sitter at its own wasm. Left to itself it looks next to the running script, which in the
+        // extension's one-file CommonJS bundle is dist/, and aborts when the file is not there: the promise never
+        // settles and every symbol tool call hangs (RB-40). A missing wasm is a clear, immediate error instead.
+        const wasm = treeSitterWasm();
+        await Parser.init({ locateFile: () => wasm });
         parserInitialized = true;
     }
-    const wasmDir = path.join(path.dirname(getRequire().resolve('tree-sitter-wasms/package.json')), 'out');
-    const lang = await Parser.Language.load(path.join(wasmDir, grammarFile));
+    const lang = await Parser.Language.load(grammarWasm(grammarFile));
     languageCache.set(grammarFile, lang);
     return lang;
 }

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

@@ -49,11 +49,7 @@ export interface PullRequestReport {
 }
 declare const readParams: z.ZodObject<{
     number: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    number?: number | undefined;
-}, {
-    number?: number | undefined;
-}>;
+}, z.core.$strip>;
 export declare function createGitHubReadTool(cfg: GitHubConfig): ToolDefinition<z.infer<typeof readParams>, PullRequestReport>;
 declare const createParams: z.ZodObject<{
     title: z.ZodString;
@@ -61,19 +57,7 @@ declare const createParams: z.ZodObject<{
     base: z.ZodOptional<z.ZodString>;
     head: z.ZodOptional<z.ZodString>;
     draft: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    body: string;
-    title: string;
-    draft?: boolean | undefined;
-    base?: string | undefined;
-    head?: string | undefined;
-}, {
-    body: string;
-    title: string;
-    draft?: boolean | undefined;
-    base?: string | undefined;
-    head?: string | undefined;
-}>;
+}, z.core.$strip>;
 export declare function createGitHubCreateTool(cfg: GitHubConfig): ToolDefinition<z.infer<typeof createParams>, {
     number: number;
     url: string;

package/dist/index.d.ts

@@ -42,7 +42,7 @@ export { createLanguageModel, formatModelId, pickAvailableProvider, resolveModel
 export { defaultSessionDir, generateSessionId, saveSession, loadSession, deleteSession, listSessions, findLatestSession, formatSessionMarkdown, formatSessionJson, appendedSince, summarizeMessage, watchSession, searchSessions, sessionText, pruneSessions, pruneByRetention, } from './sessions/index.js';
 export type { Session, ListEntry, FormatOptions, SessionUpdate, WatchSessionOptions, SessionMatch, SearchSessionsOptions, SessionPruneOptions, SessionPruneResult } from './sessions/index.js';
 export { commandDirs, expandCustomCommand, formatCustomCommands, loadCustomCommands, parseCommandFile, type CustomCommand, } from './commands/custom-commands.js';
-export { BUILTIN_TOOLS, editFileTool, fetchUrlTool, findSymbolTool, listFilesTool, memoryReadTool, memoryForgetTool, memoryWriteTool, readFileTool, runCommandTool, searchFilesTool, subAgentTool, writeFileTool, checkPolicyViolation, globToRegex, mergeToolSandbox, normalizePathPattern, pathMatchesAny, redact, countRedactions, buildRules, ToolResultCache, buildCacheKey, cachedExecute, } from './tools/index.js';
+export { BUILTIN_TOOLS, editFileTool, fetchUrlTool, findSymbolTool, gitDiffTool, dependencyAuditTool, listFilesTool, memoryReadTool, memoryForgetTool, memoryWriteTool, readFileTool, runCommandTool, searchFilesTool, subAgentTool, writeFileTool, checkPolicyViolation, globToRegex, mergeToolSandbox, normalizePathPattern, pathMatchesAny, redact, countRedactions, buildRules, ToolResultCache, buildCacheKey, cachedExecute, } from './tools/index.js';
 export type { AgentConfig, AgentEvent, AgentRunOptions, AgentRunReason, AgentRunResult, AnyLanguageModel, ApprovalDecision, CommandRunner, ModelRouter, VerifyConfig, ApprovalRequest, LanguageModelFactory, ModelConfig, PricePerMillionTokens, ProviderName, RedactOptions, TodoItem, ToolContext, UserQuestion, ToolDefinition, ToolPolicy, ToolSandbox, } from './types.js';
 export type { CacheKeyParts, CacheStats } from './tools/index.js';
 export type { RedactionRule, RedactionResult } from './tools/index.js';
@@ -82,7 +82,7 @@ export { CheckpointStore, type CheckpointStoreLimits } from './checkpoints/index
 export type { CaptureOptions, Checkpoint, CheckpointFile, CheckpointFileStatus, CheckpointSummary, CheckpointTrigger, PruneResult, RestoreResult, } from './checkpoints/index.js';
 export { SpecStore, isSafeSpecId, runKey, slugifyTaskForSpecId, SPEC_READONLY_TOOLS, splitRequirementsDesign, splitSpecSections, splitTasksSection, convertToCheckboxes, parseTasks, setTaskDone, changedSince, changeSize, keepDoneTasks, referencedPaths, specDrift, syncSpecTask } from './specs/index.js';
 export type { SpecDraft, SpecRunRecord, SpecRuns, SpecSections, SpecSummary, SpecTask, SpecDrift } from './specs/index.js';
-export { BUILTIN_SPECIALISTS, defaultConfigPath, effectiveToolsFor, BOARD_TOOL_NAMES, createBoardTools, DEFAULT_BOARD_CAP, getRegisteredSpecialist, getSpecialist, MessageBoard, listSpecialists, loadSpecialistsFromConfig, parseRouterOutput, registerSpecialist, resolveEffectiveModel, ROUTER_SYSTEM_PROMPT, runOrchestrator, runRouter, saveSpecialistsToConfig, unregisterSpecialist, validateSpecialistConfig, _resetSpecialistsForTests, _customSpecialistCount, } from './orchestrator/index.js';
+export { BUILTIN_SPECIALISTS, defaultConfigPath, effectiveToolsFor, BOARD_TOOL_NAMES, createBoardTools, DEFAULT_BOARD_CAP, getRegisteredSpecialist, getSpecialist, MessageBoard, listSpecialists, loadSpecialistsFromConfig, parseRouterOutput, registerSpecialist, resolveEffectiveModel, ROUTER_SYSTEM_PROMPT, specialistAgentConfig, runOrchestrator, runRouter, saveSpecialistsToConfig, unregisterSpecialist, validateSpecialistConfig, _resetSpecialistsForTests, _customSpecialistCount, } from './orchestrator/index.js';
 export type { BoardMessage } from './orchestrator/index.js';
 export type { BuiltInSpecialistId, CustomSpecialistConfig, LoadSpecialistsResult, OrchestratorOptions, OrchestratorPlan, OrchestratorProgressEvent, OrchestratorRunResult, OrchestratorStep, OrchestratorStepResult, SpecialistConfig, SpecialistId, SpecialistsConfigFile, } from './orchestrator/index.js';
 export { computeUnifiedDiff, computeDiffSummary, type DiffOptions, type DiffResult, type DiffSummary, } from './diff/index.js';
@@ -95,6 +95,9 @@ export { formatSteeringLine, isSafeSteeringName, loadSteering, overrideFilePath,
 export type { StartSelection, SteeringConfig, SteeringDoc, SteeringInclusion, SteeringLoadResult, SteeringSkip, } from './steering/index.js';
 export { CONFIG_KEY_COVERAGE, FORGE_CONFIG_SCHEMA } from './config-schema.js';
 export { FILE_WRITE_TOOL_NAMES, filesTouchedBy } from './tools/write-tools.js';
+export { isSafeGitRef, MAX_DIFF_CHARS } from './tools/git-diff.js';
+export { detectStackFacts, stackBlock, MAX_STACK_LIBRARIES, type StackFacts } from './agent/stack-facts.js';
+export { pickAuditors, type AuditFinding, type AuditorPlan } from './tools/dependency-audit.js';
 export { shellEnv } from './tools/shell-env.js';
 export { previewPatch } from './tools/apply-patch.js';
 export type { PatchPreview } from './tools/apply-patch.js';

package/dist/index.js

@@ -26,7 +26,7 @@ export { loadMcpConfig, parseMcpConfig, connectAll, connectOne, closeAll, mcpRes
 export { createLanguageModel, formatModelId, pickAvailableProvider, resolveModelFromEnv, resolveModelFromEnvAsync } from './providers.js';
 export { defaultSessionDir, generateSessionId, saveSession, loadSession, deleteSession, listSessions, findLatestSession, formatSessionMarkdown, formatSessionJson, appendedSince, summarizeMessage, watchSession, searchSessions, sessionText, pruneSessions, pruneByRetention, } from './sessions/index.js';
 export { commandDirs, expandCustomCommand, formatCustomCommands, loadCustomCommands, parseCommandFile, } from './commands/custom-commands.js';
-export { BUILTIN_TOOLS, editFileTool, fetchUrlTool, findSymbolTool, listFilesTool, memoryReadTool, memoryForgetTool, memoryWriteTool, readFileTool, runCommandTool, searchFilesTool, subAgentTool, writeFileTool, checkPolicyViolation, globToRegex, mergeToolSandbox, normalizePathPattern, pathMatchesAny, redact, countRedactions, buildRules, ToolResultCache, buildCacheKey, cachedExecute, } from './tools/index.js';
+export { BUILTIN_TOOLS, editFileTool, fetchUrlTool, findSymbolTool, gitDiffTool, dependencyAuditTool, listFilesTool, memoryReadTool, memoryForgetTool, memoryWriteTool, readFileTool, runCommandTool, searchFilesTool, subAgentTool, writeFileTool, checkPolicyViolation, globToRegex, mergeToolSandbox, normalizePathPattern, pathMatchesAny, redact, countRedactions, buildRules, ToolResultCache, buildCacheKey, cachedExecute, } from './tools/index.js';
 // Skills system
 export { buildSkillsBlock, builtinSkills, composeSkillsPrompt, discoverSkills, fetchSkillsCatalog, installSkillFromCatalog, loadSkillsRegistry, loadSkillsRegistryAsync, parseSkill, parseSkillsDir, resolveSkillRoots, scoreSkill, searchSkills, selectSkills, skillsRegistryFromList, DEFAULT_SKILL_CATALOG_URL, GLOBAL_SKILLS_DIR, LOCAL_SKILLS_DIR, PROJECT_SKILLS_DIR, SKILL_CATALOG_VERSION, } from './skills/index.js';
 export { cosine, embedderFromEnv, hashingEmbedder, openAiCompatibleEmbedder, } from './semantic/embedder.js';
@@ -55,7 +55,7 @@ export { CheckpointStore } from './checkpoints/index.js';
 // Specs system (spec-driven planning mode)
 export { SpecStore, isSafeSpecId, runKey, slugifyTaskForSpecId, SPEC_READONLY_TOOLS, splitRequirementsDesign, splitSpecSections, splitTasksSection, convertToCheckboxes, parseTasks, setTaskDone, changedSince, changeSize, keepDoneTasks, referencedPaths, specDrift, syncSpecTask } from './specs/index.js';
 // Orchestrator system
-export { BUILTIN_SPECIALISTS, defaultConfigPath, effectiveToolsFor, BOARD_TOOL_NAMES, createBoardTools, DEFAULT_BOARD_CAP, getRegisteredSpecialist, getSpecialist, MessageBoard, listSpecialists, loadSpecialistsFromConfig, parseRouterOutput, registerSpecialist, resolveEffectiveModel, ROUTER_SYSTEM_PROMPT, runOrchestrator, runRouter, saveSpecialistsToConfig, unregisterSpecialist, validateSpecialistConfig, _resetSpecialistsForTests, _customSpecialistCount, } from './orchestrator/index.js';
+export { BUILTIN_SPECIALISTS, defaultConfigPath, effectiveToolsFor, BOARD_TOOL_NAMES, createBoardTools, DEFAULT_BOARD_CAP, getRegisteredSpecialist, getSpecialist, MessageBoard, listSpecialists, loadSpecialistsFromConfig, parseRouterOutput, registerSpecialist, resolveEffectiveModel, ROUTER_SYSTEM_PROMPT, specialistAgentConfig, runOrchestrator, runRouter, saveSpecialistsToConfig, unregisterSpecialist, validateSpecialistConfig, _resetSpecialistsForTests, _customSpecialistCount, } from './orchestrator/index.js';
 // Diff utilities (line-level unified diff)
 export { computeUnifiedDiff, computeDiffSummary, } from './diff/index.js';
 // Structured output (`--schema` mode)
@@ -75,6 +75,9 @@ export { branchChangedFiles, branchDiff, commitAllInWorktree, compareWorktreeCon
 export { formatSteeringLine, isSafeSteeringName, loadSteering, overrideFilePath, parseSteering, pathMatchesGlob, readOverride, selectAtStart, selectOnToolTouch, setSteeringDisabled, stripSteering, wrapSteering, } from './steering/index.js';
 export { CONFIG_KEY_COVERAGE, FORGE_CONFIG_SCHEMA } from './config-schema.js';
 export { FILE_WRITE_TOOL_NAMES, filesTouchedBy } from './tools/write-tools.js';
+export { isSafeGitRef, MAX_DIFF_CHARS } from './tools/git-diff.js';
+export { detectStackFacts, stackBlock, MAX_STACK_LIBRARIES } from './agent/stack-facts.js';
+export { pickAuditors } from './tools/dependency-audit.js';
 export { shellEnv } from './tools/shell-env.js';
 export { previewPatch } from './tools/apply-patch.js';
 export { applyPatchTool, parsePatch, patchedPaths } from './tools/apply-patch.js';

package/dist/journey/answers-block.js

@@ -1,3 +1,16 @@
+/**
+ * One pass is not enough: removing the tag from `</journey-</journey-answers>answers>`
+ * joins the halves into a fresh one. Repeat until nothing changes.
+ */
+function stripClosingTag(text) {
+    let prev;
+    let out = text;
+    do {
+        prev = out;
+        out = out.replace(/<\/journey-answers>/gi, '');
+    } while (out !== prev);
+    return out;
+}
 export function renderAnswersBlock(answers) {
     // A dismissed question comes back with an empty answer. Rendering it under
     // "these are decisions" would present an open question as settled, which
@@ -5,7 +18,7 @@ export function renderAnswersBlock(answers) {
     const answered = answers.filter((a) => a.answer.trim() !== '');
     if (answered.length === 0)
         return '';
-    const lines = answered.map((a) => `- ${a.question}: ${a.answer.replace(/<\/journey-answers>/gi, '')}`);
+    const lines = answered.map((a) => `- ${a.question}: ${stripClosingTag(a.answer)}`);
     return [
         '<journey-answers>',
         'The person answered these before work started. They are decisions, not suggestions:',

package/dist/journey/offer.js

@@ -27,7 +27,8 @@ function areaOf(rel) {
 export function decideOffer(facts, verdict) {
     if (!verdict.survey)
         return { offer: false, evidence: [] };
-    const areas = [...new Set(facts.relatedSymbols.map(areaOf))];
+    // A root file is not an area, so it neither counts toward MIN_AREAS nor appears in the evidence.
+    const areas = [...new Set(facts.relatedSymbols.map(areaOf))].filter((a) => a !== ROOT_AREA);
     if (facts.relatedSymbols.length === 0) {
         const where = facts.sourceFileCount === 0
             ? 'no source files here yet'

package/dist/mcp/json-schema-to-zod.js

@@ -55,7 +55,18 @@ export function jsonSchemaToZod(schema) {
                     const propZod = jsonSchemaToZod(propSchema);
                     shape[key] = required.has(key) ? propZod : propZod.optional();
                 }
-                inner = z.object(shape).passthrough();
+                const objectZod = z.object(shape).passthrough();
+                // Zod 4 reads a missing `__proto__` key off the prototype chain and skips the property, so a required one is checked on the raw input first.
+                inner =
+                    required.has('__proto__') && Object.prototype.hasOwnProperty.call(s.properties, '__proto__')
+                        ? z
+                            .any()
+                            .refine((v) => typeof v === 'object' && v !== null && Object.prototype.hasOwnProperty.call(v, '__proto__'), {
+                            message: 'Invalid input: required property "__proto__" is missing',
+                            path: ['__proto__'],
+                        })
+                            .pipe(objectZod)
+                        : objectZod;
             }
             else if (s.additionalProperties === true) {
                 inner = z.record(z.string(), z.any());

package/dist/orchestrator/index.d.ts

@@ -7,7 +7,7 @@
  */
 export { BUILTIN_SPECIALISTS, getSpecialist, effectiveToolsFor } from './specialists.js';
 export { parseRouterOutput, ROUTER_SYSTEM_PROMPT } from './router.js';
-export { runOrchestrator, runRouter, groupStepsByParallel, resolveEffectiveModel, _dispatchGroup, type OrchestratorOptions, type OrchestratorProgressEvent, type OrchestratorWorktreeMode, } from './orchestrator.js';
+export { runOrchestrator, runRouter, groupStepsByParallel, resolveEffectiveModel, specialistAgentConfig, handoffBlock, MAX_HANDOFF_CHARS, _dispatchGroup, type OrchestratorOptions, type StepLimits, type OrchestratorProgressEvent, type OrchestratorWorktreeMode, } from './orchestrator.js';
 export { MessageBoard, DEFAULT_BOARD_CAP, type BoardMessage } from './board.js';
 export { createBoardTools, BOARD_TOOL_NAMES } from './board-tools.js';
 export { registerSpecialist, unregisterSpecialist, listSpecialists, getRegisteredSpecialist, loadSpecialistsFromConfig, saveSpecialistsToConfig, validateSpecialistConfig, defaultConfigPath, _resetSpecialistsForTests, _customSpecialistCount, type CustomSpecialistConfig, type SpecialistsConfigFile, type LoadSpecialistsResult, } from './specialists-registry.js';

package/dist/orchestrator/index.js

@@ -7,7 +7,7 @@
  */
 export { BUILTIN_SPECIALISTS, getSpecialist, effectiveToolsFor } from './specialists.js';
 export { parseRouterOutput, ROUTER_SYSTEM_PROMPT } from './router.js';
-export { runOrchestrator, runRouter, groupStepsByParallel, resolveEffectiveModel, _dispatchGroup, } from './orchestrator.js';
+export { runOrchestrator, runRouter, groupStepsByParallel, resolveEffectiveModel, specialistAgentConfig, handoffBlock, MAX_HANDOFF_CHARS, _dispatchGroup, } from './orchestrator.js';
 export { MessageBoard, DEFAULT_BOARD_CAP } from './board.js';
 export { createBoardTools, BOARD_TOOL_NAMES } from './board-tools.js';
 export { registerSpecialist, unregisterSpecialist, listSpecialists, getRegisteredSpecialist, loadSpecialistsFromConfig, saveSpecialistsToConfig, validateSpecialistConfig, defaultConfigPath, _resetSpecialistsForTests, _customSpecialistCount, } from './specialists-registry.js';

package/dist/orchestrator/orchestrator.d.ts

@@ -29,7 +29,8 @@
  *     AND the step is part of a parallel group. Solo steps never get
  *     a worktree (it's wasted overhead).
  */
-import type { AgentConfig, AgentRunResult, ModelConfig } from '../types.js';
+import type { PermissionConfig } from '../tools/permission-rules.js';
+import type { AgentConfig, AgentRunResult, ModelConfig, ToolSandbox } from '../types.js';
 import { MessageBoard, type BoardMessage } from './board.js';
 import type { OrchestratorPlan, OrchestratorRunResult, OrchestratorStep, OrchestratorStepResult, SpecialistConfig } from './types.js';
 /**
@@ -63,6 +64,12 @@ export interface OrchestratorOptions {
     maxParallelism?: number;
     /** Approval callback for the router (specialists don't ask the user: they're scoped). */
     approve?: AgentConfig['approve'];
+    /** Tools a step runs without asking (the person's `autoApproveTools`); default: the read-only tools. */
+    autoApproveTools?: readonly string[];
+    /** The person's permission rules, kept by every step. */
+    permissionRules?: PermissionConfig;
+    /** The person's tool sandbox; a step's tools are narrowed to its `allowTools`. */
+    toolSandbox?: ToolSandbox;
     /** Optional modelFactory override (for tests). */
     modelFactory?: AgentConfig['modelFactory'];
     /**
@@ -180,11 +187,7 @@ export declare function runOrchestrator(options: OrchestratorOptions): Promise<O
  * git worktree. When `always`, every step gets a worktree regardless
  * of group size. `never` disables the feature.
  */
-export declare function _dispatchGroup(group: OrchestratorStep[], base: {
-    model: ModelConfig;
-    cwd?: string;
-    modelFactory?: AgentConfig['modelFactory'];
-}, dispatchOpts: {
+export declare function _dispatchGroup(group: OrchestratorStep[], base: StepBase, dispatchOpts: {
     worktrees: OrchestratorWorktreeMode;
     cleanupBranches?: boolean;
     commitChanges?: boolean;
@@ -195,6 +198,8 @@ export declare function _dispatchGroup(group: OrchestratorStep[], base: {
     }) => void;
     onWorktreeEvent?: OrchestratorOptions['onWorktreeEvent'];
     board?: MessageBoard;
+    /** Results of the groups that ran before this one, handed to every step of this group. */
+    prior?: readonly OrchestratorStepResult[];
 }, maxParallelism: number): Promise<OrchestratorStepResult[]>;
 /**
  * Run the router agent. Exposed for testing + for the
@@ -233,3 +238,37 @@ export declare function runRouter(args: {
  * without going through `Agent.run()`.
  */
 export declare function resolveEffectiveModel(spec: SpecialistConfig, baseModel: ModelConfig): ModelConfig;
+/** The most of one earlier step's reply handed to a later step. */
+export declare const MAX_HANDOFF_CHARS = 6000;
+/**
+ * What the earlier steps of an orchestrator run produced, for a later step. Without it each step saw only the
+ * line the router wrote before any step ran, so in "plan, then code" Code never saw Plan's plan.
+ */
+export declare function handoffBlock(prior: readonly OrchestratorStepResult[]): string;
+/** What a step inherits from the run: the model, where it works, and the limits the person set. */
+interface StepBase {
+    model: ModelConfig;
+    cwd?: string;
+    modelFactory?: AgentConfig['modelFactory'];
+    limits?: StepLimits;
+}
+/** The person's limits a step must keep: a step has no one to ask, so these decide what it may do (RB-14, RB-39). */
+export interface StepLimits {
+    autoApproveTools?: readonly string[];
+    permissionRules?: PermissionConfig;
+    toolSandbox?: ToolSandbox;
+}
+/**
+ * The Agent configuration for one orchestrator step. The step sees exactly its agent's effective tools
+ * (builtins off, the sandbox narrowed to that list), and runs its read-only tools without asking, as a
+ * `sub_agent` child does: there is no one to ask, so without the list every such call is refused.
+ */
+export declare function specialistAgentConfig(args: {
+    spec: SpecialistConfig;
+    model: ModelConfig;
+    cwd?: string;
+    modelFactory?: AgentConfig['modelFactory'];
+    board?: MessageBoard;
+    limits: StepLimits;
+}): AgentConfig;
+export {};