@tea-agent/loop-agent 0.9.0 → 0.10.0-alpha.0

package/dist/executors/cursor-tool.js

@@ -1,94 +0,0 @@
-import { access } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import { executeCursorTask, truncateOutput, DEFAULT_CURSOR_MODEL, } from './cursor-executor.js';
-import { formatCursorFailureMessage, persistCursorToolExecution, } from './cursor-execution-log.js';
-import { persistCursorRunLog, computeRunDir } from '../records/one-shot-runs.js';
-export const DEFAULT_CURSOR_TOOL_MODEL = DEFAULT_CURSOR_MODEL;
-export const MAX_CURSOR_TOOL_OUTPUT_CHARS = 4_000;
-export async function validateCursorToolCwd(cwd) {
-    const resolvedCwd = resolve(cwd);
-    try {
-        await access(resolvedCwd);
-    }
-    catch {
-        return { ok: false, error: `cwd does not exist: ${resolvedCwd}` };
-    }
-    return { ok: true, resolvedCwd };
-}
-export async function runCursorTool(params, options = {}) {
-    const apiKey = options.apiKey ?? process.env.CURSOR_API_KEY;
-    if (!apiKey?.trim()) {
-        return {
-            content: [{ type: 'text', text: `Error: ${formatCursorFailureMessage('missing-api-key')}` }],
-            details: { error: 'missing-api-key', failureCategory: 'missing-api-key' },
-        };
-    }
-    const cwdCheck = await validateCursorToolCwd(params.cwd ?? process.cwd());
-    if (!cwdCheck.ok) {
-        return {
-            content: [{ type: 'text', text: `Error: ${cwdCheck.error}` }],
-            details: { error: 'invalid_cwd' },
-        };
-    }
-    const model = params.model ?? DEFAULT_CURSOR_TOOL_MODEL;
-    const runDir = options.skipRunLog ? undefined : (await computeRunDir(cwdCheck.resolvedCwd, params.task) ?? undefined);
-    const execution = await executeCursorTask({
-        task: params.task,
-        cwd: cwdCheck.resolvedCwd,
-        model,
-        apiKey,
-        runDir: runDir ?? undefined,
-        runHook: options.runHook,
-    });
-    await persistCursorToolExecution(cwdCheck.resolvedCwd, {
-        task: params.task,
-        model,
-        result: execution,
-        apiKey,
-    });
-    // Persist human-readable run log under .harness/runs/
-    if (!options.skipRunLog) {
-        await persistCursorRunLog(cwdCheck.resolvedCwd, {
-            task: params.task,
-            model,
-            channel: 'tool',
-            cwd: cwdCheck.resolvedCwd,
-            result: execution,
-            runDir,
-        });
-    }
-    const truncated = truncateOutput(execution.stdout || execution.stderr, MAX_CURSOR_TOOL_OUTPUT_CHARS);
-    const summary = truncated.text || `(No text output. Status: ${execution.status})`;
-    if (!execution.ok) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: summary || `Error: ${formatCursorFailureMessage(execution.failureCategory)}`,
-                }],
-            details: {
-                status: execution.status,
-                durationMs: execution.durationMs,
-                model,
-                truncated: truncated.truncated,
-                error: execution.failureCategory,
-                failureCategory: execution.failureCategory,
-            },
-        };
-    }
-    return {
-        content: [{ type: 'text', text: summary }],
-        details: {
-            status: execution.status,
-            durationMs: execution.durationMs,
-            model,
-            truncated: truncated.truncated,
-            failureCategory: execution.failureCategory,
-            inputTokens: readTokenField(execution.details, 'inputTokens'),
-            outputTokens: readTokenField(execution.details, 'outputTokens'),
-        },
-    };
-}
-function readTokenField(details, key) {
-    const value = details?.[key];
-    return typeof value === 'number' ? value : undefined;
-}

package/dist/executors/cursor-worker-client.js

