@tea-agent/loop-agent 0.10.0 → 0.12.0

package/dist/cli/update/state.js

@@ -0,0 +1,68 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+export function updateStatePath(homeDir) {
+    return path.join(homeDir, ".loop-agent", "update-state.json");
+}
+export function updateLockPath(homeDir) {
+    return path.join(homeDir, ".loop-agent", "update.lock");
+}
+export async function readUpdateState(statePath) {
+    try {
+        const raw = await readFile(statePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.schemaVersion !== 1)
+            return emptyState();
+        return {
+            schemaVersion: 1,
+            lastCheckedAt: stringOrUndefined(parsed.lastCheckedAt),
+            latestVersion: stringOrUndefined(parsed.latestVersion),
+            dismissedVersion: stringOrUndefined(parsed.dismissedVersion),
+            retryAfter: stringOrUndefined(parsed.retryAfter),
+        };
+    }
+    catch {
+        return emptyState();
+    }
+}
+export async function writeUpdateState(statePath, state) {
+    await mkdir(path.dirname(statePath), { recursive: true });
+    const tempPath = path.join(path.dirname(statePath), `.${path.basename(statePath)}.${process.pid}.${Date.now()}.tmp`);
+    await writeFile(tempPath, `${JSON.stringify({ ...state, schemaVersion: 1 }, null, 2)}\n`, "utf-8");
+    await rename(tempPath, statePath);
+}
+export async function acquireUpdateLock(lockPath, options = {}) {
+    const now = options.now ?? (() => new Date());
+    const staleMs = options.staleMs ?? 10 * 60 * 1000;
+    await mkdir(path.dirname(lockPath), { recursive: true });
+    try {
+        await mkdir(lockPath);
+        await writeFile(path.join(lockPath, "owner.json"), JSON.stringify({ pid: process.pid, at: now().toISOString() }), "utf-8");
+        return async () => {
+            await rm(lockPath, { recursive: true, force: true });
+        };
+    }
+    catch {
+        try {
+            const ownerRaw = await readFile(path.join(lockPath, "owner.json"), "utf-8");
+            const owner = JSON.parse(ownerRaw);
+            if (owner.at && now().getTime() - Date.parse(owner.at) > staleMs) {
+                await rm(lockPath, { recursive: true, force: true });
+                await mkdir(lockPath);
+                await writeFile(path.join(lockPath, "owner.json"), JSON.stringify({ pid: process.pid, at: now().toISOString() }), "utf-8");
+                return async () => {
+                    await rm(lockPath, { recursive: true, force: true });
+                };
+            }
+        }
+        catch {
+            return undefined;
+        }
+        return undefined;
+    }
+}
+function emptyState() {
+    return { schemaVersion: 1 };
+}
+function stringOrUndefined(value) {
+    return typeof value === "string" ? value : undefined;
+}

package/dist/cli.js

@@ -1,12 +1,45 @@
 #!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { buildLoopAgentProgram } from "./cli/program.js";
+import { createNpmUpdateClient } from "./cli/update/npm-client.js";
+import { runSelfUpdateNotifier } from "./cli/update/notifier.js";
 async function main() {
     const program = buildLoopAgentProgram({
         defaultRepoRoot: process.cwd(),
     });
     await program.parseAsync(process.argv);
+    if (process.exitCode && process.exitCode !== 0)
+        return;
+    const packageRoot = resolvePackageRoot();
+    const currentVersion = readPackageVersion(packageRoot);
+    await runSelfUpdateNotifier({
+        argv: process.argv.slice(2),
+        currentVersion,
+        env: process.env,
+        homeDir: os.homedir(),
+        stdinIsTTY: process.stdin.isTTY === true,
+        stdoutIsTTY: process.stdout.isTTY === true,
+        stderrIsTTY: process.stderr.isTTY === true,
+        client: createNpmUpdateClient({
+            currentVersion,
+            packageRoot,
+            env: process.env,
+        }),
+    });
 }
 main().catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
 });
