@ikarmic/forge-core 4.4.0 → 5.0.0

package/dist/specs/store.d.ts

@@ -23,6 +23,13 @@ export declare class SpecStore {
     get(id: string): Promise<SpecSummary | null>;
     /** List every approved spec, oldest first. */
     list(): Promise<SpecSummary[]>;
+    /** The three documents of an approved spec, or null when it doesn't exist. */
+    readDocs(id: string): Promise<SpecSections | null>;
+    /**
+     * Replace an approved spec's documents (a re-sync with the code). The previous versions
+     * are kept in `<dir>/history/<timestamp>/`, and the manifest records `syncedAt`.
+     */
+    update(id: string, sections: SpecSections, now?: Date): Promise<SpecSummary>;
     /** Delete an approved spec's directory. Returns false when it didn't exist. */
     delete(id: string): Promise<boolean>;
     private draftDir;
@@ -44,4 +51,3 @@ export declare class SpecStore {
  * all (e.g. `"!!!"`).
  */
 export declare function slugifyTaskForSpecId(task: string): string;
-//# sourceMappingURL=store.d.ts.map

package/dist/specs/store.js

@@ -14,6 +14,7 @@ import { convertToCheckboxes } from './tasks-parser.js';
 const MANIFEST_FILENAME = 'manifest.json';
 const DRAFT_FILENAME = 'draft.json';
 const RUNS_FILENAME = 'runs.json';
+const HISTORY_DIR = 'history';
 const DRAFTS_DIR = '.drafts';
 const MAX_RUNS_PER_TASK = 20;
 const SAFE_ID = /^[a-z0-9][a-z0-9._-]*$/i;
@@ -88,6 +89,38 @@ export class SpecStore {
         }
         return out.sort((a, b) => a.approvedAt.localeCompare(b.approvedAt));
     }
+    /** The three documents of an approved spec, or null when it doesn't exist. */
+    async readDocs(id) {
+        const spec = await this.get(id);
+        if (!spec)
+            return null;
+        const read = (f) => readFile(path.join(spec.dir, f), 'utf8').catch(() => '');
+        return { requirements: await read('requirements.md'), design: await read('design.md'), tasks: await read('tasks.md') };
+    }
+    /**
+     * Replace an approved spec's documents (a re-sync with the code). The previous versions
+     * are kept in `<dir>/history/<timestamp>/`, and the manifest records `syncedAt`.
+     */
+    async update(id, sections, now = new Date()) {
+        assertSafeSpecId(id);
+        const spec = await this.get(id);
+        if (!spec)
+            throw new Error(`no spec ${id}`);
+        const stamp = now.toISOString().replace(/[:.]/g, '-');
+        const backup = path.join(spec.dir, HISTORY_DIR, stamp);
+        await mkdir(backup, { recursive: true });
+        for (const f of ['requirements.md', 'design.md', 'tasks.md']) {
+            const from = path.join(spec.dir, f);
+            if (existsSync(from))
+                await writeFile(path.join(backup, f), await readFile(from, 'utf8'), 'utf8');
+        }
+        await writeFile(path.join(spec.dir, 'requirements.md'), sections.requirements, 'utf8');
+        await writeFile(path.join(spec.dir, 'design.md'), sections.design, 'utf8');
+        await writeFile(path.join(spec.dir, 'tasks.md'), sections.tasks, 'utf8');
+        const updated = { ...spec, syncedAt: now.toISOString() };
+        await writeFile(path.join(spec.dir, MANIFEST_FILENAME), JSON.stringify(updated, null, 2), 'utf8');
+        return updated;
+    }
     /** Delete an approved spec's directory. Returns false when it didn't exist. */
     async delete(id) {
         if (!isSafeSpecId(id))
@@ -222,4 +255,3 @@ export function slugifyTaskForSpecId(task) {
     const suffix = Math.random().toString(36).slice(2, 8);
     return `${slug}-${suffix}`;
 }
-//# sourceMappingURL=store.js.map

package/dist/specs/sync.d.ts

@@ -0,0 +1,29 @@
+import type { SpecSections, SpecSummary } from './types.js';
+export interface SpecDrift {
+    /** Paths the documents mention (in backticks) that no longer exist. */
+    missingPaths: string[];
+    /** Files changed since the spec was approved or last synced (committed or not), workspace-relative. */
+    changedFiles: string[];
+    tasks: {
+        done: number;
+        total: number;
+    };
+    /** When the comparison starts: the last sync, else approval. */
+    since: string;
+}
+/** Backticked tokens that look like file paths: a slash or a file extension, no spaces. */
+export declare function referencedPaths(markdown: string): string[];
+/** Files changed since `iso` (commits after it plus uncommitted work), or [] outside a git repo. */
+export declare function changedSince(cwd: string, iso: string): Promise<string[]>;
+export declare function specDrift(cwd: string, spec: Pick<SpecSummary, 'approvedAt'> & {
+    syncedAt?: string;
+}, docs: SpecSections): Promise<SpecDrift>;
+/** The task for a spec-mode run that brings the documents up to date with the code. */
+export declare function syncSpecTask(spec: Pick<SpecSummary, 'id' | 'task'>, docs: SpecSections, drift: SpecDrift): string;
+/** Re-tick tasks (matched by their written number, else their title) that were done before the sync. */
+export declare function keepDoneTasks(before: string, after: string): string;
+/** Line counts added and removed between two texts (a rough size of the change, not a diff). */
+export declare function changeSize(before: string, after: string): {
+    added: number;
+    removed: number;
+};

package/dist/specs/sync.js

@@ -0,0 +1,155 @@
+/**
+ * Re-sync an approved spec with the code. The code moves on after a spec is approved
+ * (tasks done by hand, files renamed, designs changed mid-way), so the documents drift.
+ *
+ *   - {@link specDrift} measures it without a model: paths the docs mention that are
+ *     gone, files changed since the spec was approved (or last synced), task progress.
+ *   - {@link syncSpecTask} is the task for a read-only spec-mode run that rewrites the
+ *     three documents to describe the code as it is now.
+ *   - {@link keepDoneTasks} makes sure a re-sync never un-ticks a task the user finished.
+ *
+ * The caller shows the change and writes it with `SpecStore.update` (which keeps the
+ * previous version in `history/`).
+ */
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { parseTasks, setTaskDone } from './tasks-parser.js';
+const execFileAsync = promisify(execFile);
+/** Backticked tokens that look like file paths: a slash or a file extension, no spaces. */
+export function referencedPaths(markdown) {
+    const out = new Set();
+    for (const m of markdown.matchAll(/`([^`\s]+)`/g)) {
+        let p = m[1].replace(/[:#].*$/, '').replace(/[),.;]+$/, '');
+        if (p.startsWith('./'))
+            p = p.slice(2);
+        if (!p || /^[a-z]+:\/\//i.test(p) || p.startsWith('-') || p.startsWith('@'))
+            continue;
+        const looksLikePath = (p.includes('/') && /[A-Za-z0-9_]/.test(p)) || /^[\w.-]+\.[A-Za-z][A-Za-z0-9]{0,5}$/.test(p);
+        // Globs, placeholders and versions are not paths.
+        if (!looksLikePath || /[*?{}<>$]/.test(p) || /^\d+(\.\d+)+$/.test(p))
+            continue;
+        out.add(p);
+    }
+    return [...out].sort();
+}
+async function git(cwd, args) {
+    const { stdout } = await execFileAsync('git', args, { cwd, timeout: 20_000, maxBuffer: 16 * 1024 * 1024 });
+    return stdout;
+}
+/** Files changed since `iso` (commits after it plus uncommitted work), or [] outside a git repo. */
+export async function changedSince(cwd, iso) {
+    const files = new Set();
+    try {
+        const log = await git(cwd, ['log', `--since=${iso}`, '--name-only', '--pretty=format:']);
+        for (const f of log.split('\n'))
+            if (f.trim())
+                files.add(f.trim());
+        const status = await git(cwd, ['status', '--porcelain', '--untracked-files=all']);
+        for (const line of status.split('\n')) {
+            const f = line.slice(3).trim();
+            if (!f)
+                continue;
+            files.add(f.includes(' -> ') ? f.split(' -> ')[1] : f);
+        }
+    }
+    catch {
+        return [];
+    }
+    // The spec's own files are not code drift.
+    return [...files].filter((f) => !f.startsWith('.forge/')).sort();
+}
+export async function specDrift(cwd, spec, docs) {
+    const since = spec.syncedAt ?? spec.approvedAt;
+    const mentioned = referencedPaths(`${docs.requirements}\n${docs.design}\n${docs.tasks}`);
+    const tasks = parseTasks(docs.tasks);
+    return {
+        missingPaths: mentioned.filter((p) => !existsSync(path.join(cwd, p))),
+        changedFiles: await changedSince(cwd, since),
+        tasks: { done: tasks.filter((t) => t.done).length, total: tasks.length },
+        since,
+    };
+}
+const LIST_MAX = 80;
+function list(items) {
+    if (items.length === 0)
+        return '(none)';
+    const shown = items.slice(0, LIST_MAX).map((i) => `- ${i}`);
+    if (items.length > LIST_MAX)
+        shown.push(`- … and ${items.length - LIST_MAX} more`);
+    return shown.join('\n');
+}
+/** The task for a spec-mode run that brings the documents up to date with the code. */
+export function syncSpecTask(spec, docs, drift) {
+    return `Bring the spec "${spec.id}" up to date with the code as it is now. It was written for: ${spec.task}
+
+Read the code (start with the changed files below) and rewrite the three documents so they describe what is actually built and what is still left to do:
+- requirements.md: keep every requirement and its number; change one only where the code deliberately does something else, and say so in the requirement.
+- design.md: describe the real modules, files, data shapes and flows. Fix paths and names that changed; drop parts that were not built and are no longer planned.
+- tasks.md: keep the checklist format (- [ ] / - [x]) and the task numbers. Tick a task when the code clearly does it. Never untick a ticked task. Add new unticked tasks, numbered after the last one, for work the code still needs to meet the requirements.
+
+Do not change any code. Reply with the three updated documents in the usual format.
+
+Since ${drift.since}:
+Changed files:
+${list(drift.changedFiles)}
+
+Paths the documents mention that no longer exist:
+${list(drift.missingPaths)}
+
+Task progress: ${drift.tasks.done} of ${drift.tasks.total} ticked.
+
+<current-requirements.md>
+${docs.requirements}
+</current-requirements.md>
+
+<current-design.md>
+${docs.design}
+</current-design.md>
+
+<current-tasks.md>
+${docs.tasks}
+</current-tasks.md>`;
+}
+const NUMBER = /^(\d+(?:\.\d+)*)[.)]?\s+/;
+/** A task's written number (`2.1`), or null: parseTasks falls back to its position, which moves. */
+function writtenNumber(title) {
+    return NUMBER.exec(title)?.[1] ?? null;
+}
+function bareTitle(title) {
+    return title.replace(NUMBER, '').trim().toLowerCase();
+}
+/** Re-tick tasks (matched by their written number, else their title) that were done before the sync. */
+export function keepDoneTasks(before, after) {
+    const doneBefore = parseTasks(before).filter((t) => t.done);
+    if (doneBefore.length === 0)
+        return after;
+    const numbers = new Set(doneBefore.map((t) => writtenNumber(t.title)).filter((n) => n !== null));
+    const titles = new Set(doneBefore.map((t) => bareTitle(t.title)));
+    let md = after;
+    for (const task of parseTasks(after)) {
+        if (task.done)
+            continue;
+        const n = writtenNumber(task.title);
+        if (!(n !== null && numbers.has(n)) && !titles.has(bareTitle(task.title)))
+            continue;
+        const r = setTaskDone(md, task, true);
+        if (r.ok)
+            md = r.md;
+    }
+    return md;
+}
+/** Line counts added and removed between two texts (a rough size of the change, not a diff). */
+export function changeSize(before, after) {
+    const count = (lines) => lines.reduce((m, l) => m.set(l, (m.get(l) ?? 0) + 1), new Map());
+    const a = count(before.split('\n'));
+    const b = count(after.split('\n'));
+    let added = 0;
+    let removed = 0;
+    for (const [line, n] of b)
+        added += Math.max(0, n - (a.get(line) ?? 0));
+    for (const [line, n] of a)
+        removed += Math.max(0, n - (b.get(line) ?? 0));
+    return { added, removed };
+}

package/dist/specs/tasks-parser.d.ts

@@ -25,4 +25,3 @@ export declare function setTaskDone(md: string, task: {
     reason: string;
 };
 export declare function convertToCheckboxes(md: string): string;
-//# sourceMappingURL=tasks-parser.d.ts.map

package/dist/specs/tasks-parser.js

@@ -75,4 +75,3 @@ export function convertToCheckboxes(md) {
     });
     return changed ? out.join(eolOf(md)) : md;
 }
-//# sourceMappingURL=tasks-parser.js.map

package/dist/specs/types.d.ts

@@ -36,7 +36,8 @@ export interface SpecSummary {
     id: string;
     task: string;
     approvedAt: string;
+    /** When the documents were last re-synced with the code (`SpecStore.update`). */
+    syncedAt?: string;
     /** Absolute path to `.forge/specs/<id>/`. */
     dir: string;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/specs/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/steering/glob.d.ts

@@ -12,4 +12,3 @@
  * Spec: docs/superpowers/specs/2026-09-29-steering-files-design.md §5.1
  */
 export declare function pathMatchesGlob(rawPattern: string, relPath: string): boolean;
-//# sourceMappingURL=glob.d.ts.map

package/dist/steering/glob.js

@@ -88,4 +88,3 @@ export function pathMatchesGlob(rawPattern, relPath) {
     const subject = pattern.includes('/') ? relPath : relPath.slice(relPath.lastIndexOf('/') + 1);
     return matchTokens(tokenize(pattern), subject);
 }
-//# sourceMappingURL=glob.js.map

package/dist/steering/index.d.ts

@@ -4,4 +4,3 @@ export { isSafeSteeringName, loadSteering, overrideFilePath, parseSteering, read
 export { MAX_TOOL_INJECTIONS, START_BUDGET_BYTES, TOOL_DOC_BYTES, formatSteeringLine, selectAtStart, selectOnToolTouch, stripSteering, toWorkspaceRelative, wrapSteering, } from './select.js';
 export type { StartSelection } from './select.js';
 export type { SteeringConfig, SteeringDoc, SteeringInclusion, SteeringLoadResult, SteeringSkip } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/steering/index.js

@@ -2,4 +2,3 @@
 export { pathMatchesGlob } from './glob.js';
 export { isSafeSteeringName, loadSteering, overrideFilePath, parseSteering, readOverride, setSteeringDisabled, } from './loader.js';
 export { MAX_TOOL_INJECTIONS, START_BUDGET_BYTES, TOOL_DOC_BYTES, formatSteeringLine, selectAtStart, selectOnToolTouch, stripSteering, toWorkspaceRelative, wrapSteering, } from './select.js';
-//# sourceMappingURL=index.js.map

package/dist/steering/loader.d.ts

@@ -12,4 +12,3 @@ export declare function loadSteering(cwd: string, opts?: {
     includeProject?: boolean;
     homeDir?: string;
 }): Promise<SteeringLoadResult>;
-//# sourceMappingURL=loader.d.ts.map

package/dist/steering/loader.js

@@ -150,4 +150,3 @@ export async function loadSteering(cwd, opts = {}) {
         .sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
     return { docs, warnings };
 }
-//# sourceMappingURL=loader.js.map

package/dist/steering/project-instructions.d.ts

@@ -1,4 +1,3 @@
 export declare const PROJECT_INSTRUCTION_FILES: readonly ["AGENTS.md", "CLAUDE.md", "CONVENTIONS.md"];
 export declare const MAX_INSTRUCTION_BYTES = 16000;
 export declare function buildProjectInstructionsBlock(cwd: string): Promise<string>;
-//# sourceMappingURL=project-instructions.d.ts.map

package/dist/steering/project-instructions.js

@@ -25,4 +25,3 @@ export async function buildProjectInstructionsBlock(cwd) {
     }
     return blocks.join('\n\n');
 }
-//# sourceMappingURL=project-instructions.js.map

package/dist/steering/select.d.ts

@@ -26,4 +26,3 @@ export declare function formatSteeringLine(e: {
     skipped: SteeringSkip[];
     path?: string;
 }): string;
-//# sourceMappingURL=select.d.ts.map

package/dist/steering/select.js

@@ -94,4 +94,3 @@ export function formatSteeringLine(e) {
     const skipped = e.skipped.length > 0 ? ` · skipped: ${e.skipped.map((s) => `${s.name} (${s.reason})`).join(', ')}` : '';
     return `${head}: ${applied}${skipped}`;
 }
-//# sourceMappingURL=select.js.map

package/dist/steering/types.d.ts

@@ -32,4 +32,3 @@ export interface SteeringSkip {
     name: string;
     reason: 'budget' | 'cap';
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/steering/types.js

@@ -1,3 +1,2 @@
 /** Steering files (SP3a). Spec: docs/superpowers/specs/2026-09-29-steering-files-design.md §5.1 */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/structured/index.d.ts

@@ -16,4 +16,3 @@ export type { ZodTypeAny } from 'zod';
 export { formatZodError, jsonSchemaToZod, loadSchemaFile, } from './schema.js';
 export { defaultRetryPrompt, isStructuredOutputError, runStructuredAgent, StructuredOutputError, validateFinalText, } from './retry.js';
 export type { StructuredRunOptions, StructuredRunResult } from './retry.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/structured/index.js

@@ -1,3 +1,2 @@
 export { formatZodError, jsonSchemaToZod, loadSchemaFile, } from './schema.js';
 export { defaultRetryPrompt, isStructuredOutputError, runStructuredAgent, StructuredOutputError, validateFinalText, } from './retry.js';
-//# sourceMappingURL=index.js.map

package/dist/structured/retry.d.ts

@@ -131,4 +131,3 @@ export declare class StructuredOutputError extends Error {
  */
 export declare function isStructuredOutputError(err: unknown): err is StructuredOutputError;
 export { z };
-//# sourceMappingURL=retry.d.ts.map

package/dist/structured/retry.js

@@ -200,4 +200,3 @@ export function isStructuredOutputError(err) {
 }
 // Re-export so callers don't need a second import.
 export { z };
-//# sourceMappingURL=retry.js.map

package/dist/structured/schema.d.ts

@@ -60,4 +60,3 @@ export declare function jsonSchemaToZod(schema: Record<string, unknown>): ZodTyp
  * Paths use JSON Pointer-ish dotted notation; values are quoted.
  */
 export declare function formatZodError(err: ZodError): string;
-//# sourceMappingURL=schema.d.ts.map

package/dist/structured/schema.js

@@ -291,4 +291,3 @@ function describeReceived(issue) {
         return '';
     return JSON.stringify(issue.received);
 }
-//# sourceMappingURL=schema.js.map

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

@@ -75,4 +75,3 @@ declare const actParams: z.ZodEffects<z.ZodObject<{
     selector?: string | undefined;
 }>;
 export {};
-//# sourceMappingURL=browser-tools.d.ts.map

package/dist/tools/browser-tools.js

@@ -136,4 +136,3 @@ const actParams = z
     if (v.action === 'evaluate' && !v.expression)
         ctx.addIssue({ code: 'custom', message: 'expression is required' });
 });
-//# sourceMappingURL=browser-tools.js.map

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

@@ -20,4 +20,3 @@ export interface CodebaseSearchResult {
 }
 export declare function createCodebaseSearchTool(embedder: Embedder): ToolDefinition<z.infer<typeof params>, CodebaseSearchResult>;
 export {};
-//# sourceMappingURL=codebase-search.d.ts.map

package/dist/tools/codebase-search.js

@@ -19,4 +19,3 @@ export function createCodebaseSearchTool(embedder) {
         }),
     };
 }
-//# sourceMappingURL=codebase-search.js.map

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

@@ -9,4 +9,3 @@ export declare function isAlwaysAllowable(command: string, hasCwd?: boolean): bo
 export declare function needsScriptFingerprint(command: string): boolean;
 /** Whether a `run_command` call's arguments name one of `allowed` exactly, without a working-directory override. */
 export declare function isListedCommand(args: unknown, allowed: readonly string[]): boolean;
-//# sourceMappingURL=command-allow.d.ts.map

package/dist/tools/command-allow.js

@@ -47,4 +47,3 @@ export function isListedCommand(args, allowed) {
         return false;
     return allowed.includes(normalizeCommand(a.command));
 }
-//# sourceMappingURL=command-allow.js.map

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

@@ -27,4 +27,3 @@ export interface EditFileResult {
 }
 export declare const editFileTool: ToolDefinition<z.infer<typeof params>, EditFileResult>;
 export {};
-//# sourceMappingURL=edit-file.d.ts.map

package/dist/tools/edit-file.js

@@ -56,4 +56,3 @@ function countOccurrences(haystack, needle) {
     }
     return count;
 }
-//# sourceMappingURL=edit-file.js.map

package/dist/tools/fetch-url.d.ts

@@ -39,4 +39,3 @@ export interface FetchUrlResult {
 }
 export declare const fetchUrlTool: ToolDefinition<z.infer<typeof params>, FetchUrlResult>;
 export {};
-//# sourceMappingURL=fetch-url.d.ts.map

package/dist/tools/fetch-url.js

@@ -296,4 +296,3 @@ function prettyJson(text) {
         return text;
     }
 }
-//# sourceMappingURL=fetch-url.js.map

package/dist/tools/find-references.d.ts

@@ -18,4 +18,3 @@ export interface FindReferencesResult {
 }
 export declare const findReferencesTool: ToolDefinition<z.infer<typeof params>, FindReferencesResult>;
 export {};
-//# sourceMappingURL=find-references.d.ts.map

package/dist/tools/find-references.js

@@ -37,4 +37,3 @@ export const findReferencesTool = {
 function escapeRegExp(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-//# sourceMappingURL=find-references.js.map

package/dist/tools/find-symbol.d.ts

@@ -24,4 +24,3 @@ export interface FindSymbolResult {
 }
 export declare const findSymbolTool: ToolDefinition<z.infer<typeof params>, FindSymbolResult>;
 export {};
-//# sourceMappingURL=find-symbol.d.ts.map

package/dist/tools/find-symbol.js

@@ -33,4 +33,3 @@ export const findSymbolTool = {
         return { query: args.name, matchType: 'none', matches: [] };
     },
 };
-//# sourceMappingURL=find-symbol.js.map

package/dist/tools/ignore-rules.d.ts

@@ -0,0 +1,15 @@
+/** Files read in every directory, in this order. `.forgeignore` is for paths only the agent should skip. */
+export declare const IGNORE_FILE_NAMES: readonly [".gitignore", ".forgeignore"];
+/** The closest ancestor of `dir` (itself included) that holds a `.git` entry, or null. */
+export declare function findGitRoot(dir: string): string | null;
+export declare class IgnoreRules {
+    private readonly top;
+    private readonly cache;
+    /** `top` is where rule lookup starts: the git root, or the walked directory outside a repository. */
+    private constructor();
+    /** Rules for walking anywhere under `cwd`. */
+    static forRoot(cwd: string): IgnoreRules;
+    private rulesIn;
+    /** Whether `absPath` is ignored. Paths outside the rule root are never ignored here. */
+    isIgnored(absPath: string, isDir: boolean): boolean;
+}

package/dist/tools/ignore-rules.js

@@ -0,0 +1,84 @@
+/**
+ * Git-style ignore rules for walking the workspace: `.gitignore` and `.forgeignore`
+ * files (in the walked tree and in its ancestors up to the git root) plus
+ * `.git/info/exclude`. Each file's patterns apply relative to its own directory,
+ * and a deeper file can re-include (`!pattern`) what a shallower one ignored, as in git.
+ */
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import ignore from 'ignore';
+/** Files read in every directory, in this order. `.forgeignore` is for paths only the agent should skip. */
+export const IGNORE_FILE_NAMES = ['.gitignore', '.forgeignore'];
+function readIfFile(file) {
+    try {
+        return statSync(file).isFile() ? readFileSync(file, 'utf8') : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The closest ancestor of `dir` (itself included) that holds a `.git` entry, or null. */
+export function findGitRoot(dir) {
+    let current = path.resolve(dir);
+    for (;;) {
+        if (existsSync(path.join(current, '.git')))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+export class IgnoreRules {
+    top;
+    cache = new Map();
+    /** `top` is where rule lookup starts: the git root, or the walked directory outside a repository. */
+    constructor(top) {
+        this.top = top;
+    }
+    /** Rules for walking anywhere under `cwd`. */
+    static forRoot(cwd) {
+        const abs = path.resolve(cwd);
+        return new IgnoreRules(findGitRoot(abs) ?? abs);
+    }
+    rulesIn(dir) {
+        if (this.cache.has(dir))
+            return this.cache.get(dir);
+        const chunks = [];
+        if (dir === this.top) {
+            const exclude = readIfFile(path.join(dir, '.git', 'info', 'exclude'));
+            if (exclude)
+                chunks.push(exclude);
+        }
+        for (const name of IGNORE_FILE_NAMES) {
+            const text = readIfFile(path.join(dir, name));
+            if (text)
+                chunks.push(text);
+        }
+        const rules = chunks.length > 0 ? ignore().add(chunks.join('\n')) : null;
+        this.cache.set(dir, rules);
+        return rules;
+    }
+    /** Whether `absPath` is ignored. Paths outside the rule root are never ignored here. */
+    isIgnored(absPath, isDir) {
+        const rel = path.relative(this.top, path.resolve(absPath));
+        if (!rel || rel.startsWith('..') || path.isAbsolute(rel))
+            return false;
+        const parts = rel.split(path.sep);
+        let ignored = false;
+        let dir = this.top;
+        for (let i = 0; i < parts.length; i++) {
+            const rules = this.rulesIn(dir);
+            if (rules) {
+                const sub = parts.slice(i).join('/') + (isDir ? '/' : '');
+                const verdict = rules.test(sub);
+                if (verdict.ignored)
+                    ignored = true;
+                else if (verdict.unignored)
+                    ignored = false;
+            }
+            dir = path.join(dir, parts[i]);
+        }
+        return ignored;
+    }
+}

package/dist/tools/index.d.ts

@@ -4,7 +4,8 @@ import { findReferencesTool } from './find-references.js';
 import { findSymbolTool } from './find-symbol.js';
 import { listFilesTool } from './list-files.js';
 import { listSymbolsTool } from './list-symbols.js';
-import { memoryReadTool, memoryWriteTool } from './memory.js';
+import { memoryForgetTool, memoryReadTool, memoryWriteTool } from './memory.js';
+import { editNotebookTool } from './notebook.js';
 import { readFileTool } from './read-file.js';
 import { readImageTool } from './read-image.js';
 import { runCommandTool } from './run-command.js';
@@ -25,11 +26,10 @@ type AnyToolDefinition = ToolDefinition<any, any>;
  * intentional: the model sees this order in its tool list.
  */
 export declare const BUILTIN_TOOLS: readonly AnyToolDefinition[];
-export { editFileTool, fetchUrlTool, findReferencesTool, findSymbolTool, listFilesTool, listSymbolsTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, writeFileTool, };
+export { editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, 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';
 export type { RedactionRule, RedactionResult } from './redact.js';
 export { ToolResultCache, buildCacheKey, cachedExecute } from './result-cache.js';
 export type { CacheKeyParts, CacheStats } from './result-cache.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -4,7 +4,8 @@ import { findReferencesTool } from './find-references.js';
 import { findSymbolTool } from './find-symbol.js';
 import { listFilesTool } from './list-files.js';
 import { listSymbolsTool } from './list-symbols.js';
-import { memoryReadTool, memoryWriteTool } from './memory.js';
+import { memoryForgetTool, memoryReadTool, memoryWriteTool } from './memory.js';
+import { editNotebookTool } from './notebook.js';
 import { readFileTool } from './read-file.js';
 import { readImageTool } from './read-image.js';
 import { runCommandTool } from './run-command.js';
@@ -27,14 +28,15 @@ export const BUILTIN_TOOLS = [
     findReferencesTool,
     writeFileTool,
     editFileTool,
+    editNotebookTool,
     runCommandTool,
     fetchUrlTool,
     memoryReadTool,
     memoryWriteTool,
+    memoryForgetTool,
     subAgentTool,
 ];
-export { editFileTool, fetchUrlTool, findReferencesTool, findSymbolTool, listFilesTool, listSymbolsTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, writeFileTool, };
+export { editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, 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';
-//# sourceMappingURL=index.js.map