@@ -1,223 +0,0 @@
-import { spawn } from 'node:child_process';
-import { createInterface } from 'node:readline';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { DEFAULT_CURSOR_TIMEOUT_MS, } from './cursor-executor.js';
-const WORKER_MODULE_PATH = fileURLToPath(import.meta.url);
-const WORKER_MODULE_DIR = path.dirname(WORKER_MODULE_PATH);
-const WORKER_ENTRY = resolveCursorWorkerEntryPath(WORKER_MODULE_PATH);
-let workerProcess = null;
-let workerBoot = null;
-const pending = new Map();
-let nextId = 1;
-const DEFAULT_RPC_RESPONSE_GRACE_MS = 5_000;
-const CURSOR_WORKER_STOP_SIGNAL = 'SIGTERM';
-function getRpcResponseGraceMs() {
-    const raw = process.env.CURSOR_WORKER_RPC_GRACE_MS?.trim();
-    if (raw) {
-        const parsed = Number(raw);
-        if (Number.isFinite(parsed) && parsed >= 0)
-            return parsed;
-    }
-    return DEFAULT_RPC_RESPONSE_GRACE_MS;
-}
-export function isCursorWorkerEnabled() {
-    const raw = process.env.CURSOR_USE_WORKER?.trim().toLowerCase();
-    return raw === '1' || raw === 'true' || raw === 'yes';
-}
-/** True when this process should accept worker RPC (child), not delegate to a worker. */
-export function isCursorWorkerChild() {
-    return process.env.CURSOR_WORKER_CHILD === '1';
-}
-export function shouldUseCursorWorker(options) {
-    if (options?.runHook)
-        return false;
-    if (isCursorWorkerChild())
-        return false;
-    if (options?.useWorker === true)
-        return true;
-    return isCursorWorkerEnabled();
-}
-export function resolveCursorWorkerEntryPath(modulePath) {
-    const extension = path.extname(modulePath) === '.ts' ? '.ts' : '.js';
-    return path.join(path.dirname(modulePath), `../cursor-worker-entry${extension}`);
-}
-export function buildCursorWorkerScriptArgs(entryPath) {
-    return path.extname(entryPath) === '.ts'
-        ? ['--import', 'tsx/esm', entryPath]
-        : [entryPath];
-}
-function workerScriptArgs() {
-    return buildCursorWorkerScriptArgs(WORKER_ENTRY);
-}
-export function getCursorWorkerEntryPath() {
-    return WORKER_ENTRY;
-}
-function dispatchResponse(line) {
-    let parsed;
-    try {
-        parsed = JSON.parse(line);
-    }
-    catch {
-        return;
-    }
-    const waiter = pending.get(parsed.id);
-    if (!waiter)
-        return;
-    pending.delete(parsed.id);
-    waiter.resolve(parsed);
-}
-async function ensureWorkerProcess() {
-    if (workerProcess && !workerProcess.killed && workerProcess.exitCode === null) {
-        return workerProcess;
-    }
-    if (!workerBoot) {
-        workerBoot = new Promise((resolve, reject) => {
-            const child = spawn(process.execPath, workerScriptArgs(), {
-                cwd: process.cwd(),
-                env: { ...process.env, CURSOR_WORKER_CHILD: '1' },
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            workerProcess = child;
-            const rl = createInterface({ input: child.stdout });
-            rl.on('line', dispatchResponse);
-            child.stderr?.on('data', (chunk) => {
-                const text = chunk.toString('utf-8').trim();
-                if (text)
-                    process.stderr.write(`[cursor-worker] ${text}\n`);
-            });
-            child.on('error', (err) => {
-                workerBoot = null;
-                reject(err);
-            });
-            child.on('exit', (code) => {
-                if (workerProcess !== child)
-                    return;
-                workerProcess = null;
-                workerBoot = null;
-                for (const [, waiter] of pending) {
-                    waiter.reject(new Error(`cursor worker exited with code ${code ?? 'unknown'}`));
-                }
-                pending.clear();
-            });
-            // ping to confirm ready
-            const pingId = '__boot__';
-            const bootWaiter = new Promise((res, rej) => {
-                const timeout = setTimeout(() => rej(new Error('cursor worker boot timeout')), 30_000);
-                pending.set(pingId, {
-                    resolve: (response) => {
-                        clearTimeout(timeout);
-                        if (!response.ok) {
-                            rej(new Error('cursor worker ping failed'));
-                            return;
-                        }
-                        res();
-                    },
-                    reject: (err) => {
-                        clearTimeout(timeout);
-                        rej(err);
-                    },
-                });
-            });
-            child.stdin.write(`${JSON.stringify({ id: pingId, type: 'ping' })}\n`);
-            bootWaiter.then(() => resolve()).catch(reject);
-        });
-    }
-    await workerBoot;
-    if (!workerProcess)
-        throw new Error('cursor worker failed to start');
-    return workerProcess;
-}
-export async function stopCursorWorker(signal = CURSOR_WORKER_STOP_SIGNAL) {
-    const pid = workerProcess?.pid;
-    const hadLiveWorker = Boolean(workerProcess && workerProcess.exitCode === null && !workerProcess.killed);
-    if (hadLiveWorker && workerProcess) {
-        try {
-            workerProcess.kill(signal);
-        }
-        catch {
-            /* ignore ESRCH / race with natural exit */
-        }
-    }
-    workerProcess = null;
-    workerBoot = null;
-    for (const [, waiter] of pending) {
-        waiter.reject(new Error('cursor worker stopped'));
-    }
-    pending.clear();
-    return {
-        workerPid: pid,
-        workerTerminationAttempted: hadLiveWorker,
-        workerStopSignal: hadLiveWorker ? signal : undefined,
-    };
-}
-/** Test-only: reset module singletons between cases. */
-export async function resetCursorWorkerStateForTests() {
-    await stopCursorWorker();
-    nextId = 1;
-}
-export function isCursorWorkerRunning() {
-    return Boolean(workerProcess && workerProcess.exitCode === null && !workerProcess.killed);
-}
-export async function executeCursorTaskViaWorker(options) {
-    const child = await ensureWorkerProcess();
-    const id = `req-${nextId++}`;
-    const request = {
-        id,
-        type: 'execute',
-        task: options.task,
-        cwd: options.cwd,
-        model: options.model,
-        timeoutMs: options.timeoutMs,
-        runDir: options.runDir,
-        artifactDir: options.artifactDir,
-    };
-    const taskTimeoutMs = options.timeoutMs ?? DEFAULT_CURSOR_TIMEOUT_MS;
-    const rpcGraceMs = getRpcResponseGraceMs();
-    const responsePromise = new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            pending.delete(id);
-            void stopCursorWorker().then((stopResult) => {
-                resolve({
-                    id,
-                    ok: true,
-                    result: {
-                        ok: false,
-                        status: 'timeout',
-                        failureCategory: 'timeout',
-                        model: options.model ?? 'default',
-                        durationMs: taskTimeoutMs,
-                        stdout: '',
-                        stderr: `cursor worker request timeout after ${taskTimeoutMs}ms`,
-                        details: {
-                            timedOut: true,
-                            timeoutKind: 'rpc',
-                            cancelDeferred: true,
-                            cancelAttempted: false,
-                            workerPid: stopResult.workerPid,
-                            workerTerminationAttempted: stopResult.workerTerminationAttempted,
-                            workerStopSignal: stopResult.workerStopSignal,
-                            workerRestartDeferred: true,
-                        },
-                    },
-                });
-            });
-        }, taskTimeoutMs + rpcGraceMs);
-        pending.set(id, {
-            resolve: (value) => {
-                clearTimeout(timer);
-                resolve(value);
-            },
-            reject: (err) => {
-                clearTimeout(timer);
-                reject(err);
-            },
-        });
-    });
-    child.stdin.write(`${JSON.stringify(request)}\n`);
-    const response = await responsePromise;
-    if (!response.ok) {
-        throw new Error(response.error);
-    }
-    return response.result;
-}