+function resolvePackageRoot() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+}
+function readPackageVersion(packageRoot) {
+    const pkg = JSON.parse(readFileSync(path.join(packageRoot, "package.json"), "utf-8"));
+    if (!pkg.version)
+        throw new Error("loop-agent package.json is missing version");
+    return pkg.version;
+}

package/dist/commands/cursor-prompt.js

@@ -1,5 +1,5 @@
 /**
- * Cursor Prompt — one-shot CLI for Cursor SDK tasks.
+ * Cursor Prompt — one-shot CLI for Cursor SDK tasks (sidecar).
  *
  * Usage:
  *   cursor-prompt "Fix lint errors"                    # one-shot
@@ -9,7 +9,7 @@
  *   cursor-prompt --model gpt-5.5 "Deep analysis"       # pick model
  *   cursor-prompt --cwd /path --timeout 120000 "task"   # cwd + timeout
  */
-import { executeCursorTask, DEFAULT_CURSOR_MODEL, DEFAULT_CURSOR_TIMEOUT_MS, buildCursorPrompt, classifyCursorFailure, mapRunStatusToExecutionStatus, } from "../executors/cursor-executor.js";
+import { executeCursorTask, executeCursorPromptStream, DEFAULT_CURSOR_MODEL, DEFAULT_CURSOR_TIMEOUT_MS, } from "../sidecars/cursor-prompt/index.js";
 import { createOneShotPromptParseAccum, formatUnknownFlagError, parseOneShotCommonFlag, printOneShotHelpAndExit, resolveOneShotCwd, resolveOneShotTask, } from "../shared/one-shot-prompt-args.js";
 import { persistCursorRunLog, computeRunDir } from "../records/one-shot-runs.js";
 const CURSOR_PROMPT_USAGE = [
@@ -111,12 +111,17 @@ async function runCursorPromptBatch(task, cwd, model, timeoutMs) {
     const startedAt = Date.now();
     process.stderr.write(`[cursor-prompt] running "${task.slice(0, 80)}${task.length > 80 ? "..." : ""}" (model=${model}, cwd=${cwd})\n`);
     const runDir = (await computeRunDir(cwd, task)) ?? undefined;
-    const result = await executeCursorTask({ task, cwd, model, timeoutMs, runDir });
-    // Persist human-readable run log under .harness/runs/
+    const result = await executeCursorTask({
+        task,
+        cwd,
+        model,
+        timeoutMs,
+        runDir,
+    });
     await persistCursorRunLog(cwd, {
         task,
         model,
-        channel: 'tool',
+        channel: "tool",
         cwd,
         result,
         runDir,
@@ -135,87 +140,42 @@ async function runCursorPromptBatch(task, cwd, model, timeoutMs) {
     }
 }
 async function runCursorPromptStreaming(task, cwd, model, timeoutMs) {
-    const apiKey = process.env.CURSOR_API_KEY;
-    if (!apiKey?.trim()) {
-        process.stderr.write("[cursor-prompt] CURSOR_API_KEY not set\n");
-        process.exit(1);
-    }
-    const runDir = (await computeRunDir(cwd, task)) ?? undefined;
-    const prompt = buildCursorPrompt(task, { runDir });
     const startedAt = Date.now();
-    process.stderr.write(`[cursor-prompt] streaming (model=${model}, cwd=${cwd})\n`);
-    let timeoutHandle;
-    try {
-        const { Agent } = await import("@cursor/sdk");
-        const agent = await Agent.create({
-            apiKey,
-            name: "pi-cursor-prompt",
-            model: { id: model },
-            local: { cwd },
-        });
-        const runPromise = (async () => {
-            const run = await agent.send(prompt);
-            for await (const event of run.stream()) {
-                if (event.type === "assistant") {
-                    for (const block of event.message.content) {
-                        if (block.type === "text") {
-                            process.stdout.write(block.text);
-                        }
-                    }
-                }
-            }
-            const result = await run.wait();
-            await agent[Symbol.asyncDispose]();
-            return result;
-        })();
-        const timeoutRace = new Promise((resolve) => {
-            timeoutHandle = setTimeout(() => {
-                resolve("timeout");
-            }, timeoutMs);
-        });
-        const raced = await Promise.race([
-            runPromise.then((v) => ({ kind: "done", value: v })),
-            timeoutRace.then(() => ({ kind: "timeout" })),
-        ]);
-        if (timeoutHandle)
-            clearTimeout(timeoutHandle);
-        if (raced.kind === "timeout") {
-            process.stderr.write(`\n[cursor-prompt] TIMEOUT after ${timeoutMs}ms\n`);
-            process.exit(1);
-        }
-        const elapsed = ((Date.now() - startedAt) / 1000).toFixed(1);
-        const sdkResult = raced.value;
-        process.stderr.write(`\n[cursor-prompt] done in ${elapsed}s, status=${sdkResult.status}\n`);
-        const runStatus = sdkResult.status;
-        const status = mapRunStatusToExecutionStatus(runStatus, false);
-        const ok = status === 'completed';
-        // Persist human-readable run log under .harness/runs/
-        await persistCursorRunLog(cwd, {
-            task,
-            model,
-            channel: 'tool',
-            cwd,
-            result: {
-                ok,
-                status,
-                failureCategory: ok ? 'success' : classifyCursorFailure({ runStatus, stderr: '', stdout: '' }),
-                model,
-                durationMs: sdkResult.durationMs ?? Date.now() - startedAt,
-                stdout: '', // Streaming output went directly to stdout
-                stderr: '',
-            },
-            runDir,
-        });
+    process.stderr.write(`[cursor-prompt] streaming (model=${model}, cwd=${cwd})
+`);
+    const runDir = (await computeRunDir(cwd, task)) ?? undefined;
+    const result = await executeCursorPromptStream({
+        task,
+        cwd,
+        model,
+        timeoutMs,
+        runDir,
+        callbacks: {
+            onAssistantText: (text) => process.stdout.write(text),
+        },
+    });
+    await persistCursorRunLog(cwd, {
+        task,
+        model,
+        channel: "tool",
+        cwd,
+        result,
+        runDir,
+    });
+    const elapsed = ((Date.now() - startedAt) / 1000).toFixed(1);
+    if (result.ok) {
+        process.stderr.write(`
+[cursor-prompt] done in ${elapsed}s, status=${result.status}
+`);
     }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        process.stderr.write(`\n[cursor-prompt] ERROR: ${message}\n`);
+    else {
+        const stderr = result.stderr || "(no output)";
+        process.stderr.write(`
+[cursor-prompt] FAILED in ${elapsed}s (${result.failureCategory}):
+${stderr}
+`);
         process.exit(1);
     }
-    finally {
-        if (timeoutHandle)
-            clearTimeout(timeoutHandle);
-    }
 }
 export function printCursorPromptUsage() {
     console.log(CURSOR_PROMPT_USAGE);

package/dist/commands/dag-approve.js

@@ -1,5 +1,7 @@
 import path from "node:path";
+import { access } from "node:fs/promises";
 import { assertDagRunTransferTargetAvailable, getDagRunDir, readHumanEscalation, requirePausedDagRun, transferDagRunDir, writeDagRunState, writeHumanApprovalArtifact, } from "../workflows/dag/lifecycle.js";
+import { assertSkillSnapshotCoversSpec, readSkillSnapshot, SKILL_SNAPSHOT_REL_PATH, } from "../workflows/dag/skill-snapshot.js";
 export function parseDagApproveArgs(args) {
     if (args.length === 0) {
         throw new Error("usage: dag approve --run-id <id> --option <A|B|...> [--notes \"...\"]");
@@ -59,6 +61,34 @@ export async function runDagApprove(repoRoot, rawArgs) {
     if (!optionIds.has(parsed.option)) {
         throw new Error(`option ${parsed.option} is not valid; expected one of: ${[...optionIds].join(", ")}`);
     }
+    // Fail closed before any approval/state/lifecycle mutation. Snapshot-backed
+    // runs must validate fully. A true pre-snapshot legacy run (no ref and no
+    // artifact) may still be approved so resume can perform the established
+    // legacy-resume-backfill. An artifact without a ref is an orphan and cannot
+    // be trusted or silently adopted.
+    if (state.skillSnapshotRef) {
+        try {
+            const snapshot = await readSkillSnapshot(runDir, state.skillSnapshotRef, {
+                expectedRunId: state.runId,
+            });
+            assertSkillSnapshotCoversSpec(snapshot, spec, state);
+        }
+        catch (error) {
+            throw new Error(`skill snapshot pre-approval validation failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        }
+    }
+    else {
+        const snapshotPath = path.join(runDir, ...SKILL_SNAPSHOT_REL_PATH.split("/"));
+        try {
+            await access(snapshotPath);
+            throw new Error("skill snapshot artifact exists without a state ref; refusing approval");
+        }
+        catch (error) {
+            if (!isNotFound(error)) {
+                throw new Error(`skill snapshot pre-approval validation failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+            }
+        }
+    }
     const activeRunDir = getDagRunDir(repoRoot, "active", state.runId);
     await assertDagRunTransferTargetAvailable(activeRunDir);
     const approvedAt = new Date().toISOString();
@@ -100,3 +130,9 @@ export async function runDagApprove(repoRoot, rawArgs) {
         nextRecommendedAction: "Run is approved; use dag resume to continue.",
     }, null, 2));
 }
+function isNotFound(error) {
+    return Boolean(error
+        && typeof error === "object"
+        && "code" in error
+        && error.code === "ENOENT");
+}

package/dist/commands/delegate.js

@@ -1,12 +1,11 @@
-import os from 'node:os';
-import path from 'node:path';
-import { delegateTask } from '../task/delegate.js';
-import { runCursorDelegatedTask } from '../executors/cursor-run.js';
-import { buildCursorRecoverySteps } from '../executors/cursor-executor-artifacts.js';
-import { formatCursorFailureMessage } from '../executors/cursor-execution-log.js';
-import { loadHarnessManifest } from '../governance/harness.js';
-const DELEGATE_USAGE = 'usage: delegate <taskId> [--executor pi|cursor] [--base <branch>] [--branch <name>] '
-    + '[--no-symlink] [--auto-run] [--no-auto-run]';
+import os from "node:os";
+import path from "node:path";
+import { delegateTask } from "../task/delegate.js";
+import { loadHarnessManifest } from "../governance/harness.js";
+import { generateTaskDagUseCase } from "../application/dag/generate-task-dag.js";
+import { validateDagUseCase } from "../application/dag/validate-dag.js";
+import { runDagUseCase } from "../application/dag/run-dag.js";
+const DELEGATE_USAGE = "usage: delegate <taskId> [--base <branch>] [--branch <name>] [--no-symlink] [--auto-run]";
 export function parseDelegateArgs(args) {
     if (args.length === 0) {
         throw new Error(DELEGATE_USAGE);
@@ -15,44 +14,37 @@ export function parseDelegateArgs(args) {
     let base;
     let branch;
     let symlinkNodeModules = true;
-    let autoRun = true;
-    let executor;
+    let autoRun = false;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
-        if (arg === '--base') {
+        if (arg === "--base") {
             base = args[i + 1];
             if (!base)
-                throw new Error('--base requires a value');
+                throw new Error("--base requires a value");
             i += 1;
         }
-        else if (arg === '--branch') {
+        else if (arg === "--branch") {
             branch = args[i + 1];
             if (!branch)
-                throw new Error('--branch requires a value');
+                throw new Error("--branch requires a value");
             i += 1;
         }
-        else if (arg === '--executor') {
-            const value = args[i + 1];
-            if (value !== 'pi' && value !== 'cursor') {
-                throw new Error('--executor must be "pi" or "cursor"');
-            }
-            executor = value;
-            i += 1;
+        else if (arg === "--executor") {
+            throw new Error("--executor was removed; delegate is worktree isolation only; use --auto-run for Pi DAG execution");
         }
-        else if (arg === '--no-symlink') {
+        else if (arg === "--no-symlink") {
             symlinkNodeModules = false;
         }
-        else if (arg === '--auto-run') {
+        else if (arg === "--auto-run") {
             autoRun = true;
         }
-        else if (arg === '--no-auto-run') {
-            autoRun = false;
+        else if (arg === "--no-auto-run") {
+            throw new Error("--no-auto-run was removed; delegate defaults to worktree-only (omit --auto-run)");
         }
-        else if (arg === '--supervised') {
-            throw new Error('--supervised was removed with the tmux white-box subagent lifecycle. '
-                + 'Use `delegate <taskId> --executor cursor --auto-run` for in-process Cursor SDK.');
+        else if (arg === "--supervised") {
+            throw new Error("--supervised was removed with the tmux white-box subagent lifecycle. Use `delegate <taskId> --auto-run` for Pi DAG execution in the worktree.");
         }
-        else if (!arg.startsWith('--')) {
+        else if (!arg.startsWith("--")) {
             if (taskId)
                 throw new Error(`unexpected positional argument: ${arg}`);
             taskId = arg;
@@ -62,71 +54,77 @@ export function parseDelegateArgs(args) {
         }
     }
     if (!taskId) {
-        throw new Error('delegate requires <taskId> as the first positional argument');
+        throw new Error("delegate requires <taskId> as the first positional argument");
     }
-    return { taskId, base, branch, symlinkNodeModules, autoRun, executor };
+    return { taskId, base, branch, symlinkNodeModules, autoRun };
 }
-export function printCursorFailureRecovery(taskId, result, cursorResult) {
-    console.error(`[delegate] cursor direct run failed: ${formatCursorFailureMessage(cursorResult.failureCategory)}`);
-    console.error(`  logs: .harness/tasks/${taskId}/logs/result.summary.md`);
-    for (const line of buildCursorRecoverySteps({
-        channel: 'delegate',
-        taskId,
-        sessionName: result.sessionName,
-        worktreePath: result.worktreePath,
-        failureCategory: cursorResult.failureCategory,
-    })) {
-        console.error(line);
-    }
-}
-export function printCursorDelegateNextSteps(taskId, result) {
+export function printDelegateNextSteps(taskId, result) {
+    const dagPath = path.join(os.tmpdir(), `${taskId}-dag.json`);
     const lines = [
-        `[delegate] cursor worktree ready (SDK direct).`,
+        `[delegate] worktree ready (Pi-only).`,
         `  worktree: ${result.worktreePath}`,
-        `  Next — run Cursor SDK in-process:`,
-        `    npm run dev -- delegate ${taskId} --executor cursor --auto-run`,
+        `  Next — generate, validate, and run DAG in the worktree:`,
+        `    loop-agent dag run-task ${taskId} --profile auto --strict-models --output ${JSON.stringify(dagPath)}`,
+        `    loop-agent dag validate --dag ${JSON.stringify(dagPath)} --strict-models --strict-governance`,
+        `    loop-agent run-dag --dag ${JSON.stringify(dagPath)} --cwd ${JSON.stringify(result.worktreePath)}`,
+        `  Or: loop-agent delegate ${taskId} --auto-run`,
         `  After work completes:`,
-        `    npm run dev -- harvest ${taskId}`,
+        `    loop-agent harvest ${taskId}`,
     ];
     for (const line of lines) {
         console.error(line);
     }
 }
-export function buildPiAutoRunMigrationMessage(taskId, worktreePath) {
-    const dagPath = path.join(os.tmpdir(), `${taskId}-dag.json`);
-    const cwd = worktreePath ?? '<repo-root>';
-    return [
-        'delegate --executor pi --auto-run has been removed.',
-        'Use the DAG path instead:',
-        `  1. npm run dev -- dag run-task ${taskId} --profile auto --strict-models --output ${JSON.stringify(dagPath)}`,
-        `  2. npm run dev -- dag validate --dag ${JSON.stringify(dagPath)} --strict-models --strict-governance`,
-        `  3. npm run dev -- run-dag --dag ${JSON.stringify(dagPath)} --cwd ${JSON.stringify(cwd)}`,
-    ].join('\n');
-}
-export async function runDelegate(repoRoot, rawArgs) {
+const DEFAULT_RUN_DELEGATE_DEPENDENCIES = {
+    generateTaskDag: generateTaskDagUseCase,
+    validateDag: validateDagUseCase,
+    runDag: runDagUseCase,
+};
+export async function runDelegate(repoRoot, rawArgs, dependencies = DEFAULT_RUN_DELEGATE_DEPENDENCIES) {
     const parsed = parseDelegateArgs(rawArgs);
     const manifest = await loadHarnessManifest(repoRoot);
     const result = await delegateTask(repoRoot, manifest, parsed.taskId, {
         base: parsed.base,
         branch: parsed.branch,
         symlinkNodeModules: parsed.symlinkNodeModules,
-        executor: parsed.executor,
     });
     if (parsed.autoRun) {
-        if (result.executor === 'cursor') {
-            const cursorResult = await runCursorDelegatedTask(result.worktreePath, parsed.taskId, manifest, {
-                executionMode: 'direct',
-            });
-            if (!cursorResult.ok) {
-                printCursorFailureRecovery(parsed.taskId, result, cursorResult);
-            }
-        }
-        else if (result.executor === 'pi') {
-            throw new Error(buildPiAutoRunMigrationMessage(parsed.taskId, result.worktreePath));
-        }
-    }
-    else if (result.executor === 'cursor') {
-        printCursorDelegateNextSteps(parsed.taskId, result);
+        const dagPath = path.join(os.tmpdir(), `${parsed.taskId}-delegate-dag.json`);
+        await dependencies.generateTaskDag({
+            repoRoot,
+            taskId: parsed.taskId,
+            outputPath: dagPath,
+            strictModels: true,
+            execute: false,
+            initOnly: false,
+            dryRun: false,
+            cwd: result.worktreePath,
+            profile: "auto",
+            profileExplicit: false,
+        });
+        await dependencies.validateDag({
+            repoRoot,
+            dagPath,
+            strictModelMatrix: true,
+            strictGovernance: true,
+            forbidExecutors: [],
+        });
+        const runSummary = await dependencies.runDag({
+            repoRoot,
+            dagPath,
+            cwd: result.worktreePath,
+            initOnly: false,
+            dryRun: false,
+        });
+        console.log(JSON.stringify({
+            ...result,
+            autoRun: {
+                dagPath,
+                runSummary,
+            },
+        }, null, 2));
+        return;
     }
+    printDelegateNextSteps(parsed.taskId, result);
     console.log(JSON.stringify(result, null, 2));
 }

package/dist/commands/doctor.js

@@ -2,14 +2,6 @@ import { access } from 'node:fs/promises';
 import path from 'node:path';
 import { checkPiAvailability, resolvePiBackend } from '../executors/pi-executor.js';
 import { checkPiSdkAvailability } from '../executors/pi-sdk-executor.js';
-import { resolveCursorExecutorConfig } from '../executors/config-core.js';
-import { isCursorWorkerEnabled, isCursorWorkerRunning } from '../executors/cursor-worker-client.js';
-function checkCursorAvailability() {
-    if (!process.env.CURSOR_API_KEY?.trim()) {
-        return { ok: false, detail: 'CURSOR_API_KEY not set' };
-    }
-    return { ok: true, detail: 'CURSOR_API_KEY configured' };
-}
 export async function runDoctor(adapter, repoRoot) {
     const manifest = await adapter.loadHarnessManifest(repoRoot);
     const requiredPaths = [];
@@ -36,15 +28,5 @@ export async function runDoctor(adapter, repoRoot) {
     if (backendMode === 'sdk-first' && !sdk.ok) {
         console.error(`doctor warning: CODE_AGENT_PI_BACKEND=sdk-first but pi SDK unavailable (${sdk.detail}); steps will fall back to CLI`);
     }
-    const cursorCfg = resolveCursorExecutorConfig(manifest);
-    if (cursorCfg) {
-        const cursor = checkCursorAvailability();
-        if (!cursor.ok) {
-            console.error(`doctor warning: executors.cursor registered but ${cursor.detail}`);
-        }
-        if (isCursorWorkerEnabled()) {
-            console.log(`doctor: CURSOR_USE_WORKER=1 (running=${isCursorWorkerRunning()})`);
-        }
-    }
     console.log('doctor ok');
 }