@ikarmic/forge-core 5.1.1 → 5.2.0

package/dist/tools/git-diff.js

@@ -0,0 +1,85 @@
+/**
+ * `git_diff`: the current changes, read-only, so Review and Security can see what changed without a
+ * `run_command` approval card. It runs one fixed program with fixed flags; the model chooses only a base
+ * ref, staged or not, and paths. A base that looks like an option is refused: `git diff --output=<file>`
+ * writes a file, and an option passed where a ref belongs is how a model (or a prompt it read) gets there.
+ */
+import { execFile } from 'node:child_process';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+import { resolveOnPath } from '../lsp/client.js';
+import { resolveAndCheckPath } from './shared.js';
+import { shellEnv } from './shell-env.js';
+const run = promisify(execFile);
+/** The most diff text handed to the model; the rest is cut with a note. */
+export const MAX_DIFF_CHARS = 60_000;
+const params = z.object({
+    base: z
+        .string()
+        .optional()
+        .describe('Compare against this ref (a branch, tag, commit or range such as main...HEAD). Default: HEAD, i.e. your uncommitted changes.'),
+    staged: z.boolean().optional().describe('Only the staged changes (git diff --cached).'),
+    paths: z.array(z.string()).optional().describe('Limit the diff to these files or folders inside the project.'),
+});
+/** A ref git will read as a ref, never as an option: no leading dash, only the characters refs and ranges use. */
+export function isSafeGitRef(ref) {
+    return ref.length > 0 && !ref.startsWith('-') && /^[A-Za-z0-9._/~^@{}:-]+$/.test(ref);
+}
+async function git(args, cwd) {
+    const env = shellEnv(process.env);
+    const program = resolveOnPath('git', env, process.platform) ?? 'git';
+    try {
+        // No repository code and no lock on the person's index: core.fsmonitor names a program git would run for
+        // status, and an optional index refresh can collide with the person's own commit (RB-41).
+        const safe = ['-c', 'core.fsmonitor=false', '--no-optional-locks', ...args];
+        const { stdout, stderr } = await run(program, safe, { cwd, env, maxBuffer: 64 * 1024 * 1024, windowsHide: true });
+        return { ok: true, stdout, stderr };
+    }
+    catch (err) {
+        const e = err;
+        return { ok: false, stdout: e.stdout ?? '', stderr: e.stderr ?? e.message };
+    }
+}
+function cut(text) {
+    if (text.length <= MAX_DIFF_CHARS)
+        return text;
+    const left = text.length - MAX_DIFF_CHARS;
+    return `${text.slice(0, MAX_DIFF_CHARS)}\n[diff cut: ${left} characters left out. Pass paths to see one file at a time.]`;
+}
+export const gitDiffTool = {
+    name: 'git_diff',
+    description: 'Show the current changes as a unified diff, plus new untracked files. Read-only: it never changes files or the repository. ' +
+        'By default it compares your working tree and staged changes with HEAD; pass base to compare with a branch or commit, staged for staged changes only, paths to narrow it.',
+    parameters: params,
+    execute: async (args, ctx) => {
+        if (args.base !== undefined && !isSafeGitRef(args.base)) {
+            return `git_diff refused the base "${args.base}": a base must be a branch, tag, commit or range, and must not start with "-".`;
+        }
+        const rels = (args.paths ?? []).map((p) => path.relative(ctx.cwd, resolveAndCheckPath(p, ctx)) || '.');
+        const inside = await git(['rev-parse', '--is-inside-work-tree'], ctx.cwd);
+        if (!inside.ok || inside.stdout.trim() !== 'true')
+            return 'This folder is not a git repository, so there is no diff to show.';
+        const diffArgs = ['diff', '--no-ext-diff', '--no-textconv', '--no-color'];
+        // A repository with no commit has no HEAD: its staged files are the change.
+        const hasHead = (await git(['rev-parse', '--verify', '--quiet', 'HEAD'], ctx.cwd)).ok;
+        if (args.staged || (!args.base && !hasHead))
+            diffArgs.push('--cached');
+        else if (!args.base)
+            diffArgs.push('HEAD');
+        if (args.base)
+            diffArgs.push(args.base);
+        diffArgs.push('--', ...rels);
+        const diff = await git(diffArgs, ctx.cwd);
+        if (!diff.ok)
+            return `git diff failed: ${diff.stderr.trim()}`;
+        const status = await git(['status', '--porcelain=v1', '--', ...rels], ctx.cwd);
+        const parts = [diff.stdout.trim() ? diff.stdout : '(no changes in tracked files)'];
+        if (status.ok && status.stdout.trim())
+            parts.push(`git status:\n${status.stdout}`);
+        if (status.ok && /^\?\? /m.test(status.stdout)) {
+            parts.push('Untracked files (marked ??) are new and not shown in the diff above: read them with read_file.');
+        }
+        return cut(parts.join('\n'));
+    },
+};

