stageflow 0.25.0 → 0.30.0

package/dist/mcp/checkoutTools.d.ts

@@ -0,0 +1,52 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { RunMeta, RunStore } from "../runstore/port.js";
+import type { McpToolDeps } from "./deps.js";
+export declare const CHECKOUT_CHANGES_CAP = 500;
+export declare const DEFAULT_DIFF_MAX_BYTES = 262144;
+export type CheckoutChangeStatus = "added" | "untracked" | "modified" | "deleted";
+export type CheckoutChangeEntry = {
+    path: string;
+    status: CheckoutChangeStatus;
+};
+export type CheckoutVisibilityCode = "run_not_bound" | "checkout_reclaimed" | "not_a_git_repository";
+export type CheckoutVisibilityError = {
+    ok: false;
+    code: CheckoutVisibilityCode;
+    error: string;
+    status: number;
+};
+export type BoundCheckout = {
+    ok: true;
+    runId: string;
+    meta: RunMeta;
+    checkoutRoot: string;
+    isGit: boolean;
+};
+export declare function resolveBoundCheckout(store: RunStore, runId: string): Promise<BoundCheckout | CheckoutVisibilityError>;
+export declare function parseStatusPorcelainZ(output: string): CheckoutChangeEntry[];
+export declare function listCheckoutChanges(store: RunStore, runId: string): Promise<{
+    ok: true;
+    changes: CheckoutChangeEntry[];
+    truncated: boolean;
+} | CheckoutVisibilityError>;
+export type GetRunDiffInput = {
+    mode?: "stat" | "patch";
+    path?: string;
+    maxBytes?: number;
+};
+export type GetRunDiffSuccess = {
+    ok: true;
+    mode: "stat" | "patch";
+    base_sha: string;
+    base_source: "resolved_sha" | "HEAD";
+    content: string;
+    truncated: boolean;
+    untracked: string[];
+};
+export declare function getRunDiff(store: RunStore, runId: string, input?: GetRunDiffInput): Promise<GetRunDiffSuccess | CheckoutVisibilityError>;
+export declare function readCheckoutFileBytes(store: RunStore, runId: string, relativePath: string): Promise<{
+    ok: true;
+    bytes: Buffer;
+    path: string;
+} | CheckoutVisibilityError>;
+export declare function registerCheckoutTools(server: McpServer, deps: McpToolDeps): void;

package/dist/mcp/checkoutTools.js

