@jterrats/open-orchestra 0.3.1 → 0.4.1

package/dist/commands.js

@@ -1,29 +1,23 @@
-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 { executePhaseWithLlm } from "./phase-executor.js";
+import { addEvidence, addPlaywrightEvidence, addTask, checkReadiness, checkTaskDependencies, claimLock, createHandoff, evaluateWorkflowGate, executeNextReadyTask, executePlanWithBudgetPreflight, executeReadyTaskBatch, generateExecutionPlan, generatePlaywrightTestPlan, generatePullRequestSummary, generateTaskGraphPlan, getWorkflowStatus, getWorkflowSummary, getTaskContext, getWorkflowConfig, listEvidence, listDecisions, listLocks, listReviews, listRoles, listTasks, recordReview, recordDecision, releaseLock, updateTask, } from "./workflow-services.js";
 import { validateWorkspace } from "./workspace-validator.js";
-import { addAgentLesson, listAgentLessons, listSkills, planSkillsForTask, promoteAgentLessons, readSourceOfTruth, recordSkillPlan, recordSkillRender, renderSkills, validateSkills, } from "./skills.js";
 import { getWebServerAddress, startWebApiServer } from "./web-api.js";
 import { decideTaskDelegation } from "./delegation-decision.js";
-import { lintMermaidDiagram, recordDiagramLintEvidence, } from "./diagram-validation.js";
-import { evaluateMcpOAuthProxy, } from "./mcp-oauth-proxy.js";
-import { detectStaleInstructionFilesFromManifest, resolveInstructionImportsFromFile, updateManagedInstructionFile, } from "./instruction-updates.js";
-import { applyInstructionUpdatesFromManifest } from "./instruction-apply.js";
-import { renderSubagentProtocol, upsertSubagentProtocolBlock, } from "./subagent-protocol.js";
 import { listCollaborationFlows, recommendCollaborationFlow, } from "./collaboration-flows.js";
 import { listWorkflowTemplates, renderWorkflowTemplates, selectWorkflowTemplates, validateWorkflowTemplates, } from "./workflow-templates.js";
-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 { parseRuntimeTarget } from "./runtime-adapters.js";
+export { instructionsApplyCommand, instructionsBlockCommand, instructionsImportsCommand, instructionsStaleCommand, } from "./instruction-commands.js";
+export { benchmarkCommand, estimateCommand } from "./metrics-commands.js";
+export { burndownCommand, calibrationCommand, sprintCommand, velocityCommand, } from "./sprint-commands.js";
+export { approvalsApproveCommand, approvalsListCommand, approvalsRejectCommand, approvalsShowCommand, budgetCheckCommand, configShowCommand, modelCompleteFakeCommand, modelProvidersCommand, modelProvenanceAddCommand, modelProvenanceListCommand, modelSetRoleCommand, usageCommand, } from "./model-commands.js";
+export { commandsManifestCommand, protocolBlockCommand, protocolRenderCommand, runtimeAdaptersCommand, runtimeBootstrapCommand, runtimeBriefCommand, runtimeDelegatePlanCommand, runtimeHandoffCommand, } from "./runtime-commands.js";
+export { lessonsAddCommand, lessonsListCommand, lessonsPromoteCommand, skillsListCommand, skillsPlanCommand, skillsRenderCommand, skillsValidateCommand, sourcesListCommand, } from "./skills-commands.js";
+export { diagramsLintCommand, mcpOAuthProxyEvaluateCommand, } from "./tool-commands.js";
+export { telemetryDisableCommand, telemetryEnableCommand, telemetryEvalDatasetCommand, telemetryExportCommand, telemetryStatusCommand, telemetrySubmitCommand, } from "./telemetry-commands.js";
 import { buildPrBody, createPullRequest } from "./github.js";
 export async function initCommand(options, io) {
     const root = stringOption(options["target-dir"]) ?? process.cwd();
@@ -347,56 +341,6 @@ export async function summaryCommand(options, io) {
     }
     io.log(renderSummaryMarkdown(summary));
 }