package/dist/tools/index.d.ts

@@ -3,6 +3,8 @@ import { editFileTool } from './edit-file.js';
 import { fetchUrlTool } from './fetch-url.js';
 import { findReferencesTool } from './find-references.js';
 import { findSymbolTool } from './find-symbol.js';
+import { dependencyAuditTool } from './dependency-audit.js';
+import { gitDiffTool } from './git-diff.js';
 import { listFilesTool } from './list-files.js';
 import { listSymbolsTool } from './list-symbols.js';
 import { memoryForgetTool, memoryReadTool, memoryWriteTool } from './memory.js';
@@ -30,7 +32,7 @@ type AnyToolDefinition = ToolDefinition<any, any>;
  * intentional: the model sees this order in its tool list.
  */
 export declare const BUILTIN_TOOLS: readonly AnyToolDefinition[];
-export { applyPatchTool, askUserTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, todoReadTool, todoWriteTool, writeFileTool, };
+export { applyPatchTool, askUserTool, dependencyAuditTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, gitDiffTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, todoReadTool, todoWriteTool, writeFileTool, };
 export type { ToolContext, ToolDefinition, ToolPolicy, ToolSandbox } from '../types.js';
 export { checkPolicyViolation, globToRegex, mergeToolSandbox, normalizePathPattern, pathMatchesAny } from './policy.js';
 export { redact, countRedactions, buildRules } from './redact.js';

package/dist/tools/index.js

@@ -3,6 +3,8 @@ import { editFileTool } from './edit-file.js';
 import { fetchUrlTool } from './fetch-url.js';
 import { findReferencesTool } from './find-references.js';
 import { findSymbolTool } from './find-symbol.js';
+import { dependencyAuditTool } from './dependency-audit.js';
+import { gitDiffTool } from './git-diff.js';
 import { listFilesTool } from './list-files.js';
 import { listSymbolsTool } from './list-symbols.js';
 import { memoryForgetTool, memoryReadTool, memoryWriteTool } from './memory.js';
