@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/tools/file-mutation-queue.d.ts

@@ -0,0 +1,2 @@
+export declare function withFileMutationQueue<T>(filePath: string, fn: () => Promise<T>): Promise<T>;
+export declare function withFileMutationQueues<T>(filePaths: string[], fn: () => Promise<T>): Promise<T>;

package/dist/tools/file-mutation-queue.js

@@ -0,0 +1,43 @@
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+const queues = new Map();
+function queueKey(filePath) {
+    const resolved = resolve(filePath);
+    try {
+        return realpathSync.native(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+export async function withFileMutationQueue(filePath, fn) {
+    return withQueueKey(queueKey(filePath), fn);
+}
+export async function withFileMutationQueues(filePaths, fn) {
+    const keys = [...new Set(filePaths.map(queueKey))].sort();
+    const run = (index) => {
+        if (index >= keys.length)
+            return fn();
+        return withQueueKey(keys[index], () => run(index + 1));
+    };
+    return run(0);
+}
+async function withQueueKey(key, fn) {
+    const current = queues.get(key) ?? Promise.resolve();
+    let release;
+    const next = new Promise((resolveNext) => {
+        release = resolveNext;
+    });
+    const chained = current.then(() => next);
+    queues.set(key, chained);
+    await current;
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+        if (queues.get(key) === chained) {
+            queues.delete(key);
+        }
+    }
+}

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

@@ -0,0 +1,48 @@
+export type FileObservationSource = "read" | "write" | "edit";
+export interface FileVersion {
+    hash: string;
+    mtimeMs: number;
+    size: number;
+}
+export type FileFreshnessResult = {
+    ok: true;
+    version: FileVersion;
+} | {
+    ok: false;
+    reason: "unobserved" | "missing" | "changed";
+    observed?: FileVersion;
+    current?: FileVersion;
+};
+export interface ReadHistoryEntry {
+    argOffset: number | undefined;
+    argLimit: number | undefined;
+    effectiveOffset: number;
+    effectiveLimit: number;
+    returnedLines: number;
+    totalLines: number;
+    mtimeMs: number;
+    truncated: boolean;
+}
+export declare class FileStateTracker {
+    private readonly cwd;
+    private readonly observed;
+    private readonly readHistory;
+    constructor(cwd: string);
+    getReadHistory(filePath: string): ReadHistoryEntry | undefined;
+    setReadHistory(filePath: string, entry: ReadHistoryEntry): void;
+    /**
+     * Drops all read-dedup state. Call this whenever conversation history is
+     * compacted or pruned, because the dedup stub points the model back at
+     * earlier tool_result content that may no longer be resident.
+     */
+    invalidateReadHistory(): void;
+    observe(filePath: string, source: FileObservationSource, content?: string): Promise<FileVersion>;
+    checkFresh(filePath: string): Promise<FileFreshnessResult>;
+    private resolvePath;
+    private computeVersion;
+}
+/**
+ * Inside the workspace both as written and where symlinks actually lead, so
+ * a link inside the repository cannot carry an auto-approved write outside.
+ */
+export declare function isWithinWorkspace(cwd: string, filePath: string): boolean;

package/dist/tools/file-state.js

@@ -0,0 +1,76 @@
+import { createHash } from "node:crypto";
+import { stat, readFile } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { resolveThroughLinks } from "./path-utils.js";
+export class FileStateTracker {
+    cwd;
+    observed = new Map();
+    readHistory = new Map();
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    getReadHistory(filePath) {
+        return this.readHistory.get(this.resolvePath(filePath));
+    }
+    setReadHistory(filePath, entry) {
+        this.readHistory.set(this.resolvePath(filePath), entry);
+    }
+    /**
+     * Drops all read-dedup state. Call this whenever conversation history is
+     * compacted or pruned, because the dedup stub points the model back at
+     * earlier tool_result content that may no longer be resident.
+     */
+    invalidateReadHistory() {
+        this.readHistory.clear();
+    }
+    async observe(filePath, source, content) {
+        const absolute = this.resolvePath(filePath);
+        const version = await this.computeVersion(absolute, content);
+        this.observed.set(absolute, { ...version, source, observedAt: Date.now() });
+        return version;
+    }
+    async checkFresh(filePath) {
+        const absolute = this.resolvePath(filePath);
+        const observed = this.observed.get(absolute);
+        if (!observed) {
+            return { ok: false, reason: "unobserved" };
+        }
+        let current;
+        try {
+            current = await this.computeVersion(absolute);
+        }
+        catch {
+            return { ok: false, reason: "missing", observed };
+        }
+        if (current.hash === observed.hash && current.size === observed.size) {
+            return { ok: true, version: current };
+        }
+        return { ok: false, reason: "changed", observed, current };
+    }
+    resolvePath(filePath) {
+        return resolve(this.cwd, filePath);
+    }
+    async computeVersion(filePath, content) {
+        const [stats, bytes] = await Promise.all([
+            stat(filePath),
+            content === undefined ? readFile(filePath) : Promise.resolve(Buffer.from(content, "utf-8")),
+        ]);
+        return {
+            hash: createHash("sha256").update(bytes).digest("hex"),
+            mtimeMs: stats.mtimeMs,
+            size: stats.size,
+        };
+    }
+}
+/**
+ * Inside the workspace both as written and where symlinks actually lead, so
+ * a link inside the repository cannot carry an auto-approved write outside.
+ */
+export function isWithinWorkspace(cwd, filePath) {
+    return isInside(resolve(cwd), resolve(filePath))
+        && isInside(resolveThroughLinks(cwd), resolveThroughLinks(filePath));
+}
+function isInside(root, path) {
+    const rel = relative(root, path);
+    return rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+}

package/dist/tools/grep.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Grep tool - bounded, streaming search using ripgrep.
+ *
+ * The limits in this file are model-context safety boundaries, not UI-only
+ * truncation. We stop rg as soon as a global budget is filled so a repository
+ * search can never materialize a multi-megabyte tool result in memory/history.
+ */
+import type { ToolRegistryEntry } from "../types.js";
+export declare function createGrepTool(cwd: string): ToolRegistryEntry;

package/dist/tools/grep.js

@@ -0,0 +1,387 @@
+/**
+ * Grep tool - bounded, streaming search using ripgrep.
+ *
+ * The limits in this file are model-context safety boundaries, not UI-only
+ * truncation. We stop rg as soon as a global budget is filled so a repository
+ * search can never materialize a multi-megabyte tool result in memory/history.
+ */
+import { spawn } from "node:child_process";
+import { resolve as resolvePath } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { isSensitivePath } from "./sensitive-paths.js";
+import { analyzeToolIntent } from "../agent/tool-intent.js";
+import { resolveToolPath } from "./path-utils.js";
+const DEFAULT_MATCH_LIMIT = 100;
+const MAX_MATCH_LIMIT = 1_000;
+const MAX_RENDERED_LINE_CODE_POINTS = 1_000;
+const MAX_RESULT_BYTES = 40 * 1024;
+const MAX_RAW_STDOUT_BYTES = 5 * 1024 * 1024;
+const MAX_STDERR_BYTES = 64 * 1024;
+const MAX_FILE_SIZE = "5M";
+const MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
+const GREP_TIMEOUT_MS = 30_000;
+const KILL_GRACE_MS = 250;
+const RESULT_NOTICE_RESERVE_BYTES = 1_024;
+export function createGrepTool(cwd) {
+    return {
+        name: "grep",
+        readOnly: true,
+        effect: "read",
+        description: [
+            "Search file contents using regex (via ripgrep).",
+            `Returns at most ${DEFAULT_MATCH_LIMIT} matches by default (explicit limit is capped at ${MAX_MATCH_LIMIT}),`,
+            `${MAX_RESULT_BYTES / 1024}KiB total, and ${MAX_RENDERED_LINE_CODE_POINTS} Unicode characters per rendered match.`,
+            `Files larger than ${MAX_FILE_SIZE} are skipped. Narrow path/glob/pattern when a result is marked truncated.`,
+        ].join(" "),
+        parameters: {
+            type: "object",
+            properties: {
+                pattern: { type: "string", description: "Regex pattern to search for" },
+                path: { type: "string", description: "Directory or file to search in (optional, default: cwd)" },
+                glob: { type: "string", description: "Glob pattern to filter files (optional, e.g. '*.ts')" },
+                limit: {
+                    type: "number",
+                    description: `Maximum matches to return (default ${DEFAULT_MATCH_LIMIT}, hard maximum ${MAX_MATCH_LIMIT})`,
+                },
+            },
+            required: ["pattern"],
+        },
+        async execute(args, ctx) {
+            const searchPath = args.path ? resolveToolPath(cwd, args.path) : cwd;
+            const pattern = String(args.pattern);
+            const matchLimit = normalizeMatchLimit(args.limit);
+            const intent = analyzeToolIntent({
+                name: "grep",
+                parsedArgs: {
+                    pattern,
+                    path: args.path,
+                    glob: args.glob,
+                },
+            });
+            if (isSensitivePath(searchPath)) {
+                return {
+                    content: `Error: Search blocked for sensitive credential storage: ${searchPath}`,
+                    isError: true,
+                    status: "blocked",
+                    metadata: {
+                        kind: "security",
+                        path: searchPath,
+                        pattern,
+                        searchSignature: intent.search?.signature,
+                        searchFamily: intent.search?.familyKey,
+                        reason: "Sensitive credential storage is not searchable from general-purpose tasks.",
+                    },
+                };
+            }
+            const rgArgs = [
+                "--json",
+                "--line-number",
+                "--color=never",
+                "--max-columns",
+                String(MAX_RENDERED_LINE_CODE_POINTS),
+                "--max-columns-preview",
+                "--max-filesize",
+                MAX_FILE_SIZE,
+            ];
+            if (args.glob)
+                rgArgs.push("--glob", String(args.glob));
+            rgArgs.push("--", pattern, searchPath);
+            return executeBoundedGrep({
+                cwd,
+                searchPath,
+                pattern,
+                rgArgs,
+                matchLimit,
+                abortSignal: ctx.abortSignal,
+                baseMetadata: {
+                    kind: "search",
+                    path: searchPath,
+                    pattern,
+                    searchSignature: intent.search?.signature,
+                    searchFamily: intent.search?.familyKey,
+                    maxFileSizeBytes: MAX_FILE_SIZE_BYTES,
+                },
+            });
+        },
+    };
+}
+function executeBoundedGrep(options) {
+    return new Promise((resolve) => {
+        const child = spawn("rg", options.rgArgs, {
+            cwd: options.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const decoder = new StringDecoder("utf8");
+        const matches = [];
+        // The root check alone is not enough: ripgrep searches inside an explicit
+        // hidden root, so `path: ~/.aws` would reach ~/.aws/credentials. Every
+        // matched file gets the same check the read tool applies (cached per file).
+        const sensitiveByPath = new Map();
+        const isSensitiveMatch = (absolutePath) => {
+            let sensitive = sensitiveByPath.get(absolutePath);
+            if (sensitive === undefined) {
+                sensitive = isSensitivePath(absolutePath);
+                sensitiveByPath.set(absolutePath, sensitive);
+            }
+            return sensitive;
+        };
+        let stdoutBuffer = "";
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        let stderr = "";
+        let stopReason;
+        let spawnError;
+        let settled = false;
+        let killTimer;
+        const requestStop = (reason) => {
+            if (stopReason)
+                return;
+            stopReason = reason;
+            if (child.exitCode === null && child.signalCode === null) {
+                child.kill("SIGTERM");
+                killTimer = setTimeout(() => {
+                    if (child.exitCode === null && child.signalCode === null)
+                        child.kill("SIGKILL");
+                }, KILL_GRACE_MS);
+                killTimer.unref?.();
+            }
+        };
+        const processJsonLine = (line) => {
+            if (!line.trim() || stopReason)
+                return;
+            try {
+                const event = JSON.parse(line);
+                if (event.type !== "match")
+                    return;
+                const rawPath = decodeRgField(event.data?.path);
+                // A path that is not valid UTF-8 cannot be checked (or read back by
+                // the model), so its matches are dropped rather than shown unchecked.
+                if (event.data?.path && !rawPath)
+                    return;
+                const absolutePath = rawPath ? resolvePath(options.cwd, rawPath) : undefined;
+                if (absolutePath && isSensitiveMatch(absolutePath))
+                    return;
+                const lineNumber = event.data?.line_number;
+                const rawText = decodeRgField(event.data?.lines, "[non-UTF-8 match bytes omitted]") ?? "";
+                const displayPath = rawPath || "<non-UTF-8 path>";
+                const normalizedText = rawText.replace(/\r\n/g, "\n").replace(/\r/g, "").replace(/\n$/, "");
+                const rendered = truncateCodePoints(`${displayPath}:${typeof lineNumber === "number" ? lineNumber : "?"}: ${normalizedText}`, MAX_RENDERED_LINE_CODE_POINTS);
+                matches.push({
+                    rendered,
+                    ...(absolutePath ? { absolutePath } : {}),
+                });
+                // We stop at N rather than pretending we proved there are N+1 matches.
+                // The notice says "limit reached / may be incomplete", which is honest
+                // even for the exact-fit case and avoids continuing a huge tree walk.
+                if (matches.length >= options.matchLimit)
+                    requestStop("match_limit");
+            }
+            catch {
+                // A truncated/invalid JSON event is not useful to the model. Raw byte
+                // accounting remains authoritative and will stop pathological lines.
+            }
+        };
+        const processDecodedText = (text) => {
+            stdoutBuffer += text;
+            while (!stopReason) {
+                const newline = stdoutBuffer.indexOf("\n");
+                if (newline < 0)
+                    break;
+                const line = stdoutBuffer.slice(0, newline);
+                stdoutBuffer = stdoutBuffer.slice(newline + 1);
+                processJsonLine(line);
+            }
+        };
+        child.stdout.on("data", (value) => {
+            if (stopReason)
+                return;
+            const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+            const remaining = Math.max(0, MAX_RAW_STDOUT_BYTES - stdoutBytes);
+            const accepted = chunk.subarray(0, remaining);
+            stdoutBytes += accepted.length;
+            if (accepted.length > 0)
+                processDecodedText(decoder.write(accepted));
+            if (accepted.length < chunk.length || stdoutBytes >= MAX_RAW_STDOUT_BYTES) {
+                requestStop("stdout_limit");
+            }
+        });
+        child.stdout.on("end", () => {
+            if (stopReason)
+                return;
+            processDecodedText(decoder.end());
+            if (stdoutBuffer) {
+                processJsonLine(stdoutBuffer);
+                stdoutBuffer = "";
+            }
+        });
+        child.stderr.on("data", (value) => {
+            if (stopReason)
+                return;
+            const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+            const remaining = Math.max(0, MAX_STDERR_BYTES - stderrBytes);
+            const accepted = chunk.subarray(0, remaining);
+            stderrBytes += accepted.length;
+            if (accepted.length > 0)
+                stderr += accepted.toString("utf8");
+            if (accepted.length < chunk.length || stderrBytes >= MAX_STDERR_BYTES) {
+                requestStop("stderr_limit");
+            }
+        });
+        const timeout = setTimeout(() => requestStop("timeout"), GREP_TIMEOUT_MS);
+        timeout.unref?.();
+        const onAbort = () => requestStop("aborted");
+        options.abortSignal?.addEventListener("abort", onAbort, { once: true });
+        if (options.abortSignal?.aborted)
+            onAbort();
+        child.on("error", (error) => {
+            spawnError = error;
+        });
+        child.on("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            if (killTimer)
+                clearTimeout(killTimer);
+            options.abortSignal?.removeEventListener("abort", onAbort);
+            if (stopReason === "aborted") {
+                resolve({
+                    content: "Search cancelled.",
+                    isError: true,
+                    status: "cancelled",
+                    metadata: { ...options.baseMetadata, matches: 0, truncated: false, paths: [] },
+                });
+                return;
+            }
+            if (spawnError) {
+                resolve({
+                    content: `Error calling grep: ${spawnError.message}`,
+                    isError: true,
+                    status: "command_error",
+                    metadata: { ...options.baseMetadata, matches: 0, truncated: false, paths: [] },
+                });
+                return;
+            }
+            const naturalCommandError = !stopReason && code !== 0 && code !== 1;
+            const stoppedWithoutMatches = !!stopReason && matches.length === 0;
+            if (matches.length === 0 && !stoppedWithoutMatches && !naturalCommandError) {
+                resolve({
+                    content: "No matches found.",
+                    status: "no_match",
+                    metadata: { ...options.baseMetadata, matches: 0, truncated: false, paths: [] },
+                });
+                return;
+            }
+            if (naturalCommandError && matches.length === 0) {
+                resolve({
+                    content: `Error calling grep: ${stderr.trim() || `ripgrep exited with code ${code}`}`,
+                    isError: true,
+                    status: "command_error",
+                    metadata: { ...options.baseMetadata, matches: 0, truncated: false, paths: [] },
+                });
+                return;
+            }
+            const formatted = formatMatches(matches, options.matchLimit, stopReason, naturalCommandError ? stderr.trim() : "");
+            const truncated = !!stopReason || formatted.byteTruncated || naturalCommandError;
+            const paths = [...new Set(formatted.emittedMatches.flatMap((match) => match.absolutePath ? [match.absolutePath] : []))];
+            resolve({
+                content: formatted.content,
+                ...(naturalCommandError && matches.length === 0 ? { isError: true } : {}),
+                status: stopReason === "timeout" && matches.length === 0
+                    ? "timeout"
+                    : truncated
+                        ? "partial"
+                        : "success",
+                metadata: {
+                    ...options.baseMetadata,
+                    matches: formatted.emittedMatches.length,
+                    collectedMatches: matches.length,
+                    truncated,
+                    truncationReason: stopReason ?? (formatted.byteTruncated ? "result_bytes" : naturalCommandError ? "command_error" : undefined),
+                    rawStdoutBytes: stdoutBytes,
+                    paths,
+                },
+            });
+        });
+    });
+}
+function formatMatches(matches, matchLimit, stopReason, commandWarning) {
+    const emitted = [];
+    let bodyBytes = 0;
+    const bodyBudget = MAX_RESULT_BYTES - RESULT_NOTICE_RESERVE_BYTES;
+    for (const match of matches) {
+        const lineBytes = Buffer.byteLength(match.rendered, "utf8") + (emitted.length > 0 ? 1 : 0);
+        if (bodyBytes + lineBytes > bodyBudget)
+            break;
+        emitted.push(match);
+        bodyBytes += lineBytes;
+    }
+    const byteTruncated = emitted.length < matches.length;
+    const notices = [];
+    if (stopReason === "match_limit") {
+        notices.push(`Search stopped after reaching the global limit of ${matchLimit} matches; results may be incomplete. Narrow path/glob/pattern to continue.`);
+    }
+    else if (stopReason === "stdout_limit") {
+        notices.push(`Raw ripgrep output reached ${formatBytes(MAX_RAW_STDOUT_BYTES)}; results are incomplete. Narrow the search.`);
+    }
+    else if (stopReason === "stderr_limit") {
+        notices.push(`ripgrep diagnostics reached ${formatBytes(MAX_STDERR_BYTES)}; results are incomplete.`);
+    }
+    else if (stopReason === "timeout") {
+        notices.push(`Search timed out after ${GREP_TIMEOUT_MS / 1000}s; results are incomplete. Narrow the search.`);
+    }
+    if (byteTruncated) {
+        notices.push(`Showing ${emitted.length} of ${matches.length} collected matches because tool output is capped at ${formatBytes(MAX_RESULT_BYTES)}.`);
+    }
+    if (commandWarning)
+        notices.push(`ripgrep also reported: ${truncateCodePoints(commandWarning, 300)}`);
+    let content = emitted.map((match) => match.rendered).join("\n");
+    if (notices.length > 0)
+        content += `${content ? "\n" : ""}[${notices.join(" ")}]`;
+    // The reserve above normally guarantees this. Keep an exact byte backstop so
+    // future notice copy cannot accidentally violate the model-facing contract.
+    if (Buffer.byteLength(content, "utf8") > MAX_RESULT_BYTES) {
+        content = truncateUtf8Prefix(content, MAX_RESULT_BYTES);
+    }
+    return { content, emittedMatches: emitted, byteTruncated };
+}
+function normalizeMatchLimit(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return DEFAULT_MATCH_LIMIT;
+    return Math.min(MAX_MATCH_LIMIT, Math.max(1, Math.floor(value)));
+}
+function decodeRgField(value, invalidBytesFallback) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    if (typeof record.text === "string")
+        return record.text;
+    if (typeof record.bytes === "string") {
+        try {
+            return new TextDecoder("utf-8", { fatal: true }).decode(Buffer.from(record.bytes, "base64"));
+        }
+        catch {
+            return invalidBytesFallback;
+        }
+    }
+    return undefined;
+}
+function truncateCodePoints(value, maxCodePoints) {
+    const points = Array.from(value);
+    if (points.length <= maxCodePoints)
+        return value;
+    const marker = "... [truncated]";
+    return `${points.slice(0, Math.max(0, maxCodePoints - Array.from(marker).length)).join("")}${marker}`;
+}
+function truncateUtf8Prefix(value, maxBytes) {
+    const bytes = Buffer.from(value, "utf8");
+    if (bytes.length <= maxBytes)
+        return value;
+    let end = maxBytes;
+    while (end > 0 && (bytes[end] & 0xc0) === 0x80)
+        end -= 1;
+    return bytes.subarray(0, end).toString("utf8");
+}
+function formatBytes(bytes) {
+    return bytes % 1024 === 0 ? `${bytes / 1024}KiB` : `${bytes} bytes`;
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Tool registry factory.
+ */
+export { createReadTool } from "./read.js";
+export { createBashTool } from "./bash.js";
+export { createManagedServerTools } from "./server.js";
+export { createWriteTool } from "./write.js";
+export { createEditTool } from "./edit.js";
+export { buildToolPromptOptions } from "./prompt-metadata.js";
+export { createLsTool } from "./ls.js";
+export { createGrepTool } from "./grep.js";
+export { createLspTool } from "./lsp.js";
+export { createWebFetchTool } from "./web-fetch.js";
+export { createWebSearchTool } from "./web-search.js";
+export { createSkillTool } from "./skill.js";
+export { createSkillSearchTool } from "./skill-search.js";
+export { createAgentLifecycleTools, createCloseAgentTool, createSendInputTool, createSpawnAgentTool, createWaitAgentTool } from "./agent-lifecycle.js";
+export { createExitPlanModeTool, type PlanController } from "./exit-plan-mode.js";
+export { createToolSearchTool, type ToolSearchController } from "./tool-search.js";
+export { createQuestionTool } from "./question.js";
+export { createMemoryTool } from "./memory.js";
+import type { ToolRegistryEntry } from "../types.js";
+import type { ApprovalController } from "../approval/types.js";
+import type { SkillRegistry } from "../skills/registry.js";
+import { type PlanController } from "./exit-plan-mode.js";
+import { type LspService } from "../lsp/index.js";
+import { type ToolSearchController } from "./tool-search.js";
+import type { QuestionController } from "../question/index.js";
+import type { CheckpointStore } from "../checkpoints.js";
+import { FileStateTracker } from "./file-state.js";
+import type { GoalStore } from "../goal/store.js";
+import type { ProcessManager } from "../tasks/manager.js";
+import type { PromotionChannel } from "../tasks/promotion.js";
+export interface CreateAllToolsOptions {
+    planController?: PlanController;
+    approvalController?: ApprovalController;
+    questionController?: QuestionController;
+    toolSearchController?: ToolSearchController;
+    lspService?: LspService;
+    fileStateTracker?: FileStateTracker;
+    /**
+     * Lazy accessor for the session's checkpoint store (the session manager may
+     * not exist yet when tools are created). Used by edit/write to snapshot
+     * files before mutating them so /rewind can restore.
+     */
+    checkpoints?: () => CheckpointStore | undefined;
+    /** Shared goal state; when present, registers the update_goal tool. */
+    goalStore?: GoalStore;
+    /**
+     * Unified process manager (background tasks + managed servers). Background
+     * tasks are a per-host capability (background-tasks design §2.0): pass the
+     * manager AND set allowBackgroundTasks only in hosts that wire the full
+     * completion story (currently the interactive TUI). Without it, bash
+     * rejects run_in_background and the task tools are not registered.
+     */
+    processManager?: ProcessManager;
+    allowBackgroundTasks?: boolean;
+    /** Ctrl+B send-to-background requests from the TUI (design §2.5). */
+    promotionChannel?: PromotionChannel;
+    /** Grok-style foreground wait budget before a Bash Execute is demoted. */
+    autoBackgroundAfterMs?: number | false;
+}
+export declare function createAllTools(cwd: string, skillRegistry?: SkillRegistry, options?: CreateAllToolsOptions): ToolRegistryEntry[];