@tea-agent/loop-agent 0.1.0

package/dist/executors/cursor-executor.js

@@ -0,0 +1,468 @@
+import { createHash } from "node:crypto";
+import { referencePathJoin } from "../shared/path-refs.js";
+/** Cursor SDK account default (user → team → system). Override per call when needed. */
+export const DEFAULT_CURSOR_MODEL = "default";
+export const DEFAULT_CURSOR_TIMEOUT_MS = 1_800_000;
+/** Detect stalled stream consumption before the full task deadline. */
+export const DEFAULT_CURSOR_STREAM_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+/** Avoid hanging indefinitely in wait() when the stream is already done. */
+export const WAIT_AFTER_STREAM_GRACE_MS = 15_000;
+export const MAX_CURSOR_STDOUT_BYTES = 64_000;
+export const MAX_CURSOR_STDERR_BYTES = 16_000;
+const ARTIFACT_INSTRUCTIONS = [
+    "Write clear deliverables: 修改记录.md (what changed + risk) and 验证结果.md (verification commands + pass/fail).",
+].join("\n");
+const CURSOR_INSTRUCTIONS = [
+    "You are a coding agent delegated by a parent agent (Pi).",
+    "Work in the configured workspace directory.",
+    "Help the user inspect, edit, and validate code with small focused changes.",
+    "Before changing files, understand the surrounding code and preserve unrelated user work.",
+    "Keep progress updates concise and summarize the result clearly.",
+    "Do NOT initiate conversation or ask clarifying questions — deliver the result directly.",
+].join("\n");
+export function resolveArtifactWriteDir(options) {
+    if (options.artifactDir)
+        return options.artifactDir;
+    if (options.runDir)
+        return referencePathJoin(options.runDir, "artifacts");
+    return undefined;
+}
+export function buildArtifactPathPrompt(writeDir) {
+    if (!writeDir)
+        return `After changes, write artifacts/修改记录.md and artifacts/验证结果.md with verification evidence.
+${ARTIFACT_INSTRUCTIONS}`;
+    return [
+        `After changes, write the following files:`,
+        `  - ${referencePathJoin(writeDir, "修改记录.md")}`,
+        `  - ${referencePathJoin(writeDir, "验证结果.md")}`,
+        ARTIFACT_INSTRUCTIONS,
+    ].join("\n");
+}
+export function buildCursorPrompt(userTask, artifactOptions) {
+    const artifactPrompt = buildArtifactPathPrompt(resolveArtifactWriteDir(artifactOptions ?? {}));
+    return [
+        CURSOR_INSTRUCTIONS,
+        artifactPrompt,
+        "",
+        "## User Task",
+        userTask,
+    ].join("\n");
+}
+export function truncateOutput(text, maxBytes) {
+    if (!text)
+        return { text, truncated: false };
+    if (maxBytes <= 0) {
+        return { text: "\n...[truncated]", truncated: true };
+    }
+    if (Buffer.byteLength(text, "utf-8") <= maxBytes) {
+        return { text, truncated: false };
+    }
+    let low = 0;
+    let high = text.length;
+    while (low < high) {
+        const mid = Math.ceil((low + high) / 2);
+        if (Buffer.byteLength(text.slice(0, mid), "utf-8") <= maxBytes) {
+            low = mid;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    let end = low;
+    // Avoid ending the prefix on a dangling UTF-16 high surrogate.
+    if (end > 0) {
+        const code = text.charCodeAt(end - 1);
+        if (code >= 0xd800 && code <= 0xdbff)
+            end -= 1;
+    }
+    return {
+        text: `${text.slice(0, end)}\n...[truncated]`,
+        truncated: true,
+    };
+}
+export function redactApiKey(text, apiKey) {
+    if (!apiKey)
+        return text;
+    return text.split(apiKey).join("<redacted-api-key>");
+}
+export function redactPromptForLog(prompt) {
+    const hash = createHash("sha256").update(prompt).digest("hex").slice(0, 12);
+    return `<prompt sha256=${hash} len=${prompt.length}>`;
+}
+export function buildRedactedExecutorRecord(input) {
+    const apiKey = input.apiKey ?? process.env.CURSOR_API_KEY;
+    const stdout = truncateOutput(redactApiKey(input.result.stdout, apiKey), 2_000);
+    const stderr = truncateOutput(redactApiKey(input.result.stderr, apiKey), 2_000);
+    const record = {
+        executor: input.executor,
+        model: input.model,
+        durationMs: input.durationMs,
+        failureCategory: input.failureCategory,
+        ok: input.ok,
+        status: input.status,
+        redactedCommand: redactPromptForLog(input.prompt),
+        stdout: stdout.text,
+        stderr: stderr.text,
+        artifactPath: input.result.artifactPath,
+        details: {
+            ...(input.result.details ?? {}),
+            stdoutTruncated: stdout.truncated,
+            stderrTruncated: stderr.truncated,
+        },
+    };
+    if (input.result.tokensUsed !== undefined) {
+        record.tokensUsed = input.result.tokensUsed;
+    }
+    return record;
+}
+export function buildCursorExecutorEnv(apiKey) {
+    const env = {
+        HOME: process.env.HOME,
+        PATH: process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin",
+        NODE_OPTIONS: "",
+    };
+    if (apiKey) {
+        env.CURSOR_API_KEY = apiKey;
+    }
+    else if (process.env.CURSOR_API_KEY) {
+        env.CURSOR_API_KEY = process.env.CURSOR_API_KEY;
+    }
+    return env;
+}
+export function classifyCursorFailure(input) {
+    if (input.timedOut)
+        return "timeout";
+    const combined = `${input.startupError ?? ""}\n${input.stderr ?? ""}\n${input.stdout ?? ""}`.toLowerCase();
+    if (/missing-api-key|missing api key|set cursor_api_key|cursor_api_key environment variable is not set/.test(combined)) {
+        return "missing-api-key";
+    }
+    if (/unauthorized|forbidden|invalid api key|authentication|auth failed/.test(combined)) {
+        return "auth";
+    }
+    if (/network|econnreset|etimedout|socket hang up|connection reset|dns|fetch failed/.test(combined)) {
+        return "network";
+    }
+    if (input.runStatus === "cancelled")
+        return "unknown";
+    if (input.exitCode !== undefined &&
+        input.exitCode !== null &&
+        input.exitCode !== 0) {
+        return "nonzero-exit";
+    }
+    if (input.runStatus && !["finished", "completed"].includes(input.runStatus)) {
+        return "nonzero-exit";
+    }
+    return "success";
+}
+export function mapRunStatusToExecutionStatus(runStatus, timedOut) {
+    if (timedOut)
+        return "timeout";
+    if (runStatus === "cancelled")
+        return "cancelled";
+    if (runStatus === "finished" || runStatus === "completed")
+        return "completed";
+    return "failed";
+}
+export class CursorTimeoutError extends Error {
+    timeoutKind;
+    constructor(message, timeoutKind) {
+        super(message);
+        this.name = "CursorTimeoutError";
+        this.timeoutKind = timeoutKind;
+    }
+}
+export function isCursorTimeoutError(error) {
+    return error instanceof CursorTimeoutError;
+}
+export async function withCursorTimeout(promise, timeoutMs, timeoutMessage, timeoutKind) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new CursorTimeoutError(timeoutMessage, timeoutKind)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+export function buildStreamIdleTimeoutMessage(input) {
+    const effective = `${input.timeoutMs}ms`;
+    if (input.timeoutMs < input.streamIdleTimeoutMs) {
+        return `Cursor stream produced no events within ${effective} before the task deadline (configured stream idle timeout: ${input.streamIdleTimeoutMs}ms)`;
+    }
+    return `Cursor stream produced no events within ${effective}`;
+}
+export async function bestEffortCancelRun(run) {
+    if (!run)
+        return false;
+    const canCancel = typeof run.cancel === "function" &&
+        (run.supports?.("cancel") ?? true);
+    if (!canCancel)
+        return false;
+    try {
+        await run.cancel();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function extractCursorTokenUsage(runResult) {
+    if (!runResult || typeof runResult !== "object")
+        return undefined;
+    const usage = runResult.usage;
+    if (!usage || typeof usage !== "object")
+        return undefined;
+    const raw = usage;
+    const inputTokens = typeof raw.inputTokens === "number" ? raw.inputTokens : undefined;
+    const outputTokens = typeof raw.outputTokens === "number" ? raw.outputTokens : undefined;
+    if (inputTokens === undefined && outputTokens === undefined) {
+        return undefined;
+    }
+    const totalTokens = (inputTokens ?? 0) + (outputTokens ?? 0);
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens: totalTokens > 0 ? totalTokens : undefined,
+    };
+}
+function applyTokenUsageToResult(result, usage) {
+    if (!usage)
+        return;
+    result.details = { ...(result.details ?? {}), usage };
+    if (usage.totalTokens !== undefined) {
+        result.tokensUsed = usage.totalTokens;
+    }
+}
+export async function executeCursorTask(options) {
+    const { shouldUseCursorWorker, executeCursorTaskViaWorker } = await import("./cursor-worker-client.js");
+    if (shouldUseCursorWorker(options)) {
+        return executeCursorTaskViaWorker(options);
+    }
+    const model = options.model ?? DEFAULT_CURSOR_MODEL;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_CURSOR_TIMEOUT_MS;
+    const apiKey = options.apiKey ?? process.env.CURSOR_API_KEY;
+    if (!apiKey?.trim() && !options.runHook) {
+        return {
+            ok: false,
+            status: "failed",
+            failureCategory: "missing-api-key",
+            model,
+            durationMs: 0,
+            stdout: "",
+            stderr: "CURSOR_API_KEY environment variable is not set.",
+            details: { startupError: true },
+        };
+    }
+    const prompt = buildCursorPrompt(options.task, {
+        artifactDir: options.artifactDir,
+        runDir: options.runDir,
+    });
+    const startedAt = Date.now();
+    if (options.runHook) {
+        try {
+            const hookResult = await options.runHook({
+                apiKey: apiKey ?? "",
+                cwd: options.cwd,
+                model,
+                task: prompt,
+                timeoutMs,
+            });
+            const stdoutResult = truncateOutput(hookResult.stdout ?? "", MAX_CURSOR_STDOUT_BYTES);
+            const stderrResult = truncateOutput(hookResult.stderr ?? "", MAX_CURSOR_STDERR_BYTES);
+            const failureCategory = hookResult.ok
+                ? "success"
+                : classifyCursorFailure({
+                    runStatus: hookResult.status,
+                    stderr: hookResult.stderr,
+                    stdout: hookResult.stdout,
+                });
+            return {
+                ok: hookResult.ok,
+                status: hookResult.status ?? (hookResult.ok ? "completed" : "failed"),
+                failureCategory,
+                model,
+                durationMs: Date.now() - startedAt,
+                stdout: stdoutResult.text,
+                stderr: stderrResult.text,
+                details: {
+                    ...(hookResult.details ?? {}),
+                    truncated: stdoutResult.truncated || stderrResult.truncated,
+                },
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                ok: false,
+                status: "failed",
+                failureCategory: classifyCursorFailure({
+                    startupError: message,
+                    stderr: message,
+                }),
+                model,
+                durationMs: Date.now() - startedAt,
+                stdout: "",
+                stderr: message,
+                details: { startupError: true },
+            };
+        }
+    }
+    let agent;
+    let run;
+    let disposeError;
+    let result;
+    const streamIdleTimeoutMs = options.streamIdleTimeoutMs ?? DEFAULT_CURSOR_STREAM_IDLE_TIMEOUT_MS;
+    const disposeAgent = async () => {
+        if (!agent)
+            return;
+        const toDispose = agent;
+        agent = undefined;
+        try {
+            await toDispose[Symbol.asyncDispose]();
+        }
+        catch (disposeErr) {
+            disposeError =
+                disposeErr instanceof Error ? disposeErr.message : String(disposeErr);
+        }
+    };
+    const attachDisposeError = (details = {}) => disposeError ? { ...details, disposeError } : details;
+    const buildTimeoutResult = (message, timeoutKind, outputText = "", cancelAttempted = false) => {
+        const stdoutResult = truncateOutput(outputText, MAX_CURSOR_STDOUT_BYTES);
+        return {
+            ok: false,
+            status: "timeout",
+            failureCategory: "timeout",
+            model,
+            durationMs: Date.now() - startedAt,
+            stdout: stdoutResult.text,
+            stderr: message,
+            details: {
+                timedOut: true,
+                timeoutKind,
+                cancelAttempted,
+                truncated: stdoutResult.truncated,
+            },
+        };
+    };
+    let outputText = "";
+    try {
+        const { Agent } = await import("@cursor/sdk");
+        agent = (await Agent.create({
+            apiKey: apiKey ?? "",
+            name: "pi-harness-cursor",
+            model: { id: model },
+            local: { cwd: options.cwd },
+        }));
+        run = await agent.send(prompt);
+        const iterator = run.stream()[Symbol.asyncIterator]();
+        const deadline = startedAt + timeoutMs;
+        while (true) {
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                throw new CursorTimeoutError(`Cursor execution timed out after ${timeoutMs}ms`, "total");
+            }
+            const timeoutForNext = Math.min(remaining, streamIdleTimeoutMs);
+            const timeoutKind = timeoutForNext < streamIdleTimeoutMs ? "total" : "stream-idle";
+            const next = await withCursorTimeout(iterator.next(), timeoutForNext, buildStreamIdleTimeoutMessage({
+                timeoutMs: timeoutForNext,
+                streamIdleTimeoutMs,
+            }), timeoutKind);
+            if (next.done)
+                break;
+            const event = next.value;
+            if (event.type === "assistant") {
+                for (const block of event.message?.content ?? []) {
+                    if (block.type === "text") {
+                        outputText += block.text ?? "";
+                    }
+                }
+            }
+        }
+        const waitGraceMs = Math.min(deadline - Date.now(), WAIT_AFTER_STREAM_GRACE_MS);
+        if (waitGraceMs <= 0) {
+            throw new CursorTimeoutError(`Cursor execution timed out after ${timeoutMs}ms`, "total");
+        }
+        let runResult;
+        try {
+            runResult = await withCursorTimeout(run.wait(), waitGraceMs, `Cursor run did not finalize within ${waitGraceMs}ms after stream completion`, "wait-grace");
+        }
+        catch (waitErr) {
+            if (isCursorTimeoutError(waitErr) &&
+                run.status !== "running" &&
+                run.status !== undefined) {
+                runResult = {
+                    status: run.status,
+                    durationMs: run.durationMs,
+                };
+            }
+            else {
+                throw waitErr;
+            }
+        }
+        const stdoutResult = truncateOutput(outputText, MAX_CURSOR_STDOUT_BYTES);
+        const runStatus = String(runResult?.status ?? "");
+        const status = mapRunStatusToExecutionStatus(runStatus, false);
+        const ok = status === "completed" && outputText.trim().length > 0;
+        const failureCategory = ok
+            ? "success"
+            : classifyCursorFailure({
+                runStatus,
+                stderr: "",
+                stdout: outputText,
+            });
+        const usage = extractCursorTokenUsage(runResult);
+        result = {
+            ok,
+            status,
+            failureCategory,
+            model,
+            durationMs: runResult?.durationMs ??
+                Date.now() - startedAt,
+            stdout: stdoutResult.text,
+            stderr: "",
+            details: {
+                truncated: stdoutResult.truncated,
+                runStatus: runResult?.status,
+            },
+        };
+        applyTokenUsageToResult(result, usage);
+    }
+    catch (error) {
+        if (isCursorTimeoutError(error)) {
+            const cancelAttempted = await bestEffortCancelRun(run);
+            result = buildTimeoutResult(error.message, error.timeoutKind, outputText, cancelAttempted);
+        }
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            const stderrResult = truncateOutput(redactApiKey(message, apiKey), MAX_CURSOR_STDERR_BYTES);
+            result = {
+                ok: false,
+                status: "failed",
+                failureCategory: classifyCursorFailure({
+                    startupError: message,
+                    stderr: message,
+                }),
+                model,
+                durationMs: Date.now() - startedAt,
+                stdout: "",
+                stderr: stderrResult.text,
+                details: { startupError: true, truncated: stderrResult.truncated },
+            };
+        }
+    }
+    finally {
+        if (run?.status === "running") {
+            await bestEffortCancelRun(run);
+        }
+        await disposeAgent();
+        if (result) {
+            result.details = attachDisposeError(result.details ?? {});
+        }
+    }
+    return result;
+}

package/dist/executors/cursor-run.js

@@ -0,0 +1,115 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { validateCursorArtifacts } from './cursor-artifacts.js';
+import { buildCursorPrompt, executeCursorTask, } from './cursor-executor.js';
+import { writeCursorExecutorArtifacts } from './cursor-executor-artifacts.js';
+import { appendCursorExecutionLog, buildCursorExecutionLogRecord, } from './cursor-execution-log.js';
+import { assertCursorExecutorAvailable, resolveCursorExecutorConfig, resolveCursorModelForTaskConfig, } from './config-core.js';
+import { appendWorkflowLog } from '../shared/logger.js';
+import { getTaskDir, getTaskPaths, loadTaskConfig } from '../task/runtime.js';
+export async function runCursorDelegatedTask(repoRoot, taskId, manifest, options = {}) {
+    const taskConfig = await loadTaskConfig(repoRoot, taskId);
+    if (taskConfig.executor !== 'cursor') {
+        throw new Error(`runCursorDelegatedTask requires executor=cursor, got "${taskConfig.executor ?? 'pi'}"`);
+    }
+    assertCursorExecutorAvailable(manifest);
+    const cursorConfig = resolveCursorExecutorConfig(manifest);
+    const taskDir = getTaskDir(repoRoot, taskId);
+    const userTask = await buildCursorTaskDescription(repoRoot, taskId);
+    const model = resolveCursorModelForTaskConfig(taskConfig, cursorConfig);
+    await appendWorkflowLog(taskDir, `cursor executor start model=${model}`);
+    const result = await executeCursorTask({
+        task: userTask,
+        cwd: repoRoot,
+        model,
+        timeoutMs: taskConfig.timeoutMs,
+        runHook: options.runHook,
+    });
+    const prompt = buildCursorPrompt(userTask);
+    const executionContext = {
+        channel: 'delegate',
+        cwd: repoRoot,
+        executionMode: options.executionMode ?? 'direct',
+        taskId,
+    };
+    await appendCursorExecutionLog(taskDir, buildCursorExecutionLogRecord({
+        context: executionContext,
+        model,
+        prompt,
+        result,
+    }));
+    await writeCursorExecutorArtifacts(path.join(taskDir, 'logs'), {
+        prompt,
+        model,
+        context: executionContext,
+        result,
+    });
+    const artifactIssues = await validateCursorTaskArtifacts(repoRoot, taskId);
+    if (!result.ok) {
+        await appendWorkflowLog(taskDir, `cursor executor failed category=${result.failureCategory}`);
+        return result;
+    }
+    if (artifactIssues.length > 0) {
+        await appendWorkflowLog(taskDir, `cursor artifact validation failed: ${artifactIssues.join('; ')}`);
+        return {
+            ...result,
+            ok: false,
+            status: 'failed',
+            failureCategory: 'invalid-output',
+            stderr: artifactIssues.join('\n'),
+            details: {
+                ...(result.details ?? {}),
+                artifactIssues,
+            },
+        };
+    }
+    const postRun = options.postRun ?? 'none';
+    if (postRun === 'verify') {
+        const message = 'Cursor direct run no longer runs legacy sequential verify; use DAG verification, promote-run, or closeout.';
+        await appendWorkflowLog(taskDir, `cursor post-run verify rejected: ${message}`);
+        return {
+            ...result,
+            ok: false,
+            status: 'failed',
+            failureCategory: 'nonzero-exit',
+            stderr: message,
+            details: {
+                ...(result.details ?? {}),
+                postRunFailed: true,
+            },
+        };
+    }
+    await appendWorkflowLog(taskDir, 'cursor executor completed; one-shot evidence only');
+    return result;
+}
+async function buildCursorTaskDescription(repoRoot, taskId) {
+    const paths = getTaskPaths(repoRoot, taskId);
+    const taskConfig = await loadTaskConfig(repoRoot, taskId);
+    const requirement = await readFile(path.join(paths.sourceDir, '需求.md'), 'utf-8');
+    const constraints = await readFile(path.join(paths.sourceDir, '执行约束.md'), 'utf-8');
+    return [
+        `# Task ${taskId}`,
+        '',
+        '## 需求.md',
+        requirement.trim(),
+        '',
+        '## 执行约束.md',
+        constraints.trim(),
+        '',
+        '## Path boundaries',
+        `- allowedPaths: ${(taskConfig.allowedPaths ?? []).join(', ') || '(read-only; no code writes outside .harness/tasks/)'}`,
+        `- forbiddenPaths: ${(taskConfig.forbiddenPaths ?? []).join(', ') || '(none)'}`,
+        '',
+        '## Required artifacts',
+        '- artifacts/修改记录.md must include 修改摘要 / 修改文件 / 验证 / 风险',
+        '- artifacts/验证结果.md must include commands, exit code, pass/fail',
+    ].join('\n');
+}
+async function validateCursorTaskArtifacts(repoRoot, taskId) {
+    const paths = getTaskPaths(repoRoot, taskId);
+    const modifyLogPath = path.join(paths.taskDir, 'artifacts', '修改记录.md');
+    const verifyResultPath = path.join(paths.taskDir, 'artifacts', '验证结果.md');
+    const modifyLog = await readFile(modifyLogPath, 'utf-8');
+    const verifyResult = await readFile(verifyResultPath, 'utf-8');
+    return validateCursorArtifacts(modifyLog, verifyResult);
+}

package/dist/executors/cursor-tool.js

@@ -0,0 +1,94 @@
+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;
+}