@nxuss/lemma 1.18.0 → 1.18.2

package/dist/cjs/mcp/tools/workspace.js

@@ -0,0 +1,675 @@
+"use strict";
+/**
+ * Workspace file/dir CRUD and command execution: read_workspace_file,
+ * write_workspace_file, create_workspace_file, apply_workspace_patch,
+ * run_workspace_command, output_region, list_workspace_dir. Split out of ../tools.ts
+ * (see that file's history for why) — pure relocation, no behavior change.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKSPACE_TOOL_HANDLERS = exports.WORKSPACE_TOOL_DEFINITIONS = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const SemanticScrubber_1 = require("../../security/SemanticScrubber");
+const TheBrainV2_1 = require("../../subconscious/TheBrainV2");
+const ContextSqueezer_1 = require("../../utils/ContextSqueezer");
+const reportSavings_1 = require("../../utils/reportSavings");
+const utils_1 = require("../utils");
+const TokenReceipt_1 = require("../../utils/TokenReceipt");
+const ExecAuditLog_1 = require("../../utils/ExecAuditLog");
+const CommandOutputDistiller_1 = require("../../utils/CommandOutputDistiller");
+const PatchMatcher_1 = require("../../utils/PatchMatcher");
+const ReadWorkspaceCache_1 = require("../../utils/ReadWorkspaceCache");
+const OutputDelta_1 = require("../../utils/OutputDelta");
+const OutputLedger_1 = require("../../utils/OutputLedger");
+const SpeculativeWarmer_1 = require("../../utils/SpeculativeWarmer");
+const LineNumberMap_1 = require("../../utils/LineNumberMap");
+const FileOutline_1 = require("../../utils/FileOutline");
+const workspaceShared_1 = require("../workspaceShared");
+exports.WORKSPACE_TOOL_DEFINITIONS = [
+    {
+        name: "read_workspace_file",
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+        description: "Read a file inside the workspace. Compresses comments/whitespace and scrubs API keys. Every line carries its REAL line number in the original file (compression removes lines, it never renumbers them), so you can cite file:line and patch precisely without re-reading. The header lists which imports were compressed away. Use offset/limit to read a line range of a large file. If this exact view was already read this session and hasn't changed on disk, returns an UNCHANGED marker plus a symbol outline. If it changed only slightly, returns a CHANGED marker with a unified diff to apply to the copy you already hold. Either way, pass force:true to get the full file when it is no longer in your context.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root" },
+                compact: { type: "boolean", description: "Whether to compress comments and whitespace", default: true },
+                force: { type: "boolean", description: "Bypass the unchanged-file short-circuit and always return full content", default: false },
+                lineNumbers: { type: "boolean", description: "Prefix each line with its real line number in the original file", default: true },
+                offset: { type: "number", description: "First line to read (1-indexed). Omit to start at the beginning." },
+                limit: { type: "number", description: "How many lines to read from offset. Omit to read to the end." },
+            },
+            required: ["filePath"],
+        },
+    },
+    {
+        name: "write_workspace_file",
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+        description: "Write full contents to a file inside the workspace. Creates parent directories automatically.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root" },
+                content: { type: "string", description: "The complete content to write" },
+            },
+            required: ["filePath", "content"],
+        },
+    },
+    {
+        name: "create_workspace_file",
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+        description: "Create a NEW file in the workspace. Fails immediately if the file already exists — use write_workspace_file or apply_workspace_patch to modify existing files. Creates parent directories automatically. Returns a minimal token-free ACK: no file content is echoed back, saving provider output tokens.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root for the new file" },
+                content: { type: "string", description: "The complete initial content for the new file" },
+            },
+            required: ["filePath", "content"],
+        },
+    },
+    {
+        name: "apply_workspace_patch",
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+        description: "Apply a smart search-and-replace patch to an existing file. Falls back through whitespace-normalized, indent-anchored, and fuzzy matching if the exact block isn't found — so a searchContent built from a compacted read still applies. Safe against duplicate matches. On total failure, the error includes a diff against the closest candidate block.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root" },
+                searchContent: { type: "string", description: "The exact search block to find" },
+                replaceContent: { type: "string", description: "The replacement block" },
+            },
+            required: ["filePath", "searchContent", "replaceContent"],
+        },
+    },
+    {
+        name: "run_workspace_command",
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+        execution: { taskSupport: "optional" },
+        description: "Execute a bash command in the workspace root. Default timeout 120s — raise it with timeoutMs for a full test or build run (max 600s). Captures both stdout and stderr, and returns whatever was produced even if the command times out. Long test/build/lint output is distilled deterministically — for jest, vitest and tsc it returns the failing tests or diagnostics with their locations and reasons, dropping code frames and node_modules stack frames; anything else falls back to head/tail plus error-matching lines. The complete output is always stored first and the reply carries a handle: nothing is lost, use output_region to retrieve any part verbatim. Pass raw:true to skip distillation.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "The bash command to run" },
+                raw: {
+                    type: "boolean",
+                    description: "Return the complete untouched output instead of the distilled view",
+                    default: false,
+                },
+                timeoutMs: {
+                    type: "number",
+                    description: "Milliseconds before the command is killed (default 120000, max 600000)",
+                    default: 120000,
+                },
+            },
+            required: ["command"],
+        },
+    },
+    {
+        name: "output_region",
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+        description: "Retrieve any part of a command output previously stored by run_workspace_command, verbatim. This is what makes distillation lossless — use it when the distilled view isn't enough. Pass all:true for the whole output, section for one named block (a failing test title or a file path, as listed in the distilled view), or startLine/endLine for a range.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                handle: { type: "string", description: "The handle reported by run_workspace_command" },
+                section: { type: "string", description: "Name of a section to retrieve (failing test title or file path)" },
+                startLine: { type: "number", description: "First line to return (1-indexed, inclusive)" },
+                endLine: { type: "number", description: "Last line to return (1-indexed, inclusive)" },
+                all: { type: "boolean", description: "Return the complete stored output", default: false },
+            },
+            required: ["handle"],
+        },
+    },
+    {
+        name: "list_workspace_dir",
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+        description: "List files and subdirectories recursively to navigate the repository structure.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                dirPath: { type: "string", description: "Directory relative to project root", default: "" },
+                maxDepth: { type: "number", description: "Maximum recursion depth", default: 3 },
+            },
+        },
+    },
+];
+async function handleReadWorkspaceFile(args) {
+    const filePath = args?.filePath;
+    const compact = args?.compact !== false;
+    const force = !!args?.force;
+    const lineNumbers = args?.lineNumbers !== false;
+    const offset = typeof args?.offset === "number" && args.offset > 0 ? Math.floor(args.offset) : undefined;
+    const limit = typeof args?.limit === "number" && args.limit > 0 ? Math.floor(args.limit) : undefined;
+    if (!filePath)
+        throw new Error("filePath is required");
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = (0, utils_1.safeResolvePath)(workspaceRoot, filePath);
+        const fullContent = fs_1.default.readFileSync(resolved, "utf8");
+        const view = { compact, lineNumbers, offset, limit };
+        // The range is applied to the original file, before any compression: `offset` means the
+        // line the user would see in an editor, not a position in the squeezed output.
+        const allLines = fullContent.split("\n");
+        const startIndex = offset ? Math.min(offset - 1, allLines.length) : 0;
+        const endIndex = limit ? Math.min(startIndex + limit, allLines.length) : allLines.length;
+        const ranged = offset || limit ? allLines.slice(startIndex, endIndex).join("\n") : fullContent;
+        const rangeHeader = offset || limit
+            ? `[lines ${startIndex + 1}-${endIndex} of ${allLines.length} in ${filePath}]\n`
+            : "";
+        let content = ranged;
+        const originalSize = content.length;
+        const dedup = (0, ReadWorkspaceCache_1.checkAlreadySent)(resolved, view, content);
+        if (!force && dedup.unchanged) {
+            (0, reportSavings_1.reportSavings)({
+                source: "contextSqueeze",
+                charsBefore: originalSize,
+                charsAfter: 0,
+                toolName: "read_workspace_file",
+                filePath,
+            });
+            // A hash alone is not actionable: the model's context may have been compacted since,
+            // in which case it no longer holds the copy this marker tells it to reuse. The outline
+            // costs ~50 tokens and is enough to either locate what it needs or decide to re-fetch.
+            const outline = (0, FileOutline_1.formatOutline)((0, FileOutline_1.fileOutline)(content), allLines.length);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: [
+                            `UNCHANGED: ${filePath} is identical to what you already read this session (hash ${dedup.hash.slice(0, 12)}) — reuse your existing copy.`,
+                            `If it is no longer in your context, re-fetch with force:true. Structure:`,
+                            outline,
+                        ].join("\n"),
+                    },
+                ],
+            };
+        }
+        // Line numbers are computed against the pre-squeeze text and carried through, so a
+        // compressed read still reports the position the code actually occupies on disk.
+        let numbers = null;
+        if (compact) {
+            const squeezed = (0, ContextSqueezer_1.squeezeCode)(content);
+            if (lineNumbers) {
+                numbers = (0, LineNumberMap_1.mapSqueezedToOriginal)(content, squeezed).map((n) => (n === null ? null : n + startIndex));
+            }
+            content = squeezed;
+            if (content.length < originalSize) {
+                (0, reportSavings_1.reportSavings)({
+                    source: "contextSqueeze",
+                    charsBefore: originalSize,
+                    charsAfter: content.length,
+                    toolName: "read_workspace_file",
+                    filePath,
+                });
+            }
+        }
+        else if (lineNumbers) {
+            numbers = (0, LineNumberMap_1.sequentialNumbers)(content, startIndex + 1);
+        }
+        try {
+            const scrubber = new SemanticScrubber_1.SemanticScrubber();
+            const { maskedPrompt } = scrubber.mask(content);
+            // Masking must not change the line count, or every number after a masked secret would
+            // be off. If it ever does, drop the gutter rather than print numbers that lie.
+            if (numbers && maskedPrompt.split("\n").length !== content.split("\n").length) {
+                numbers = null;
+            }
+            content = maskedPrompt;
+        }
+        catch (err) {
+            (0, utils_1.logWarn)("read_workspace_file", "SemanticScrubber failed, returning raw content");
+        }
+        if (numbers)
+            content = (0, LineNumberMap_1.withLineNumbers)(content, numbers);
+        // The file changed, but usually only slightly — the common case in an edit loop is a
+        // few lines moving in a file the model already holds in full. Re-sending everything
+        // charges for the whole file (and keeps charging, since tool results stay in the
+        // transcript). A diff against the exact text we last emitted covers the same ground
+        // for a fraction of the tokens; `shouldEmitDelta` declines whenever it wouldn't.
+        if (!force) {
+            const previousEmitted = (0, ReadWorkspaceCache_1.getLastEmitted)(resolved, view);
+            if (previousEmitted !== null) {
+                const delta = (0, OutputDelta_1.shouldEmitDelta)(previousEmitted, content);
+                if (delta.emit) {
+                    (0, reportSavings_1.reportSavings)({
+                        source: "contextSqueeze",
+                        charsBefore: content.length,
+                        charsAfter: delta.body.length,
+                        toolName: "read_workspace_file",
+                        filePath,
+                    });
+                    (0, ReadWorkspaceCache_1.recordSent)(resolved, view, dedup.hash, content);
+                    (0, SpeculativeWarmer_1.warmNeighbors)(workspaceRoot, resolved);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: [
+                                    `CHANGED: ${filePath} — ${delta.hunkCount} hunk(s), +${delta.added}/-${delta.removed} since you last read it.`,
+                                    `Apply this diff to the copy you already have. Line numbers are real positions in the file on disk.`,
+                                    `If you no longer hold that copy, re-fetch with force:true.`,
+                                    ``,
+                                    delta.body,
+                                ].join("\n") + (0, workspaceShared_1.formatRecallNote)(filePath),
+                            },
+                        ],
+                    };
+                }
+            }
+        }
+        (0, ReadWorkspaceCache_1.recordSent)(resolved, view, dedup.hash, content);
+        (0, SpeculativeWarmer_1.warmNeighbors)(workspaceRoot, resolved);
+        return { content: [{ type: "text", text: rangeHeader + content + (0, workspaceShared_1.formatRecallNote)(filePath) }] };
+    }
+    catch (err) {
+        (0, utils_1.logError)("read_workspace_file", err);
+        return { content: [{ type: "text", text: `Error reading file: ${err.message}` }] };
+    }
+}
+async function handleWriteWorkspaceFile(args) {
+    const filePath = args?.filePath;
+    const content = args?.content;
+    if (!filePath || content === undefined)
+        throw new Error("filePath and content are required");
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = (0, utils_1.safeResolvePath)(workspaceRoot, filePath);
+        const dir = path_1.default.dirname(resolved);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        fs_1.default.writeFileSync(resolved, content, "utf8");
+        (0, ExecAuditLog_1.recordExecAudit)({ tool: "write_workspace_file", detail: resolved, allowed: true });
+        const blastRadius = (0, workspaceShared_1.formatBlastRadiusNote)((0, TheBrainV2_1.getBrain)().findBlastRadius(filePath));
+        return { content: [{ type: "text", text: `Success: Written file to ${filePath}${blastRadius}` }] };
+    }
+    catch (err) {
+        (0, utils_1.logError)("write_workspace_file", err);
+        return { content: [{ type: "text", text: `Error writing file: ${err.message}` }] };
+    }
+}
+// ── Create Workspace File (zero-token ACK) ───────────────────────────
+async function handleCreateWorkspaceFile(args) {
+    const filePath = args?.filePath;
+    const content = args?.content;
+    if (!filePath || content === undefined)
+        throw new Error("filePath and content are required");
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = (0, utils_1.safeResolvePath)(workspaceRoot, filePath);
+        if (fs_1.default.existsSync(resolved)) {
+            return { content: [{ type: "text", text: `Error: File already exists at ${filePath}. Use write_workspace_file or apply_workspace_patch to modify it.` }] };
+        }
+        const dir = path_1.default.dirname(resolved);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        fs_1.default.writeFileSync(resolved, content, "utf8");
+        (0, ExecAuditLog_1.recordExecAudit)({ tool: "create_workspace_file", detail: resolved, allowed: true });
+        // Minimal ACK — no content echoed back to save provider output tokens
+        return { content: [{ type: "text", text: `OK:created:${filePath}` }] };
+    }
+    catch (err) {
+        (0, utils_1.logError)("create_workspace_file", err);
+        return { content: [{ type: "text", text: `Error creating file: ${err.message}` }] };
+    }
+}
+/**
+ * `read_workspace_file` now returns a "123| code" gutter, which makes it easy to paste a block
+ * back into a patch with the numbers still attached. That block matches nothing on disk, so the
+ * patch fails for a reason that has nothing to do with the edit. Strip the gutter when *every*
+ * non-empty line carries one — a uniform prefix is a gutter; a lone "12| " inside real code is
+ * not, and must be left alone.
+ */
+function stripLineNumberGutter(text) {
+    const lines = text.split("\n");
+    const nonEmpty = lines.filter((l) => l.trim().length > 0);
+    if (nonEmpty.length === 0)
+        return text;
+    const GUTTER = /^\s*\d+\|\s?/;
+    if (!nonEmpty.every((l) => GUTTER.test(l)))
+        return text;
+    return lines.map((l) => l.replace(GUTTER, "")).join("\n");
+}
+// Splices one resolved match into the file and writes it. Shared by the normal
+// single-match path and the ambiguous-match-resolved-via-elicitation path below.
+async function applyMatch(match, filePath, resolved, originalContent, searchContent, replaceContent) {
+    let updatedContent;
+    if (match.strategy === "exact" && match.charStart !== undefined && match.charEnd !== undefined) {
+        // Splice by character offset — the search block may be a mid-line fragment, and
+        // a whole-line splice would discard everything else sharing that line.
+        updatedContent = originalContent.slice(0, match.charStart) + replaceContent + originalContent.slice(match.charEnd);
+    }
+    else {
+        const contentLines = originalContent.split("\n");
+        const finalReplace = (0, PatchMatcher_1.reindentReplacement)(replaceContent, searchContent, contentLines[match.startLine]);
+        const updatedLines = [...contentLines.slice(0, match.startLine), ...finalReplace.split("\n"), ...contentLines.slice(match.endLine + 1)];
+        updatedContent = updatedLines.join("\n");
+    }
+    const elicited = await (0, utils_1.tryElicitConfirmation)(`Apply a patch to ${filePath}? This replaces ${searchContent.length} char(s) with ${replaceContent.length} char(s) ` +
+        `starting at line ${match.startLine + 1}.`);
+    if (elicited.supported && !elicited.confirmed) {
+        return { content: [{ type: "text", text: `Patch to ${filePath} was not applied: declined during confirmation.` }] };
+    }
+    fs_1.default.writeFileSync(resolved, updatedContent, "utf8");
+    (0, ExecAuditLog_1.recordExecAudit)({ tool: "apply_workspace_patch", detail: resolved, allowed: true });
+    const note = match.strategy === "exact" ? "" : ` (matched via ${match.strategy}, score ${match.score.toFixed(2)})`;
+    const blastRadius = (0, workspaceShared_1.formatBlastRadiusNote)((0, TheBrainV2_1.getBrain)().findBlastRadius(filePath));
+    return { content: [{ type: "text", text: `Success: Patch successfully applied to ${filePath}${note}${blastRadius}` }] };
+}
+async function handleApplyWorkspacePatch(args) {
+    const filePath = args?.filePath;
+    const rawSearch = args?.searchContent;
+    const rawReplace = args?.replaceContent;
+    if (!filePath || !rawSearch || rawReplace === undefined) {
+        throw new Error("filePath, searchContent, and replaceContent are required");
+    }
+    const searchContent = stripLineNumberGutter(rawSearch);
+    // Only strip the replacement's gutter when the search block had one too: that pairing means
+    // the model was working from a numbered read. Stripping unconditionally would mangle a
+    // replacement that legitimately contains "1| " (a table, a doc block).
+    const replaceContent = searchContent !== rawSearch ? stripLineNumberGutter(rawReplace) : rawReplace;
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = (0, utils_1.safeResolvePath)(workspaceRoot, filePath);
+        if (!fs_1.default.existsSync(resolved)) {
+            return { content: [{ type: "text", text: `Error: File ${filePath} does not exist.` }] };
+        }
+        const originalContent = fs_1.default.readFileSync(resolved, "utf8");
+        const matchResult = (0, PatchMatcher_1.findMatch)(originalContent, searchContent);
+        if (!Array.isArray(matchResult)) {
+            if (matchResult.reason === "ambiguous") {
+                const candidates = matchResult.candidates ?? [];
+                if (candidates.length > 0) {
+                    const chosen = await (0, utils_1.tryElicitChoice)(`${candidates.length} equally good matches found for the search content in ${filePath}. Which one should be patched?`, candidates.map((c) => ({
+                        title: `line ${c.startLine + 1}: ${c.matchedText.split("\n")[0].slice(0, 80)}`,
+                    })));
+                    if (chosen.index !== null) {
+                        return applyMatch(candidates[chosen.index], filePath, resolved, originalContent, searchContent, replaceContent);
+                    }
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Multiple matches found for the search content. Please provide a larger search block with unique surrounding context lines to make it unambiguous.`,
+                        },
+                    ],
+                };
+            }
+            if (matchResult.candidateDiff) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: No match found for the search content. Closest candidate starts at line ${matchResult.candidateStartLine} (- = your searchContent, + = actual file content):\n\n${matchResult.candidateDiff}`,
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: Target search content not found in file, and no similar block was found to diff against.`,
+                    },
+                ],
+            };
+        }
+        return applyMatch(matchResult[0], filePath, resolved, originalContent, searchContent, replaceContent);
+    }
+    catch (err) {
+        (0, utils_1.logError)("apply_workspace_patch", err);
+        return { content: [{ type: "text", text: `Error applying patch: ${err.message}` }] };
+    }
+}
+// Async replacement for spawnSync: a blocking syscall inside a `tools/call` handler
+// freezes the whole (single-threaded) MCP server for the run's entire duration — including
+// task-status polls for THIS run once it's task-augmented (see runAsTask in tasks.ts), which
+// would otherwise defeat the point of making the tool pollable. `spawn` keeps the event loop
+// free while the command runs. Shape of the resolved value mirrors spawnSync's return value
+// on the fields the caller actually reads, so the rest of handleRunWorkspaceCommand is unchanged.
+function spawnCollect(command, cwd, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)(command, {
+            cwd,
+            shell: true,
+            env: { ...process.env },
+            // spawnSync closed stdin immediately (no `input` option given), so a command reading
+            // from stdin (e.g. `sed` with no file argument) saw EOF right away. Plain `spawn`
+            // leaves stdin as an open pipe by default — nothing ever writes to or closes it — so
+            // the same command hangs until the timeout kills it. "ignore" reproduces the old,
+            // immediate-EOF behavior.
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        const MAX_BUFFER = 20 * 1024 * 1024;
+        let timedOut = false;
+        let settled = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+        }, timeoutMs);
+        child.stdout?.on("data", (chunk) => {
+            if (stdoutBytes >= MAX_BUFFER)
+                return;
+            stdoutBytes += chunk.length;
+            stdout += chunk.toString("utf8");
+        });
+        child.stderr?.on("data", (chunk) => {
+            if (stderrBytes >= MAX_BUFFER)
+                return;
+            stderrBytes += chunk.length;
+            stderr += chunk.toString("utf8");
+        });
+        child.on("error", (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ stdout, stderr, status: null, timedOut, error: err });
+        });
+        child.on("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ stdout, stderr, status: code, timedOut });
+        });
+    });
+}
+async function handleRunWorkspaceCommand(args) {
+    const command = args?.command;
+    if (!command)
+        throw new Error("command is required");
+    // ── Security: allowlist check ──────────────────────────────────────────────
+    const check = (0, utils_1.isCommandAllowed)(command);
+    if (!check.allowed) {
+        (0, ExecAuditLog_1.recordExecAudit)({ tool: "run_workspace_command", detail: command, allowed: false, reason: check.reason });
+        const allowed = (0, utils_1.loadAllowedCommands)().join(', ');
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `❌ Command blocked by Lemma security policy.`,
+                        ``,
+                        `Command: ${command}`,
+                        `Reason: ${check.reason ?? "The base command is not in the allowed list."}`,
+                        ``,
+                        `Allowed command prefixes:`,
+                        `  ${allowed}`,
+                        ``,
+                        `To extend the allowlist, add to lemma.config.json:`,
+                        `  { "mcp": { "allowedCommandPrefixes": ["your-command"] } }`,
+                    ].join("\n"),
+                }],
+        };
+    }
+    // ── End allowlist check ────────────────────────────────────────────────
+    const workspaceRoot = process.cwd();
+    try {
+        // spawn (via spawnCollect above) rather than execSync: execSync leaves stderr attached to
+        // the parent unless stdio is overridden, which silently dropped the output of every tool
+        // that reports on stderr (jest and tsc both do) on a successful run. It also gives us
+        // stdout, stderr and the exit code through one code path instead of a throw-on-failure split.
+        // 15s was below the runtime of the commands this tool exists for: a real `npm test` or
+        // `tsc --noEmit` always tripped it, so the distillation pipeline never ran on the output
+        // it was built for and the call was pure overhead before falling back to a plain shell.
+        const DEFAULT_TIMEOUT_MS = 120000;
+        const MAX_TIMEOUT_MS = 600000;
+        const requested = typeof args?.timeoutMs === "number" && args.timeoutMs > 0 ? args.timeoutMs : DEFAULT_TIMEOUT_MS;
+        const timeoutMs = Math.min(Math.floor(requested), MAX_TIMEOUT_MS);
+        const elicited = await (0, utils_1.tryElicitConfirmation)(`Run this command in the workspace root?\n\n${command}`);
+        if (elicited.supported && !elicited.confirmed) {
+            return { content: [{ type: "text", text: `Command was not run: declined during confirmation.\n\nCommand: ${command}` }] };
+        }
+        const result = await spawnCollect(command, workspaceRoot, timeoutMs);
+        const timedOut = result.timedOut;
+        (0, ExecAuditLog_1.recordExecAudit)({
+            tool: "run_workspace_command",
+            detail: command,
+            allowed: true,
+            exitCode: result.status,
+            reason: timedOut ? "timed out" : undefined,
+        });
+        if (result.error && !timedOut) {
+            return {
+                content: [{ type: "text", text: `Command could not be executed: ${result.error.message}` }],
+            };
+        }
+        const stdout = result.stdout || "";
+        const stderr = result.stderr || "";
+        const combined = [stdout, stderr].filter((s) => s.trim().length > 0).join("\n");
+        const status = result.status ?? 0;
+        // A timed-out run still produced output, and that partial output is normally where the
+        // failure is. Discarding it forced the whole command to be re-run somewhere else.
+        const header = timedOut
+            ? `Command timed out after ${Math.round(timeoutMs / 1000)}s (killed): ${command}\nOutput produced before the kill is below — it may be incomplete. Re-run with a higher timeoutMs if it was still making progress.`
+            : status === 0
+                ? "Command completed successfully."
+                : `Command failed with exit code ${status}.`;
+        if (!combined.trim()) {
+            return { content: [{ type: "text", text: `${header}\n\n(no output)` }] };
+        }
+        const distilled = (0, CommandOutputDistiller_1.distillCommandOutput)(combined, { command, raw: args?.raw === true });
+        if (distilled.handle) {
+            (0, TokenReceipt_1.recordReceiptEvent)("tool_call", `run_workspace_command distilled (${distilled.format})`, {
+                command,
+                originalChars: distilled.originalChars,
+                distilledChars: distilled.distilledChars,
+                handle: distilled.handle,
+            });
+        }
+        // A debug loop runs the same command repeatedly and the output barely moves between
+        // runs. The header is part of the compared text on purpose: a pass/fail flip must never
+        // be reported as "identical", even in the rare case where the body alone matches.
+        // The footer is deliberately excluded and always re-appended — it carries this run's
+        // `output_region` handle, which is different every time and must stay usable.
+        const body = `${header}\n\nOutput:\n${distilled.text}`;
+        const footer = (0, CommandOutputDistiller_1.buildDistillFooter)(distilled);
+        const key = (0, OutputLedger_1.ledgerKey)("run_workspace_command", { command, cwd: workspaceRoot, raw: args?.raw === true });
+        const ledger = (0, OutputLedger_1.checkOutput)(key, body, {
+            label: `\`${command}\``,
+            rerunHint: "The command did run again — this reports its result, it does not skip execution.",
+        });
+        (0, OutputLedger_1.recordOutput)(key, body);
+        if (ledger.replacement) {
+            (0, reportSavings_1.reportSavings)({
+                source: "contextSqueeze",
+                charsBefore: body.length,
+                charsAfter: ledger.replacement.length,
+                toolName: "run_workspace_command",
+            });
+            (0, TokenReceipt_1.recordReceiptEvent)("tool_call", `run_workspace_command ${ledger.status} vs. earlier run`, {
+                command,
+                savedChars: ledger.savedChars,
+            });
+            return { content: [{ type: "text", text: ledger.replacement + footer }] };
+        }
+        return {
+            content: [
+                { type: "text", text: body + footer },
+            ],
+        };
+    }
+    catch (err) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Command could not be executed: ${err?.message || String(err)}`,
+                },
+            ],
+        };
+    }
+}
+async function handleOutputRegion(args) {
+    const handle = args?.handle;
+    if (!handle)
+        throw new Error("handle is required");
+    const region = (0, CommandOutputDistiller_1.readRegion)({
+        handle,
+        section: args?.section,
+        startLine: args?.startLine,
+        endLine: args?.endLine,
+        all: args?.all === true,
+    });
+    if (!region.found) {
+        const parts = [region.error ?? `Could not read region for handle "${handle}".`];
+        if (region.availableSections?.length) {
+            parts.push("", "Available sections:", ...region.availableSections.map((s) => `  ${s}`));
+        }
+        return { content: [{ type: "text", text: parts.join("\n") }] };
+    }
+    const scope = region.startLine === 1 && region.endLine === region.totalLines
+        ? `complete output (${region.totalLines} lines)`
+        : `lines ${region.startLine}-${region.endLine} of ${region.totalLines}`;
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Raw output for \`${region.command ?? "?"}\` — ${scope}, verbatim:\n\n${region.text}`,
+            },
+        ],
+    };
+}
+async function handleListWorkspaceDir(args) {
+    const dirPath = args?.dirPath || "";
+    const maxDepth = args?.maxDepth || 3;
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = (0, utils_1.safeResolvePath)(workspaceRoot, dirPath);
+        const list = (0, workspaceShared_1.listDirRecursive)(resolved, dirPath, 1, maxDepth);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: list.length > 0 ? list.join("\n") : "(Directory is empty or inaccessible)",
+                },
+            ],
+        };
+    }
+    catch (err) {
+        (0, utils_1.logError)("list_workspace_dir", err);
+        return { content: [{ type: "text", text: `Error listing directory: ${err.message}` }] };
+    }
+}
+exports.WORKSPACE_TOOL_HANDLERS = {
+    read_workspace_file: handleReadWorkspaceFile,
+    write_workspace_file: handleWriteWorkspaceFile,
+    create_workspace_file: handleCreateWorkspaceFile,
+    apply_workspace_patch: handleApplyWorkspacePatch,
+    run_workspace_command: handleRunWorkspaceCommand,
+    output_region: handleOutputRegion,
+    list_workspace_dir: handleListWorkspaceDir,
+};
+//# sourceMappingURL=workspace.js.map