package/dist/executors/cursor-worker-protocol.js

@@ -1,18 +0,0 @@
-export function parseWorkerRequestLine(line) {
-    const parsed = JSON.parse(line);
-    if (!parsed || typeof parsed !== 'object' || !('id' in parsed) || !('type' in parsed)) {
-        throw new Error('invalid worker request');
-    }
-    if (parsed.type === 'ping')
-        return parsed;
-    if (parsed.type === 'execute') {
-        if (typeof parsed.task !== 'string' || typeof parsed.cwd !== 'string') {
-            throw new Error('execute request requires task and cwd');
-        }
-        return parsed;
-    }
-    throw new Error(`unknown worker request type: ${parsed.type}`);
-}
-export function serializeWorkerResponse(response) {
-    return `${JSON.stringify(response)}\n`;
-}

package/dist/executors/cursor-worker-server.js

@@ -1,54 +0,0 @@
-import { createInterface } from 'node:readline';
-import { executeCursorTask } from './cursor-executor.js';
-import { parseWorkerRequestLine, serializeWorkerResponse, } from './cursor-worker-protocol.js';
-export async function handleCursorWorkerRequest(request) {
-    if (request.type === 'ping') {
-        return {
-            id: request.id,
-            ok: true,
-            result: {
-                ok: true,
-                status: 'completed',
-                failureCategory: 'success',
-                model: 'worker',
-                durationMs: 0,
-                stdout: 'pong',
-                stderr: '',
-                details: { worker: true },
-            },
-        };
-    }
-    try {
-        const result = await executeCursorTask({
-            task: request.task,
-            cwd: request.cwd,
-            model: request.model,
-            timeoutMs: request.timeoutMs,
-            runDir: request.runDir,
-            artifactDir: request.artifactDir,
-        });
-        return { id: request.id, ok: true, result };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return { id: request.id, ok: false, error: message };
-    }
-}
-export async function runCursorWorkerOnStreams(input, output) {
-    const rl = createInterface({ input, crlfDelay: Infinity });
-    for await (const line of rl) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        let response;
-        try {
-            const request = parseWorkerRequestLine(trimmed);
-            response = await handleCursorWorkerRequest(request);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            response = { id: 'unknown', ok: false, error: message };
-        }
-        output.write(serializeWorkerResponse(response));
-    }
-}

