@tea-agent/loop-agent 0.1.0

package/dist/commands/dag-validate.js

@@ -0,0 +1,186 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { loadDagSpecFromFile } from "../workflows/dag/runner.js";
+import { assertValidDagSpec, collectExecutorModelWarnings, collectForbiddenExecutorIssues, collectGovernanceWarnings, validateDagSpec, } from "../workflows/dag/validate.js";
+import { inferGovernanceProfile } from "../workflows/dag/governance-profile.js";
+import { topoSortToRanks } from "../workflows/dag/topo.js";
+import { runSpineAudit } from "../governance/spine-audit.js";
+export function parseDagValidateArgs(args) {
+    if (args.length === 0) {
+        throw new Error("usage: dag validate --dag <path> [--strict-models] [--strict-governance]");
+    }
+    let dagPath;
+    let strictModelMatrix = false;
+    let strictGovernance = false;
+    const forbidExecutors = [];
+    let spineTaskId;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--dag") {
+            dagPath = args[++i];
+            if (!dagPath) {
+                throw new Error("dag validate --dag requires a path");
+            }
+            continue;
+        }
+        if (arg.startsWith("--dag=")) {
+            dagPath = arg.slice("--dag=".length);
+            if (!dagPath) {
+                throw new Error("dag validate --dag requires a path");
+            }
+            continue;
+        }
+        if (arg === "--strict-models") {
+            strictModelMatrix = true;
+            continue;
+        }
+        if (arg === "--strict-governance") {
+            strictGovernance = true;
+            continue;
+        }
+        if (arg === "--forbid-executor") {
+            const executor = args[++i];
+            if (!executor) {
+                throw new Error("dag validate --forbid-executor requires an executor");
+            }
+            forbidExecutors.push(executor);
+            continue;
+        }
+        if (arg === "--spine-task") {
+            spineTaskId = args[++i];
+            if (!spineTaskId) {
+                throw new Error("dag validate --spine-task requires a task id");
+            }
+            continue;
+        }
+        if (arg.startsWith("--spine-task=")) {
+            spineTaskId = arg.slice("--spine-task=".length);
+            if (!spineTaskId) {
+                throw new Error("dag validate --spine-task requires a task id");
+            }
+            continue;
+        }
+        if (arg.startsWith("--forbid-executor=")) {
+            const executor = arg.slice("--forbid-executor=".length);
+            if (!executor) {
+                throw new Error("dag validate --forbid-executor requires an executor");
+            }
+            forbidExecutors.push(executor);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag validate flag: ${arg}`);
+        }
+        if (dagPath) {
+            throw new Error(`unexpected positional argument: ${arg}`);
+        }
+        dagPath = arg;
+    }
+    if (!dagPath) {
+        throw new Error("dag validate requires --dag <path>");
+    }
+    return {
+        dagPath: path.resolve(dagPath),
+        strictModelMatrix,
+        strictGovernance,
+        forbidExecutors,
+        spineTaskId,
+    };
+}
+function formatModelMatrixWarnings(warnings) {
+    return warnings.map((warning) => ({
+        executor: warning.executor,
+        complexity: warning.complexity,
+        expected: warning.expected,
+        actual: warning.actual,
+    }));
+}
+function formatGovernanceWarnings(warnings) {
+    return warnings.map((warning) => ({
+        type: warning.type,
+        message: warning.message,
+    }));
+}
+function ensureStrictModelMatrix(warnings) {
+    if (warnings.length === 0) {
+        return;
+    }
+    const details = warnings
+        .map((entry) => `executor=${entry.executor}, complexity=${entry.complexity}, expected=${entry.expected}, actual=${entry.actual}`)
+        .join("; ");
+    throw new Error(`non-canonical executorModels overrides are blocked by --strict-models: ${details}`);
+}
+async function loadRawTaskExecutorMap(dagPath) {
+    const raw = JSON.parse(await readFile(dagPath, "utf-8"));
+    const map = new Map();
+    for (const task of raw.tasks ?? []) {
+        if (typeof task.id === "string")
+            map.set(task.id, task.executor);
+    }
+    return map;
+}
+function ensureNoForbiddenExecutors(spec, forbidExecutors, rawTaskExecutors) {
+    const supported = new Set(["cursor", "pi", "shell", "static"]);
+    const normalized = forbidExecutors.map((executor) => {
+        if (!supported.has(executor)) {
+            throw new Error(`unsupported executor for --forbid-executor: ${executor}`);
+        }
+        return executor;
+    });
+    const issues = collectForbiddenExecutorIssues(spec, normalized);
+    if (issues.length === 0)
+        return;
+    const details = issues
+        .map((issue) => {
+        const implicitDefault = rawTaskExecutors.get(issue.taskId) === undefined;
+        return `task=${issue.taskId}, executor=${issue.executor}${implicitDefault ? " (implicit default)" : ""}`;
+    })
+        .join("; ");
+    throw new Error(`forbidden executor present: ${details}`);
+}
+export async function runDagValidate(repoRoot, rawArgs) {
+    const parsed = parseDagValidateArgs(rawArgs);
+    const spec = await loadDagSpecFromFile(parsed.dagPath);
+    const rawTaskExecutors = await loadRawTaskExecutorMap(parsed.dagPath);
+    ensureNoForbiddenExecutors(spec, parsed.forbidExecutors, rawTaskExecutors);
+    const validationIssues = validateDagSpec(spec);
+    const warnings = collectExecutorModelWarnings(spec);
+    const governanceWarnings = collectGovernanceWarnings(validationIssues);
+    if (parsed.strictModelMatrix) {
+        ensureStrictModelMatrix(warnings);
+    }
+    const spineAudit = parsed.spineTaskId
+        ? await runSpineAudit(repoRoot, parsed.spineTaskId)
+        : undefined;
+    if (parsed.strictGovernance && spineAudit && !spineAudit.ok) {
+        throw new Error(`minimal spec spine audit failed for ${parsed.spineTaskId}: ${spineAudit.findings
+            .filter((finding) => finding.severity === "error")
+            .map((finding) => `${finding.type}: ${finding.message}`)
+            .join("; ")}`);
+    }
+    assertValidDagSpec(spec, {
+        issues: validationIssues,
+        strictGovernance: parsed.strictGovernance,
+    });
+    const { ranks } = topoSortToRanks(spec);
+    const governanceProfile = inferGovernanceProfile(spec);
+    console.log(JSON.stringify({
+        mode: "validate",
+        title: spec.title,
+        taskCount: spec.tasks.length,
+        ranks,
+        governanceProfile,
+        spineAudit: spineAudit
+            ? {
+                ok: spineAudit.ok,
+                taskId: spineAudit.taskId,
+                findings: spineAudit.findings,
+                verifyCommandLabels: spineAudit.verifyCommandLabels,
+            }
+            : undefined,
+        warnings: [
+            ...formatModelMatrixWarnings(warnings),
+            ...formatGovernanceWarnings(governanceWarnings),
+        ],
+    }, null, 2));
+}

package/dist/commands/dag-workflow-compile.js

@@ -0,0 +1,91 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { compileWorkflowToDag, defaultCompileManifestPath, } from "../workflows/dynamic/compile.js";
+import { parseWorkflowSpec } from "../workflows/dynamic/validate.js";
+import { resolveCliPath } from "../shared/path-refs.js";
+export function parseDagWorkflowCompileArgs(args) {
+    if (args.length === 0) {
+        throw new Error("usage: dag workflow-compile --workflow <path> --output <path> [--manifest <path>]");
+    }
+    let workflowPath;
+    let outputPath;
+    let manifestPath;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--workflow") {
+            workflowPath = args[++i];
+            if (!workflowPath) {
+                throw new Error("dag workflow-compile --workflow requires a path");
+            }
+            continue;
+        }
+        if (arg.startsWith("--workflow=")) {
+            workflowPath = arg.slice("--workflow=".length);
+            if (!workflowPath) {
+                throw new Error("dag workflow-compile --workflow requires a path");
+            }
+            continue;
+        }
+        if (arg === "--output") {
+            outputPath = args[++i];
+            if (!outputPath) {
+                throw new Error("dag workflow-compile --output requires a path");
+            }
+            continue;
+        }
+        if (arg.startsWith("--output=")) {
+            outputPath = arg.slice("--output=".length);
+            if (!outputPath) {
+                throw new Error("dag workflow-compile --output requires a path");
+            }
+            continue;
+        }
+        if (arg === "--manifest") {
+            manifestPath = args[++i];
+            if (!manifestPath) {
+                throw new Error("dag workflow-compile --manifest requires a path");
+            }
+            continue;
+        }
+        if (arg.startsWith("--manifest=")) {
+            manifestPath = arg.slice("--manifest=".length);
+            if (!manifestPath) {
+                throw new Error("dag workflow-compile --manifest requires a path");
+            }
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag workflow-compile flag: ${arg}`);
+        }
+        throw new Error(`unexpected positional argument: ${arg}`);
+    }
+    if (!workflowPath) {
+        throw new Error("dag workflow-compile requires --workflow <path>");
+    }
+    if (!outputPath) {
+        throw new Error("dag workflow-compile requires --output <path>");
+    }
+    return {
+        workflowPath: resolveCliPath(workflowPath),
+        outputPath: resolveCliPath(outputPath),
+        manifestPath: manifestPath ? resolveCliPath(manifestPath) : undefined,
+    };
+}
+export async function runDagWorkflowCompile(_repoRoot, rawArgs) {
+    const parsed = parseDagWorkflowCompileArgs(rawArgs);
+    const raw = JSON.parse(await readFile(parsed.workflowPath, "utf-8"));
+    const spec = parseWorkflowSpec(raw);
+    const result = compileWorkflowToDag(spec, { sourcePath: parsed.workflowPath });
+    const manifestPath = parsed.manifestPath ?? defaultCompileManifestPath(parsed.outputPath);
+    await mkdir(path.dirname(parsed.outputPath), { recursive: true });
+    await mkdir(path.dirname(manifestPath), { recursive: true });
+    await writeFile(parsed.outputPath, `${JSON.stringify(result.dag, null, 2)}\n`, "utf-8");
+    await writeFile(manifestPath, `${JSON.stringify(result.manifest, null, 2)}\n`, "utf-8");
+    console.log(JSON.stringify({
+        mode: "workflow-compile",
+        name: spec.meta.name,
+        nodeCount: spec.nodes.length,
+        outputPath: parsed.outputPath,
+        manifestPath,
+    }, null, 2));
+}