-export async function usageCommand(options, io) {
-    const report = await getUsageReport(stringOption(options.task));
-    if (options.json) {
-        io.log(JSON.stringify(report, null, 2));
-        return;
-    }
-    io.log(renderUsageReport(report));
-}
-export async function budgetCheckCommand(options, io) {
-    const result = await checkUsageBudget(stringOption(options.task));
-    if (options.json) {
-        io.log(JSON.stringify(result, null, 2));
-    }
-    else {
-        io.log(renderBudgetCheck(result));
-    }
-    if (!result.passed) {
-        throw new Error("budget check failed");
-    }
-}
-export async function approvalsListCommand(options, io) {
-    const approvals = await listApprovals(stringOption(options.task));
-    if (options.json) {
-        io.log(JSON.stringify(approvals, null, 2));
-        return;
-    }
-    if (approvals.length === 0) {
-        io.log("No approvals");
-        return;
-    }
-    for (const approval of approvals) {
-        io.log(`${approval.id} [${approval.status}] ${approval.taskId ?? "no-task"} ${approval.artifact}`);
-    }
-}
-export async function approvalsShowCommand(options, io) {
-    const approval = await showApproval(requireArg(options, "id"));
-    if (options.json) {
-        io.log(JSON.stringify(approval, null, 2));
-        return;
-    }
-    io.log(approval.content);
-}
-export async function approvalsApproveCommand(options, io) {
-    const approval = await approveApproval(parseApprovalDecision(options));
-    io.log(`Approved ${approval.id}`);
-}
-export async function approvalsRejectCommand(options, io) {
-    const approval = await rejectApproval(parseApprovalDecision(options));
-    io.log(`Rejected ${approval.id}`);
-}
 export async function prSummaryCommand(options, io) {
     const summary = await generatePullRequestSummary(requireArg(options, "task"));
     if (options.json) {
@@ -458,254 +402,6 @@ export async function playwrightEvidenceCommand(options, io) {
     }));
     io.log(`Created ${artifact}`);
 }