package/dist/executors/cursor-worker.js

@@ -1,3 +0,0 @@
-export * from "./cursor-worker-client.js";
-export * from "./cursor-worker-protocol.js";
-export * from "./cursor-worker-server.js";

package/dist/executors/cursor.js

@@ -1,6 +0,0 @@
-export * from "./cursor-artifacts.js";
-export * from "./cursor-execution-log.js";
-export * from "./cursor-executor-artifacts.js";
-export * from "./cursor-executor.js";
-export * from "./cursor-run.js";
-export * from "./cursor-tool.js";

package/dist/executors/dag-cursor-executor.js

@@ -1,87 +0,0 @@
-import path from "node:path";
-import { ensureDagNodeArtifactDir } from "../infrastructure/harness/artifact-store.js";
-import { executeCursorTask } from "./cursor-executor.js";
-import { writeCursorExecutorArtifacts } from "./cursor-executor-artifacts.js";
-import { buildCursorExecutionLogRecord, persistCursorExecutionLog, } from "./cursor-execution-log.js";
-import { readGitStatusPorcelain, runPostRunWriteGuard, } from "./shell-write-guard.js";
-export async function executeDagCursorNode(input, meta) {
-    const started = Date.now();
-    let beforeStatus;
-    try {
-        beforeStatus = await readGitStatusPorcelain(input.cwd);
-    }
-    catch {
-        // Non-git cwd: skip write guard (documented limitation).
-        beforeStatus = undefined;
-    }
-    const artifactDir = await ensureDagNodeArtifactDir(meta.runDir, input.task.id);
-    const result = await executeCursorTask({
-        task: input.prompt,
-        cwd: input.cwd,
-        model: input.model,
-        useWorker: true,
-        artifactDir,
-    });
-    const executionContext = {
-        channel: "dag",
-        cwd: input.cwd,
-        dagRunId: meta.runId,
-        dagNodeId: input.task.id,
-    };
-    await persistCursorExecutionLog(meta.runDir, buildCursorExecutionLogRecord({
-        context: executionContext,
-        model: input.model,
-        prompt: input.prompt,
-        result,
-    }));
-    await writeCursorExecutorArtifacts(path.join(meta.runDir, input.task.id), {
-        prompt: input.prompt,
-        model: input.model,
-        context: executionContext,
-        result,
-    });
-    let writeGuardOk = true;
-    let writeGuardViolations = [];
-    if (beforeStatus !== undefined) {
-        try {
-            const guard = await runPostRunWriteGuard({
-                rootCwd: input.cwd,
-                beforeStatus,
-                writePolicy: input.task.writePolicy,
-                writeSet: input.task.writeSet,
-                allowedPaths: input.task.allowedPaths,
-                forbiddenPaths: input.task.forbiddenPaths,
-                concurrentSiblingWriteSets: meta.concurrentSiblingWriteSets,
-            });
-            writeGuardOk = guard.ok;
-            writeGuardViolations = guard.violations;
-        }
-        catch {
-            writeGuardOk = false;
-            writeGuardViolations = ["write guard failed: git status unavailable"];
-        }
-    }
-    const ok = result.ok && writeGuardOk;
-    const stderrParts = [result.stderr];
-    if (!writeGuardOk) {
-        stderrParts.push(`write guard failed: ${writeGuardViolations.join(", ")}`);
-        if (meta.writeGuardAttribution === "best-effort") {
-            stderrParts.push("write guard note: concurrent rank writers use best-effort per-node attribution; keep same-rank writeSet entries disjoint");
-        }
-    }
-    const executionResult = {
-        ok,
-        stdout: result.stdout,
-        stderr: stderrParts.filter(Boolean).join("\n\n"),
-        failureCategory: !result.ok
-            ? result.failureCategory
-            : !writeGuardOk
-                ? "write-guard"
-                : result.failureCategory,
-        durationMs: result.durationMs ?? Date.now() - started,
-    };
-    if (result.tokensUsed !== undefined) {
-        executionResult.tokensUsed = result.tokensUsed;
-    }
-    return executionResult;
-}