package/dist/commands/dag-workflow-plan.js

@@ -0,0 +1,130 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { WORKFLOW_PLAN_PROFILES, buildWorkflowSpecForProfile, } from "../workflows/dynamic/profiles.js";
+import { assertValidWorkflowSpec } from "../workflows/dynamic/validate.js";
+import { resolveCliPath } from "../shared/path-refs.js";
+function isWorkflowPlanProfile(value) {
+    return WORKFLOW_PLAN_PROFILES.includes(value);
+}
+export function parseDagWorkflowPlanArgs(args) {
+    if (args.length === 0) {
+        throw new Error("usage: dag workflow-plan <task-id> --profile pr-review --output <path> [--changed-file <path>]...");
+    }
+    const [taskId, ...rest] = args;
+    if (!taskId || taskId.startsWith("-")) {
+        throw new Error("dag workflow-plan requires <task-id>");
+    }
+    let profile;
+    let outputPath;
+    let base;
+    let head;
+    const changedFiles = [];
+    for (let i = 0; i < rest.length; i += 1) {
+        const arg = rest[i];
+        if (arg === "--profile") {
+            const value = rest[++i];
+            if (!value)
+                throw new Error("dag workflow-plan --profile requires a value");
+            if (!isWorkflowPlanProfile(value)) {
+                throw new Error(`unsupported workflow profile: ${value} (expected ${WORKFLOW_PLAN_PROFILES.join("|")})`);
+            }
+            profile = value;
+            continue;
+        }
+        if (arg.startsWith("--profile=")) {
+            const value = arg.slice("--profile=".length);
+            if (!isWorkflowPlanProfile(value)) {
+                throw new Error(`unsupported workflow profile: ${value} (expected ${WORKFLOW_PLAN_PROFILES.join("|")})`);
+            }
+            profile = value;
+            continue;
+        }
+        if (arg === "--output") {
+            outputPath = rest[++i];
+            if (!outputPath)
+                throw new Error("dag workflow-plan --output requires a path");
+            continue;
+        }
+        if (arg.startsWith("--output=")) {
+            outputPath = arg.slice("--output=".length);
+            if (!outputPath)
+                throw new Error("dag workflow-plan --output requires a path");
+            continue;
+        }
+        if (arg === "--base") {
+            base = rest[++i];
+            if (!base)
+                throw new Error("dag workflow-plan --base requires a value");
+            continue;
+        }
+        if (arg.startsWith("--base=")) {
+            base = arg.slice("--base=".length);
+            continue;
+        }
+        if (arg === "--head") {
+            head = rest[++i];
+            if (!head)
+                throw new Error("dag workflow-plan --head requires a value");
+            continue;
+        }
+        if (arg.startsWith("--head=")) {
+            head = arg.slice("--head=".length);
+            continue;
+        }
+        if (arg === "--changed-file") {
+            const file = rest[++i];
+            if (!file) {
+                throw new Error("dag workflow-plan --changed-file requires a path");
+            }
+            changedFiles.push(file);
+            continue;
+        }
+        if (arg.startsWith("--changed-file=")) {
+            const file = arg.slice("--changed-file=".length);
+            if (!file) {
+                throw new Error("dag workflow-plan --changed-file requires a path");
+            }
+            changedFiles.push(file);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag workflow-plan flag: ${arg}`);
+        }
+        throw new Error(`unexpected positional argument: ${arg}`);
+    }
+    if (!profile) {
+        throw new Error("dag workflow-plan requires --profile <profile>");
+    }
+    if (!outputPath) {
+        throw new Error("dag workflow-plan requires --output <path>");
+    }
+    return {
+        taskId,
+        profile,
+        outputPath: resolveCliPath(outputPath),
+        base,
+        head,
+        changedFiles,
+    };
+}
+export async function runDagWorkflowPlan(_repoRoot, rawArgs) {
+    const parsed = parseDagWorkflowPlanArgs(rawArgs);
+    const spec = buildWorkflowSpecForProfile({
+        profile: parsed.profile,
+        taskId: parsed.taskId,
+        base: parsed.base,
+        head: parsed.head,
+        changedFiles: parsed.changedFiles,
+    });
+    assertValidWorkflowSpec(spec);
+    await mkdir(path.dirname(parsed.outputPath), { recursive: true });
+    await writeFile(parsed.outputPath, `${JSON.stringify(spec, null, 2)}\n`, "utf-8");
+    console.log(JSON.stringify({
+        mode: "workflow-plan",
+        profile: parsed.profile,
+        taskId: parsed.taskId,
+        nodeCount: spec.nodes.length,
+        final: spec.final.from,
+        outputPath: parsed.outputPath,
+    }, null, 2));
+}

package/dist/commands/dag-workflow-validate.js

@@ -0,0 +1,66 @@
+import { readFile } from "node:fs/promises";
+import { assertValidWorkflowSpec, parseWorkflowSpec, validateWorkflowSpec, } from "../workflows/dynamic/validate.js";
+import { compileWorkflowToDag } from "../workflows/dynamic/compile.js";
+import { assertValidDagSpec, validateDagSpec } from "../workflows/dag/validate.js";
+import { resolveCliPath } from "../shared/path-refs.js";
+export function parseDagWorkflowValidateArgs(args) {
+    if (args.length === 0) {
+        throw new Error("usage: dag workflow-validate --workflow <path> [--strict-governance]");
+    }
+    let workflowPath;
+    let strictGovernance = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--workflow") {
+            workflowPath = args[++i];
+            if (!workflowPath) {
+                throw new Error("dag workflow-validate --workflow requires a path");
+            }
+            continue;
+        }
+        if (arg.startsWith("--workflow=")) {
+            workflowPath = arg.slice("--workflow=".length);
+            if (!workflowPath) {
+                throw new Error("dag workflow-validate --workflow requires a path");
+            }
+            continue;
+        }
+        if (arg === "--strict-governance") {
+            strictGovernance = true;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag workflow-validate flag: ${arg}`);
+        }
+        if (workflowPath) {
+            throw new Error(`unexpected positional argument: ${arg}`);
+        }
+        workflowPath = arg;
+    }
+    if (!workflowPath) {
+        throw new Error("dag workflow-validate requires --workflow <path>");
+    }
+    return { workflowPath: resolveCliPath(workflowPath), strictGovernance };
+}
+export async function runDagWorkflowValidate(_repoRoot, rawArgs) {
+    const parsed = parseDagWorkflowValidateArgs(rawArgs);
+    const raw = JSON.parse(await readFile(parsed.workflowPath, "utf-8"));
+    const spec = parseWorkflowSpec(raw);
+    const issues = validateWorkflowSpec(spec);
+    assertValidWorkflowSpec(spec);
+    const compiled = compileWorkflowToDag(spec, { sourcePath: parsed.workflowPath });
+    const dagIssues = validateDagSpec(compiled.dag);
+    assertValidDagSpec(compiled.dag, {
+        issues: dagIssues,
+        strictGovernance: parsed.strictGovernance,
+    });
+    console.log(JSON.stringify({
+        mode: "workflow-validate",
+        name: spec.meta.name,
+        nodeCount: spec.nodes.length,
+        final: spec.final.from,
+        strictGovernance: parsed.strictGovernance,
+        issues,
+        dagIssues,
+    }, null, 2));
+}