-export async function configShowCommand(options, io) {
-    const config = await getWorkflowConfig();
-    if (options.json) {
-        io.log(JSON.stringify(config, null, 2));
-        return;
-    }
-    io.log(`Tools: ${Object.keys(config.tools ?? {}).length}`);
-    io.log(`Role routes: ${Object.keys(config.providers?.byRole ?? {}).length}`);
-}
-export async function modelProvidersCommand(options, io) {
-    const providers = await listConfiguredModelProviders();
-    if (options.json) {
-        io.log(JSON.stringify(providers, null, 2));
-        return;
-    }
-    if (providers.length === 0) {
-        io.log("No configured model providers");
-        return;
-    }
-    for (const provider of providers) {
-        io.log(`${provider.scope}: ${provider.provider}/${provider.model} (${provider.timeoutMs}ms)`);
-    }
-}
-export async function modelSetRoleCommand(options, io) {
-    const role = requireArg(options, "role");
-    const routing = parseProviderRouting(options);
-    await setRoleModelProvider(role, routing);
-    io.log(`Configured model provider for ${role}`);
-}
-export async function modelProvenanceAddCommand(options, io) {
-    const record = await recordModelProvenance({
-        task: requireArg(options, "task"),
-        role: requireArg(options, "role"),
-        provider: requireArg(options, "provider"),
-        model: requireArg(options, "model"),
-        promptId: requireArg(options, "prompt-id"),
-        responseId: requireArg(options, "response-id"),
-        inputTokens: numberOption(options["input-tokens"], 0),
-        outputTokens: numberOption(options["output-tokens"], 0),
-        estimatedCostUsd: numberOption(options["estimated-cost-usd"], 0),
-        finishReason: requireArg(options, "finish-reason"),
-    });
-    io.log(`Recorded model provenance ${record.responseId}`);
-}
-export async function modelProvenanceListCommand(options, io) {
-    const records = await listModelProvenance(stringOption(options.task));
-    if (options.json) {
-        io.log(JSON.stringify(records, null, 2));
-        return;
-    }
-    if (records.length === 0) {
-        io.log("No model provenance");
-        return;
-    }
-    for (const record of records) {
-        io.log(`${record.task} ${record.role} ${record.provider}/${record.model} ${record.responseId}`);
-    }
-}
-export async function modelCompleteFakeCommand(options, io) {
-    const result = await completeWithProviderFallback({
-        provider: requireArg(options, "provider"),
-        model: requireArg(options, "model"),
-        fallbacks: parseCsv(options.fallbacks),
-        maxTokens: 0,
-        maxCostUsd: 0,
-        timeoutMs: 30000,
-        retries: 0,
-        requiredCapabilities: [],
-    }, requireArg(options, "prompt"), removeUndefined({
-        failingProviders: parseCsv(options["fail-provider"]),
-        taskId: stringOption(options.task),
-        role: stringOption(options.role) ?? "parent",
-    }));
-    if (options.json) {
-        io.log(JSON.stringify(result, null, 2));
-        return;
-    }
-    io.log(`Fake completion used ${result.provider}/${result.model} fallback=${String(result.fallbackUsed)}`);
-}
-export async function telemetryStatusCommand(options, io) {
-    const telemetry = await getTelemetryConsent();
-    if (options.json) {
-        io.log(JSON.stringify(telemetry, null, 2));
-        return;
-    }
-    io.log("Telemetry: " + (telemetry.enabled ? "enabled" : "off"));
-    io.log("Level: " + telemetry.level);
-    io.log("Policy: " + telemetry.policyVersion);
-}
-export async function telemetryEnableCommand(options, io) {
-    const level = parseTelemetryLevel(stringOption(options.level) ?? "metadata");
-    if (requiresSensitiveTelemetryOptIn(level) && !options["confirm-sensitive"]) {
-        throw new Error("prompt-sample and eval-dataset telemetry require --confirm-sensitive");
-    }
-    const telemetry = await enableTelemetryConsent({
-        level,
-        actor: stringOption(options.actor) ?? "user",
-    });
-    if (options.json) {
-        io.log(JSON.stringify(telemetry, null, 2));
-        return;
-    }
-    io.log("Telemetry enabled at level " + telemetry.level);
-}
-export async function telemetryExportCommand(options, io) {
-    const result = await exportTelemetryDataset({
-        dryRun: Boolean(options["dry-run"]),
-    });
-    if (options.json) {
-        io.log(JSON.stringify(result, null, 2));
-        return;
-    }
-    io.log((result.dryRun ? "Telemetry export dry run" : "Telemetry exported") +
-        ": " +
-        result.recordCount +
-        " record(s)");
-    if (result.file) {
-        io.log("File: " + result.file);
-    }
-}
-export async function telemetrySubmitCommand(options, io) {
-    const result = await submitTelemetryDataset({
-        file: requireArg(options, "file"),
-        endpoint: requireArg(options, "endpoint"),
-    });
-    if (options.json) {
-        io.log(JSON.stringify(result, null, 2));
-        return;
-    }
-    io.log("Telemetry submission recorded: " + result.fileHash);
-}
-export async function telemetryEvalDatasetCommand(options, io) {
-    const result = await exportTelemetryEvalDataset({
-        dryRun: Boolean(options["dry-run"]),
-    });
-    if (options.json) {
-        io.log(JSON.stringify(result, null, 2));
-        return;
-    }
-    io.log((result.dryRun ? "Eval dataset dry run" : "Eval dataset exported") +
-        ": " +
-        result.recordCount +
-        " record(s)");
-    if (result.file) {
-        io.log("File: " + result.file);
-    }
-}
-export async function telemetryDisableCommand(options, io) {
-    const telemetry = await disableTelemetryConsent({
-        actor: stringOption(options.actor) ?? "user",
-    });
-    if (options.json) {
-        io.log(JSON.stringify(telemetry, null, 2));
-        return;
-    }
-    io.log("Telemetry disabled");
-}
-export async function instructionsApplyCommand(options, io) {
-    const report = await applyInstructionUpdatesFromManifest({
-        manifestPath: requireArg(options, "manifest"),
-        check: Boolean(options.check),
-        dryRun: Boolean(options["dry-run"]),
-        force: Boolean(options.force),
-    });
-    if (options.json) {
-        io.log(JSON.stringify(report, null, 2));
-        return;
-    }
-    io.log("Instruction update " +
-        report.mode +
-        ": " +
-        report.totals.changed +
-        " changed, " +
-        report.totals.unchanged +
-        " unchanged, " +
-        report.totals.blocked +
-        " blocked");
-    for (const item of report.items) {
-        io.log(item.status +
-            " " +
-            item.filePath +
-            "#" +
-            item.blockId +
-            " - " +
-            item.reason);
-    }
-}
-export async function instructionsStaleCommand(options, io) {
-    const report = await detectStaleInstructionFilesFromManifest({
-        manifestPath: requireArg(options, "manifest"),
-    });
-    if (options.json) {
-        io.log(JSON.stringify(report, null, 2));
-        return;
-    }
-    io.log("Instruction file status:");
-    for (const item of report.items) {
-        io.log(item.status +
-            " " +
-            item.filePath +
-            "#" +
-            item.blockId +
-            " - " +
-            item.reason);
-    }
-}
-export async function instructionsBlockCommand(options, io) {
-    const result = await updateManagedInstructionFile({
-        filePath: resolveWorkspaceWritePath(process.cwd(), requireArg(options, "file")),
-        contentPath: resolveWorkspaceWritePath(process.cwd(), requireArg(options, "content-file")),
-        input: {
-            blockId: requireArg(options, "block"),
-            generator: stringOption(options.generator) ?? "open-orchestra",
-            version: stringOption(options.version) ?? "1",
-            target: parseInstructionTarget(stringOption(options.target) ?? "generic"),
-            sourceManifest: stringOption(options["source-manifest"]) ?? "local",
-        },
-        check: Boolean(options.check),
-        dryRun: Boolean(options["dry-run"]),
-        force: Boolean(options.force),
-    });
-    if (options.json) {
-        io.log(JSON.stringify(result, null, 2));
-        return;
-    }
-    if (result.drift) {
-        io.log("Drift detected for " + requireArg(options, "block"));
-        return;
-    }
-    io.log(result.changed
-        ? "Instruction block changed"
-        : "Instruction block unchanged");
-}
-export async function instructionsImportsCommand(options, io) {
-    const result = await resolveInstructionImportsFromFile({
-        registryPath: requireArg(options, "registry"),
-        entryId: requireArg(options, "entry"),
-        target: parseInstructionTarget(stringOption(options.target) ?? "generic"),
-    });
-    if (options.json) {
-        io.log(JSON.stringify(result, null, 2));
-        return;
-    }
-    io.log(result.content);
-}
-function parseInstructionTarget(value) {
-    return parseRuntimeTarget(value);
-}
 export async function collaborationFlowsCommand(options, io) {
     const flows = listCollaborationFlows();
     if (options.json) {
@@ -786,283 +482,6 @@ export async function workflowTemplateRenderCommand(options, io) {
     }
     io.log(rendered.content);
 }
-export async function commandsManifestCommand(options, io) {
-    const manifest = listCommandManifest();
-    if (options.json) {
-        io.log(JSON.stringify(manifest, null, 2));
-        return;
-    }
-    for (const command of manifest) {
-        io.log(command.command + " - " + command.summary);
-    }
-}
-export async function runtimeAdaptersCommand(options, io) {
-    const adapters = listRuntimeAdapters();
-    if (options.json) {
-        io.log(JSON.stringify(adapters, null, 2));
-        return;
-    }
-    for (const adapter of adapters) {
-        io.log(adapter.target +
-            " - " +
-            adapter.label +
-            " (" +
-            adapter.defaultInstructionFiles.join(", ") +
-            ")");
-    }
-}
-export async function runtimeBootstrapCommand(options, io) {
-    const target = parseSkillRenderTarget(stringOption(options.target) ?? "generic");
-    const bootstrap = renderRuntimeBootstrap(target);
-    const filePath = stringOption(options.file);
-    if (filePath) {
-        const resolvedFilePath = resolveWorkspaceWritePath(process.cwd(), path.normalize(filePath));
-        const existing = await readFile(resolvedFilePath, "utf8").catch(() => "");
-        const result = upsertRuntimeBootstrapBlock(existing, bootstrap, {
-            force: Boolean(options.force),
-        });
-        if (!options.check && !options["dry-run"] && !result.drift) {
-            await writeFile(resolvedFilePath, result.content);
-        }
-        if (options.json) {
-            io.log(JSON.stringify(result, null, 2));
-            return;
-        }
-        io.log(result.changed
-            ? "Runtime bootstrap changed"
-            : "Runtime bootstrap unchanged");
-        return;
-    }
-    if (options.json) {
-        io.log(JSON.stringify(bootstrap, null, 2));
-        return;
-    }
-    io.log(bootstrap.content);
-}
-export async function protocolRenderCommand(options, io) {
-    const protocol = await renderSubagentProtocol(removeUndefined({
-        target: parseSkillRenderTarget(stringOption(options.target) ?? "generic"),
-        taskId: stringOption(options.task),
-    }));
-    if (options.json) {
-        io.log(JSON.stringify(protocol, null, 2));
-        return;
-    }
-    io.log(protocol.content);
-}
-export async function protocolBlockCommand(options, io) {
-    const filePath = requireArg(options, "file");
-    const protocol = await renderSubagentProtocol(removeUndefined({
-        target: parseSkillRenderTarget(stringOption(options.target) ?? "generic"),
-        taskId: stringOption(options.task),
-    }));
-    const existing = await readFile(filePath, "utf8").catch(() => "");
-    const result = upsertSubagentProtocolBlock(existing, protocol, {
-        force: Boolean(options.force),
-    });
-    const shouldWrite = !options.check && !options["dry-run"] && !result.drift && result.changed;
-    if (shouldWrite) {
-        await writeFile(filePath, result.content);
-    }
-    if (options.json) {
-        io.log(JSON.stringify(result, null, 2));
-        return;
-    }
-    if (result.drift) {
-        io.log("Drift detected for subagent protocol block");
-        return;
-    }
-    io.log(result.changed
-        ? "Subagent protocol block changed"
-        : "Subagent protocol block unchanged");
-}
-export async function diagramsLintCommand(options, io) {
-    const result = await lintMermaidDiagram({
-        filePath: requireArg(options, "file"),
-    });
-    const evidence = stringOption(options.task)
-        ? await recordDiagramLintEvidence({
-            taskId: stringOption(options.task) ?? "",
-            result,
-        })
-        : undefined;
-    const output = removeUndefined({ result, evidence });
-    if (options.json) {
-        io.log(JSON.stringify(output, null, 2));
-    }
-    else {
-        io.log(result.valid ? "Mermaid diagram valid" : "Mermaid diagram invalid");
-        if (result.installHint) {
-            io.log(result.installHint);
-        }
-        if (evidence) {
-            io.log("Created " + evidence.artifact);
-        }
-    }
-    if (!result.valid) {
-        throw new Error("diagram lint failed");
-    }
-}
-export async function mcpOAuthProxyEvaluateCommand(options, io) {
-    const evaluation = evaluateMcpOAuthProxy(removeUndefined({
-        enabled: Boolean(options.enable),
-        mode: parseMcpProxyMode(stringOption(options.mode) ?? "stdio-proxy"),
-        serverUrl: requireArg(options, "server-url"),
-        tokenStorage: parseMcpSecretStorage(stringOption(options["token-storage"]) ?? "keychain"),
-        tokenPath: stringOption(options["token-path"]),
-        refreshWindowSeconds: Number(stringOption(options["refresh-window"]) ?? 300),
-        approvedBy: options.approve
-            ? (stringOption(options.approver) ?? "local-user")
-            : undefined,
-    }));
-    if (options.json) {
-        io.log(JSON.stringify(evaluation, null, 2));
-        return;
-    }
-    io.log(evaluation.approved
-        ? "MCP proxy plan approved"
-        : "MCP proxy plan has risks");
-    for (const risk of evaluation.risks) {
-        io.log("RISK: " + risk);
-    }
-}
-function parseMcpProxyMode(value) {
-    if (["stdio-proxy", "direct-http", "tool-native-oauth"].includes(value)) {
-        return value;
-    }
-    throw new Error("unknown MCP proxy mode: " + value);
-}
-function parseMcpSecretStorage(value) {
-    if (["keychain", "libsecret", "windows-credential", "secure-file"].includes(value)) {
-        return value;
-    }
-    throw new Error("unknown MCP secret storage: " + value);
-}
-export async function skillsValidateCommand(options, io) {
-    const report = await validateSkills();
-    if (options.json) {
-        io.log(JSON.stringify(report, null, 2));
-    }
-    else {
-        io.log(report.valid ? "Skills valid" : "Skills invalid");
-        for (const error of report.errors) {
-            io.log(`ERROR: ${error}`);
-        }
-        for (const warning of report.warnings) {
-            io.log(`WARN: ${warning}`);
-        }
-    }
-    if (!report.valid) {
-        throw new Error("skills validation failed");
-    }
-}
-export async function sourcesListCommand(options, io) {
-    const sources = await readSourceOfTruth();
-    if (options.json) {
-        io.log(JSON.stringify(sources, null, 2));
-        return;
-    }
-    for (const source of sources) {
-        io.log(`${source.id ?? "unknown"} - ${source.name ?? "Unnamed source"}`);
-        io.log(`  ${(source.locations ?? []).join(", ")}`);
-    }
-}
-export async function lessonsListCommand(options, io) {
-    const lessons = await listAgentLessons();
-    if (options.json) {
-        io.log(JSON.stringify(lessons, null, 2));
-        return;
-    }
-    if (lessons.length === 0) {
-        io.log("No lessons");
-        return;
-    }
-    for (const lesson of lessons) {
-        io.log(`${lesson.timestamp} ${lesson.operation}: ${lesson.errorSignature}`);
-    }
-}
-export async function lessonsAddCommand(options, io) {
-    const lesson = await addAgentLesson(removeUndefined({
-        taskId: stringOption(options.task),
-        actor: stringOption(options.actor) ?? "parent",
-        operation: requireArg(options, "operation"),
-        failedAction: requireArg(options, "failed-action"),
-        errorSignature: requireArg(options, "error-signature"),
-        rootCause: requireArg(options, "root-cause"),
-        fix: requireArg(options, "fix"),
-        prevention: requireArg(options, "prevention"),
-        appliesTo: parseCsv(options["applies-to"]),
-        verifiedBy: parseCsv(options["verified-by"]),
-    }));
-    if (options.json) {
-        io.log(JSON.stringify(lesson, null, 2));
-        return;
-    }
-    io.log(`Recorded lesson ${lesson.errorSignature}`);
-}
-export async function lessonsPromoteCommand(options, io) {
-    const result = await promoteAgentLessons(removeUndefined({
-        to: parsePromotionTarget(stringOption(options.to) ?? "doc"),
-        filter: stringOption(options.filter),
-    }));
-    if (options.json) {
-        io.log(JSON.stringify(result, null, 2));
-        return;
-    }
-    io.log(`Created ${result.artifact}`);
-    io.log(`Promoted lessons: ${result.lessons.length}`);
-}
-function parsePromotionTarget(value) {
-    if (["skill", "rule", "doc"].includes(value)) {
-        return value;
-    }
-    throw new Error(`unknown promotion target: ${value}`);
-}
-export async function skillsListCommand(options, io) {
-    const skills = listSkills();
-    if (options.json) {
-        io.log(JSON.stringify(skills, null, 2));
-        return;
-    }
-    for (const skill of skills) {
-        io.log(`${skill.id} - ${skill.name} (${skill.loadBudget})`);
-        io.log(`  ${skill.summary}`);
-        io.log(`  sources: ${skill.sourceGroups.join(", ")}`);
-    }
-}
-export async function skillsPlanCommand(options, io) {
-    const plan = await planSkillsForTask(requireArg(options, "task"));
-    await recordSkillPlan(plan);
-    if (options.json) {
-        io.log(JSON.stringify(plan, null, 2));
-        return;
-    }
-    io.log(`Skills for ${plan.taskId}:`);
-    for (const item of plan.selected) {
-        io.log(`  ${item.skill.id} (score ${item.score})`);
-        for (const reason of item.rationale) {
-            io.log(`    - ${reason}`);
-        }
-    }
-    io.log(`Source groups: ${plan.sourceGroups.join(", ")}`);
-}
-export async function skillsRenderCommand(options, io) {
-    const target = parseSkillRenderTarget(stringOption(options.target) ?? "generic");
-    const rendered = await renderSkills({
-        target,
-        taskId: stringOption(options.task),
-        skillIds: parseCsv(options.skills),
-    });
-    await recordSkillRender(rendered);
-    if (options.json) {
-        io.log(JSON.stringify(rendered, null, 2));
-        return;
-    }
-    io.log(rendered.content);
-}
-function parseSkillRenderTarget(value) {
-    return parseRuntimeTarget(value);
-}
 // --- Autonomous workflow commands ---
 const GATE_MODES = ["none", "phase", "all"];
 export async function workflowRunCommand(options, io) {
@@ -1104,11 +523,15 @@ export async function workflowRunCommand(options, io) {
         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}]`);
+    if (run.status === "done") {
+        io.log(`Workflow complete [run=${run.id}]`);
+    }
+    else if (run.status === "paused") {
+        io.log(`Workflow paused — approve gate review then run: orchestra workflow run --task ${taskId} --resume ${run.id}`);
+    }
+    else {
+        io.log(`Workflow ${run.status} [run=${run.id}]`);
+    }
 }
 export async function workflowRunListCommand(options, io) {
     const cwd = process.cwd();
@@ -1245,7 +668,30 @@ async function executePhases(cwd, run, startIndex, io) {
         else if (existing.status === "awaiting_clarification") {
             io.log(`↺ ${def.phase} (${def.role}) resuming after clarification`);
         }
-        // Architect sizing gate — always enforced regardless of --gates mode
+        // 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;
+        }
+        const llmResult = await executePhaseWithLlm({
+            root: cwd,
+            run: current,
+            phase: def,
+            phaseIndex: i,
+        }).catch(async (error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            io.log(`✗ ${def.phase} provider execution failed: ${message}`);
+            current = await markRunFailed(cwd, current, message);
+            return null;
+        });
+        if (!llmResult)
+            return current;
+        if (llmResult.mode === "llm") {
+            io.log(`  ✓ llm artifact (${llmResult.artifact})`);
+        }
+        // Architect sizing gate — always enforced regardless of --gates mode.
+        // In LLM mode, the architect phase records the sizing decision before this check.
         if (def.phase === "architect") {
             const sizing = await checkArchitectSizing(cwd, current.taskId);
             if (!sizing.found) {
@@ -1258,27 +704,25 @@ async function executePhases(cwd, run, startIndex, io) {
             }
             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 outcome = llmResult.outcome;
         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}`);