@@ -0,0 +1,332 @@
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { lstat, readdir, readFile, readlink } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { diff, lsFilesOthersZ, revParse, statusPorcelainZ, } from "../git/operations.js";
+import { projectRunBindingDetail } from "../runstore/runProjection.js";
+import { mapStoreLookupError } from "../server/operatorResults.js";
+import { assertSafeRunId, CHECKOUT_PATH_MESSAGES, classifyArtifactContent, resolveContainedRelativePath, } from "./readArtifact.js";
+import { imageResult, textResult } from "./toolResults.js";
+export const CHECKOUT_CHANGES_CAP = 500;
+export const DEFAULT_DIFF_MAX_BYTES = 262_144;
+async function detectGitCheckout(root) {
+    try {
+        const inside = await revParse(root, ["--is-inside-work-tree"]);
+        return inside === "true";
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveBoundCheckout(store, runId) {
+    assertSafeRunId(runId);
+    let meta;
+    try {
+        meta = await store.readRunMeta(runId);
+    }
+    catch (err) {
+        const mapped = mapStoreLookupError(err, { policy: "run" });
+        throw new Error(mapped.error);
+    }
+    const binding = projectRunBindingDetail(meta);
+    if (binding.kind === "unbound") {
+        return {
+            ok: false,
+            code: "run_not_bound",
+            error: "run is not bound to a checkout",
+            status: 400,
+        };
+    }
+    const checkoutRoot = meta.checkout_root?.trim();
+    if (!checkoutRoot) {
+        return {
+            ok: false,
+            code: "checkout_reclaimed",
+            error: "checkout has been reclaimed",
+            status: 404,
+        };
+    }
+    if (!existsSync(checkoutRoot)) {
+        return {
+            ok: false,
+            code: "checkout_reclaimed",
+            error: "checkout has been reclaimed",
+            status: 404,
+        };
+    }
+    const isGit = await detectGitCheckout(checkoutRoot);
+    return { ok: true, runId, meta, checkoutRoot, isGit };
+}
+function nulSplit(output) {
+    return output.split("\0").filter((part) => part.length > 0);
+}
+export function parseStatusPorcelainZ(output) {
+    const parts = nulSplit(output);
+    const changes = [];
+    for (let i = 0; i < parts.length; i += 1) {
+        const entry = parts[i];
+        if (entry.length < 3)
+            continue;
+        const xy = entry.slice(0, 2);
+        const firstPath = entry.slice(3);
+        const isRenameOrCopy = xy[0] === "R" || xy[0] === "C";
+        let filePath = firstPath;
+        if (isRenameOrCopy) {
+            const next = parts[i + 1];
+            if (next !== undefined) {
+                filePath = next;
+                i += 1;
+            }
+        }
+        if (xy === "??") {
+            changes.push({ path: filePath, status: "untracked" });
+            continue;
+        }
+        if (xy === "!!")
+            continue;
+        if (xy.includes("D") && !isRenameOrCopy) {
+            changes.push({ path: filePath, status: "deleted" });
+            continue;
+        }
+        if (xy[0] === "A" || xy[1] === "A" || isRenameOrCopy) {
+            changes.push({ path: filePath, status: "added" });
+            continue;
+        }
+        changes.push({ path: filePath, status: "modified" });
+    }
+    return changes;
+}
+function capChanges(changes) {
+    if (changes.length <= CHECKOUT_CHANGES_CAP) {
+        return { changes, truncated: false };
+    }
+    return {
+        changes: changes.slice(0, CHECKOUT_CHANGES_CAP),
+        truncated: true,
+    };
+}
+async function fingerprintFile(root, relativePath) {
+    const target = path.join(root, relativePath);
+    try {
+        const stats = await lstat(target);
+        if (stats.isSymbolicLink()) {
+            const targetPath = await readlink(target);
+            return `link:${createHash("sha256").update(targetPath).digest("hex")}`;
+        }
+        if (!stats.isFile())
+            return `other:${stats.mode}:${stats.size}`;
+        const contents = await readFile(target);
+        return `file:${createHash("sha256").update(contents).digest("hex")}`;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return "missing";
+        throw error;
+    }
+}
+async function listNonGitFiles(root, relativeDir = "") {
+    const absDir = relativeDir ? path.join(root, relativeDir) : root;
+    let entries;
+    try {
+        entries = await readdir(absDir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    const files = [];
+    for (const entry of entries) {
+        if (entry.name === ".pi-agent" || entry.name === ".git")
+            continue;
+        const rel = relativeDir ? path.join(relativeDir, entry.name) : entry.name;
+        if (entry.name === "auth.json")
+            continue;
+        if (entry.isSymbolicLink() || entry.isFile()) {
+            files.push(rel.split(path.sep).join("/"));
+            continue;
+        }
+        if (entry.isDirectory()) {
+            files.push(...(await listNonGitFiles(root, rel)));
+        }
+    }
+    return files;
+}
+async function listNonGitChanges(checkoutRoot) {
+    const files = (await listNonGitFiles(checkoutRoot)).sort();
+    const changes = [];
+    for (const file of files) {
+        const fingerprint = await fingerprintFile(checkoutRoot, file);
+        if (fingerprint === "missing")
+            continue;
+        changes.push({ path: file, status: "untracked" });
+        if (changes.length > CHECKOUT_CHANGES_CAP)
+            break;
+    }
+    return capChanges(changes);
+}
+export async function listCheckoutChanges(store, runId) {
+    const bound = await resolveBoundCheckout(store, runId);
+    if (!bound.ok)
+        return bound;
+    if (!bound.isGit) {
+        const listed = await listNonGitChanges(bound.checkoutRoot);
+        return { ok: true, ...listed };
+    }
+    const porcelain = await statusPorcelainZ(bound.checkoutRoot);
+    return { ok: true, ...capChanges(parseStatusPorcelainZ(porcelain)) };
+}
+export async function getRunDiff(store, runId, input = {}) {
+    const bound = await resolveBoundCheckout(store, runId);
+    if (!bound.ok)
+        return bound;
+    if (!bound.isGit) {
+        return {
+            ok: false,
+            code: "not_a_git_repository",
+            error: "checkout is not a git repository",
+            status: 400,
+        };
+    }
+    const mode = input.mode ?? "stat";
+    const maxBytes = typeof input.maxBytes === "number" && Number.isFinite(input.maxBytes)
+        ? Math.max(0, Math.floor(input.maxBytes))
+        : DEFAULT_DIFF_MAX_BYTES;
+    let baseSha = bound.meta.resolved_sha?.trim() || undefined;
+    let baseSource = "resolved_sha";
+    if (!baseSha) {
+        baseSha = await revParse(bound.checkoutRoot, ["HEAD"]);
+        baseSource = "HEAD";
+    }
+    const pathArgs = input.path !== undefined && input.path.trim().length > 0
+        ? ["--", input.path]
+        : ["--"];
+    const diffArgs = mode === "patch"
+        ? ["--patch", "--no-color", baseSha, ...pathArgs]
+        : ["--stat", baseSha, ...pathArgs];
+    let content = await diff(bound.checkoutRoot, diffArgs);
+    const othersRaw = await lsFilesOthersZ(bound.checkoutRoot);
+    let untracked = nulSplit(othersRaw);
+    if (input.path !== undefined && input.path.trim().length > 0) {
+        const filter = input.path.replace(/\\/g, "/");
+        untracked = untracked.filter((file) => file === filter || file.startsWith(`${filter}/`));
+    }
+    let truncated = false;
+    if (mode === "patch" && content.length > maxBytes) {
+        content = content.slice(0, maxBytes);
+        truncated = true;
+    }
+    if (untracked.length > CHECKOUT_CHANGES_CAP) {
+        untracked = untracked.slice(0, CHECKOUT_CHANGES_CAP);
+        truncated = true;
+    }
+    return {
+        ok: true,
+        mode,
+        base_sha: baseSha,
+        base_source: baseSource,
+        content,
+        truncated,
+        untracked,
+    };
+}
+export async function readCheckoutFileBytes(store, runId, relativePath) {
+    const bound = await resolveBoundCheckout(store, runId);
+    if (!bound.ok)
+        return bound;
+    const realPath = await resolveContainedRelativePath(bound.checkoutRoot, relativePath, CHECKOUT_PATH_MESSAGES);
+    return { ok: true, bytes: await readFile(realPath), path: relativePath };
+}
+function visibilityErrorResult(err) {
+    return textResult({ error: err.error, code: err.code, status: err.status }, true);
+}
+export function registerCheckoutTools(server, deps) {
+    const { store } = deps;
+    server.registerTool("list_checkout_changes", {
+        description: "List dirty/untracked paths in the run's bound checkout. Repository and git path bindings use git status; non-git path bindings use filesystem fingerprints. Unbound → run_not_bound; reclaimed checkout → checkout_reclaimed. Caps at 500 entries with truncated: true.",
+        inputSchema: z.object({
+            runId: z.string(),
+        }),
+    }, async ({ runId }) => {
+        try {
+            const result = await listCheckoutChanges(store, runId);
+            if (!result.ok)
+                return visibilityErrorResult(result);
+            return textResult({
+                runId,
+                changes: result.changes,
+                truncated: result.truncated,
+            });
+        }
+        catch (err) {
+            const mapped = mapStoreLookupError(err, { policy: "run" });
+            return textResult({ error: mapped.error, status: mapped.status }, true);
+        }
+    });
+    server.registerTool("get_run_diff", {
+        description: "Diff the run's bound git checkout against its recorded base SHA (resolved_sha). mode defaults to stat; patch enforces maxBytes (default 262144) with truncated: true. Unbound → run_not_bound; non-git path → not_a_git_repository; reclaimed → checkout_reclaimed.",
+        inputSchema: z.object({
+            runId: z.string(),
+            mode: z.enum(["stat", "patch"]).optional(),
+            path: z.string().optional(),
+            maxBytes: z.number().optional(),
+        }),
+    }, async ({ runId, mode, path: filterPath, maxBytes }) => {
+        try {
+            const result = await getRunDiff(store, runId, {
+                mode,
+                path: filterPath,
+                maxBytes,
+            });
+            if (!result.ok)
+                return visibilityErrorResult(result);
+            return textResult({
+                runId,
+                mode: result.mode,
+                base_sha: result.base_sha,
+                base_source: result.base_source,
+                content: result.content,
+                truncated: result.truncated,
+                untracked: result.untracked,
+            });
+        }
+        catch (err) {
+            const mapped = mapStoreLookupError(err, { policy: "run" });
+            return textResult({ error: mapped.error, status: mapped.status }, true);
+        }
+    });
+    server.registerTool("read_checkout_file", {
+        description: "Read a file from the run's bound checkout by relative path (contained under checkout_root). Same deny-list as read_artifact (.pi-agent, auth.json, traversal). Images return an MCP image block; UTF-8 returns JSON { runId, path, content }.",
+        inputSchema: z.object({
+            runId: z.string(),
+            path: z.string(),
+        }),
+    }, async ({ runId, path: relativePath }) => {
+        try {
+            const result = await readCheckoutFileBytes(store, runId, relativePath);
+            if (!result.ok)
+                return visibilityErrorResult(result);
+            const classified = classifyArtifactContent(relativePath, result.bytes);
+            if (classified.kind === "image") {
+                return imageResult(classified.mimeType, result.bytes, {
+                    runId,
+                    path: relativePath,
+                    mimeType: classified.mimeType,
+                });
+            }
+            if (classified.kind === "utf8") {
+                return textResult({
+                    runId,
+                    path: relativePath,
+                    content: result.bytes.toString("utf8"),
+                });
+            }
+            return textResult({ error: "Checkout file is not valid UTF-8 text", status: 400 }, true);
+        }
+        catch (err) {
+            const mapped = mapStoreLookupError(err, { policy: "artifact" });
+            return textResult({ error: mapped.error, status: mapped.status }, true);
+        }
+    });
+}

package/dist/mcp/controlTools.js

@@ -1,13 +1,17 @@
 import path from "node:path";
 import { z } from "zod";
+import { writeAudit } from "../logging/audit.js";
+import { logger as rootLogger } from "../logging/logger.js";
 import { findProjectRoot } from "../project/findProjectRoot.js";
 import { mapRetryStageFailure, mapStartFailure, mapStoreLookupError, } from "../server/operatorResults.js";
+import { callerIdFromRequestAuth, getRequestAuth, } from "../server/requestAuthContext.js";
 import { attemptStreamLogPath } from "../runstore/workspaceLayout.js";
 import { parseAskOperatorAnswer } from "../tools/askOperator.js";
 import { readStreamLogTail } from "./tailStreamLog.js";
 import { textResult } from "./toolResults.js";
 import { projectWaitingGates } from "./waitingGates.js";
 import { readStageVerificationHistory } from "../runstore/verificationHistory.js";
+const auditLog = rootLogger.child({ component: "audit" });
 export function registerControlTools(server, deps) {
     const { manager, store, cwd } = deps;
     server.registerTool("list_waiting", {
@@ -51,13 +55,36 @@ export function registerControlTools(server, deps) {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
+            writeAudit(auditLog, {
+                caller_id: callerIdFromRequestAuth(),
+                surface: getRequestAuth()?.surface ?? "mcp",
+                action: "answer_gate",
+                target_run_id: runId,
+                outcome: "error",
+            });
             return textResult({ error: message, status: 400 }, true);
         }
         const result = await manager.deliverAnswer(runId, stageId, parsed);
         if (!result.ok) {
+            writeAudit(auditLog, {
+                caller_id: callerIdFromRequestAuth(),
+                surface: getRequestAuth()?.surface ?? "mcp",
+                action: "answer_gate",
+                target_run_id: runId,
+                outcome: "error",
+            });
             return textResult({ error: result.reason, status: result.status }, true);
         }
-        return textResult({ ok: true });
+        writeAudit(auditLog, {
+            caller_id: callerIdFromRequestAuth(),
+            surface: getRequestAuth()?.surface ?? "mcp",
+            action: "answer_gate",
+            target_run_id: runId,
+            outcome: "ok",
+        });
+        return textResult(result.verification !== undefined
+            ? { ok: true, verification: result.verification }
+            : { ok: true });
     });
     server.registerTool("decide_feedback_loop", {
         description: "Resolve a feedback-loop wait_for_human decision (extend, continue, or abandon). Same semantics as POST /api/runs/:id/stages/:stageId/feedback-decision.",
@@ -233,8 +260,23 @@ export function registerControlTools(server, deps) {
     }, async ({ runId, stageId }) => {
         const result = await manager.retryStage(runId, stageId);
         if (!result.ok) {
+            writeAudit(auditLog, {
+                caller_id: callerIdFromRequestAuth(),
+                surface: getRequestAuth()?.surface ?? "mcp",
+                action: "retry_stage",
+                target_run_id: runId,
+                outcome: "error",
+                ...(result.code !== undefined ? { error_code: result.code } : {}),
+            });
             return textResult({ ...mapRetryStageFailure(result), status: result.status }, true);
         }
+        writeAudit(auditLog, {
+            caller_id: callerIdFromRequestAuth(),
+            surface: getRequestAuth()?.surface ?? "mcp",
+            action: "retry_stage",
+            target_run_id: runId,
+            outcome: "ok",
+        });
         return textResult({
             runId: result.runId,
             stageId: result.stageId,
@@ -242,7 +284,7 @@ export function registerControlTools(server, deps) {
         });
     });
     server.registerTool("resume_stage", {
-        description: "Resume a stage that failed because it timed out, continuing the same attempt/session (same as POST .../resume). Does not start a new attempt — use retry_stage to start over.",
+        description: "Resume an interrupted stage or a stage that failed because it timed out, continuing the same attempt/session (same as POST .../resume). Does not start a new attempt — use retry_stage to start over.",
         inputSchema: z.object({
             runId: z.string(),
             stageId: z.string(),
@@ -250,8 +292,23 @@ export function registerControlTools(server, deps) {
     }, async ({ runId, stageId }) => {
         const result = await manager.resumeTimedOutStage(runId, stageId);
         if (!result.ok) {
+            writeAudit(auditLog, {
+                caller_id: callerIdFromRequestAuth(),
+                surface: getRequestAuth()?.surface ?? "mcp",
+                action: "resume_stage",
+                target_run_id: runId,
+                outcome: "error",
+                ...(result.code !== undefined ? { error_code: result.code } : {}),
+            });
             return textResult({ ...mapRetryStageFailure(result), status: result.status }, true);
         }
+        writeAudit(auditLog, {
+            caller_id: callerIdFromRequestAuth(),
+            surface: getRequestAuth()?.surface ?? "mcp",
+            action: "resume_stage",
+            target_run_id: runId,
+            outcome: "ok",
+        });
         return textResult({
             runId: result.runId,
             stageId: result.stageId,
@@ -259,7 +316,7 @@ export function registerControlTools(server, deps) {
         });
     });
     server.registerTool("abandon_stage", {
-        description: "Abandon a running stage (marks it failed/interrupted). Does not dismiss HITL — waiting stages return 409; answer them with answer_gate. There is no run-level cancel tool.",
+        description: "Abandon a running stage (marks it failed). Does not dismiss HITL — waiting stages return 409; answer them with answer_gate. Prefer cancel_run to stop an entire run.",
         inputSchema: z.object({
             runId: z.string(),
             stageId: z.string(),
@@ -268,27 +325,146 @@ export function registerControlTools(server, deps) {
         const result = await manager.abandonStage(runId, stageId);
         if (!result.ok) {
             const fail = result;
+            writeAudit(auditLog, {
+                caller_id: callerIdFromRequestAuth(),
+                surface: getRequestAuth()?.surface ?? "mcp",
+                action: "abandon_stage",
+                target_run_id: runId,
+                outcome: "error",
+            });
             return textResult({ error: fail.reason, status: fail.status }, true);
         }
+        writeAudit(auditLog, {
+            caller_id: callerIdFromRequestAuth(),
+            surface: getRequestAuth()?.surface ?? "mcp",
+            action: "abandon_stage",
+            target_run_id: runId,
+            outcome: "ok",
+        });
         return textResult({
             ok: true,
             runId: result.runId,
             stageId: result.stageId,
         });
     });
+    server.registerTool("cancel_run", {
+        description: "Cancel a non-terminal run (marks it cancelled, terminalizes pending/running/waiting stages, releases the checkout lease). Signals live stage workers via process-group kill (SIGTERM, then SIGKILL escalation) so agent grandchildren are included. Reason is required free-text and stored on the run as cancel_reason.",
+        inputSchema: z.object({
+            runId: z.string(),
+            reason: z.string().min(1),
+        }),
+    }, async ({ runId, reason }) => {
+        const result = await manager.cancelRun(runId, reason);
+        if (!result.ok) {
+            const fail = result;
+            writeAudit(auditLog, {
+                caller_id: callerIdFromRequestAuth(),
+                surface: getRequestAuth()?.surface ?? "mcp",
+                action: "cancel_run",
+                target_run_id: runId,
+                outcome: "error",
+            });
+            return textResult({ error: fail.reason, status: fail.status }, true);
+        }
+        writeAudit(auditLog, {
+            caller_id: callerIdFromRequestAuth(),
+            surface: getRequestAuth()?.surface ?? "mcp",
+            action: "cancel_run",
+            target_run_id: runId,
+            outcome: "ok",
+        });
+        return textResult({
+            ok: true,
+            runId: result.runId,
+        });
+    });
+    server.registerTool("delete_run", {
+        description: "Hard-delete a terminal run (store rows, workspace, worktree, run branch, and A2A tasks/artifacts). Active runs (created/queued/running) require force: true, which cancels first then deletes. Irreversible.",
+        inputSchema: z.object({
+            runId: z.string(),
+            force: z.boolean().optional(),
+        }),
+    }, async ({ runId, force }) => {
+        const result = await manager.deleteRun(runId, {
+            force,
+            channel: "mcp",
+        });
+        if (!result.ok) {
+            const fail = result;
+            writeAudit(auditLog, {
+                caller_id: callerIdFromRequestAuth(),
+                surface: getRequestAuth()?.surface ?? "mcp",
+                action: "delete_run",
+                target_run_id: runId,
+                outcome: "error",
+            });
+            return textResult({ error: fail.reason, status: fail.status }, true);
+        }
+        writeAudit(auditLog, {
+            caller_id: callerIdFromRequestAuth(),
+            surface: getRequestAuth()?.surface ?? "mcp",
+            action: "delete_run",
+            target_run_id: runId,
+            outcome: "ok",
+        });
+        return textResult({
+            ok: true,
+            runId: result.runId,
+        });
+    });
+    server.registerTool("gc_runs", {
+        description: "Run retention GC (SLIM then PURGE then bare-cache eviction). Default execute: false is dry-run (report candidates only). execute: true is irreversible bulk reclaim — slimmed/purged runIds and evicted bare caches are returned in the report.",
+        inputSchema: z.object({
+            execute: z.boolean().optional(),
+        }),
+    }, async ({ execute }) => {
+        const result = await manager.gcRuns({
+            execute: execute === true,
+            channel: "mcp",
+        });
+        if (!result.ok) {
+            const fail = result;
+            return textResult({ error: fail.reason, status: fail.status }, true);
+        }
+        return textResult({
+            slimmed: result.slimmed,
+            purged: result.purged,
+            bareCachesEvicted: result.bareCachesEvicted,
+        });
+    });
     server.registerTool("rerun", {
-        description: "Start a new run from a completed or failed run's pipeline/task locators. Returns { runId } for the new run.",
+        description: "Start a new run from a completed or failed run's pipeline/task locators. Optional pinned: true replays the prior resolved_sha for repository bindings. Returns { runId } for the new run.",
         inputSchema: z.object({
             runId: z.string(),
+            pinned: z.boolean().optional(),
         }),
-    }, async ({ runId }) => {
-        const result = await manager.rerun(runId);
+    }, async ({ runId, pinned }) => {
+        const callerId = callerIdFromRequestAuth();
+        const result = await manager.rerun(runId, {
+            ...(pinned !== undefined ? { pinned } : {}),
+            callerId,
+        });
         if (!result.ok) {
+            writeAudit(auditLog, {
+                caller_id: callerId,
+                surface: getRequestAuth()?.surface ?? "mcp",
+                action: "rerun",
+                target_run_id: runId,
+                outcome: "error",
+                ...(result.code !== undefined ? { error_code: result.code } : {}),
+            });
             return textResult({
                 ...mapStartFailure(result),
                 ...(result.status !== undefined ? { status: result.status } : {}),
             }, true);
         }
+        writeAudit(auditLog, {
+            caller_id: callerId,
+            surface: getRequestAuth()?.surface ?? "mcp",
+            action: "rerun",
+            target_run_id: result.runId,
+            outcome: "ok",
+        });
         return textResult({ runId: result.runId });
     });
 }

package/dist/mcp/deps.d.ts

@@ -1,3 +1,4 @@
+import type { BootProviderResult } from "../agent/bootProviderConfig.js";
 import type { ProviderAuthContext } from "../agent/providerAuth.js";
 import type { RunStore } from "../runstore/port.js";
 import type { RunChangeBus } from "../runtime/runChangeBus.js";
@@ -6,8 +7,10 @@ export type McpToolDeps = {
     manager: RunManager;
     store: RunStore;
     cwd: string;
+    agentDir?: string;
     providerAuthContext?: ProviderAuthContext;
     projectRoot?: string;
+    providerBoot?: BootProviderResult;
 };
 export type McpHttpDeps = McpToolDeps & {
     runChangeBus: RunChangeBus;

package/dist/mcp/getStartedTool.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { McpToolDeps } from "./deps.js";
+export declare function registerGetStartedTool(server: McpServer, deps: McpToolDeps): void;