package/dist/workflows/loop/actions/cursor-fix.js

@@ -1,191 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { DEFAULT_CURSOR_MODEL, DEFAULT_CURSOR_TIMEOUT_MS, executeCursorTask, } from "../../../executors/cursor-executor.js";
-import { pathsChangedDuringRun, readGitStatusPorcelain, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "../../../executors/shell-write-guard.js";
-import { computeRunDir, persistCursorRunLog } from "../../../records/one-shot-runs.js";
-import { writeLoopCursorFixRecord } from "../../../infrastructure/harness/loop-action-store.js";
-import { loadTaskConfig } from "../../../task/runtime.js";
-import { getLoopPaths } from "../paths.js";
-import { appendLoopRound } from "../rounds.js";
-import { rewriteLoopContext } from "../context.js";
-import { readLoopRounds } from "../rounds.js";
-import { validateLoopCursorFixPolicy } from "../policy/cursor-fix-policy.js";
-import { filterLoopOwnedChangedPaths, hasDagRound, relativeRef } from "./shared.js";
-import { readLatestPiReviewRecord } from "./pi-review.js";
-function extractChangedPaths(result) {
-    const raw = result.details?.changedPaths;
-    if (!Array.isArray(raw))
-        return undefined;
-    return raw.filter((value) => typeof value === "string");
-}
-export async function buildLoopCursorFixPrompt(repoRoot, taskId) {
-    const paths = getLoopPaths(repoRoot, taskId);
-    const [objective, context] = await Promise.all([
-        readFile(paths.objectivePath, "utf-8"),
-        readFile(paths.contextPath, "utf-8"),
-    ]);
-    const config = await loadTaskConfig(repoRoot, taskId);
-    const rounds = await readLoopRounds(repoRoot, taskId);
-    const latestReview = await readLatestPiReviewRecord(repoRoot, taskId);
-    validateLoopCursorFixPolicy({
-        allowedPaths: config.allowedPaths,
-        forbiddenPaths: config.forbiddenPaths,
-        complexity: config.complexity,
-        dagFallbackReason: config.dagFallbackReason ?? "",
-        hasDagRound: hasDagRound(rounds),
-    });
-    return [
-        `Task id: ${taskId}`,
-        "Exact objective: implement the next bounded fix described by the loop context.",
-        "",
-        "Allowed paths:",
-        ...config.allowedPaths.map((entry) => `- ${entry}`),
-        "",
-        "Forbidden paths:",
-        ...(config.forbiddenPaths.length > 0
-            ? config.forbiddenPaths.map((entry) => `- ${entry}`)
-            : ["- none"]),
-        "",
-        "Hard constraints:",
-        "- Preserve unrelated files and user work.",
-        "- Do not touch forbidden paths.",
-        "- Do not mark the loop complete; shell verification or review must follow.",
-        "",
-        "Expected verification:",
-        "- Run the verification commands listed in the task constraints after the fix, or explain why they were not run.",
-        "",
-        "<latest_pi_review>",
-        latestReview
-            ? [
-                `recommendedAction: ${latestReview.structured.recommendedAction}`,
-                `rootCause: ${latestReview.structured.rootCause}`,
-                `fixScope: ${latestReview.structured.fixScope.join(", ")}`,
-                `invariant: ${latestReview.structured.invariant ?? "unknown"}`,
-            ].join("\n")
-            : "No structured Pi review record found.",
-        "</latest_pi_review>",
-        "",
-        "<objective>",
-        objective.trim(),
-        "</objective>",
-        "",
-        "<context>",
-        context.trim(),
-        "</context>",
-    ].join("\n");
-}
-async function defaultCursorFixExecutor(input) {
-    return executeCursorTask({
-        task: input.prompt,
-        cwd: input.cwd,
-        model: input.model,
-        timeoutMs: input.timeoutMs,
-        runDir: input.runDir,
-    });
-}
-export async function runLoopCursorFix(repoRoot, taskId, options = {}) {
-    const config = await loadTaskConfig(repoRoot, taskId);
-    const rounds = await readLoopRounds(repoRoot, taskId);
-    validateLoopCursorFixPolicy({
-        allowedPaths: config.allowedPaths,
-        forbiddenPaths: config.forbiddenPaths,
-        complexity: config.complexity,
-        dagFallbackReason: config.dagFallbackReason ?? "",
-        hasDagRound: hasDagRound(rounds),
-    });
-    const model = options.model ?? config.cursorModel ?? DEFAULT_CURSOR_MODEL;
-    const timeoutMs = options.timeoutMs ?? DEFAULT_CURSOR_TIMEOUT_MS;
-    const cwd = options.cwd ? path.resolve(repoRoot, options.cwd) : repoRoot;
-    const executor = options.executor ?? defaultCursorFixExecutor;
-    const round = rounds.length + 1;
-    const latestReview = await readLatestPiReviewRecord(repoRoot, taskId);
-    const prompt = await buildLoopCursorFixPrompt(repoRoot, taskId);
-    const runDir = (await computeRunDir(repoRoot, `${taskId} cursor-fix r${round}`)) ?? undefined;
-    const beforeStatus = await readGitStatusPorcelain(repoRoot).catch(() => "");
-    const result = await executor({ prompt, cwd, model, timeoutMs, runDir });
-    const explicitChangedPaths = extractChangedPaths(result);
-    let changedPaths = explicitChangedPaths
-        ? filterLoopOwnedChangedPaths(explicitChangedPaths, repoRoot, runDir)
-        : undefined;
-    const guard = explicitChangedPaths
-        ? validateShellWriteGuard({
-            changedPaths: changedPaths ?? [],
-            writePolicy: "exclusive",
-            writeSet: config.allowedPaths,
-            forbiddenPaths: config.forbiddenPaths,
-        })
-        : await (async () => {
-            const afterStatus = await readGitStatusPorcelain(repoRoot).catch(() => "");
-            changedPaths = filterLoopOwnedChangedPaths(pathsChangedDuringRun(snapshotGitStatusPorcelain(beforeStatus), snapshotGitStatusPorcelain(afterStatus)), repoRoot, runDir);
-            return validateShellWriteGuard({
-                changedPaths,
-                writePolicy: "exclusive",
-                writeSet: config.allowedPaths,
-                forbiddenPaths: config.forbiddenPaths,
-            });
-        })();
-    const finalResult = guard.ok
-        ? result
-        : {
-            ...result,
-            ok: false,
-            status: "failed",
-            failureCategory: "path-violation",
-            stderr: [
-                result.stderr,
-                `loop cursor-fix path violations: ${guard.violations.join(", ")}`,
-            ]
-                .filter(Boolean)
-                .join("\n"),
-        };
-    const persisted = await persistCursorRunLog(repoRoot, {
-        task: prompt,
-        model,
-        channel: "tool",
-        cwd,
-        result: finalResult,
-        taskId,
-        runDir,
-    });
-    const runRef = persisted?.logPath
-        ? relativeRef(repoRoot, persisted.logPath)
-        : "";
-    const paths = getLoopPaths(repoRoot, taskId);
-    const record = {
-        schemaVersion: 1,
-        taskId,
-        round,
-        action: "cursor-fix",
-        ok: finalResult.ok,
-        model,
-        runRef,
-        allowedPaths: config.allowedPaths,
-        forbiddenPaths: config.forbiddenPaths,
-        changedPaths: changedPaths ?? [],
-        writeGuardViolations: guard.violations,
-        fixScope: latestReview?.structured.fixScope ?? [],
-        rootCause: latestReview?.structured.rootCause ?? "",
-        invariant: latestReview?.structured.invariant ?? "",
-        expectedNextVerification: "loop shell-verify or required task verification commands",
-        recordedAt: new Date().toISOString(),
-    };
-    const recordPath = path.join(paths.reviewDir, `round-${round}-cursor-fix.json`);
-    await writeLoopCursorFixRecord(repoRoot, taskId, round, record);
-    await appendLoopRound(repoRoot, taskId, {
-        action: "cursor-fix",
-        refs: [runRef, relativeRef(repoRoot, recordPath)].filter(Boolean),
-        result: finalResult.ok ? "cursor fix completed" : "cursor fix failed",
-        verification: finalResult.ok
-            ? "cursor-fix completed; shell verification still required"
-            : `cursor-fix failed: ${finalResult.failureCategory}`,
-        lesson: finalResult.ok
-            ? "cursor-fix changed only allowed paths; completion remains gated by verification"
-            : finalResult.stderr || finalResult.stdout || "cursor-fix failed",
-        next: "run shell verification for the cursor fix",
-        decision: "continue",
-        failureCategory: finalResult.ok ? undefined : finalResult.failureCategory,
-        completedCriteria: finalResult.ok ? ["cursor bounded fix action executed"] : [],
-    });
-    await rewriteLoopContext(repoRoot, taskId);
-    return record;
-}