+            const nextPhase = AUTONOMOUS_PHASE_SEQUENCE[i + 1]?.phase;
+            io.log(`  ⏸ gate ${def.phase}→${nextPhase} — review: ${result.reviewArtifact}`);
             io.log(`  Approve: orchestra workflow run --task ${current.taskId} --resume ${current.id}`);
+            io.log(``);
+            io.log(`╔══ GATE PAUSE: ${def.phase.toUpperCase()} → ${nextPhase?.toUpperCase()} ══════════════════════`);
+            io.log(`║  Run:    ${current.id}`);
+            io.log(`║  Task:   ${current.taskId}`);
+            io.log(`║  Review: ${result.reviewArtifact}`);
+            io.log(`║`);
+            io.log(`║  To approve, run:`);
+            io.log(`║    orchestra workflow run --task ${current.taskId} --resume ${current.id}`);
+            io.log(`╚══════════════════════════════════════════════════════════════`);
             return current;
         }
         // QA failure — loop back to developer with findings as context
@@ -1347,141 +791,6 @@ async function workflowDryRun(options, io, taskId, gates, maxIterations) {
         }, 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),
@@ -1489,6 +798,9 @@ function parseRuntimeTargetOptions(options) {
     ];
     return [...new Set(targetValues)].map((target) => parseRuntimeTarget(target));
 }
