@jterrats/open-orchestra 0.2.1 → 0.3.1

package/dist/commands.js

@@ -2,6 +2,11 @@ import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { initWorkspace } from "./workspace.js";
 import { requireArg } from "./args.js";
+import { AUTONOMOUS_PHASE_SEQUENCE, autonomousRunsPath, checkArchitectSizing, closePhase, createAutonomousRun, initPhase, listAutonomousRuns, markRunDone, markRunFailed, readAutonomousRun, resumePhaseIndex, suspendPhaseForClarification, resumePhaseFromClarification, } from "./autonomous-workflow.js";
+import { listClarifications, openClarification, answerClarification, } from "./clarification.js";
+import { computeBenchmark, recordEstimate, summarizeBenchmark, } from "./benchmark.js";
+import { computeSprintBurndown, renderBurndownAscii } from "./burndown.js";
+import { SIZING_LABELS } from "./types.js";
 import { resolveWorkspaceWritePath } from "./fs-utils.js";
 import { addEvidence, addPlaywrightEvidence, addTask, approveApproval, checkUsageBudget, checkReadiness, checkTaskDependencies, claimLock, completeWithProviderFallback, createHandoff, evaluateWorkflowGate, executeNextReadyTask, executePlanWithBudgetPreflight, executeReadyTaskBatch, generateExecutionPlan, generatePlaywrightTestPlan, generatePullRequestSummary, generateTaskGraphPlan, getUsageReport, getWorkflowStatus, getWorkflowSummary, getTaskContext, getWorkflowConfig, listEvidence, listConfiguredModelProviders, listDecisions, listLocks, listApprovals, listReviews, listRoles, listTasks, rejectApproval, recordReview, recordModelProvenance, recordDecision, releaseLock, setRoleModelProvider, showApproval, updateTask, listModelProvenance, } from "./workflow-services.js";
 import { validateWorkspace } from "./workspace-validator.js";
@@ -19,6 +24,7 @@ import { listCommandManifest } from "./command-manifest.js";
 import { listRuntimeAdapters, parseRuntimeTarget } from "./runtime-adapters.js";
 import { renderRuntimeBootstrap, upsertRuntimeBootstrapBlock, } from "./runtime-bootstrap.js";
 import { disableTelemetryConsent, enableTelemetryConsent, exportTelemetryDataset, exportTelemetryEvalDataset, getTelemetryConsent, parseTelemetryLevel, requiresSensitiveTelemetryOptIn, submitTelemetryDataset, } from "./telemetry.js";
