qlogicagent 2.13.5 → 2.13.7

package/dist/protocol/wire/chat-types.d.ts

@@ -1,106 +0,0 @@
-/**
- * Chat Wire Types — fundamental data types that cross the JSON-RPC boundary.
- *
- * These types appear in RPC method params/results (session/prompt, session.resume, etc.)
- * and are needed by every consumer that interacts with the agent.
- */
-import type { ToolRiskLevel } from "./web-capability.js";
-export type { ToolRiskLevel } from "./web-capability.js";
-export type ChatMessageRole = "system" | "user" | "assistant" | "tool";
-/** Thinking block from Anthropic Messages API (DeepSeek, Claude, etc.) */
-export interface ThinkingBlock {
-    thinking: string;
-    signature: string;
-}
-/** Tool call within an assistant message. */
-export interface ToolCallMessage {
-    id: string;
-    type: "function";
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-/**
- * Chat message — the fundamental unit of conversation over JSON-RPC.
- *
- * Used in `session/prompt` params (user sends messages to agent)
- * and `session.resume` result (agent returns conversation history).
- */
-export interface ChatMessage {
-    role: ChatMessageRole;
-    content: string | null;
-    /** For assistant messages with tool calls. */
-    tool_calls?: ToolCallMessage[];
-    /** For tool result messages. */
-    tool_call_id?: string;
-    /** For tool result messages — tool name. */
-    name?: string;
-    /** Anthropic thinking blocks — must be passed back to API in subsequent requests. */
-    thinkingBlocks?: ThinkingBlock[];
-    /** Image URLs for vision-capable models. */
-    imageUrls?: string[];
-    /** Image detail level: 'auto' | 'low' | 'high' | 'xhigh'. */
-    imageDetail?: "auto" | "low" | "high" | "xhigh";
-    /** Max image pixels budget (Volcengine image_pixel_limit). */
-    imagePixelLimit?: {
-        minPixels?: number;
-        maxPixels?: number;
-    };
-    /** Video URLs for video-understanding models. */
-    videoUrls?: string[];
-    /** Per-video fps for video understanding (0.2-5, default 1). */
-    videoFps?: number;
-    /** Audio format hint: 'mp3' | 'wav' | 'aac' | 'm4a'. */
-    audioFormat?: "mp3" | "wav" | "aac" | "m4a";
-    /** Audio URLs for audio-understanding models. */
-    audioUrls?: string[];
-    /** Pre-uploaded file IDs for document/media understanding. */
-    fileIds?: Array<{
-        id: string;
-        mimeType?: string;
-        size?: number;
-    }>;
-}
-export type ToolCapabilityCategory = "orchestration" | "filesystem" | "web" | "search" | "memory" | "media" | "developer" | "mcp" | "automation" | "system" | "other";
-export interface LocalizedToolText {
-    key: string;
-    fallback: string;
-    values?: Partial<Record<string, string>>;
-}
-/**
- * Tool definition — wire format as sent over JSON-RPC.
- *
- * Used in `session/prompt` params (host provides available tools)
- * and `tools.list` result (agent reports its tool inventory).
- */
-export interface ToolDefinition {
-    type: "function";
-    function: {
-        name: string;
-        description: string;
-        parameters?: Record<string, unknown>;
-    };
-    /** Tool scheduling metadata from host manifest (optional). */
-    meta?: {
-        category?: ToolCapabilityCategory;
-        displayName?: LocalizedToolText;
-        displayDescription?: LocalizedToolText;
-        serialOnly?: boolean;
-        parallelSafe?: boolean;
-        /** Unified permission risk class. */
-        riskLevel?: ToolRiskLevel;
-        /** If true, host should request user approval before execution. */
-        requiresApproval?: boolean;
-        /** Tool is read-only / safe — skip approval even in strict mode. */
-        isReadOnly?: boolean;
-        /** Tool can cause irreversible side-effects — force approval in default mode. */
-        isDangerous?: boolean;
-        /** Tool deletes data (files, records, cloud resources). */
-        isDelete?: boolean;
-        /** Tool sends data or requests to an external service. */
-        isEgress?: boolean;
-        /** Egress carries user data (true) vs. read-only external query (false). */
-        egressCarriesData?: boolean;
-    };
-}

package/dist/protocol/wire/chat-types.js

@@ -1,7 +0,0 @@
-/**
- * Chat Wire Types — fundamental data types that cross the JSON-RPC boundary.
- *
- * These types appear in RPC method params/results (session/prompt, session.resume, etc.)
- * and are needed by every consumer that interacts with the agent.
- */
-export {};

package/dist/protocol/wire/checkpoint-runtime.d.ts

@@ -1,61 +0,0 @@
-import type { MutationCheckpointContract, MutationCheckpointSnapshotEntryContract, MutationCheckpointPhase, MutationCheckpointRestoreAckContract, MutationCheckpointRestoreContract, MutationCheckpointRollbackResultContract } from "./checkpoint.js";
-type MutationCheckpointStartParams = {
-    runId: string;
-    toolCallId: string;
-    sessionId?: string;
-    toolName: string;
-    actionFingerprint?: string;
-    args?: Record<string, unknown>;
-};
-type MutationCheckpointFinishParams = {
-    runId: string;
-    toolCallId: string;
-    phase: Extract<MutationCheckpointPhase, "captured" | "failed" | "restored">;
-    error?: string;
-};
-interface PersistedMutationCheckpointEntry {
-    relativePath: string;
-    kind: MutationCheckpointSnapshotEntryContract["kind"];
-    sourcePath: string;
-    snapshotPath?: string;
-    snapshotSha256?: string;
-}
-interface PersistedMutationCheckpointRecord extends MutationCheckpointContract {
-    workspaceRoot: string;
-    snapshotDir: string;
-    entries: PersistedMutationCheckpointEntry[];
-    restoreHistory: MutationCheckpointRestoreContract[];
-}
-type MutationCheckpointRestoreOutcome = {
-    restoreAck: MutationCheckpointRestoreAckContract;
-    restored: MutationCheckpointRestoreContract;
-    rollbackResult: MutationCheckpointRollbackResultContract;
-};
-type MutationCheckpointRuntimeRecord = Pick<PersistedMutationCheckpointRecord, "checkpointId" | "sessionId" | "workingDirectory" | "pathHints" | "snapshotSha256" | "snapshotEntryCount">;
-export interface MutationCheckpointRuntimeManager {
-    getCheckpointIdForToolCall(params: {
-        runId: string;
-        toolCallId: string;
-    }): string | null;
-    noteCheckpointStart(params: MutationCheckpointStartParams): Promise<MutationCheckpointContract>;
-    noteCheckpointFinished(params: MutationCheckpointFinishParams): MutationCheckpointContract | null;
-    restoreCheckpoint(params: {
-        checkpointId: string;
-        reason?: string;
-        restoreId?: string;
-    }): Promise<{
-        record: MutationCheckpointRuntimeRecord | null;
-        outcome: MutationCheckpointRestoreOutcome;
-    } | null>;
-}
-export interface MutationCheckpointRuntimeManagerDeps {
-    writeJsonAtomic: (filePath: string, data: unknown, options: {
-        trailingNewline: boolean;
-    }) => Promise<void>;
-    resolveWorkspaceRoot: (workspaceDir?: string) => string;
-    currentWorkingDirectory?: () => string;
-    checkpointStateDir?: string;
-    now?: () => number;
-}
-export declare function createMutationCheckpointRuntimeManager(deps: MutationCheckpointRuntimeManagerDeps): MutationCheckpointRuntimeManager;
-export {};

package/dist/protocol/wire/checkpoint-runtime.js

@@ -1,499 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-export function createMutationCheckpointRuntimeManager(deps) {
-    const recordsByCheckpointId = new Map();
-    const checkpointIdByToolCall = new Map();
-    const dedupeByRun = new Map();
-    const CHECKPOINT_STATE_DIR = deps.checkpointStateDir ?? path.join(".qlogicagent", "checkpoints", "mutations");
-    const now = deps.now ?? (() => Date.now());
-    function buildToolCallKey(runId, toolCallId) {
-        return `${runId}:${toolCallId}`;
-    }
-    function ensureTrailingSeparator(value) {
-        return value.endsWith(path.sep) ? value : `${value}${path.sep}`;
-    }
-    function isPathWithinRoot(root, candidate) {
-        const normalizedRoot = ensureTrailingSeparator(path.resolve(root));
-        const normalizedCandidate = path.resolve(candidate);
-        return (normalizedCandidate === path.resolve(root) || normalizedCandidate.startsWith(normalizedRoot));
-    }
-    function normalizeRelativePath(root, candidate) {
-        const relativePath = path.relative(root, candidate);
-        if (!relativePath || relativePath === ".") {
-            return null;
-        }
-        if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
-            return null;
-        }
-        return relativePath;
-    }
-    function normalizePathHint(value) {
-        if (typeof value !== "string") {
-            return null;
-        }
-        const trimmed = value.trim();
-        if (!trimmed) {
-            return null;
-        }
-        return path.normalize(trimmed);
-    }
-    function collectPathHints(args) {
-        if (!args) {
-            return [];
-        }
-        const hints = [];
-        const seen = new Set();
-        for (const key of ["path", "filePath", "oldPath", "newPath", "target", "cwd", "dir"]) {
-            const normalized = normalizePathHint(args[key]);
-            if (!normalized || seen.has(normalized)) {
-                continue;
-            }
-            seen.add(normalized);
-            hints.push(normalized);
-        }
-        return hints;
-    }
-    function resolveWorkingDirectory(pathHints) {
-        for (const hint of pathHints) {
-            if (path.isAbsolute(hint)) {
-                return path.dirname(hint);
-            }
-        }
-        return deps.currentWorkingDirectory?.() ?? process.cwd();
-    }
-    function resolveWorkspaceRootFromArgs(args) {
-        const workspaceDir = typeof args?.workspaceDir === "string" ? args.workspaceDir : undefined;
-        return deps.resolveWorkspaceRoot(workspaceDir);
-    }
-    function resolveCandidatePath(params) {
-        return path.isAbsolute(params.hint)
-            ? path.resolve(params.hint)
-            : path.resolve(params.workingDirectory, params.hint);
-    }
-    function resolveSnapshotStateDir(workspaceRoot) {
-        return path.join(workspaceRoot, CHECKPOINT_STATE_DIR);
-    }
-    function shouldSkipCheckpointPath(params) {
-        const checkpointStateDir = resolveSnapshotStateDir(params.workspaceRoot);
-        return isPathWithinRoot(checkpointStateDir, params.candidatePath);
-    }
-    function buildSnapshotDir(workspaceRoot, checkpointId) {
-        return path.join(resolveSnapshotStateDir(workspaceRoot), checkpointId);
-    }
-    function buildRecordPath(snapshotDir) {
-        return path.join(snapshotDir, "record.json");
-    }
-    function buildSnapshotDataPath(snapshotDir) {
-        return path.join(snapshotDir, "snapshot");
-    }
-    function sha256Hex(value) {
-        return createHash("sha256").update(value).digest("hex");
-    }
-    async function hashFile(filePath) {
-        return sha256Hex(await fs.readFile(filePath));
-    }
-    async function hashDirectory(dirPath) {
-        const entries = await fs.readdir(dirPath, { withFileTypes: true });
-        entries.sort((left, right) => left.name.localeCompare(right.name));
-        const childDigests = [];
-        for (const entry of entries) {
-            const childPath = path.join(dirPath, entry.name);
-            const childDigest = entry.isDirectory()
-                ? await hashDirectory(childPath)
-                : entry.isFile()
-                    ? await hashFile(childPath)
-                    : sha256Hex(entry.name);
-            childDigests.push(`${entry.name}:${entry.isDirectory() ? "dir" : entry.isFile() ? "file" : "other"}:${childDigest}`);
-        }
-        return sha256Hex(`dir\n${childDigests.join("\n")}`);
-    }
-    async function hashSnapshotPath(entry) {
-        if (entry.kind === "missing") {
-            return undefined;
-        }
-        if (!entry.snapshotPath) {
-            throw new Error(`checkpoint entry missing snapshot path for hashing: ${entry.kind}`);
-        }
-        return entry.kind === "directory"
-            ? await hashDirectory(entry.snapshotPath)
-            : await hashFile(entry.snapshotPath);
-    }
-    async function finalizeSnapshotIntegrity(entries) {
-        const snapshotEntries = [];
-        for (const entry of entries) {
-            const snapshotSha256 = await hashSnapshotPath(entry);
-            if (snapshotSha256) {
-                entry.snapshotSha256 = snapshotSha256;
-            }
-            snapshotEntries.push({
-                relativePath: entry.relativePath,
-                kind: entry.kind,
-                ...(snapshotSha256 ? { snapshotSha256 } : {}),
-            });
-        }
-        const snapshotSha256 = sha256Hex(snapshotEntries
-            .map((entry) => `${entry.relativePath}:${entry.kind}:${entry.snapshotSha256 ?? "missing"}`)
-            .join("\n"));
-        return {
-            snapshotEntries,
-            snapshotEntryCount: snapshotEntries.length,
-            snapshotSha256,
-        };
-    }
-    async function assertSnapshotIntegrity(record) {
-        const currentEntries = [];
-        for (const entry of record.entries) {
-            const snapshotSha256 = await hashSnapshotPath(entry);
-            if (entry.kind !== "missing" && snapshotSha256 !== entry.snapshotSha256) {
-                throw new Error(`checkpoint snapshot integrity mismatch: ${entry.relativePath}`);
-            }
-            currentEntries.push({
-                relativePath: entry.relativePath,
-                kind: entry.kind,
-                ...(snapshotSha256 ? { snapshotSha256 } : {}),
-            });
-        }
-        const aggregateSha256 = sha256Hex(currentEntries
-            .map((entry) => `${entry.relativePath}:${entry.kind}:${entry.snapshotSha256 ?? "missing"}`)
-            .join("\n"));
-        if (aggregateSha256 !== record.snapshotSha256) {
-            throw new Error(`checkpoint snapshot aggregate integrity mismatch: ${record.checkpointId}`);
-        }
-    }
-    function pruneNestedPaths(paths) {
-        const sorted = [...paths].sort((left, right) => left.length - right.length);
-        const kept = [];
-        for (const candidate of sorted) {
-            if (kept.some((entry) => isPathWithinRoot(entry, candidate))) {
-                continue;
-            }
-            kept.push(candidate);
-        }
-        return kept;
-    }
-    function resolveSnapshotTargets(params) {
-        const uniqueTargets = new Set();
-        for (const hint of params.pathHints) {
-            const candidatePath = resolveCandidatePath({
-                workspaceRoot: params.workspaceRoot,
-                workingDirectory: params.workingDirectory,
-                hint,
-            });
-            if (!isPathWithinRoot(params.workspaceRoot, candidatePath)) {
-                continue;
-            }
-            if (shouldSkipCheckpointPath({ workspaceRoot: params.workspaceRoot, candidatePath })) {
-                continue;
-            }
-            const relativePath = normalizeRelativePath(params.workspaceRoot, candidatePath);
-            if (!relativePath) {
-                continue;
-            }
-            uniqueTargets.add(path.resolve(candidatePath));
-        }
-        return pruneNestedPaths([...uniqueTargets]);
-    }
-    async function persistCheckpointRecord(record) {
-        await deps.writeJsonAtomic(buildRecordPath(record.snapshotDir), record, { trailingNewline: true });
-    }
-    async function captureCheckpointEntries(params) {
-        const snapshotDataPath = buildSnapshotDataPath(params.snapshotDir);
-        const entries = [];
-        for (const target of params.targets) {
-            const relativePath = normalizeRelativePath(params.workspaceRoot, target);
-            if (!relativePath) {
-                continue;
-            }
-            const snapshotPath = path.join(snapshotDataPath, relativePath);
-            try {
-                const stat = await fs.stat(target);
-                if (stat.isDirectory()) {
-                    await fs.mkdir(path.dirname(snapshotPath), { recursive: true });
-                    await fs.cp(target, snapshotPath, { recursive: true, force: true });
-                    entries.push({
-                        relativePath,
-                        kind: "directory",
-                        sourcePath: target,
-                        snapshotPath,
-                    });
-                    continue;
-                }
-                if (stat.isFile()) {
-                    await fs.mkdir(path.dirname(snapshotPath), { recursive: true });
-                    await fs.copyFile(target, snapshotPath);
-                    entries.push({
-                        relativePath,
-                        kind: "file",
-                        sourcePath: target,
-                        snapshotPath,
-                    });
-                    continue;
-                }
-                entries.push({
-                    relativePath,
-                    kind: "missing",
-                    sourcePath: target,
-                });
-            }
-            catch {
-                entries.push({
-                    relativePath,
-                    kind: "missing",
-                    sourcePath: target,
-                });
-            }
-        }
-        return entries;
-    }
-    async function createPersistedCheckpointRecord(params) {
-        const createdAtMs = now();
-        const snapshotDir = buildSnapshotDir(params.workspaceRoot, params.checkpointId);
-        const entries = await captureCheckpointEntries({
-            workspaceRoot: params.workspaceRoot,
-            snapshotDir,
-            targets: params.targets,
-        });
-        const integrity = await finalizeSnapshotIntegrity(entries);
-        const record = {
-            checkpointId: params.checkpointId,
-            runId: params.runId,
-            ...(params.toolCallId ? { toolCallId: params.toolCallId } : {}),
-            ...(params.sessionId ? { sessionId: params.sessionId } : {}),
-            toolName: params.toolName,
-            ...(params.actionFingerprint ? { actionFingerprint: params.actionFingerprint } : {}),
-            dedupeKey: params.dedupeKey,
-            workspaceRoot: params.workspaceRoot,
-            workingDirectory: params.workingDirectory,
-            pathHints: params.pathHints,
-            snapshotDir,
-            backend: "workspace-copy",
-            phase: "pending",
-            snapshotSha256: integrity.snapshotSha256,
-            snapshotEntryCount: integrity.snapshotEntryCount,
-            snapshotEntries: integrity.snapshotEntries,
-            createdAtMs,
-            updatedAtMs: createdAtMs,
-            entries,
-            restoreHistory: [],
-        };
-        await persistCheckpointRecord(record);
-        return record;
-    }
-    async function createRecoveryCheckpoint(params) {
-        const checkpointId = `mcp-${randomUUID()}`;
-        const targets = params.sourceRecord.entries.map((entry) => path.join(params.sourceRecord.workspaceRoot, entry.relativePath));
-        const record = await createPersistedCheckpointRecord({
-            checkpointId,
-            runId: params.sourceRecord.runId,
-            sessionId: params.sourceRecord.sessionId,
-            toolName: "checkpoint.restore.guard",
-            dedupeKey: `${params.sourceRecord.dedupeKey}:restore-guard:${checkpointId}`,
-            workspaceRoot: params.sourceRecord.workspaceRoot,
-            workingDirectory: params.sourceRecord.workingDirectory,
-            pathHints: params.sourceRecord.entries.map((entry) => entry.relativePath),
-            targets,
-        });
-        const captured = {
-            ...record,
-            phase: "captured",
-            updatedAtMs: now(),
-            ...(params.reason ? { error: `pre-restore snapshot: ${params.reason}` } : {}),
-        };
-        recordsByCheckpointId.set(captured.checkpointId, captured);
-        await persistCheckpointRecord(captured);
-        return captured;
-    }
-    async function applyCheckpointEntryRestore(record) {
-        for (const entry of record.entries) {
-            const targetPath = path.join(record.workspaceRoot, entry.relativePath);
-            if (!isPathWithinRoot(record.workspaceRoot, targetPath)) {
-                throw new Error(`checkpoint target escapes workspace root: ${entry.relativePath}`);
-            }
-            await fs.rm(targetPath, { recursive: true, force: true }).catch(() => undefined);
-            if (entry.kind === "missing") {
-                continue;
-            }
-            if (!entry.snapshotPath) {
-                throw new Error(`checkpoint entry missing snapshot path: ${entry.relativePath}`);
-            }
-            if (entry.kind === "directory") {
-                await fs.mkdir(path.dirname(targetPath), { recursive: true });
-                await fs.cp(entry.snapshotPath, targetPath, { recursive: true, force: true });
-                continue;
-            }
-            await fs.mkdir(path.dirname(targetPath), { recursive: true });
-            await fs.copyFile(entry.snapshotPath, targetPath);
-        }
-    }
-    function buildDedupeKey(params) {
-        return params.actionFingerprint ?? `${params.toolName}:${params.workingDirectory}`;
-    }
-    async function noteMutationCheckpointStart(params) {
-        const toolCallKey = buildToolCallKey(params.runId, params.toolCallId);
-        const existingCheckpointId = checkpointIdByToolCall.get(toolCallKey);
-        if (existingCheckpointId) {
-            const existing = recordsByCheckpointId.get(existingCheckpointId);
-            if (existing) {
-                return existing;
-            }
-        }
-        const pathHints = collectPathHints(params.args);
-        const workingDirectory = resolveWorkingDirectory(pathHints);
-        const workspaceRoot = resolveWorkspaceRootFromArgs(params.args);
-        const dedupeKey = buildDedupeKey({
-            toolName: params.toolName,
-            actionFingerprint: params.actionFingerprint,
-            workingDirectory,
-        });
-        let runDedupe = dedupeByRun.get(params.runId);
-        if (!runDedupe) {
-            runDedupe = new Map();
-            dedupeByRun.set(params.runId, runDedupe);
-        }
-        const dedupedCheckpointId = runDedupe.get(dedupeKey);
-        if (dedupedCheckpointId) {
-            checkpointIdByToolCall.set(toolCallKey, dedupedCheckpointId);
-            const deduped = recordsByCheckpointId.get(dedupedCheckpointId);
-            if (deduped) {
-                return deduped;
-            }
-        }
-        const checkpointId = `mcp-${randomUUID()}`;
-        const targets = resolveSnapshotTargets({ workspaceRoot, workingDirectory, pathHints });
-        const record = await createPersistedCheckpointRecord({
-            checkpointId,
-            runId: params.runId,
-            toolCallId: params.toolCallId,
-            sessionId: params.sessionId,
-            toolName: params.toolName,
-            actionFingerprint: params.actionFingerprint,
-            dedupeKey,
-            workspaceRoot,
-            workingDirectory,
-            pathHints,
-            targets,
-        });
-        runDedupe.set(dedupeKey, checkpointId);
-        checkpointIdByToolCall.set(toolCallKey, checkpointId);
-        recordsByCheckpointId.set(checkpointId, record);
-        return record;
-    }
-    function noteMutationCheckpointFinished(params) {
-        const toolCallKey = buildToolCallKey(params.runId, params.toolCallId);
-        const checkpointId = checkpointIdByToolCall.get(toolCallKey);
-        if (!checkpointId) {
-            return null;
-        }
-        const existing = recordsByCheckpointId.get(checkpointId);
-        if (!existing) {
-            return null;
-        }
-        const persistedNext = {
-            ...existing,
-            phase: params.phase,
-            updatedAtMs: now(),
-            ...(params.error ? { error: params.error } : {}),
-        };
-        recordsByCheckpointId.set(checkpointId, persistedNext);
-        void persistCheckpointRecord(persistedNext);
-        return persistedNext;
-    }
-    function getMutationCheckpoint(checkpointId) {
-        return recordsByCheckpointId.get(checkpointId) ?? null;
-    }
-    function getMutationCheckpointForToolCall(params) {
-        const checkpointId = checkpointIdByToolCall.get(buildToolCallKey(params.runId, params.toolCallId));
-        if (!checkpointId) {
-            return null;
-        }
-        return recordsByCheckpointId.get(checkpointId) ?? null;
-    }
-    async function restoreMutationCheckpoint(params) {
-        const record = recordsByCheckpointId.get(params.checkpointId);
-        if (!record) {
-            return null;
-        }
-        await assertSnapshotIntegrity(record);
-        const recoveryCheckpoint = await createRecoveryCheckpoint({
-            sourceRecord: record,
-            reason: params.reason,
-        });
-        await applyCheckpointEntryRestore(record);
-        const restoredAtMs = now();
-        const restore = {
-            restoreId: params.restoreId?.trim() || `restore-${randomUUID()}`,
-            checkpointId: record.checkpointId,
-            runId: record.runId,
-            sessionId: record.sessionId,
-            restoredAtMs,
-            ...(params.reason ? { reason: params.reason } : {}),
-        };
-        const updated = {
-            ...record,
-            phase: "restored",
-            updatedAtMs: restoredAtMs,
-            restoreHistory: [...record.restoreHistory, restore],
-        };
-        const restoreAck = {
-            restoreId: restore.restoreId,
-            checkpointId: record.checkpointId,
-            runId: record.runId,
-            ...(record.sessionId ? { sessionId: record.sessionId } : {}),
-            requestedAtMs: restoredAtMs,
-            ackedAtMs: restoredAtMs,
-            accepted: true,
-            ...(params.reason ? { reason: params.reason } : {}),
-        };
-        const rollbackResult = {
-            restoreId: restore.restoreId,
-            checkpointId: record.checkpointId,
-            rollbackCheckpointId: recoveryCheckpoint.checkpointId,
-            runId: record.runId,
-            ...(record.sessionId ? { sessionId: record.sessionId } : {}),
-            completedAtMs: restoredAtMs,
-            ...(params.reason ? { reason: params.reason } : {}),
-        };
-        recordsByCheckpointId.set(record.checkpointId, updated);
-        await persistCheckpointRecord(updated);
-        return {
-            restoreAck,
-            restored: restore,
-            rollbackResult,
-        };
-    }
-    function projectRuntimeRecord(record) {
-        if (!record) {
-            return null;
-        }
-        return {
-            checkpointId: record.checkpointId,
-            sessionId: record.sessionId,
-            workingDirectory: record.workingDirectory,
-            pathHints: record.pathHints,
-            snapshotSha256: record.snapshotSha256,
-            snapshotEntryCount: record.snapshotEntryCount,
-        };
-    }
-    return {
-        getCheckpointIdForToolCall(params) {
-            return getMutationCheckpointForToolCall(params)?.checkpointId ?? null;
-        },
-        async noteCheckpointStart(params) {
-            return await noteMutationCheckpointStart(params);
-        },
-        noteCheckpointFinished(params) {
-            return noteMutationCheckpointFinished(params);
-        },
-        async restoreCheckpoint(params) {
-            const outcome = await restoreMutationCheckpoint(params);
-            if (!outcome) {
-                return null;
-            }
-            return {
-                record: projectRuntimeRecord(getMutationCheckpoint(params.checkpointId)),
-                outcome,
-            };
-        },
-    };
-}