+function parseSkillRenderTarget(value) {
+    return parseRuntimeTarget(value);
+}
 function parseCsv(value) {
     if (typeof value !== "string" || value.trim() === "") {
         return [];
@@ -1537,18 +849,6 @@ function parseRiskAcceptance(options) {
     });
     return Object.keys(acceptance).length > 0 ? acceptance : undefined;
 }
-function parseProviderRouting(options) {
-    return {
-        provider: requireArg(options, "provider"),
-        model: requireArg(options, "model"),
-        fallbacks: parseCsv(options.fallbacks),
-        maxTokens: numberOption(options["max-tokens"], 0),
-        maxCostUsd: numberOption(options["max-cost-usd"], 0),
-        timeoutMs: numberOption(options["timeout-ms"], 30000),
-        retries: numberOption(options.retries, 0),
-        requiredCapabilities: parseCsv(options.capabilities),
-    };
-}
 function parseBudgetEscalationDecision(options) {
     if (options["approve-budget-fallback"]) {
         return removeUndefined({
@@ -1566,13 +866,6 @@ function parseBudgetEscalationDecision(options) {
     }
     return undefined;
 }
-function parseApprovalDecision(options) {
-    return {
-        id: requireArg(options, "id"),
-        approver: requireArg(options, "approver"),
-        rationale: requireArg(options, "rationale"),
-    };
-}
 function numberOption(value, fallback) {
     if (typeof value !== "string" || value.trim() === "") {
         return fallback;
@@ -1709,43 +1002,6 @@ function renderSummaryMarkdown(summary) {
         "",
     ].join("\n");
 }
-function renderUsageReport(report) {
-    return [
-        `Usage${report.taskId ? ` for ${report.taskId}` : ""}`,
-        `- Requests: ${report.totals.requests}`,
-        `- Input tokens: ${report.totals.inputTokens}`,
-        `- Output tokens: ${report.totals.outputTokens}`,
-        `- Total tokens: ${report.totals.totalTokens}`,
-        `- Estimated cost USD: ${report.totals.estimatedCostUsd}`,
-        "",
-        "By role:",
-        ...usageLines(report.byRole),
-        "",
-        "By provider:",
-        ...usageLines(report.byProvider),
-    ].join("\n");
-}
-function renderBudgetCheck(result) {
-    return [
-        `Budget check${result.taskId ? ` for ${result.taskId}` : ""}: ${result.passed ? "passed" : "failed"}`,
-        `- Applied budgets: ${result.appliedBudgets.length > 0
-            ? result.appliedBudgets.join(", ")
-            : "none"}`,
-        `- Requests: ${result.usage.totals.requests}`,
-        `- Total tokens: ${result.usage.totals.totalTokens}`,
-        `- Estimated cost USD: ${result.usage.totals.estimatedCostUsd}`,
-        "",
-        "Violations:",
-        ...(result.violations.length === 0
-            ? ["- none"]
-            : result.violations.map((violation) => `- ${violation.scope} ${violation.metric}: ${violation.actual} > ${violation.limit}`)),
-    ].join("\n");
-}
-function usageLines(items) {
-    return items.length === 0
-        ? ["- none"]
-        : items.map((item) => `- ${item.key}: ${item.requests} requests, ${item.totalTokens} tokens, $${item.estimatedCostUsd}`);
-}
 function renderPullRequestSummaryMarkdown(summary) {
     return [
         `# PR Summary: ${summary.task.id}`,