@tea-agent/loop-agent 0.1.0

package/dist/commands/loop.js

@@ -0,0 +1,241 @@
+import { appendLoopSignal, appendLoopRound, generateLoopCloseout, initializeLoop, loadLoopState, parseLoopSignalType, rewriteLoopContext, runLoopAuto, runLoopCursorFix, runLoopDagAction, runLoopPiReview, runLoopShellVerification, runLoopWorkflowAction, } from "../workflows/loop/index.js";
+function usage() {
+    return [
+        "usage: loop <init|status|run|record-round|add-signal|closeout> <task-id> [options]",
+        "  loop init <task-id> [--recover] [--max-rounds N]",
+        "  loop status <task-id> [--json]",
+        "  loop run <task-id> --action shell-verify [--command <cmd>]... [--timeout-ms N] [--cwd <repo-relative-dir>]",
+        "  loop run <task-id> --action pi-review [--provider <id>] [--model <id>] [--timeout-ms N] [--cwd <repo-relative-dir>]",
+        "  loop run <task-id> --action cursor-fix [--model <id>] [--timeout-ms N] [--cwd <repo-relative-dir>]",
+        "  loop run <task-id> --action dag [--execute] [--dag <path>] [--run-id <id>] [--max-concurrent N] [--cwd <repo-relative-dir>] [--no-cursor]",
+        "  loop run <task-id> --action workflow [--profile pr-review|--workflow <path>] [--execute] [--run-id <id>] [--changed-file <path>]... [--cwd <repo-relative-dir>]",
+        "  loop run <task-id> --auto [--max-rounds N] [--allow-cursor-fix]",
+        "  loop record-round <task-id> --action <name> --result <summary> --lesson <summary> --next <summary> --decision <continue|pause|blocked|complete> [--verification <summary>] [--failure-category <category>] [--ref <path>]...",
+        "  loop add-signal <task-id> --type <human_followup|approval|scope_changed|review_feedback> --message <text> [--urgent] [--ref <path>]...",
+        "  loop closeout <task-id>",
+    ].join("\n");
+}
+function readFlag(args, flag) {
+    const index = args.indexOf(flag);
+    if (index < 0)
+        return undefined;
+    const value = args[index + 1];
+    if (!value)
+        throw new Error(`${flag} requires a value`);
+    return value;
+}
+function readRepeatedFlag(args, flag) {
+    const values = [];
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] === flag) {
+            const value = args[index + 1];
+            if (!value)
+                throw new Error(`${flag} requires a value`);
+            values.push(value);
+            index += 1;
+        }
+    }
+    return values;
+}
+function requireFlag(args, flag) {
+    const value = readFlag(args, flag);
+    if (!value)
+        throw new Error(`${flag} is required\n${usage()}`);
+    return value;
+}
+function parseDecision(value) {
+    if (value === "continue" ||
+        value === "pause" ||
+        value === "blocked" ||
+        value === "complete") {
+        return value;
+    }
+    throw new Error(`invalid loop decision: ${value}`);
+}
+function parseRecordRoundArgs(args) {
+    return {
+        action: requireFlag(args, "--action"),
+        refs: readRepeatedFlag(args, "--ref"),
+        result: requireFlag(args, "--result"),
+        verification: readFlag(args, "--verification"),
+        lesson: requireFlag(args, "--lesson"),
+        next: requireFlag(args, "--next"),
+        decision: parseDecision(requireFlag(args, "--decision")),
+        failureCategory: readFlag(args, "--failure-category"),
+        completedCriteria: readRepeatedFlag(args, "--completed-criterion"),
+    };
+}
+export async function runLoop(repoRoot, args) {
+    const [subcommand, taskId, ...rest] = args;
+    if (!subcommand || !taskId)
+        throw new Error(usage());
+    if (subcommand === "init") {
+        const maxRoundsRaw = readFlag(rest, "--max-rounds");
+        let maxRounds;
+        if (maxRoundsRaw) {
+            const parsed = Number.parseInt(maxRoundsRaw, 10);
+            if (!Number.isInteger(parsed) || parsed <= 0) {
+                throw new Error("--max-rounds must be a positive integer");
+            }
+            maxRounds = parsed;
+        }
+        const result = await initializeLoop(repoRoot, taskId, {
+            recover: rest.includes("--recover"),
+            maxRounds,
+        });
+        console.log(JSON.stringify({
+            taskId,
+            created: result.created,
+            status: result.state.status,
+            round: result.state.round,
+            loopDir: result.paths.loopDir,
+        }, null, 2));
+        return;
+    }
+    if (subcommand === "status") {
+        const state = await loadLoopState(repoRoot, taskId);
+        if (rest.includes("--json")) {
+            console.log(JSON.stringify(state, null, 2));
+            return;
+        }
+        console.log([
+            `taskId: ${state.taskId}`,
+            `status: ${state.status}`,
+            `round: ${state.round}/${state.maxRounds}`,
+            `lastDecision: ${state.lastDecision}`,
+            `lastAction: ${state.lastAction}`,
+            `sourceStale: ${state.freshness.sourceStale}`,
+            `openFrontier: ${state.openFrontier.join("; ")}`,
+        ].join("\n"));
+        return;
+    }
+    if (subcommand === "record-round") {
+        const entry = await appendLoopRound(repoRoot, taskId, parseRecordRoundArgs(rest));
+        await rewriteLoopContext(repoRoot, taskId);
+        console.log(JSON.stringify(entry, null, 2));
+        return;
+    }
+    if (subcommand === "add-signal") {
+        const entry = await appendLoopSignal(repoRoot, taskId, {
+            type: parseLoopSignalType(requireFlag(rest, "--type")),
+            message: requireFlag(rest, "--message"),
+            urgent: rest.includes("--urgent"),
+            refs: readRepeatedFlag(rest, "--ref"),
+        });
+        console.log(JSON.stringify(entry, null, 2));
+        return;
+    }
+    if (subcommand === "closeout") {
+        const record = await generateLoopCloseout(repoRoot, taskId);
+        console.log(JSON.stringify(record, null, 2));
+        return;
+    }
+    if (subcommand === "run") {
+        if (rest.includes("--auto")) {
+            const maxRoundsRaw = readFlag(rest, "--max-rounds");
+            let maxRounds;
+            if (maxRoundsRaw) {
+                const parsed = Number.parseInt(maxRoundsRaw, 10);
+                if (!Number.isInteger(parsed) || parsed <= 0) {
+                    throw new Error("--max-rounds must be a positive integer");
+                }
+                maxRounds = parsed;
+            }
+            const record = await runLoopAuto(repoRoot, taskId, {
+                maxRounds,
+                allowCursorFix: rest.includes("--allow-cursor-fix"),
+            });
+            console.log(JSON.stringify(record, null, 2));
+            return;
+        }
+        const action = readFlag(rest, "--action");
+        const timeoutRaw = readFlag(rest, "--timeout-ms");
+        let timeoutMs;
+        if (timeoutRaw) {
+            const parsed = Number.parseInt(timeoutRaw, 10);
+            if (!Number.isInteger(parsed) || parsed <= 0) {
+                throw new Error("--timeout-ms must be a positive integer");
+            }
+            timeoutMs = parsed;
+        }
+        if (action === "pi-review") {
+            const record = await runLoopPiReview(repoRoot, taskId, {
+                timeoutMs,
+                cwd: readFlag(rest, "--cwd"),
+                provider: readFlag(rest, "--provider"),
+                model: readFlag(rest, "--model"),
+            });
+            console.log(JSON.stringify(record, null, 2));
+            return;
+        }
+        if (action === "cursor-fix") {
+            const record = await runLoopCursorFix(repoRoot, taskId, {
+                timeoutMs,
+                cwd: readFlag(rest, "--cwd"),
+                model: readFlag(rest, "--model"),
+            });
+            console.log(JSON.stringify(record, null, 2));
+            return;
+        }
+        if (action === "dag") {
+            const maxConcurrentRaw = readFlag(rest, "--max-concurrent");
+            let maxConcurrent;
+            if (maxConcurrentRaw) {
+                const parsed = Number.parseInt(maxConcurrentRaw, 10);
+                if (!Number.isInteger(parsed) || parsed <= 0) {
+                    throw new Error("--max-concurrent must be a positive integer");
+                }
+                maxConcurrent = parsed;
+            }
+            const record = await runLoopDagAction(repoRoot, taskId, {
+                mode: rest.includes("--execute") ? "execute" : "review",
+                cwd: readFlag(rest, "--cwd"),
+                dagPath: readFlag(rest, "--dag"),
+                runId: readFlag(rest, "--run-id"),
+                maxConcurrent,
+                noCursor: rest.includes("--no-cursor"),
+            });
+            console.log(JSON.stringify(record, null, 2));
+            return;
+        }
+        if (action === "workflow") {
+            const maxConcurrentRaw = readFlag(rest, "--max-concurrent");
+            let maxConcurrent;
+            if (maxConcurrentRaw) {
+                const parsed = Number.parseInt(maxConcurrentRaw, 10);
+                if (!Number.isInteger(parsed) || parsed <= 0) {
+                    throw new Error("--max-concurrent must be a positive integer");
+                }
+                maxConcurrent = parsed;
+            }
+            const profile = readFlag(rest, "--profile");
+            if (profile && profile !== "pr-review") {
+                throw new Error(`unsupported workflow profile: ${profile}`);
+            }
+            const record = await runLoopWorkflowAction(repoRoot, taskId, {
+                mode: rest.includes("--execute") ? "execute" : "review",
+                cwd: readFlag(rest, "--cwd"),
+                profile: profile,
+                workflowPath: readFlag(rest, "--workflow"),
+                runId: readFlag(rest, "--run-id"),
+                maxConcurrent,
+                base: readFlag(rest, "--base"),
+                head: readFlag(rest, "--head"),
+                changedFiles: readRepeatedFlag(rest, "--changed-file"),
+            });
+            console.log(JSON.stringify(record, null, 2));
+            return;
+        }
+        if (action !== "shell-verify") {
+            throw new Error("loop run currently supports --action shell-verify|pi-review|cursor-fix|dag|workflow");
+        }
+        const record = await runLoopShellVerification(repoRoot, taskId, {
+            commands: readRepeatedFlag(rest, "--command"),
+            timeoutMs,
+            cwd: readFlag(rest, "--cwd"),
+        });
+        console.log(JSON.stringify(record, null, 2));
+        return;
+    }
+    throw new Error(usage());
+}