package/dist/commands/delegate.js

@@ -0,0 +1,132 @@
+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]';
+export function parseDelegateArgs(args) {
+    if (args.length === 0) {
+        throw new Error(DELEGATE_USAGE);
+    }
+    let taskId;
+    let base;
+    let branch;
+    let symlinkNodeModules = true;
+    let autoRun = true;
+    let executor;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--base') {
+            base = args[i + 1];
+            if (!base)
+                throw new Error('--base requires a value');
+            i += 1;
+        }
+        else if (arg === '--branch') {
+            branch = args[i + 1];
+            if (!branch)
+                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 === '--no-symlink') {
+            symlinkNodeModules = false;
+        }
+        else if (arg === '--auto-run') {
+            autoRun = true;
+        }
+        else if (arg === '--no-auto-run') {
+            autoRun = false;
+        }
+        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.startsWith('--')) {
+            if (taskId)
+                throw new Error(`unexpected positional argument: ${arg}`);
+            taskId = arg;
+        }
+        else {
+            throw new Error(`unknown delegate flag: ${arg}`);
+        }
+    }
+    if (!taskId) {
+        throw new Error('delegate requires <taskId> as the first positional argument');
+    }
+    return { taskId, base, branch, symlinkNodeModules, autoRun, executor };
+}
+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) {
+    const lines = [
+        `[delegate] cursor worktree ready (SDK direct).`,
+        `  worktree: ${result.worktreePath}`,
+        `  Next — run Cursor SDK in-process:`,
+        `    npm run dev -- delegate ${taskId} --executor cursor --auto-run`,
+        `  After work completes:`,
+        `    npm run dev -- 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 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);
+    }
+    console.log(JSON.stringify(result, null, 2));
+}

package/dist/commands/docs-archive.js

@@ -0,0 +1,5 @@
+import { archivePlan } from '../governance/checks.js';
+export async function runDocsArchive(repoRoot, planPath) {
+    const result = await archivePlan(repoRoot, planPath);
+    console.log(JSON.stringify(result, null, 2));
+}

package/dist/commands/docs-audit.js

@@ -0,0 +1,5 @@
+import { auditDocs } from '../governance/checks.js';
+export async function runDocsAudit(repoRoot) {
+    const result = await auditDocs(repoRoot);
+    console.log(JSON.stringify(result, null, 2));
+}

package/dist/commands/doctor.js

@@ -0,0 +1,50 @@
+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 = [];
+    for (const key of ['readme', 'agents', 'governanceIndex', 'principles', 'workflow', 'verificationMatrix']) {
+        const value = manifest.entrypoints[key];
+        if (value)
+            requiredPaths.push(value);
+    }
+    const checkRepoScript = manifest.scripts?.checkRepo;
+    if (checkRepoScript)
+        requiredPaths.push(checkRepoScript);
+    requiredPaths.push('.harness/prompts/analyze.md');
+    requiredPaths.push('.harness/prompts/plan.md');
+    for (const rel of requiredPaths) {
+        await access(path.join(repoRoot, rel));
+    }
+    const pi = checkPiAvailability();
+    if (!pi.ok) {
+        throw new Error(`pi unavailable: ${pi.detail}`);
+    }
+    const backendMode = resolvePiBackend();
+    const sdk = await checkPiSdkAvailability(repoRoot);
+    console.log(`doctor: pi backend=${backendMode} cli=${pi.ok ? 'ok' : 'fail'} sdk=${sdk.ok ? 'ok' : 'unavailable'}`);
+    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');
+}