@tea-agent/loop-agent 0.10.0 → 0.11.0

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

@@ -1,134 +0,0 @@
-import path from "node:path";
-import { writeTextArtifactFile } from "../infrastructure/harness/artifact-store.js";
-import { redactPromptForLog, truncateOutput, } from "./cursor-executor.js";
-import { formatCursorFailureMessage, } from "./cursor-execution-log.js";
-const SUMMARY_STDOUT_MAX = 4_000;
-const SUMMARY_STDERR_MAX = 2_000;
-export function buildPromptRedactedMarkdown(prompt) {
-    const redacted = redactPromptForLog(prompt);
-    return [
-        "# Cursor prompt (redacted)",
-        "",
-        `- ${redacted}`,
-        "",
-        "Full prompt text is not stored. See `logs/executor.jsonl` for the same hash reference.",
-        "",
-    ].join("\n");
-}
-export function buildCursorRecoverySteps(input) {
-    const taskId = input.taskId ?? "<task-id>";
-    const session = input.sessionName ?? `task-${taskId}`;
-    const lines = ["## Recovery steps", ""];
-    if (input.failureCategory) {
-        lines.push(`- **Failure**: ${formatCursorFailureMessage(input.failureCategory)} (\`${input.failureCategory}\`)`);
-        lines.push("");
-    }
-    if (input.channel === "delegate") {
-        lines.push("### Retry in-process (direct SDK)");
-        lines.push("```bash");
-        lines.push("cd .");
-        lines.push(`npm run dev -- delegate ${taskId} --executor cursor --auto-run`);
-        lines.push("```");
-        if (input.worktreePath) {
-            lines.push("");
-            lines.push(`- Worktree: \`${input.worktreePath}\``);
-        }
-        lines.push("");
-        lines.push("### Promote evidence");
-        lines.push("```bash");
-        lines.push(`npm run dev -- promote-run ${taskId} --run-id <run-id>`);
-        lines.push(`npm run dev -- closeout task ${taskId}`);
-        lines.push("```");
-        lines.push("");
-        lines.push("### After closeout");
-        lines.push("```bash");
-        lines.push(`npm run dev -- harvest ${taskId}`);
-        lines.push("```");
-    }
-    else if (input.channel === "dag") {
-        lines.push("### Re-run DAG node");
-        lines.push("- Fix upstream outputs or prompts in the DAG JSON, then re-run `run-dag` with a new `--run-id`.");
-        lines.push("- Inspect `executor.jsonl` and per-node `result.summary.md` under `.harness/dag-runs/completed/<run-id>/` (or `active/<run-id>/` while the run is still in progress).");
-    }
-    else {
-        lines.push("### Pi cursor tool");
-        lines.push("- Retry with a clearer `task` and correct `cwd`.");
-        lines.push("- Check `.harness/cache/cursor-executions.jsonl` when cwd contains `.harness`.");
-    }
-    if (input.failureCategory === "missing-api-key") {
-        lines.push("");
-        lines.push("- Export `CURSOR_API_KEY` before retrying.");
-    }
-    return lines;
-}
-function formatTokenUsage(result) {
-    const rows = [];
-    if (result.tokensUsed !== undefined) {
-        rows.push(`| tokensUsed | ${result.tokensUsed} |`);
-    }
-    const usage = result.details?.usage;
-    if (typeof usage?.inputTokens === "number") {
-        rows.push(`| inputTokens | ${usage.inputTokens} |`);
-    }
-    if (typeof usage?.outputTokens === "number") {
-        rows.push(`| outputTokens | ${usage.outputTokens} |`);
-    }
-    if (typeof usage?.totalTokens === "number" &&
-        result.tokensUsed === undefined) {
-        rows.push(`| totalTokens | ${usage.totalTokens} |`);
-    }
-    return rows;
-}
-export function buildResultSummaryMarkdown(input) {
-    const stdout = truncateOutput(input.result.stdout, SUMMARY_STDOUT_MAX);
-    const stderr = truncateOutput(input.result.stderr || "", SUMMARY_STDERR_MAX);
-    const recovery = input.recoveryLines ??
-        buildCursorRecoverySteps({
-            channel: input.context.channel,
-            taskId: input.context.taskId,
-            sessionName: input.context.taskId
-                ? `task-${input.context.taskId}`
-                : undefined,
-            worktreePath: input.context.cwd,
-            failureCategory: input.result.ok
-                ? undefined
-                : input.result.failureCategory,
-        });
-    const meta = [
-        "# Cursor execution summary",
-        "",
-        "## Run metadata",
-        "",
-        `| Field | Value |`,
-        `|-------|-------|`,
-        `| channel | ${input.context.channel} |`,
-    ];
-    if (input.context.executionMode)
-        meta.push(`| executionMode | ${input.context.executionMode} |`);
-    if (input.context.taskId)
-        meta.push(`| taskId | ${input.context.taskId} |`);
-    if (input.context.dagRunId)
-        meta.push(`| dagRunId | ${input.context.dagRunId} |`);
-    if (input.context.dagNodeId)
-        meta.push(`| dagNodeId | ${input.context.dagNodeId} |`);
-    meta.push(`| cwd | ${input.context.cwd} |`, `| model | ${input.model} |`, `| ok | ${input.result.ok} |`, `| status | ${input.result.status} |`, `| failureCategory | ${input.result.failureCategory} |`, `| durationMs | ${input.result.durationMs} |`, ...formatTokenUsage(input.result), "", "## Prompt reference", "", `- ${redactPromptForLog(input.prompt)}`, "", "## Output", "");
-    if (stdout.text.trim()) {
-        meta.push("### stdout", "", "```text", stdout.text, "```", "");
-        if (stdout.truncated)
-            meta.push("_(stdout truncated)_", "");
-    }
-    if (stderr.text.trim()) {
-        meta.push("### stderr", "", "```text", stderr.text, "```", "");
-        if (stderr.truncated)
-            meta.push("_(stderr truncated)_", "");
-    }
-    meta.push(...recovery, "");
-    return meta.join("\n");
-}
-export async function writeCursorExecutorArtifacts(artifactsDir, input) {
-    const promptPath = path.join(artifactsDir, "prompt.redacted.md");
-    const summaryPath = path.join(artifactsDir, "result.summary.md");
-    await writeTextArtifactFile(promptPath, buildPromptRedactedMarkdown(input.prompt));
-    await writeTextArtifactFile(summaryPath, buildResultSummaryMarkdown(input));
-    return { promptPath, summaryPath };
-}

package/dist/executors/cursor-run.js

@@ -1,115 +0,0 @@
-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

@@ -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";