package/dist/commands/new-task.js

@@ -0,0 +1,5 @@
+import { createTask } from '../task/runtime.js';
+export async function runNewTask(repoRoot, taskId, title) {
+    const taskDir = await createTask(repoRoot, taskId, title);
+    console.log(taskDir);
+}

package/dist/commands/pi-prompt.js

@@ -0,0 +1,181 @@
+/**
+ * Pi Prompt — one-shot CLI for Pi SDK short tasks.
+ *
+ * Usage:
+ *   pi-prompt "Fix lint errors"
+ *   pi-prompt --stdin
+ *   pi-prompt --file task.md
+ *   pi-prompt --model gpt-5.5 --provider wizard-local "Deep analysis"
+ *   pi-prompt --cwd /path --timeout 120000 "task"
+ */
+import { DEFAULT_TIMEOUT_MS } from "../executors/pi-executor.js";
+import { createOneShotPromptParseAccum, formatUnknownFlagError, parseOneShotCommonFlag, printOneShotHelpAndExit, resolveOneShotCwd, resolveOneShotTask, } from "../shared/one-shot-prompt-args.js";
+import { executeSingleSdkAttempt } from "../executors/pi-sdk-executor.js";
+export const DEFAULT_PI_PROVIDER = "wizard-local";
+export const DEFAULT_PI_MODEL = "glm-5.2";
+export const DEFAULT_PI_TOOLS = [
+    "read",
+    "bash",
+    "ast_grep_search",
+    "lsp_diagnostics",
+    "subagent",
+];
+const PI_PROMPT_USAGE = [
+    "usage: pi-prompt [options] [task]",
+    "",
+    '  pi-prompt "Fix lint errors in src/"              One-shot task',
+    "  pi-prompt --stdin                                 Read task from stdin",
+    "  pi-prompt --file task.md                          Read task from a file",
+    '  pi-prompt --model gpt-5.5 "Deep analysis"         Use a high model',
+    '  pi-prompt --cwd /path --timeout 60000 "task"      Custom cwd + timeout',
+    "",
+    "options:",
+    "  --stdin                  Read task from stdin (ignores positional task)",
+    "  --file <path>            Read task from a file",
+    "  --cwd <path>             Working directory (default: cwd)",
+    `  --provider <id>          Provider id (default: ${DEFAULT_PI_PROVIDER})`,
+    `  --model <id>             Model id (default: ${DEFAULT_PI_MODEL})`,
+    "  --thinking <level>       Thinking level (provider-specific)",
+    `  --timeout <ms>           Timeout in ms (default: ${DEFAULT_TIMEOUT_MS})`,
+    `  --tools <csv>            Tool names (default: ${DEFAULT_PI_TOOLS.join(",")})`,
+    "  --system <text>          Base system prompt",
+    "  --append-system-prompt <text>  Append to system prompt",
+    "  --help, -h               Show this help",
+].join("\n");
+function parseToolsCsv(value) {
+    return value
+        .split(",")
+        .map((tool) => tool.trim())
+        .filter((tool) => tool.length > 0);
+}
+function buildSystemPrompt(args) {
+    const parts = [args.system, args.appendSystemPrompt].filter((part) => Boolean(part?.trim()));
+    if (parts.length === 0) {
+        return "You are running as a one-shot Pi SDK prompt from loop-agent pi-prompt. Keep the response concise and task-focused.";
+    }
+    return parts.join("\n\n");
+}
+export function parsePiPromptArgs(args) {
+    const accum = createOneShotPromptParseAccum();
+    let provider;
+    let model;
+    let thinking;
+    let tools;
+    let system;
+    let appendSystemPrompt;
+    for (let i = 0; i < args.length; i += 1) {
+        const common = parseOneShotCommonFlag(args, i, accum);
+        if (common.kind === "help") {
+            printOneShotHelpAndExit(PI_PROMPT_USAGE);
+        }
+        if (common.kind === "consumed") {
+            i = common.nextIndex;
+            continue;
+        }
+        const arg = args[i];
+        if (arg === "--provider") {
+            provider = args[i + 1];
+            if (!provider)
+                throw new Error("--provider requires a provider id");
+            i += 1;
+        }
+        else if (arg === "--model") {
+            model = args[i + 1];
+            if (!model)
+                throw new Error("--model requires a model id");
+            i += 1;
+        }
+        else if (arg === "--thinking") {
+            thinking = args[i + 1];
+            if (!thinking)
+                throw new Error("--thinking requires a level");
+            i += 1;
+        }
+        else if (arg === "--tools") {
+            const val = args[i + 1];
+            if (!val)
+                throw new Error("--tools requires a comma-separated list");
+            tools = parseToolsCsv(val);
+            if (tools.length === 0) {
+                throw new Error("--tools requires at least one tool name");
+            }
+            i += 1;
+        }
+        else if (arg === "--system") {
+            system = args[i + 1];
+            if (!system)
+                throw new Error("--system requires text");
+            i += 1;
+        }
+        else if (arg === "--append-system-prompt") {
+            appendSystemPrompt = args[i + 1];
+            if (!appendSystemPrompt) {
+                throw new Error("--append-system-prompt requires text");
+            }
+            i += 1;
+        }
+        else {
+            throw formatUnknownFlagError(arg, PI_PROMPT_USAGE);
+        }
+    }
+    const task = resolveOneShotTask(accum, PI_PROMPT_USAGE);
+    return {
+        task,
+        cwd: resolveOneShotCwd(accum.cwd),
+        provider,
+        model,
+        thinking,
+        timeoutMs: accum.timeoutMs,
+        tools,
+        system,
+        appendSystemPrompt,
+    };
+}
+export async function runPiPrompt(args) {
+    const effectiveCwd = args.cwd ?? process.cwd();
+    const provider = args.provider ?? DEFAULT_PI_PROVIDER;
+    const model = args.model ?? DEFAULT_PI_MODEL;
+    const timeoutMs = args.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const toolNames = args.tools ?? [...DEFAULT_PI_TOOLS];
+    const prompt = buildSystemPrompt(args);
+    const startedAt = Date.now();
+    process.stderr.write(`[pi-prompt] running "${args.task.slice(0, 80)}${args.task.length > 80 ? "..." : ""}" (provider=${provider}, model=${model}, cwd=${effectiveCwd})\n`);
+    const result = await executeSingleSdkAttempt({
+        repoRoot: effectiveCwd,
+        prompt,
+        userMessage: args.task,
+        attachedFiles: [],
+        toolNames,
+        timeoutMs,
+        step: "implement",
+        modelConfig: {
+            provider,
+            model,
+            thinking: args.thinking,
+        },
+    });
+    const elapsed = ((Date.now() - startedAt) / 1000).toFixed(1);
+    if (result.ok) {
+        process.stderr.write(`[pi-prompt] done in ${elapsed}s\n`);
+        process.stdout.write(result.assistantText);
+        if (!result.assistantText.endsWith("\n"))
+            process.stdout.write("\n");
+        return;
+    }
+    const detail = result.stderr?.trim()
+        ? result.stderr.trim()
+        : excerptOutput(result.stdout);
+    process.stderr.write(`[pi-prompt] FAILED in ${elapsed}s (${result.failureCategory}):\n${detail}\n`);
+    process.exit(1);
+}
+function excerptOutput(stdout, maxChars = 2000) {
+    const trimmed = stdout.trim();
+    if (!trimmed)
+        return "(no output)";
+    if (trimmed.length <= maxChars)
+        return trimmed;
+    return `${trimmed.slice(0, maxChars)}…`;
+}
+export function printPiPromptUsage() {
+    console.log(PI_PROMPT_USAGE);
+}