@@ -30,6 +32,8 @@ export const BUILTIN_TOOLS = [
     findSymbolTool,
     listSymbolsTool,
     findReferencesTool,
+    gitDiffTool,
+    dependencyAuditTool,
     writeFileTool,
     editFileTool,
     applyPatchTool,
@@ -45,7 +49,7 @@ export const BUILTIN_TOOLS = [
     todoReadTool,
     askUserTool,
 ];
-export { applyPatchTool, askUserTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, todoReadTool, todoWriteTool, writeFileTool, };
+export { applyPatchTool, askUserTool, dependencyAuditTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, gitDiffTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, todoReadTool, todoWriteTool, writeFileTool, };
 export { checkPolicyViolation, globToRegex, mergeToolSandbox, normalizePathPattern, pathMatchesAny } from './policy.js';
 export { redact, countRedactions, buildRules } from './redact.js';
 export { ToolResultCache, buildCacheKey, cachedExecute } from './result-cache.js';

package/dist/tools/list-files.d.ts

@@ -2,30 +2,12 @@ import { z } from 'zod';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     path: z.ZodOptional<z.ZodString>;
-    /** Maximum entries to return. Defaults to 500. */
     max_entries: z.ZodOptional<z.ZodNumber>;
-    /** Include dotfiles. Default false. */
     include_hidden: z.ZodOptional<z.ZodBoolean>;
     include_ignored: z.ZodOptional<z.ZodBoolean>;
-    /** Recurse into subdirectories. Default false. */
     recursive: z.ZodOptional<z.ZodBoolean>;
-    /** Max recursion depth when recursive=true. Default 4. */
     max_depth: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    path?: string | undefined;
-    recursive?: boolean | undefined;
-    max_entries?: number | undefined;
-    include_hidden?: boolean | undefined;
-    include_ignored?: boolean | undefined;
-    max_depth?: number | undefined;
-}, {
-    path?: string | undefined;
-    recursive?: boolean | undefined;
-    max_entries?: number | undefined;
-    include_hidden?: boolean | undefined;
-    include_ignored?: boolean | undefined;
-    max_depth?: number | undefined;
-}>;
+}, z.core.$strip>;
 export interface ListEntry {
     path: string;
     type: 'file' | 'directory' | 'other';

package/dist/tools/list-symbols.d.ts

@@ -3,11 +3,7 @@ import type { SymbolKind } from '../code-index/types.js';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     path: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>;
+}, z.core.$strip>;
 export interface SymbolOutlineEntry {
     name: string;
     kind: SymbolKind;

package/dist/tools/memory.d.ts

@@ -2,21 +2,13 @@ import { z } from 'zod';
 import { type MemoryType } from '../memory/memory-store.js';
 import type { ToolDefinition } from '../types.js';
 declare const readParams: z.ZodObject<{
-    /**
-     * Which memory to read: 'project' (default), 'global', or 'both'. 'both'
-     * returns the merged view with project overriding global on heading
-     * collisions: the same view the system-prompt injector sees.
-     */
-    scope: z.ZodOptional<z.ZodEnum<["project", "global", "both"]>>;
-    /** Optional heading to filter by. Returns just that section's body. */
+    scope: z.ZodOptional<z.ZodEnum<{
+        project: "project";
+        global: "global";
+        both: "both";
+    }>>;
     section: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    section?: string | undefined;
-    scope?: "project" | "global" | "both" | undefined;
-}, {
-    section?: string | undefined;
-    scope?: "project" | "global" | "both" | undefined;
-}>;
+}, z.core.$strip>;
 export interface MemoryReadResult {
     scope: 'project' | 'global' | 'both';
     content: string;
@@ -31,30 +23,21 @@ export declare const memoryReadTool: ToolDefinition<z.infer<typeof readParams>,
 /** Longest body `memory_write` accepts. Memory holds short facts, not documents. */
 export declare const MAX_BODY_CHARS = 1200;
 declare const writeParams: z.ZodObject<{
-    /** Where to write: 'project' (default) or 'global'. */
-    scope: z.ZodOptional<z.ZodEnum<["project", "global"]>>;
-    /** Section heading. If the heading already exists (ignoring case and spacing), replaces its body. */
+    scope: z.ZodOptional<z.ZodEnum<{
+        project: "project";
+        global: "global";
+    }>>;
     heading: z.ZodString;
-    /** Section body. Markdown allowed. */
     body: z.ZodString;
-    type: z.ZodOptional<z.ZodEnum<["convention", "decision", "correction", "reference"]>>;
-    refs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    type: z.ZodOptional<z.ZodEnum<{
+        convention: "convention";
+        decision: "decision";
+        correction: "correction";
+        reference: "reference";
+    }>>;
+    refs: z.ZodOptional<z.ZodArray<z.ZodString>>;
     pin: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    body: string;
-    heading: string;
-    type?: "convention" | "decision" | "correction" | "reference" | undefined;
-    refs?: string[] | undefined;
-    pin?: boolean | undefined;
-    scope?: "project" | "global" | undefined;
-}, {
-    body: string;
-    heading: string;
-    type?: "convention" | "decision" | "correction" | "reference" | undefined;
-    refs?: string[] | undefined;
-    pin?: boolean | undefined;
-    scope?: "project" | "global" | undefined;
-}>;
+}, z.core.$strip>;
 export interface MemoryWriteResult {
     scope: 'project' | 'global';
     path: string;
@@ -69,15 +52,12 @@ export interface MemoryWriteResult {
 }
 export declare const memoryWriteTool: ToolDefinition<z.infer<typeof writeParams>, MemoryWriteResult>;
 declare const forgetParams: z.ZodObject<{
-    scope: z.ZodOptional<z.ZodEnum<["project", "global"]>>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        project: "project";
+        global: "global";
+    }>>;
     heading: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    heading: string;
-    scope?: "project" | "global" | undefined;
-}, {
-    heading: string;
-    scope?: "project" | "global" | undefined;
-}>;
+}, z.core.$strip>;
 export interface MemoryForgetResult {
     scope: 'project' | 'global';
     heading: string;

package/dist/tools/notebook.d.ts

@@ -39,26 +39,20 @@ export declare function outputText(output: unknown): string;
 export declare function renderNotebook(nb: Notebook): string;
 declare const params: z.ZodObject<{
     path: z.ZodString;
-    mode: z.ZodOptional<z.ZodEnum<["replace", "insert", "delete"]>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        replace: "replace";
+        delete: "delete";
+        insert: "insert";
+    }>>;
     cell_index: z.ZodOptional<z.ZodNumber>;
     cell_id: z.ZodOptional<z.ZodString>;
     source: z.ZodOptional<z.ZodString>;
-    cell_type: z.ZodOptional<z.ZodEnum<["code", "markdown", "raw"]>>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    mode?: "replace" | "delete" | "insert" | undefined;
-    source?: string | undefined;
-    cell_type?: "code" | "raw" | "markdown" | undefined;
-    cell_index?: number | undefined;
-    cell_id?: string | undefined;
-}, {
-    path: string;
-    mode?: "replace" | "delete" | "insert" | undefined;
-    source?: string | undefined;
-    cell_type?: "code" | "raw" | "markdown" | undefined;
-    cell_index?: number | undefined;
-    cell_id?: string | undefined;
-}>;
+    cell_type: z.ZodOptional<z.ZodEnum<{
+        code: "code";
+        raw: "raw";
+        markdown: "markdown";
+    }>>;
+}, z.core.$strip>;
 export interface EditNotebookResult {
     path: string;
     mode: 'replace' | 'insert' | 'delete';

package/dist/tools/read-file.d.ts

@@ -2,19 +2,9 @@ import { z } from 'zod';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     path: z.ZodString;
-    /** 1-based line number to start reading from. Omit to start at the beginning. */
     offset: z.ZodOptional<z.ZodNumber>;
-    /** Maximum number of lines to return. Defaults to 2000. */
     max_lines: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    offset?: number | undefined;
-    max_lines?: number | undefined;
-}, {
-    path: string;
-    offset?: number | undefined;
-    max_lines?: number | undefined;
-}>;
+}, z.core.$strip>;
 export interface ReadFileResult {
     path: string;
     totalLines: number;

package/dist/tools/read-image.d.ts

@@ -26,19 +26,8 @@ import { z } from 'zod';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     path: z.ZodString;
-    /**
-     * Maximum bytes to read. The tool errors if the file exceeds this
-     * limit; the default is 5 MB which covers most screenshots and
-     * diagrams without flooding the model context.
-     */
     max_bytes: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    max_bytes?: number | undefined;
-}, {
-    path: string;
-    max_bytes?: number | undefined;
-}>;
+}, z.core.$strip>;
 export interface ReadImageResult {
     path: string;
     mime: string;

package/dist/tools/read-only.d.ts

@@ -3,6 +3,6 @@
  * anything. Asking before each of them is noise, so they are approved without a prompt by default;
  * edits, commands, web access and sub-agents still ask.
  */
-export declare const READ_ONLY_TOOLS: readonly ["read_file", "list_files", "search_files", "find_symbol", "list_symbols", "find_references", "codebase_search", "memory_read", "sub_agent_wait"];
+export declare const READ_ONLY_TOOLS: readonly ["read_file", "list_files", "search_files", "find_symbol", "list_symbols", "find_references", "git_diff", "codebase_search", "memory_read", "sub_agent_wait"];
 /** The tools that run without a prompt: the user's list, or the read-only tools when none is set. */
 export declare function resolveAutoApprove(configured?: readonly string[]): string[];

package/dist/tools/read-only.js

@@ -10,6 +10,8 @@ export const READ_ONLY_TOOLS = [
     'find_symbol',
     'list_symbols',
     'find_references',
+    // Runs one fixed git command; refuses option-shaped refs.
+    'git_diff',
     'codebase_search',
     'memory_read',
     // Only observes the sub-agents the person already let start.

package/dist/tools/run-command.d.ts

@@ -2,25 +2,9 @@ import { z } from 'zod';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     command: z.ZodString;
-    /**
-     * Optional explicit timeout in ms. Default 60_000 (1 minute). Set to 0 to
-     * disable (not recommended).
-     */
     timeout_ms: z.ZodOptional<z.ZodNumber>;
-    /**
-     * Optional working directory override. Must be inside the project root
-     * unless the configured ToolContext permits otherwise.
-     */
     cwd: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    command: string;
-    timeout_ms?: number | undefined;
-    cwd?: string | undefined;
-}, {
-    command: string;
-    timeout_ms?: number | undefined;
-    cwd?: string | undefined;
-}>;
+}, z.core.$strip>;
 export interface RunCommandResult {
     command: string;
     exitCode: number | null;

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

@@ -4,26 +4,10 @@ declare const params: z.ZodObject<{
     pattern: z.ZodString;
     path: z.ZodOptional<z.ZodString>;
     include: z.ZodOptional<z.ZodString>;
-    /** Maximum matches to return. Default 200. */
     max_results: z.ZodOptional<z.ZodNumber>;
     include_ignored: z.ZodOptional<z.ZodBoolean>;
-    /** Show a few lines of context around each match. */
     context_lines: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    pattern: string;
-    path?: string | undefined;
-    include?: string | undefined;
-    max_results?: number | undefined;
-    include_ignored?: boolean | undefined;
-    context_lines?: number | undefined;
-}, {
-    pattern: string;
-    path?: string | undefined;
-    include?: string | undefined;
-    max_results?: number | undefined;
-    include_ignored?: boolean | undefined;
-    context_lines?: number | undefined;
-}>;
+}, z.core.$strip>;
 export interface SearchMatch {
     path: string;
     line: number;

package/dist/tools/sub-agent-wait.d.ts

@@ -1,15 +1,9 @@
 import { z } from 'zod';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
-    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
     timeout_seconds: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    ids?: string[] | undefined;
-    timeout_seconds?: number | undefined;
-}, {
-    ids?: string[] | undefined;
-    timeout_seconds?: number | undefined;
-}>;
+}, z.core.$strip>;
 export interface SubAgentWaitResult {
     agents: Array<{
         id: string;

package/dist/tools/sub-agent.d.ts

@@ -2,84 +2,16 @@ import { z } from 'zod';
 import { type AgentDef } from '../agents/agent-files.js';
 import type { AgentConfig, ModelConfig, ToolContext, ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
-    /** The task for the sub-agent to perform. Free-form text. */
     task: z.ZodString;
-    /** Name of an agent file (`.forge/agents/<name>.md`) to run as: its prompt, tools, model and step cap. */
     agent: z.ZodOptional<z.ZodString>;
-    /** Hard cap on iterations for the sub-agent. Default 10. */
     max_iterations: z.ZodOptional<z.ZodNumber>;
-    /**
-     * Run the sub-agent without approval prompts (autonomous). Defaults to
-     * `false` even when the parent is in `--auto` mode: the sub-agent is
-     * expected to be focused and short-lived, so the explicit opt-in is
-     * deliberate to avoid runaway destructive work.
-     */
     auto: z.ZodOptional<z.ZodBoolean>;
-    /**
-     * Working directory for the sub-agent. Defaults to the parent's cwd.
-     * Useful when the sub-task should operate on a subdirectory without
-     * dragging the parent through the navigation.
-     */
     cwd: z.ZodOptional<z.ZodString>;
-    /**
-     * Run the sub-agent in an isolated git worktree. The worktree is
-     * created at `<repoRoot>/.forge/worktrees/<label>/`, the child runs
-     * there, and the worktree is removed on completion (success or
-     * error). Falls back to plain `cwd` mode (with a stderr warning)
-     * when the parent's cwd is not inside a git repo.
-     *
-     * Pair this with `orchestrator run` parallel dispatch (v2.3) to
-     * safely run multiple specialists concurrently without them
-     * clobbering each other's files.
-     */
     use_worktree: z.ZodOptional<z.ZodBoolean>;
-    /**
-     * Human-readable label for the worktree (used in the branch name and
-     * directory). Defaults to a random short hash. Ignored when
-     * `use_worktree` is false.
-     */
     worktree_label: z.ZodOptional<z.ZodString>;
-    /**
-     * v2.14: when `use_worktree: true`, also delete the auto-created
-     * `forge/<label>-<short-sha>` branch once the worktree's working
-     * tree is gone. Default `true` because sub-agents are short-lived
-     * and orphan branches are pure clutter.
-     *
-     * Set to `false` when you want to inspect the diff afterwards (e.g.
-     * `git diff main..forge/<label>-<sha>`) or hand the branch to a
-     * human reviewer.
-     *
-     * The branch is only deleted when no other worktree currently
-     * references it, so two Forge sessions working on the same branch
-     * won't collide.
-     */
     cleanup_branch: z.ZodOptional<z.ZodBoolean>;
-    /**
-     * Start the child and return at once. The child keeps working while the parent continues; collect its answer with
-     * `sub_agent_wait`. Only where the surface can show background runs; elsewhere the child runs to completion as usual.
-     */
     background: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    task: string;
-    agent?: string | undefined;
-    cwd?: string | undefined;
-    auto?: boolean | undefined;
-    background?: boolean | undefined;
-    max_iterations?: number | undefined;
-    use_worktree?: boolean | undefined;
-    worktree_label?: string | undefined;
-    cleanup_branch?: boolean | undefined;
-}, {
-    task: string;
-    agent?: string | undefined;
-    cwd?: string | undefined;
-    auto?: boolean | undefined;
-    background?: boolean | undefined;
-    max_iterations?: number | undefined;
-    use_worktree?: boolean | undefined;
-    worktree_label?: string | undefined;
-    cleanup_branch?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 /** What `sub_agent { background: true }` returns instead of a result. */
 export interface SubAgentStarted {
     started: true;

package/dist/tools/todo.d.ts

@@ -7,26 +7,14 @@ import type { TodoItem, ToolDefinition } from '../types.js';
 declare const writeParams: z.ZodObject<{
     todos: z.ZodArray<z.ZodObject<{
         content: z.ZodString;
-        status: z.ZodEnum<["pending", "in_progress", "completed"]>;
-    }, "strip", z.ZodTypeAny, {
-        status: "pending" | "in_progress" | "completed";
-        content: string;
-    }, {
-        status: "pending" | "in_progress" | "completed";
-        content: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    todos: {
-        status: "pending" | "in_progress" | "completed";
-        content: string;
-    }[];
-}, {
-    todos: {
-        status: "pending" | "in_progress" | "completed";
-        content: string;
-    }[];
-}>;
-declare const readParams: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            in_progress: "in_progress";
+            completed: "completed";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const readParams: z.ZodObject<{}, z.core.$strip>;
 export declare const todoWriteTool: ToolDefinition<z.infer<typeof writeParams>, {
     todos: TodoItem[];
 }>;

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

@@ -39,13 +39,7 @@ export declare function searchWeb(cfg: WebSearchConfig, query: string, count: nu
 declare const params: z.ZodObject<{
     query: z.ZodString;
     max_results: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    query: string;
-    max_results?: number | undefined;
-}, {
-    query: string;
-    max_results?: number | undefined;
-}>;
+}, z.core.$strip>;
 export interface WebSearchToolResult {
     provider: WebSearchProvider;
     query: string;

package/dist/tools/write-file.d.ts

@@ -3,13 +3,7 @@ import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     path: z.ZodString;
     content: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    content: string;
-}, {
-    path: string;
-    content: string;
-}>;
+}, z.core.$strip>;
 export interface WriteFileResult {
     path: string;
     bytes: number;

package/dist/types.d.ts

@@ -564,6 +564,8 @@ export interface AgentConfig {
      * be surprising.
      */
     disableMemory?: boolean;
+    /** Leave out the `<stack>` block (the versions the workspace's files state). Default: included. */
+    disableStackFacts?: boolean;
     /**
      * Skip injecting `AGENTS.md` / `CLAUDE.md` / `CONVENTIONS.md` from the
      * working directory into the system prompt.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikarmic/forge-core",
-  "version": "5.1.1",
+  "version": "5.2.0",
   "description": "Agent engine for IKarmic AI Forge. Model loop, tools, MCP, sandbox, memory, compaction, plan mode, skills, hooks.",
   "type": "module",
   "main": "./dist/index.js",
@@ -56,13 +56,13 @@
     "tree-sitter-wasms": "^0.1.13",
     "undici": "^7.30.0",
     "web-tree-sitter": "0.20.8",
-    "zod": "^3.23.0"
+    "zod": "^4.6.7"
   },
   "devDependencies": {
     "@ai-sdk/provider": "^4.0.0",
     "@types/node": "^22.7.0",
     "typescript": "^5.6.3",
-    "vitest": "^5.0.2"
+    "vitest": "^5.0.5"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",