+import { buildPrBody, createPullRequest } from "./github.js";
 export async function initCommand(options, io) {
     const root = stringOption(options["target-dir"]) ?? process.cwd();
     const input = {
@@ -1057,6 +1063,425 @@ export async function skillsRenderCommand(options, io) {
 function parseSkillRenderTarget(value) {
     return parseRuntimeTarget(value);
 }
+// --- Autonomous workflow commands ---
+const GATE_MODES = ["none", "phase", "all"];
+export async function workflowRunCommand(options, io) {
+    const cwd = process.cwd();
+    const taskId = requireArg(options, "task");
+    const gates = (stringOption(options.gates) ?? "phase");
+    const maxIterations = numberOption(options["max-iterations"], 5);
+    const file = autonomousRunsPath(cwd);
+    if (!GATE_MODES.includes(gates)) {
+        throw new Error(`--gates must be one of: ${GATE_MODES.join(", ")}`);
+    }
+    if (options["dry-run"]) {
+        return workflowDryRun(options, io, taskId, gates, maxIterations);
+    }
+    let run;
+    let startIndex;
+    if (options.resume) {
+        const existing = await readAutonomousRun(cwd, String(options.resume));
+        if (!existing)
+            throw new Error(`workflow run not found: ${String(options.resume)}`);
+        run = existing;
+        startIndex = resumePhaseIndex(run);
+        if (startIndex === -1) {
+            io.log(`Workflow ${run.id} is already complete`);
+            if (options.json)
+                io.log(JSON.stringify({ run, file, cwd }, null, 2));
+            return;
+        }
+        io.log(`Resuming run ${run.id} from phase ${AUTONOMOUS_PHASE_SEQUENCE[startIndex]?.phase}`);
+    }
+    else {
+        run = await createAutonomousRun(cwd, { taskId, gates, maxIterations });
+        startIndex = 0;
+        io.log(`Started autonomous workflow ${run.id} for task ${taskId} [gates=${gates}]`);
+    }
+    run = await executePhases(cwd, run, startIndex, io);
+    const result = { run, file, cwd };
+    if (options.json) {
+        io.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    io.log(run.status === "done"
+        ? `Workflow complete [run=${run.id}]`
+        : run.status === "paused"
+            ? `Workflow paused — approve gate review then run: orchestra workflow run --task ${taskId} --resume ${run.id}`
+            : `Workflow ${run.status} [run=${run.id}]`);
+}
+export async function workflowRunListCommand(options, io) {
+    const cwd = process.cwd();
+    const runs = await listAutonomousRuns(cwd);
+    if (options.json) {
+        io.log(JSON.stringify(runs, null, 2));
+        return;
+    }
+    if (runs.length === 0) {
+        io.log("No workflow runs");
+        return;
+    }
+    for (const run of runs) {
+        const phases = run.phases.map((p) => `${p.phase}:${p.status}`).join(" → ");
+        io.log(`${run.id} [${run.status}] task=${run.taskId} gates=${run.gates}`);
+        if (phases)
+            io.log(`  ${phases}`);
+    }
+}
+const CLARIFICATION_TARGETS = ["po", "architect"];
+const CLARIFICATION_ALLOWED_PHASES = new Set(["developer", "qa"]);
+export async function workflowClarifyCommand(options, io) {
+    const cwd = process.cwd();
+    const runId = requireArg(options, "run");
+    const from = requireArg(options, "from");
+    const to = requireArg(options, "to");
+    const question = requireArg(options, "question");
+    if (!CLARIFICATION_TARGETS.includes(to)) {
+        throw new Error(`--to must be one of: ${CLARIFICATION_TARGETS.join(", ")}`);
+    }
+    const run = await readAutonomousRun(cwd, runId);
+    if (!run)
+        throw new Error(`workflow run not found: ${runId}`);
+    // Find the active phase (running or already awaiting_clarification)
+    const activePhaseIdx = run.phases.findIndex((p) => p.role === from &&
+        (p.status === "running" || p.status === "awaiting_clarification"));
+    if (activePhaseIdx === -1) {
+        throw new Error(`no active phase found for role ${from} in run ${runId}`);
+    }
+    const activePhase = run.phases[activePhaseIdx];
+    if (!CLARIFICATION_ALLOWED_PHASES.has(activePhase.phase)) {
+        throw new Error(`clarification is only allowed from developer or qa phases (active: ${activePhase.phase})`);
+    }
+    // Open clarification record
+    const record = await openClarification(cwd, {
+        runId,
+        taskId: run.taskId,
+        fromRole: from,
+        to,
+        question,
+    });
+    // Suspend the phase if it's still running
+    if (activePhase.status === "running") {
+        const phaseSeqIdx = AUTONOMOUS_PHASE_SEQUENCE.findIndex((d) => d.phase === activePhase.phase);
+        await suspendPhaseForClarification(cwd, run, phaseSeqIdx);
+    }
+    if (options.json) {
+        io.log(JSON.stringify(record, null, 2));
+        return;
+    }
+    io.log(`Clarification ${record.id} opened — waiting for ${record.toRole}`);
+    io.log(`  Question: ${record.question}`);
+    io.log(`  Respond with:`);
+    io.log(`  orchestra workflow clarify-respond --run ${runId} --clarification ${record.id} --answer "<text>"`);
+}
+export async function workflowClarifyRespondCommand(options, io) {
+    const cwd = process.cwd();
+    const runId = requireArg(options, "run");
+    const clarificationId = requireArg(options, "clarification");
+    const answer = requireArg(options, "answer");
+    const run = await readAutonomousRun(cwd, runId);
+    if (!run)
+        throw new Error(`workflow run not found: ${runId}`);
+    const record = await answerClarification(cwd, {
+        id: clarificationId,
+        answer,
+    });
+    // Resume the suspended phase back to running
+    const phaseSeqIdx = AUTONOMOUS_PHASE_SEQUENCE.findIndex((d) => d.role === record.fromRole);
+    if (phaseSeqIdx !== -1) {
+        const phase = run.phases.find((p) => p.role === record.fromRole);
+        if (phase?.status === "awaiting_clarification") {
+            await resumePhaseFromClarification(cwd, run, phaseSeqIdx);
+        }
+    }
+    if (options.json) {
+        io.log(JSON.stringify(record, null, 2));
+        return;
+    }
+    io.log(`Clarification ${record.id} answered`);
+    io.log(`  Answer: ${record.answer}`);
+    io.log(`  Resume with:`);
+    io.log(`  orchestra workflow run --task ${run.taskId} --resume ${runId}`);
+}
+export async function workflowClarifyListCommand(options, io) {
+    const cwd = process.cwd();
+    const runId = requireArg(options, "run");
+    const clarifications = await listClarifications(cwd, runId);
+    if (options.json) {
+        io.log(JSON.stringify(clarifications, null, 2));
+        return;
+    }
+    if (clarifications.length === 0) {
+        io.log(`No clarifications for run ${runId}`);
+        return;
+    }
+    for (const c of clarifications) {
+        const status = c.status === "answered" ? "✓" : "⏳";
+        io.log(`${status} [${c.id}] ${c.fromRole} → ${c.toRole}`);
+        io.log(`  Q: ${c.question}`);
+        if (c.answer)
+            io.log(`  A: ${c.answer}`);
+    }
+}
+const DEV_PHASE_INDEX = AUTONOMOUS_PHASE_SEQUENCE.findIndex((d) => d.phase === "developer");
+async function executePhases(cwd, run, startIndex, io) {
+    let current = run;
+    let qaFailNotes;
+    for (let i = startIndex; i < AUTONOMOUS_PHASE_SEQUENCE.length; i++) {
+        const def = AUTONOMOUS_PHASE_SEQUENCE[i];
+        // Init phase task (skip if already has a running/done/clarification record from resume)
+        const existing = current.phases.find((p) => p.phase === def.phase && p.status !== "qa_failed");
+        if (!existing || existing.status === "pending") {
+            const retryContext = def.phase === "developer" && qaFailNotes ? qaFailNotes : undefined;
+            const phaseRecord = await initPhase(cwd, current, i, retryContext);
+            current = { ...current, phases: [...current.phases, phaseRecord] };
+            if (retryContext) {
+                io.log(`↺ ${def.phase} (${def.role}) retry — QA findings: ${retryContext.slice(0, 80)}`);
+            }
+            else {
+                io.log(`→ ${def.phase} (${def.role}) task=${phaseRecord.taskId}`);
+            }
+        }
+        else if (existing.status === "awaiting_clarification") {
+            io.log(`↺ ${def.phase} (${def.role}) resuming after clarification`);
+        }
+        // Architect sizing gate — always enforced regardless of --gates mode
+        if (def.phase === "architect") {
+            const sizing = await checkArchitectSizing(cwd, current.taskId);
+            if (!sizing.found) {
+                io.log(`⚠ Architect phase requires a sizing decision before handoff to developer.`);
+                io.log(`  Record one with:`);
+                io.log(`  orchestra decision add --task ${current.taskId} --owner architect --title "Story sizing" --decision "<xs|s|m|l|xl> [N points]" --context "..." --consequences "..." --status accepted`);
+                io.log(`  Then resume: orchestra workflow run --task ${current.taskId} --resume ${current.id}`);
+                current = await markRunFailed(cwd, current, "Architect sizing decision required before developer handoff");
+                return current;
+            }
+            io.log(`  ✓ sizing=${sizing.sizing}${sizing.points !== undefined ? ` (${sizing.points} pts)` : ""}`);
+        }
+        // QA loop guard
+        if (def.phase === "qa" && current.qaIterations >= current.maxIterations) {
+            io.log(`✗ QA failed after ${current.maxIterations} iterations — workflow blocked`);
+            current = await markRunFailed(cwd, current, `Max QA iterations (${current.maxIterations}) reached`);
+            return current;
+        }
+        // Determine outcome — QA phase can fail and route back to developer
+        // When LLM execution lands (ORCH-019), this will be the actual QA verdict.
+        // For now the outcome is always done; qa_fail is exercised via tests/simulation.
+        const outcome = {
+            kind: "done",
+            notes: def.summary,
+        };
+        const result = await closePhase(cwd, current, i, outcome);
+        current = result.run;
+        if (result.handoffArtifact) {
+            io.log(`  ✓ handoff → ${AUTONOMOUS_PHASE_SEQUENCE[i + 1]?.role ?? "end"} (${result.handoffArtifact})`);
+        }
+        if (result.reviewArtifact) {
+            io.log(`  ⏸ gate ${def.phase}→${AUTONOMOUS_PHASE_SEQUENCE[i + 1]?.phase} — review: ${result.reviewArtifact}`);
+            io.log(`  Approve: orchestra workflow run --task ${current.taskId} --resume ${current.id}`);
+            return current;
+        }
+        // QA failure — loop back to developer with findings as context
+        const closedPhase = current.phases.find((p) => p.phase === def.phase && p.status === "qa_failed");
+        if (closedPhase) {
+            qaFailNotes = closedPhase.notes ?? "QA findings — see QA phase artifact";
+            io.log(`  ✗ qa failed (iteration ${current.qaIterations}/${current.maxIterations}) — routing back to developer`);
+            i = DEV_PHASE_INDEX - 1; // will be incremented to DEV_PHASE_INDEX at top of loop
+            continue;
+        }
+        // Release phase: auto-create PR if configured
+        if (def.phase === "release") {
+            const config = await getWorkflowConfig(cwd);
+            if (config.github?.autoCreatePr) {
+                try {
+                    const prSummary = await generatePullRequestSummary(current.taskId, cwd);
+                    const prBody = buildPrBody(prSummary, current.qaIterations);
+                    const prTitle = `${current.taskId}: ${prSummary.task.title}`;
+                    const prResult = await createPullRequest({
+                        title: prTitle,
+                        body: prBody,
+                        ...(config.github.baseBranch
+                            ? { baseBranch: config.github.baseBranch }
+                            : {}),
+                    });
+                    await addEvidence({
+                        task: current.taskId,
+                        role: "release_manager",
+                        type: "report",
+                        summary: `PR created: ${prResult.url}`,
+                    }, cwd);
+                    io.log(`  ✓ PR created: ${prResult.url}`);
+                }
+                catch (err) {
+                    io.log(`  ⚠ PR creation failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
+    }
+    current = await markRunDone(cwd, current);
+    return current;
+}
+async function workflowDryRun(options, io, taskId, gates, maxIterations) {
+    const gateTransitions = new Set(["po→architect", "qa→release"]);
+    io.log(`Dry run — no records will be created`);
+    io.log(`Task: ${taskId}  gates: ${gates}  max-iterations: ${maxIterations}`);
+    io.log(``);
+    for (let i = 0; i < AUTONOMOUS_PHASE_SEQUENCE.length; i++) {
+        const def = AUTONOMOUS_PHASE_SEQUENCE[i];
+        const next = AUTONOMOUS_PHASE_SEQUENCE[i + 1];
+        const transitionKey = next ? `${def.phase}→${next.phase}` : "";
+        const gateLabel = gates === "all"
+            ? "gate=yes"
+            : gates === "phase" && gateTransitions.has(transitionKey)
+                ? "gate=yes"
+                : "gate=no";
+        io.log(`  ${def.phase} (${def.role})  ${gateLabel}`);
+    }
+    if (options.json) {
+        io.log(JSON.stringify({
+            dryRun: true,
+            taskId,
+            gates,
+            maxIterations,
+            phases: AUTONOMOUS_PHASE_SEQUENCE,
+        }, null, 2));
+    }
+}
+// --- Estimate & Benchmark commands ---
+const CONFIDENCE_LEVELS = ["low", "medium", "high"];
+export async function estimateCommand(options, io) {
+    const cwd = process.cwd();
+    const taskId = requireArg(options, "task");
+    const sizingRaw = requireArg(options, "sizing");
+    const soloDays = numberOption(options["solo-days"], 0);
+    const aiDays = numberOption(options["ai-unguided-days"], 0);
+    const confidence = (stringOption(options.confidence) ??
+        "medium");
+    const declaredBy = stringOption(options["declared-by"]) ?? "pm";
+    if (!SIZING_LABELS.includes(sizingRaw)) {
+        throw new Error(`--sizing must be one of: ${SIZING_LABELS.join(", ")}`);
+    }
+    if (!CONFIDENCE_LEVELS.includes(confidence)) {
+        throw new Error(`--confidence must be one of: ${CONFIDENCE_LEVELS.join(", ")}`);
+    }
+    if (soloDays <= 0)
+        throw new Error(`--solo-days must be > 0`);
+    if (aiDays <= 0)
+        throw new Error(`--ai-unguided-days must be > 0`);
+    const record = await recordEstimate(cwd, {
+        taskId,
+        sizingLabel: sizingRaw,
+        soloEstimateDays: soloDays,
+        aiUnguidedEstimateDays: aiDays,
+        confidence,
+        declaredBy,
+    });
+    if (options.json) {
+        io.log(JSON.stringify(record, null, 2));
+        return;
+    }
+    io.log(`Estimate recorded for ${taskId} [${record.id}]`);
+    io.log(`  Sizing:      ${record.sizingLabel}`);
+    io.log(`  Solo:        ${record.soloEstimateDays}d`);
+    io.log(`  AI-unguided: ${record.aiUnguidedEstimateDays}d`);
+    io.log(`  Confidence:  ${record.confidence}`);
+    io.log(`  Declared by: ${record.declaredBy}`);
+}
+export async function benchmarkCommand(options, io) {
+    const cwd = process.cwd();
+    if (options.summary) {
+        const summary = await summarizeBenchmark(cwd);
+        if (options.json) {
+            io.log(JSON.stringify(summary, null, 2));
+            return;
+        }
+        if (summary.stories.length === 0) {
+            io.log("No estimates recorded yet. Use: orchestra estimate --task <id> ...");
+            return;
+        }
+        const header = `${"Story".padEnd(14)} ${"Size".padEnd(4)} ${"Solo".padEnd(6)} ${"AI".padEnd(6)} ${"Actual".padEnd(8)} ${"vs Solo".padEnd(8)} ${"vs AI".padEnd(8)} ${"QA".padEnd(4)} ${"Rev".padEnd(4)} ${"Blk".padEnd(4)} ${"Ev".padEnd(4)} ${"Les"}`;
+        io.log(header);
+        io.log("─".repeat(header.length));
+        for (const s of summary.stories) {
+            const actual = s.actualDays !== null ? `${s.actualDays}d` : "pending";
+            const vsSolo = s.vsSoloPct !== null
+                ? `${s.vsSoloPct > 0 ? "+" : ""}${s.vsSoloPct}%`
+                : "—";
+            const vsAi = s.vsAiUnguidedPct !== null
+                ? `${s.vsAiUnguidedPct > 0 ? "+" : ""}${s.vsAiUnguidedPct}%`
+                : "—";
+            io.log(`${s.taskId.padEnd(14)} ${s.sizingLabel.padEnd(4)} ${`${s.soloEstimateDays}d`.padEnd(6)} ${`${s.aiUnguidedEstimateDays}d`.padEnd(6)} ${actual.padEnd(8)} ${vsSolo.padEnd(8)} ${vsAi.padEnd(8)} ${String(s.qaIterations).padEnd(4)} ${String(s.quality.reviewCount).padEnd(4)} ${String(s.quality.blockingReviews).padEnd(4)} ${String(s.quality.evidenceCount).padEnd(4)} ${s.quality.lessonCount}`);
+        }
+        if (summary.totalWithActuals > 0) {
+            io.log("");
+            io.log(`Avg savings vs solo:        ${summary.avgVsSoloPct}%`);
+            io.log(`Avg savings vs AI-unguided: ${summary.avgVsAiUnguidedPct}%`);
+            io.log(`Stories with actuals:       ${summary.totalWithActuals}/${summary.stories.length}`);
+        }
+        return;
+    }
+    const taskId = requireArg(options, "task");
+    const result = await computeBenchmark(cwd, taskId);
+    if (options.json) {
+        io.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    io.log(`Benchmark: ${taskId}  [${result.status}]`);
+    io.log(`  Sizing:      ${result.sizingLabel}`);
+    io.log(`  Solo:        ${result.soloEstimateDays}d  (declared)`);
+    io.log(`  AI-unguided: ${result.aiUnguidedEstimateDays}d  (declared)`);
+    io.log(`  Actual:      ${result.actualDays !== null ? `${result.actualDays}d` : "pending — run not complete"}`);
+    if (result.vsSoloPct !== null) {
+        const sign = result.vsSoloPct > 0 ? "+" : "";
+        io.log(`  vs Solo:     ${sign}${result.vsSoloPct}%`);
+        io.log(`  vs AI:       ${result.vsAiUnguidedPct !== null ? `${result.vsAiUnguidedPct > 0 ? "+" : ""}${result.vsAiUnguidedPct}%` : "—"}`);
+    }
+    io.log(`  QA loops:    ${result.qaIterations}`);
+    io.log(`  Reviews:     ${result.quality.reviewCount} (${result.quality.blockingReviews} blocking)`);
+    io.log(`  Evidence:    ${result.quality.evidenceCount} artifacts`);
+    io.log(`  Gate blocks: ${result.quality.gateBlockCount}`);
+    io.log(`  Lessons:     ${result.quality.lessonCount}`);
+    if (result.quality.totalInputTokens > 0 ||
+        result.quality.totalOutputTokens > 0) {
+        io.log(`  Tokens:      ${result.quality.totalInputTokens}in / ${result.quality.totalOutputTokens}out`);
+        io.log(`  Cost:        $${result.quality.estimatedCostUsd}`);
+    }
+}
+// --- Burndown command ---
+export async function burndownCommand(options, io) {
+    const cwd = process.cwd();
+    const sprintCsv = requireArg(options, "sprint");
+    const sprintTaskIds = sprintCsv
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    if (sprintTaskIds.length === 0)
+        throw new Error(`--sprint requires at least one task id`);
+    const series = await computeSprintBurndown(cwd, sprintTaskIds);
+    if (options.json) {
+        io.log(JSON.stringify(series, null, 2));
+        return;
+    }
+    for (const w of series.warnings)
+        io.log(`⚠ ${w}`);
+    if (series.totalPoints === 0) {
+        io.log("No points to chart — record estimates first with: orchestra estimate --task <id> ...");
+        return;
+    }
+    io.log(`Sprint burndown  total=${series.totalPoints} pts  tasks=${series.sprintTaskIds.length}`);
+    io.log("");
+    io.log(renderBurndownAscii(series));
+    io.log("");
+    io.log("Task breakdown:");
+    for (const t of series.taskBreakdown) {
+        const arch = t.architectPoints !== null ? `arch=${t.architectPoints}` : "arch=—";
+        const dev = t.developerPoints !== null ? `dev=${t.developerPoints}` : "dev=—";
+        const done = t.completedAt
+            ? `done ${t.completedAt.slice(0, 10)}`
+            : "pending";
+        io.log(`  ${t.taskId.padEnd(14)} ${arch.padEnd(10)} ${dev.padEnd(10)} resolved=${t.resolvedPoints}  ${done}`);
+    }
+}
 function parseRuntimeTargetOptions(options) {
     const targetValues = [
         ...parseCsv(options.target),