package/dist/commands/pi-reuse-benchmark.js

@@ -0,0 +1,153 @@
+import path from "node:path";
+import { buildPiReuseBenchmarkResult, formatPiReuseBenchmarkMarkdown, } from "../executors/pi-reuse-benchmark.js";
+export function parsePiReuseBenchmarkArgs(args) {
+    let reportPath;
+    let approvalPath;
+    let offExecutorPath;
+    let onExecutorPath;
+    let offTaskId;
+    let onTaskId;
+    let json = false;
+    let markdown = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--markdown") {
+            markdown = true;
+            continue;
+        }
+        if (arg === "--report") {
+            reportPath = args[++i];
+            if (!reportPath) {
+                throw new Error("pi-reuse-benchmark --report requires a path");
+            }
+            continue;
+        }
+        if (arg.startsWith("--report=")) {
+            reportPath = arg.slice("--report=".length);
+            continue;
+        }
+        if (arg === "--approval") {
+            approvalPath = args[++i];
+            if (!approvalPath) {
+                throw new Error("pi-reuse-benchmark --approval requires a path");
+            }
+            continue;
+        }
+        if (arg.startsWith("--approval=")) {
+            approvalPath = arg.slice("--approval=".length);
+            continue;
+        }
+        if (arg === "--off-executor") {
+            offExecutorPath = args[++i];
+            if (!offExecutorPath) {
+                throw new Error("pi-reuse-benchmark --off-executor requires a path");
+            }
+            continue;
+        }
+        if (arg.startsWith("--off-executor=")) {
+            offExecutorPath = arg.slice("--off-executor=".length);
+            continue;
+        }
+        if (arg === "--on-executor") {
+            onExecutorPath = args[++i];
+            if (!onExecutorPath) {
+                throw new Error("pi-reuse-benchmark --on-executor requires a path");
+            }
+            continue;
+        }
+        if (arg.startsWith("--on-executor=")) {
+            onExecutorPath = arg.slice("--on-executor=".length);
+            continue;
+        }
+        if (arg === "--off-task") {
+            offTaskId = args[++i];
+            if (!offTaskId) {
+                throw new Error("pi-reuse-benchmark --off-task requires a task id");
+            }
+            continue;
+        }
+        if (arg.startsWith("--off-task=")) {
+            offTaskId = arg.slice("--off-task=".length);
+            continue;
+        }
+        if (arg === "--on-task") {
+            onTaskId = args[++i];
+            if (!onTaskId) {
+                throw new Error("pi-reuse-benchmark --on-task requires a task id");
+            }
+            continue;
+        }
+        if (arg.startsWith("--on-task=")) {
+            onTaskId = arg.slice("--on-task=".length);
+            continue;
+        }
+        if (arg === "--help" || arg === "-h") {
+            printPiReuseBenchmarkUsage();
+            process.exit(0);
+        }
+        throw new Error(`unknown pi-reuse-benchmark argument: ${arg}`);
+    }
+    if (!json && !markdown) {
+        json = true;
+    }
+    return {
+        reportPath,
+        approvalPath,
+        offExecutorPath,
+        onExecutorPath,
+        offTaskId,
+        onTaskId,
+        json,
+        markdown,
+    };
+}
+export function printPiReuseBenchmarkUsage() {
+    console.log(`usage: pi-reuse-benchmark [options]
+
+Deterministic Pi runtime reuse benchmark/decision summary (no live Pi calls).
+
+Options:
+  --report <path>         Benchmark report markdown (approval status)
+  --approval <path>       Explicit approval JSON artifact
+  --off-executor <path>   Baseline executor.jsonl (reuse off)
+  --on-executor <path>    Treatment executor.jsonl (reuse on)
+  --off-task <task-id>    Resolve baseline from .harness/tasks/<id>/logs/executor.jsonl
+  --on-task <task-id>     Resolve treatment from .harness/tasks/<id>/logs/executor.jsonl
+  --json                  Emit JSON (default when no format flag is set)
+  --markdown              Emit Markdown summary
+  -h, --help              Show this help
+
+Recommendations: defer | maintain-opt-in | eligible-for-human-review
+Never changes CODE_AGENT_PI_REUSE_RUNTIME default (off).`);
+}
+function resolveRepoRelative(repoRoot, filePath) {
+    if (!filePath)
+        return undefined;
+    return path.isAbsolute(filePath) ? filePath : path.resolve(repoRoot, filePath);
+}
+export async function runPiReuseBenchmark(repoRoot, rawArgs) {
+    const parsed = parsePiReuseBenchmarkArgs(rawArgs);
+    const input = {
+        repoRoot,
+        reportPath: resolveRepoRelative(repoRoot, parsed.reportPath),
+        approvalPath: resolveRepoRelative(repoRoot, parsed.approvalPath),
+        offExecutorPath: resolveRepoRelative(repoRoot, parsed.offExecutorPath),
+        onExecutorPath: resolveRepoRelative(repoRoot, parsed.onExecutorPath),
+        offTaskId: parsed.offTaskId,
+        onTaskId: parsed.onTaskId,
+    };
+    const result = await buildPiReuseBenchmarkResult(input);
+    if (parsed.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    if (parsed.markdown) {
+        if (parsed.json) {
+            console.log("");
+        }
+        process.stdout.write(formatPiReuseBenchmarkMarkdown(result));
+    }
+}

package/dist/commands/plan-list.js

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

package/dist/commands/promote-run.js

@@ -0,0 +1,29 @@
+import { promoteRunEvidence } from '../records/promotion.js';
+export function parsePromoteRunArgs(args) {
+    const [taskId, ...rest] = args;
+    if (!taskId)
+        throw new Error('usage: promote-run <task-id> --run-id <run-id>');
+    let runId;
+    for (let i = 0; i < rest.length; i += 1) {
+        const arg = rest[i];
+        if (arg === '--run-id') {
+            runId = rest[++i];
+            if (!runId)
+                throw new Error('promote-run --run-id requires a value');
+            continue;
+        }
+        if (arg.startsWith('--run-id=')) {
+            runId = arg.slice('--run-id='.length);
+            continue;
+        }
+        throw new Error(`unknown promote-run flag: ${arg}`);
+    }
+    if (!runId)
+        throw new Error('usage: promote-run <task-id> --run-id <run-id>');
+    return { taskId, runId };
+}
+export async function runPromoteRun(repoRoot, args) {
+    const parsed = parsePromoteRunArgs(args);
+    const result = await promoteRunEvidence(repoRoot, parsed.taskId, parsed.runId);
+    console.log(JSON.stringify(result, null, 2));
+}

package/dist/commands/reference-index.js

@@ -0,0 +1,16 @@
+/** Feature-study reference index command (compatibility-only). */
+import { buildReferenceIndex } from '../shared/reference-context.js';
+import { loadTaskConfig } from '../task/runtime.js';
+export async function runReferenceIndex(repoRoot, taskId) {
+    const taskConfig = await loadTaskConfig(repoRoot, taskId);
+    const index = await buildReferenceIndex(repoRoot, taskId, taskConfig);
+    const fileCount = index.repos.reduce((sum, repo) => sum + repo.files.length, 0);
+    console.log(JSON.stringify({
+        taskId,
+        manifestPath: `${repoRoot}/.harness/tasks/${taskId}/source/references/index.json`,
+        repoCount: index.repos.length,
+        indexedFileCount: fileCount,
+        docCount: index.docs.length,
+        truncatedRepos: index.repos.filter((repo) => repo.truncated).map((repo) => repo.name),
+    }, null, 2));
+}