@jterrats/open-orchestra 0.1.0

package/dist/commands.js

@@ -0,0 +1,883 @@
+import { initWorkspace } from "./workspace.js";
+import { requireArg } from "./args.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";
+import { getWebServerAddress, startWebApiServer } from "./web-api.js";
+export async function initCommand(options, io) {
+    const base = await initWorkspace({ force: Boolean(options.force) });
+    io.log(`Initialized ${base}`);
+    io.log("Next: add tasks to .agent-workflow/tasks.json and run orchestra status");
+}
+export async function statusCommand(options, io) {
+    const status = await getWorkflowStatus();
+    if (options.json) {
+        io.log(JSON.stringify(status, null, 2));
+        return;
+    }
+    io.log(`Tasks: ${status.tasks.total}`);
+    for (const [name, count] of Object.entries(status.tasks.byStatus)) {
+        io.log(`  ${name}: ${count}`);
+    }
+    io.log(`Locks: ${status.locks.total}`);
+    if (status.tasks.blocked.length > 0) {
+        io.log("Blocked:");
+        for (const task of status.tasks.blocked) {
+            io.log(`  ${task.id}: ${task.reason}`);
+        }
+    }
+}
+export async function validateCommand(options, io) {
+    const report = await validateWorkspace();
+    if (options.json) {
+        io.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        io.log(report.valid ? "Workspace valid" : "Workspace 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("workspace validation failed");
+    }
+}
+export async function webCommand(options, io) {
+    const serverOptions = {};
+    const host = stringOption(options.host);
+    if (host) {
+        serverOptions.host = host;
+    }
+    if (options.port) {
+        serverOptions.port = numberOption(options.port, 3717);
+    }
+    const server = await startWebApiServer(serverOptions);
+    io.log(`Open Orchestra web API listening at ${getWebServerAddress(server)}`);
+}
+export async function taskAddCommand(options, io) {
+    const input = removeUndefined({
+        id: requireArg(options, "id"),
+        title: requireArg(options, "title"),
+        ownerRole: requireArg(options, "owner"),
+        dependencies: parseCsv(options.depends),
+        backlogItem: stringOption(options.backlog),
+        goal: stringOption(options.goal),
+        scope: stringOption(options.scope),
+        acceptanceCriteria: parseCsv(options.acceptance),
+        assumptions: parseCsv(options.assumptions),
+        risks: parseCsv(options.risks),
+        paths: parseCsv(options.paths),
+        testStrategy: stringOption(options["test-strategy"]),
+        architectureApproval: parseArchitectureApproval(options),
+        qaGate: parseQaGate(options),
+        riskGate: parseRiskGate(options),
+    });
+    const task = await addTask(input);
+    io.log(`Added task ${task.id}`);
+}
+export async function taskListCommand(options, io) {
+    const tasks = await listTasks();
+    if (options.json) {
+        io.log(JSON.stringify(tasks, null, 2));
+        return;
+    }
+    if (tasks.length === 0) {
+        io.log("No tasks");
+        return;
+    }
+    for (const task of tasks) {
+        io.log(`${task.id} [${task.status}] ${task.title} (${task.ownerRole})`);
+    }
+}
+export async function rolesListCommand(options, io) {
+    const roles = await listRoles();
+    if (options.json) {
+        io.log(JSON.stringify(roles, null, 2));
+        return;
+    }
+    if (roles.length === 0) {
+        io.log("No roles");
+        return;
+    }
+    for (const role of roles) {
+        const gates = role.gateParticipation?.join(", ") || "none";
+        io.log(`${role.id} - ${role.name} (gates: ${gates})`);
+    }
+}
+export async function taskUpdateCommand(options, io) {
+    const id = requireArg(options, "id");
+    await updateTask(removeUndefined({
+        id,
+        status: stringOption(options.status),
+        blockedReason: stringOption(options["blocked-reason"]),
+    }));
+    io.log(`Updated task ${id}`);
+}
+export async function taskDepsCommand(options, io) {
+    const report = await checkTaskDependencies(requireArg(options, "id"));
+    if (options.json) {
+        io.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    io.log(renderDependencyReport(report));
+}
+export async function graphPlanCommand(options, io) {
+    const plan = await generateTaskGraphPlan();
+    if (options.json) {
+        io.log(JSON.stringify(plan, null, 2));
+        return;
+    }
+    io.log(renderTaskGraphPlan(plan));
+}
+export async function graphRunNextCommand(options, io) {
+    const run = await executeNextReadyTask();
+    if (options.json) {
+        io.log(JSON.stringify(run, null, 2));
+        return;
+    }
+    io.log(renderExecutionRunMarkdown(run));
+}
+export async function graphRunReadyCommand(options, io) {
+    const batch = await executeReadyTaskBatch();
+    if (options.json) {
+        io.log(JSON.stringify(batch, null, 2));
+        return;
+    }
+    io.log(renderTaskGraphBatchRun(batch));
+    if (batch.failure) {
+        throw new Error(`graph batch failed: ${batch.failure.taskId}`);
+    }
+}
+export async function lockListCommand(options, io) {
+    const locks = await listLocks();
+    if (options.json) {
+        io.log(JSON.stringify(locks, null, 2));
+        return;
+    }
+    if (locks.length === 0) {
+        io.log("No locks");
+        return;
+    }
+    for (const lock of locks) {
+        io.log(`${lock.id} ${lock.path} (${lock.taskId}, ${lock.ownerRole})`);
+    }
+}
+export async function lockClaimCommand(options, io) {
+    const lock = await claimLock(removeUndefined({
+        id: stringOption(options.id) ?? `lock-${Date.now()}`,
+        taskId: requireArg(options, "task"),
+        ownerRole: requireArg(options, "role"),
+        path: requireArg(options, "path"),
+        reason: requireArg(options, "reason"),
+        expiresAt: stringOption(options.expires),
+    }));
+    io.log(`Claimed lock ${lock.id}`);
+}
+export async function lockReleaseCommand(options, io) {
+    const id = requireArg(options, "id");
+    await releaseLock(id);
+    io.log(`Released lock ${id}`);
+}
+export async function readinessCommand(options, io) {
+    const taskId = requireArg(options, "task");
+    const { task, report } = await checkReadiness(taskId);
+    if (options.markdown) {
+        io.log(renderReadinessMarkdown(task, report));
+        return;
+    }
+    io.log(JSON.stringify(report, null, 2));
+}
+export async function gateCommand(options, io) {
+    const gateId = requireArg(options, "gate");
+    const taskId = requireArg(options, "task");
+    const result = await evaluateWorkflowGate(gateId, taskId);
+    if (options.markdown) {
+        io.log(renderGateMarkdown(result));
+        return;
+    }
+    io.log(JSON.stringify(result, null, 2));
+}
+export async function handoffCommand(options, io) {
+    const { artifact } = await createHandoff(removeUndefined({
+        task: requireArg(options, "task"),
+        from: requireArg(options, "from"),
+        to: requireArg(options, "to"),
+        changed: requireArg(options, "changed"),
+        behavior: requireArg(options, "behavior"),
+        tests: requireArg(options, "tests"),
+        commands: requireArg(options, "commands"),
+        status: stringOption(options.status),
+        gaps: stringOption(options.gaps),
+        risks: stringOption(options.risks),
+        playwright: stringOption(options.playwright),
+    }));
+    io.log(`Created ${artifact}`);
+}
+export async function reviewCommand(options, io) {
+    const input = {
+        task: requireArg(options, "task"),
+        role: requireArg(options, "role"),
+        result: requireArg(options, "result"),
+        severity: stringOption(options.severity) ?? "info",
+        findings: requireArg(options, "findings"),
+        recommendation: requireArg(options, "recommendation"),
+    };
+    const { artifact } = await recordReview(input);
+    io.log(`Created ${artifact}`);
+}
+export async function decisionAddCommand(options, io) {
+    const decision = await recordDecision({
+        task: requireArg(options, "task"),
+        title: requireArg(options, "title"),
+        context: requireArg(options, "context"),
+        decision: requireArg(options, "decision"),
+        consequences: requireArg(options, "consequences"),
+        status: (stringOption(options.status) ?? "accepted"),
+        owner: requireArg(options, "owner"),
+    });
+    io.log(`Created ${decision.artifact}`);
+}
+export async function decisionListCommand(options, io) {
+    const decisions = await listDecisions(stringOption(options.task));
+    if (options.json) {
+        io.log(JSON.stringify(decisions, null, 2));
+        return;
+    }
+    if (decisions.length === 0) {
+        io.log("No decisions");
+        return;
+    }
+    for (const decision of decisions) {
+        io.log(`${decision.taskId ?? "no-task"} ${decision.actor}: ${decision.summary}`);
+    }
+}
+export async function reviewListCommand(options, io) {
+    const reviews = await listReviews(stringOption(options.task));
+    if (options.json) {
+        io.log(JSON.stringify(reviews, null, 2));
+        return;
+    }
+    if (reviews.length === 0) {
+        io.log("No reviews");
+        return;
+    }
+    for (const review of reviews) {
+        const result = String(review.metadata.result ?? "unknown");
+        const severity = String(review.metadata.severity ?? "unknown");
+        io.log(`${review.taskId ?? "no-task"} ${review.actor} ${result} (${severity})`);
+    }
+}
+export async function evidenceCommand(options, io) {
+    const input = removeUndefined({
+        task: requireArg(options, "task"),
+        role: requireArg(options, "role"),
+        type: requireArg(options, "type"),
+        summary: requireArg(options, "summary"),
+        path: options.path,
+        command: options.command,
+        exitCode: options["exit-code"],
+    });
+    const { artifact } = await addEvidence(input);
+    io.log(`Created ${artifact}`);
+}
+export async function evidenceListCommand(options, io) {
+    const evidence = await listEvidence(stringOption(options.task));
+    if (options.json) {
+        io.log(JSON.stringify(evidence, null, 2));
+        return;
+    }
+    if (evidence.length === 0) {
+        io.log("No evidence");
+        return;
+    }
+    for (const item of evidence) {
+        const type = String(item.metadata.type ?? "unknown");
+        io.log(`${item.taskId ?? "no-task"} ${item.actor} ${type}: ${item.summary}`);
+    }
+}
+export async function summaryCommand(options, io) {
+    const summary = await getWorkflowSummary();
+    if (options.json) {
+        io.log(JSON.stringify(summary, null, 2));
+        return;
+    }
+    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) {
+        io.log(JSON.stringify(summary, null, 2));
+        return;
+    }
+    io.log(renderPullRequestSummaryMarkdown(summary));
+}
+export async function contextCommand(options, io) {
+    const context = await getTaskContext(requireArg(options, "task"));
+    if (options.json) {
+        io.log(JSON.stringify(context, null, 2));
+        return;
+    }
+    io.log(renderTaskContextMarkdown(context));
+}
+export async function planCommand(options, io) {
+    const plan = await generateExecutionPlan(requireArg(options, "task"));
+    if (options.json) {
+        io.log(JSON.stringify(plan, null, 2));
+        return;
+    }
+    io.log(renderExecutionPlanMarkdown(plan));
+}
+export async function runCommand(options, io) {
+    const taskId = requireArg(options, "task");
+    const run = await executePlanWithBudgetPreflight(taskId, process.cwd(), parseBudgetEscalationDecision(options));
+    if (options.json) {
+        io.log(JSON.stringify(run, null, 2));
+        return;
+    }
+    io.log(renderExecutionRunMarkdown(run));
+}
+export async function playwrightPlanCommand(options, io) {
+    const plan = await generatePlaywrightTestPlan(requireArg(options, "task"));
+    if (options.json) {
+        io.log(JSON.stringify(plan, null, 2));
+        return;
+    }
+    io.log(renderPlaywrightPlanMarkdown(plan));
+}
+export async function playwrightEvidenceCommand(options, io) {
+    const { artifact } = await addPlaywrightEvidence(removeUndefined({
+        task: requireArg(options, "task"),
+        kind: requireArg(options, "kind"),
+        path: requireArg(options, "path"),
+        summary: requireArg(options, "summary"),
+        runId: stringOption(options["run-id"]),
+    }));
+    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)}`);
+}
+function parseCsv(value) {
+    if (typeof value !== "string" || value.trim() === "") {
+        return [];
+    }
+    return value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function stringOption(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function removeUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+function parseArchitectureApproval(options) {
+    const approval = removeUndefined({
+        proposal: stringOption(options["architecture-proposal"]),
+        userApproved: options["user-approved"] ? true : undefined,
+        approvedBy: stringOption(options["architecture-approved-by"]),
+        approvedAt: stringOption(options["architecture-approved-at"]),
+    });
+    return Object.keys(approval).length > 0 ? approval : undefined;
+}
+function parseQaGate(options) {
+    const qaGate = removeUndefined({
+        plan: stringOption(options["qa-plan"]),
+        executionStatus: stringOption(options["qa-execution-status"]),
+        deferredRationale: stringOption(options["qa-deferred-rationale"]),
+        deferredOwner: stringOption(options["qa-deferred-owner"]),
+    });
+    return Object.keys(qaGate).length > 0 ? qaGate : undefined;
+}
+function parseRiskGate(options) {
+    const impactAreas = parseCsv(options["risk-areas"]);
+    const riskGate = removeUndefined({
+        impactAreas: impactAreas.length > 0 ? impactAreas : undefined,
+        acceptance: parseRiskAcceptance(options),
+    });
+    return Object.keys(riskGate).length > 0 ? riskGate : undefined;
+}
+function parseRiskAcceptance(options) {
+    const acceptance = removeUndefined({
+        acceptedBy: stringOption(options["risk-accepted-by"]),
+        rationale: stringOption(options["risk-acceptance-rationale"]),
+    });
+    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({
+            approved: true,
+            approver: stringOption(options.approver),
+            rationale: stringOption(options.rationale),
+        });
+    }
+    if (options["reject-budget-fallback"]) {
+        return removeUndefined({
+            approved: false,
+            approver: stringOption(options.approver),
+            rationale: stringOption(options.rationale),
+        });
+    }
+    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;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`invalid number: ${value}`);
+    }
+    return parsed;
+}
+function renderReadinessMarkdown(task, report) {
+    const status = report.isReady ? "passed" : "blocked";
+    const missing = report.missing.length > 0
+        ? report.missing.map((field) => `- ${field}`).join("\n")
+        : "- none";
+    return [
+        `# Readiness ${task.id}`,
+        "",
+        `Status: ${status}`,
+        "",
+        "Missing fields:",
+        missing,
+        "",
+    ].join("\n");
+}
+function renderGateMarkdown(report) {
+    const status = report.passed ? "passed" : "blocked";
+    const missing = report.missing.length > 0
+        ? report.missing.map((field) => `- ${field}`).join("\n")
+        : "- none";
+    return [
+        `# Gate ${report.gateId}`,
+        "",
+        `Status: ${status}`,
+        "",
+        "Missing fields:",
+        missing,
+        "",
+    ].join("\n");
+}
+function renderDependencyReport(report) {
+    return [
+        `Dependencies for ${report.taskId}: ${report.isSatisfied ? "satisfied" : "blocked"}`,
+        ...(report.dependencies.length === 0
+            ? ["- none"]
+            : report.dependencies.map((dependency) => `- ${dependency.id}: ${dependency.status} (${dependency.isComplete ? "complete" : "incomplete"})`)),
+    ].join("\n");
+}
+function renderTaskGraphPlan(plan) {
+    return [
+        "Task graph plan",
+        "",
+        "Ready:",
+        ...taskGraphReadyLines(plan.ready),
+        "",
+        "Blocked:",
+        ...taskGraphBlockedLines(plan.blocked),
+        "",
+        "Locked:",
+        ...taskGraphLockedLines(plan.locked),
+        "",
+        "Complete:",
+        ...taskGraphReadyLines(plan.complete),
+    ].join("\n");
+}
+function renderTaskGraphBatchRun(batch) {
+    return [
+        "Task graph batch run",
+        `- Selected: ${batch.selectedTaskIds.join(", ")}`,
+        `- Completed runs: ${batch.runs.length}`,
+        `- Locked: ${batch.locked.map((task) => task.id).join(", ") || "none"}`,
+        `- Artifact: ${batch.artifact ?? "none"}`,
+        ...(batch.failure
+            ? [`- Failure: ${batch.failure.taskId}: ${batch.failure.error}`]
+            : ["- Failure: none"]),
+    ].join("\n");
+}
+function taskGraphReadyLines(items) {
+    return items.length === 0
+        ? ["- none"]
+        : items.map((item) => `- ${item.id} [${item.status}] ${item.title} (${item.ownerRole})`);
+}
+function taskGraphBlockedLines(items) {
+    return items.length === 0
+        ? ["- none"]
+        : items.map((item) => {
+            const blockers = item.incomplete
+                .map((dependency) => `${dependency.id}:${dependency.status}`)
+                .join(", ");
+            return `- ${item.id} [${item.status}] ${item.title} blocked by ${blockers}`;
+        });
+}
+function taskGraphLockedLines(items) {
+    return items.length === 0
+        ? ["- none"]
+        : items.map((item) => {
+            const locks = item.locks
+                .map((lock) => lock.conflictPath
+                ? `${lock.id}:${lock.path}->${lock.conflictPath}`
+                : `${lock.id}:${lock.path}`)
+                .join(", ");
+            return `- ${item.id} [${item.status}] ${item.title} locked by ${locks}`;
+        });
+}
+function renderSummaryMarkdown(summary) {
+    return [
+        "# Agent Workflow Summary",
+        "",
+        `- Tasks: ${summary.tasks.length}`,
+        `- Locks: ${summary.locks.length}`,
+        `- Reviews: ${summary.reviews.length}`,
+        `- Evidence: ${summary.evidence.length}`,
+        `- Events: ${summary.eventCount}`,
+        "",
+        "## Tasks",
+        ...(summary.tasks.length === 0
+            ? ["- none"]
+            : summary.tasks.map((task) => `- ${task.id} [${task.status}] ${task.title} (${task.ownerRole})`)),
+        "",
+        "## Blockers",
+        ...(summary.blockers.length === 0
+            ? ["- none"]
+            : summary.blockers.map((task) => `- ${task.id}: ${task.blockedReason ?? "not specified"}`)),
+        "",
+        "## Reviews",
+        ...(summary.reviews.length === 0
+            ? ["- none"]
+            : summary.reviews.map((event) => `- ${event.taskId ?? "no-task"} ${event.actor}: ${String(event.metadata.result ?? "unknown")}`)),
+        "",
+        "## Evidence",
+        ...(summary.evidence.length === 0
+            ? ["- none"]
+            : summary.evidence.map((event) => `- ${event.taskId ?? "no-task"} ${event.actor}: ${event.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}`,
+        "",
+        `## Task`,
+        `- Title: ${summary.task.title}`,
+        `- Owner: ${summary.task.ownerRole}`,
+        `- Status: ${summary.task.status}`,
+        `- Goal: ${summary.task.goal ?? "not specified"}`,
+        `- Scope: ${summary.task.scope ?? "not specified"}`,
+        "",
+        "## Acceptance Criteria",
+        ...listOrNone(summary.task.acceptanceCriteria),
+        "",
+        "## Risks",
+        ...listOrNone(summary.risks),
+        "",
+        "## Gates",
+        ...eventLines(summary.gates),
+        "",
+        "## Evidence",
+        ...eventLines(summary.evidence),
+        "",
+        "## Reviews",
+        ...eventLines(summary.reviews),
+        "",
+        "## Handoffs",
+        ...eventLines(summary.handoffs),
+        "",
+        "## Active Locks",
+        ...(summary.locks.length === 0
+            ? ["- none"]
+            : summary.locks.map((lock) => `- ${lock.id}: ${lock.path}`)),
+        "",
+        "## Rollout",
+        `- ${summary.rollout}`,
+        "",
+        "## Rollback",
+        `- ${summary.rollback}`,
+        "",
+    ].join("\n");
+}
+function renderTaskContextMarkdown(context) {
+    return [
+        `# Task Context: ${context.task.id}`,
+        "",
+        `- Title: ${context.task.title}`,
+        `- Owner: ${context.task.ownerRole}`,
+        `- Status: ${context.task.status}`,
+        `- Dependencies: ${context.dependencies.isSatisfied ? "satisfied" : "blocked"}`,
+        `- Locks: ${context.locks.length}`,
+        `- Risks: ${context.risks.length}`,
+        "",
+        "## Decisions",
+        ...eventLines(context.decisions),
+        "",
+        "## Handoffs",
+        ...eventLines(context.handoffs),
+        "",
+        "## Reviews",
+        ...eventLines(context.reviews),
+        "",
+        "## Evidence",
+        ...eventLines(context.evidence),
+        "",
+        "## Gates",
+        ...eventLines(context.gates),
+        "",
+        "## Model Provenance",
+        ...(context.modelProvenance.length === 0
+            ? ["- none"]
+            : context.modelProvenance.map((record) => `- ${record.role}: ${record.provider}/${record.model} ${record.responseId}`)),
+        "",
+    ].join("\n");
+}
+function renderExecutionPlanMarkdown(plan) {
+    return [
+        `# Execution Plan: ${plan.taskId}`,
+        "",
+        ...plan.steps.map((step) => {
+            const gate = step.gate ? ` gate=${step.gate}` : "";
+            const dependsOn = step.dependsOn.length > 0
+                ? ` dependsOn=${step.dependsOn.join(",")}`
+                : "";
+            return `- ${step.id}: ${step.role}${gate}${dependsOn} - ${step.action}`;
+        }),
+        "",
+    ].join("\n");
+}
+function renderExecutionRunMarkdown(run) {
+    return [
+        `# Execution Run: ${run.taskId}`,
+        "",
+        `- Provider: ${run.provider}`,
+        `- Model: ${run.model}`,
+        "",
+        ...run.steps.map((step) => `- ${step.id}: ${step.role} ${step.status} ${step.responseId ?? step.error ?? ""}`.trim()),
+        "",
+    ].join("\n");
+}
+function renderPlaywrightPlanMarkdown(plan) {
+    return [
+        `# Playwright Test Plan: ${plan.taskId}`,
+        "",
+        `- Title: ${plan.title}`,
+        `- Target user: ${plan.targetUser}`,
+        "",
+        "## Scenarios",
+        ...plan.scenarios.flatMap((scenario) => [
+            `### ${scenario.name}`,
+            `- Source: ${scenario.source}`,
+            `- Page object: ${scenario.pageObject}`,
+            `- Selectors: ${scenario.selectors.join("; ")}`,
+            `- Assertions: ${scenario.assertions.join("; ")}`,
+            `- Evidence: ${scenario.evidence.join(", ")}`,
+            "",
+        ]),
+        "## Fixtures",
+        ...listOrNone(plan.fixtures),
+        "",
+        "## Notes",
+        ...listOrNone(plan.notes),
+        "",
+    ].join("\n");
+}
+function eventLines(events) {
+    return events.length === 0
+        ? ["- none"]
+        : events.map((event) => {
+            const artifacts = event.artifacts?.join(", ") ?? "no artifacts";
+            return `- ${event.type}: ${event.summary} (${artifacts})`;
+        });
+}
+function listOrNone(items) {
+    return items && items.length > 0
+        ? items.map((item) => `- ${item}`)
+        : ["- none"];
+}
+//# sourceMappingURL=commands.js.map