@jterrats/open-orchestra 0.4.0 → 0.4.2-beta.1

package/dist/commands.js

@@ -1,31 +1,25 @@
-import { readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { initWorkspace } from "./workspace.js";
+import { appendEvent, 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, computeVelocity, recordEstimate, summarizeBenchmark, } from "./benchmark.js";
-import { computeSprintBurndown, renderBurndownAscii } from "./burndown.js";
-import { calibrationReport, closeSprint, startSprint, velocityTrend, } from "./sprint-metrics.js";
+import { TASK_STATUSES } from "./constants.js";
+import { queryMemory, recordMemoryEvent, renderMemoryPacket, } from "./memory.js";
+import { AUTONOMOUS_PHASE_SEQUENCE, autonomousRunsPath, checkArchitectSizing, closePhase, cancelRun, createAutonomousRun, initPhase, listActiveAutonomousRuns, listAutonomousRuns, markRunDone, markRunFailed, readAutonomousRun, resumePhaseIndex, suspendPhaseForClarification, resumePhaseFromClarification, } from "./autonomous-workflow.js";
+import { listClarifications, listClarificationsByTask, openClarification, answerClarification, resolveClarificationRole, } from "./clarification.js";
 import { executePhaseWithLlm } from "./phase-executor.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 { addEvidence, addPlaywrightEvidence, addTask, archiveTask, approveWorkflowGate, checkReadiness, checkTaskDependencies, claimLock, createHandoff, deleteTask, evaluateWorkflowGate, executeNextReadyTask, executePlanWithBudgetPreflight, executeReadyTaskBatch, generateExecutionPlan, generatePlaywrightTestPlan, generatePullRequestSummary, generateTaskGraphPlan, getWorkflowStatus, getWorkflowSummary, getTaskContext, getWorkflowConfig, listEvidence, listDecisions, listLocks, listReviews, listRoles, listTasks, previewTaskGraphRun, recordReview, recordDecision, releaseLock, updateTask, validatePreRun, } 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, lessonsDeleteCommand, lessonsListCommand, lessonsPromoteCommand, skillsListCommand, skillsPlanCommand, skillsRenderCommand, skillsValidateCommand, sourcesListCommand, } from "./skills-commands.js";
+export { diagramsLintCommand, mcpOAuthProxyEvaluateCommand, mcpOAuthProxyStartCommand, mcpOAuthProxyTokenCommand, } 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();
@@ -71,6 +65,23 @@ export async function statusCommand(options, io) {
     }
 }
 export async function validateCommand(options, io) {
+    if (options["pre-run"]) {
+        const report = await validatePreRun(requireArg(options, "task"), removeUndefined({
+            bypass: Boolean(options.bypass),
+            bypassOwner: stringOption(options["bypass-owner"]),
+            bypassRationale: stringOption(options["bypass-rationale"]),
+        }));
+        if (options.json) {
+            io.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            io.log(renderPreRunValidation(report));
+        }
+        if (!report.allowed) {
+            throw new Error(`pre-run validation failed: ${report.missing.join(", ")}`);
+        }
+        return;
+    }
     const report = await validateWorkspace();
     if (options.json) {
         io.log(JSON.stringify(report, null, 2));
@@ -122,7 +133,11 @@ export async function taskAddCommand(options, io) {
     io.log(`Added task ${task.id}`);
 }
 export async function taskListCommand(options, io) {
-    const tasks = await listTasks();
+    if (options.help || options.h) {
+        io.log("task list [--json] [--status <csv>] [--owner <role>] [--filter <text>] [--top-level] [--include-archived]");
+        return;
+    }
+    const tasks = filterTasks(await listTasks(), options);
     if (options.json) {
         io.log(JSON.stringify(tasks, null, 2));
         return;
@@ -135,6 +150,67 @@ export async function taskListCommand(options, io) {
         io.log(`${task.id} [${task.status}] ${task.title} (${task.ownerRole})`);
     }
 }
+function filterTasks(tasks, options) {
+    const statuses = parseTaskStatusFilter(options.status);
+    const owner = stringOption(options.owner);
+    const textFilter = stringOption(options.filter)?.toLowerCase();
+    return tasks.filter((task) => matchesStatus(task, statuses) &&
+        (options["include-archived"] || task.status !== "archived") &&
+        (!owner || task.ownerRole === owner) &&
+        (!textFilter || taskSearchText(task).includes(textFilter)) &&
+        (!options["top-level"] || isTopLevelTask(task)));
+}
+function parseTaskStatusFilter(value) {
+    const statuses = parseCsv(value);
+    const invalid = statuses.filter((status) => !TASK_STATUSES.includes(status));
+    if (invalid.length > 0) {
+        throw new Error(`unknown task status: ${invalid.join(", ")}. Valid statuses: ${TASK_STATUSES.join(", ")}`);
+    }
+    return new Set(statuses);
+}
+function matchesStatus(task, statuses) {
+    return statuses.size === 0 || statuses.has(task.status);
+}
+function taskSearchText(task) {
+    return `${task.id} ${task.title}`.toLowerCase();
+}
+function isTopLevelTask(task) {
+    return !["pm", "po", "architect", "developer", "qa", "release"].some((phase) => task.id.includes(`-${phase}-`));
+}
+export async function taskShowCommand(options, io) {
+    const id = requireArg(options, "id");
+    const task = (await listTasks()).find((candidate) => candidate.id === id);
+    if (!task) {
+        throw new Error(`unknown task: ${id}`);
+    }
+    if (options.json) {
+        io.log(JSON.stringify(task, null, 2));
+        return;
+    }
+    for (const line of renderTaskDetails(task)) {
+        io.log(line);
+    }
+}
+export async function taskDeleteCommand(options, io) {
+    const task = await deleteTask(requireArg(options, "id"), {
+        force: Boolean(options.force),
+    });
+    if (options.json) {
+        io.log(JSON.stringify(task, null, 2));
+        return;
+    }
+    io.log(`Deleted task ${task.id}`);
+}
+export async function taskArchiveCommand(options, io) {
+    const task = await archiveTask(requireArg(options, "id"), {
+        force: Boolean(options.force),
+    });
+    if (options.json) {
+        io.log(JSON.stringify(task, null, 2));
+        return;
+    }
+    io.log(`Archived task ${task.id}`);
+}
 export async function rolesListCommand(options, io) {
     const roles = await listRoles();
     if (options.json) {
@@ -154,6 +230,15 @@ export async function taskUpdateCommand(options, io) {
     const id = requireArg(options, "id");
     await updateTask(removeUndefined({
         id,
+        title: stringOption(options.title),
+        ownerRole: stringOption(options.owner),
+        goal: stringOption(options.goal),
+        scope: stringOption(options.scope),
+        paths: csvOption(options.paths),
+        acceptanceCriteria: singleValueArrayOption(options.acceptance),
+        assumptions: singleValueArrayOption(options.assumptions),
+        risks: singleValueArrayOption(options.risks),
+        testStrategy: stringOption(options["test-strategy"]),
         status: stringOption(options.status),
         blockedReason: stringOption(options["blocked-reason"]),
     }));
@@ -176,6 +261,15 @@ export async function graphPlanCommand(options, io) {
     io.log(renderTaskGraphPlan(plan));
 }
 export async function graphRunNextCommand(options, io) {
+    if (options["dry-run"]) {
+        const preview = await previewTaskGraphRun("run-next");
+        if (options.json) {
+            io.log(JSON.stringify(preview, null, 2));
+            return;
+        }
+        io.log(renderTaskGraphDryRunPreview(preview));
+        return;
+    }
     const run = await executeNextReadyTask();
     if (options.json) {
         io.log(JSON.stringify(run, null, 2));
@@ -184,6 +278,15 @@ export async function graphRunNextCommand(options, io) {
     io.log(renderExecutionRunMarkdown(run));
 }
 export async function graphRunReadyCommand(options, io) {
+    if (options["dry-run"]) {
+        const preview = await previewTaskGraphRun("run-ready");
+        if (options.json) {
+            io.log(JSON.stringify(preview, null, 2));
+            return;
+        }
+        io.log(renderTaskGraphDryRunPreview(preview));
+        return;
+    }
     const batch = await executeReadyTaskBatch();
     if (options.json) {
         io.log(JSON.stringify(batch, null, 2));
@@ -256,6 +359,7 @@ export async function handoffCommand(options, io) {
         gaps: stringOption(options.gaps),
         risks: stringOption(options.risks),
         playwright: stringOption(options.playwright),
+        updateOwner: options["update-owner"] ? true : undefined,
     }));
     io.log(`Created ${artifact}`);
 }
@@ -349,56 +453,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) {
@@ -425,6 +479,40 @@ export async function contextCommand(options, io) {
     }
     io.log(renderTaskContextMarkdown(context));
 }
+export async function memoryQueryCommand(options, io) {
+    const hook = parseMemoryHook(stringOption(options.hook));
+    const taskId = stringOption(options.task);
+    const query = stringOption(options.query);
+    const packet = await queryMemory({
+        ...(taskId ? { taskId } : {}),
+        hook,
+        ...(query ? { query } : {}),
+        tokenBudget: numberOption(options.budget, 900),
+    });
+    await recordMemoryEvent(process.cwd(), packet, "MEMORY_QUERIED");
+    if (options.json) {
+        io.log(JSON.stringify(packet, null, 2));
+        return;
+    }
+    io.log(renderMemoryPacket(packet));
+}
+export async function memoryHookCommand(options, io) {
+    const point = parseMemoryHook(requireArg(options, "point"));
+    const taskId = stringOption(options.task);
+    const query = stringOption(options.query);
+    const packet = await queryMemory({
+        ...(taskId ? { taskId } : {}),
+        hook: point,
+        ...(query ? { query } : {}),
+        tokenBudget: numberOption(options.budget, 900),
+    });
+    await recordMemoryEvent(process.cwd(), packet, "MEMORY_HOOK_RAN");
+    if (options.json) {
+        io.log(JSON.stringify(packet, null, 2));
+        return;
+    }
+    io.log(renderMemoryPacket(packet));
+}
 export async function planCommand(options, io) {
     const plan = await generateExecutionPlan(requireArg(options, "task"));
     if (options.json) {
@@ -435,7 +523,12 @@ export async function planCommand(options, io) {
 }
 export async function runCommand(options, io) {
     const taskId = requireArg(options, "task");
-    const run = await executePlanWithBudgetPreflight(taskId, process.cwd(), parseBudgetEscalationDecision(options));
+    const run = await executePlanWithBudgetPreflight(taskId, process.cwd(), parseBudgetEscalationDecision(options), removeUndefined({
+        estimatedCostUsd: stringOption(options["estimate-cost"])
+            ? numberOption(options["estimate-cost"], 0)
+            : undefined,
+        override: options.yes ? true : undefined,
+    }));
     if (options.json) {
         io.log(JSON.stringify(run, null, 2));
         return;
@@ -460,254 +553,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) {
@@ -788,283 +633,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) {
@@ -1072,12 +640,22 @@ export async function workflowRunCommand(options, io) {
     const taskId = requireArg(options, "task");
     const gates = (stringOption(options.gates) ?? "phase");
     const maxIterations = numberOption(options["max-iterations"], 5);
+    const timeoutMinutes = numberOption(options["timeout-minutes"], 0);
     const file = autonomousRunsPath(cwd);
+    const phaseSelection = await resolveWorkflowPhaseSelection(cwd, options);
+    const config = await getWorkflowConfig(cwd);
+    const phaseTimeoutMinutes = config.workflow?.phaseTimeoutMinutes ?? 0;
     if (!GATE_MODES.includes(gates)) {
         throw new Error(`--gates must be one of: ${GATE_MODES.join(", ")}`);
     }
+    if (timeoutMinutes < 0) {
+        throw new Error("--timeout-minutes must be 0 or greater");
+    }
+    if (phaseTimeoutMinutes < 0) {
+        throw new Error("workflow.phaseTimeoutMinutes must be 0 or greater");
+    }
     if (options["dry-run"]) {
-        return workflowDryRun(options, io, taskId, gates, maxIterations);
+        return workflowDryRun(options, io, taskId, gates, maxIterations, phaseSelection);
     }
     let run;
     let startIndex;
@@ -1086,21 +664,39 @@ export async function workflowRunCommand(options, io) {
         if (!existing)
             throw new Error(`workflow run not found: ${String(options.resume)}`);
         run = existing;
-        startIndex = resumePhaseIndex(run);
+        if (run.status === "canceled" || run.status === "failed") {
+            throw new Error(`workflow run ${run.id} is ${run.status} and cannot be resumed`);
+        }
+        const resumeSequence = phaseSequenceForRun(run, phaseSelection.sequence);
+        startIndex = resumePhaseIndex(run, resumeSequence);
         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}`);
+        const pausedGate = run.phases.findLast((phase) => phase.status === "gate_paused");
+        if (pausedGate && !pausedGate.approvedBy) {
+            io.log(`WARN: gate ${pausedGate.gateId ?? gateIdForPausedPhase(pausedGate.phase, resumeSequence)} has no recorded approval; continuing for backward compatibility`);
+        }
+        io.log(`Resuming run ${run.id} from phase ${resumeSequence[startIndex]?.phase}`);
+        run = { ...run, phaseSequence: resumeSequence.map((phase) => phase.phase) };
     }
     else {
-        run = await createAutonomousRun(cwd, { taskId, gates, maxIterations });
+        run = await createAutonomousRun(cwd, {
+            taskId,
+            gates,
+            maxIterations,
+            phaseSequence: phaseSelection.sequence.map((phase) => phase.phase),
+            skippedPhases: phaseSelection.skipped,
+        });
         startIndex = 0;
         io.log(`Started autonomous workflow ${run.id} for task ${taskId} [gates=${gates}]`);
     }
-    run = await executePhases(cwd, run, startIndex, io);
+    run = await executePhases(cwd, run, startIndex, io, phaseSequenceForRun(run, phaseSelection.sequence), {
+        runTimeoutMinutes: timeoutMinutes,
+        phaseTimeoutMinutes,
+    });
     const result = { run, file, cwd };
     if (options.json) {
         io.log(JSON.stringify(result, null, 2));
@@ -1118,7 +714,9 @@ export async function workflowRunCommand(options, io) {
 }
 export async function workflowRunListCommand(options, io) {
     const cwd = process.cwd();
-    const runs = await listAutonomousRuns(cwd);
+    const runs = options.active
+        ? await listActiveAutonomousRuns(cwd)
+        : await listAutonomousRuns(cwd);
     if (options.json) {
         io.log(JSON.stringify(runs, null, 2));
         return;
@@ -1134,17 +732,35 @@ export async function workflowRunListCommand(options, io) {
             io.log(`  ${phases}`);
     }
 }
-const CLARIFICATION_TARGETS = ["po", "architect"];
-const CLARIFICATION_ALLOWED_PHASES = new Set(["developer", "qa"]);
+export async function workflowCancelCommand(options, io) {
+    const run = await cancelRun(process.cwd(), requireArg(options, "run"), stringOption(options.reason) ?? "Workflow run canceled");
+    if (options.json) {
+        io.log(JSON.stringify(run, null, 2));
+        return;
+    }
+    io.log(`Workflow canceled [run=${run.id}]`);
+}
+export async function workflowGateApproveCommand(options, io) {
+    const approval = await approveWorkflowGate({
+        runId: requireArg(options, "run"),
+        gateId: requireArg(options, "gate"),
+        approver: requireArg(options, "approver"),
+        rationale: requireArg(options, "rationale"),
+    });
+    if (options.json) {
+        io.log(JSON.stringify(approval, null, 2));
+        return;
+    }
+    io.log(approval.alreadyApproved
+        ? `Gate ${approval.gateId} already approved by ${approval.approver}`
+        : `Approved gate ${approval.gateId} for run ${approval.run.id}`);
+}
 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 from = await resolveClarificationRole(cwd, requireArg(options, "from"));
+    const to = await resolveClarificationRole(cwd, 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}`);
@@ -1155,9 +771,6 @@ export async function workflowClarifyCommand(options, io) {
         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,
@@ -1168,8 +781,9 @@ export async function workflowClarifyCommand(options, io) {
     });
     // 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);
+        const sequence = phaseSequenceForRun(run);
+        const phaseSeqIdx = sequence.findIndex((d) => d.phase === activePhase.phase);
+        await suspendPhaseForClarification(cwd, run, phaseSeqIdx, sequence);
     }
     if (options.json) {
         io.log(JSON.stringify(record, null, 2));
@@ -1193,11 +807,12 @@ export async function workflowClarifyRespondCommand(options, io) {
         answer,
     });
     // Resume the suspended phase back to running
-    const phaseSeqIdx = AUTONOMOUS_PHASE_SEQUENCE.findIndex((d) => d.role === record.fromRole);
+    const sequence = phaseSequenceForRun(run);
+    const phaseSeqIdx = 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);
+            await resumePhaseFromClarification(cwd, run, phaseSeqIdx, sequence);
         }
     }
     if (options.json) {
@@ -1211,14 +826,25 @@ export async function workflowClarifyRespondCommand(options, io) {
 }
 export async function workflowClarifyListCommand(options, io) {
     const cwd = process.cwd();
-    const runId = requireArg(options, "run");
-    const clarifications = await listClarifications(cwd, runId);
+    const runId = stringOption(options.run);
+    const taskId = stringOption(options.task);
+    if (runId && taskId) {
+        throw new Error("workflow clarify-list accepts either --run or --task, not both");
+    }
+    if (!runId && !taskId) {
+        throw new Error("workflow clarify-list requires --run or --task");
+    }
+    const clarifications = runId
+        ? await listClarifications(cwd, runId)
+        : await listClarificationsByTask(cwd, taskId);
     if (options.json) {
         io.log(JSON.stringify(clarifications, null, 2));
         return;
     }
     if (clarifications.length === 0) {
-        io.log(`No clarifications for run ${runId}`);
+        io.log(runId
+            ? `No clarifications for run ${runId}`
+            : `No clarifications for task ${taskId}`);
         return;
     }
     for (const c of clarifications) {
@@ -1229,17 +855,115 @@ export async function workflowClarifyListCommand(options, io) {
             io.log(`  A: ${c.answer}`);
     }
 }
-const DEV_PHASE_INDEX = AUTONOMOUS_PHASE_SEQUENCE.findIndex((d) => d.phase === "developer");
-async function executePhases(cwd, run, startIndex, io) {
+const MEMORY_HOOK_POINTS = [
+    "before_plan",
+    "before_implementation",
+    "before_handoff",
+    "before_final",
+    "after_failure",
+];
+function parseMemoryHook(value) {
+    const hook = value ?? "before_implementation";
+    if (!MEMORY_HOOK_POINTS.includes(hook)) {
+        throw new Error(`memory hook must be one of: ${MEMORY_HOOK_POINTS.join(", ")}`);
+    }
+    return hook;
+}
+async function resolveWorkflowPhaseSelection(root, options) {
+    const config = await getWorkflowConfig(root);
+    const configuredIds = config.workflow?.phaseSequence;
+    const baseSequence = configuredIds
+        ? phaseSequenceFromIds(configuredIds, "workflow.phaseSequence")
+        : AUTONOMOUS_PHASE_SEQUENCE;
+    const skipIds = parseCsv(options.skip);
+    validatePhaseIds(skipIds, "--skip");
+    const skipSet = new Set(skipIds);
+    const sequence = baseSequence.filter((phase) => !skipSet.has(phase.phase));
+    validateWorkflowPhaseSequence(sequence);
+    const sequenceIds = new Set(sequence.map((phase) => phase.phase));
+    const skipped = AUTONOMOUS_PHASE_SEQUENCE.filter((phase) => !sequenceIds.has(phase.phase));
+    return { sequence, skipped };
+}
+function phaseSequenceForRun(run, fallback = AUTONOMOUS_PHASE_SEQUENCE) {
+    return run.phaseSequence
+        ? phaseSequenceFromIds(run.phaseSequence, "run.phaseSequence")
+        : fallback;
+}
+function phaseSequenceFromIds(ids, source) {
+    validatePhaseIds(ids, source);
+    const byId = new Map(AUTONOMOUS_PHASE_SEQUENCE.map((phase) => [phase.phase, phase]));
+    return ids.map((id) => byId.get(id));
+}
+function validatePhaseIds(ids, source) {
+    const valid = new Set(AUTONOMOUS_PHASE_SEQUENCE.map((phase) => phase.phase));
+    const unknown = ids.filter((id) => !valid.has(id));
+    if (unknown.length > 0) {
+        throw new Error(`${source} contains invalid phase(s): ${unknown.join(", ")}. Valid phases: ${[...valid].join(", ")}`);
+    }
+}
+function validateWorkflowPhaseSequence(sequence) {
+    if (sequence.length === 0) {
+        throw new Error("workflow phase sequence cannot be empty");
+    }
+    const ids = sequence.map((phase) => phase.phase);
+    const duplicates = ids.filter((id, index) => ids.indexOf(id) !== index);
+    if (duplicates.length > 0) {
+        throw new Error(`workflow phase sequence contains duplicate phase(s): ${[...new Set(duplicates)].join(", ")}`);
+    }
+    const qaIndex = ids.indexOf("qa");
+    const developerIndex = ids.indexOf("developer");
+    if (qaIndex !== -1 && developerIndex === -1) {
+        throw new Error("workflow phase sequence with qa must include developer");
+    }
+    if (qaIndex !== -1 && developerIndex > qaIndex) {
+        throw new Error("workflow phase sequence must place developer before qa");
+    }
+}
+function phaseExceededTimeout(run, phaseId, timeoutMs) {
+    const phase = run.phases.find((candidate) => candidate.phase === phaseId &&
+        (candidate.status === "running" ||
+            candidate.status === "awaiting_clarification"));
+    if (!phase) {
+        return false;
+    }
+    return Date.now() - new Date(phase.startedAt).getTime() > timeoutMs;
+}
+async function recordWorkflowTimeout(root, run, input) {
+    await appendEvent(root, {
+        type: "WORKFLOW_TIMEOUT",
+        taskId: run.taskId,
+        actor: "parent",
+        summary: input.reason,
+        metadata: {
+            runId: run.id,
+            phase: input.phase,
+            timeoutMinutes: input.timeoutMinutes,
+        },
+    });
+}
+function gateIdForPausedPhase(phase, sequence = AUTONOMOUS_PHASE_SEQUENCE) {
+    const sequenceIndex = sequence.findIndex((candidate) => candidate.phase === phase);
+    const next = sequence[sequenceIndex + 1]?.phase ?? "end";
+    return `${phase}->${next}`;
+}
+async function executePhases(cwd, run, startIndex, io, sequence, timeoutOptions) {
     let current = run;
     let qaFailNotes;
-    for (let i = startIndex; i < AUTONOMOUS_PHASE_SEQUENCE.length; i++) {
-        const def = AUTONOMOUS_PHASE_SEQUENCE[i];
+    const devPhaseIndex = sequence.findIndex((d) => d.phase === "developer");
+    const runDeadlineMs = timeoutOptions.runTimeoutMinutes > 0
+        ? new Date(run.createdAt).getTime() +
+            timeoutOptions.runTimeoutMinutes * 60 * 1000
+        : undefined;
+    const phaseTimeoutMs = timeoutOptions.phaseTimeoutMinutes > 0
+        ? timeoutOptions.phaseTimeoutMinutes * 60 * 1000
+        : undefined;
+    for (let i = startIndex; i < sequence.length; i++) {
+        const def = 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);
+            const phaseRecord = await initPhase(cwd, current, i, retryContext, sequence);
             current = { ...current, phases: [...current.phases, phaseRecord] };
             if (retryContext) {
                 io.log(`↺ ${def.phase} (${def.role}) retry — QA findings: ${retryContext.slice(0, 80)}`);
@@ -1265,7 +989,7 @@ async function executePhases(cwd, run, startIndex, io) {
         }).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);
+            current = await markRunFailed(cwd, current, message, def.phase);
             return null;
         });
         if (!llmResult)
@@ -1273,6 +997,17 @@ async function executePhases(cwd, run, startIndex, io) {
         if (llmResult.mode === "llm") {
             io.log(`  ✓ llm artifact (${llmResult.artifact})`);
         }
+        if (phaseTimeoutMs !== undefined &&
+            phaseExceededTimeout(current, def.phase, phaseTimeoutMs)) {
+            io.log(`✗ ${def.phase} phase timeout`);
+            await recordWorkflowTimeout(cwd, current, {
+                phase: def.phase,
+                reason: "phase timeout",
+                timeoutMinutes: timeoutOptions.phaseTimeoutMinutes,
+            });
+            current = await markRunFailed(cwd, current, "phase timeout", def.phase);
+            return current;
+        }
         // 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") {
@@ -1288,15 +1023,15 @@ async function executePhases(cwd, run, startIndex, io) {
             io.log(`  ✓ sizing=${sizing.sizing}${sizing.points !== undefined ? ` (${sizing.points} pts)` : ""}`);
         }
         const outcome = llmResult.outcome;
-        const result = await closePhase(cwd, current, i, outcome);
+        const result = await closePhase(cwd, current, i, outcome, sequence);
         current = result.run;
         if (result.handoffArtifact) {
-            io.log(`  ✓ handoff → ${AUTONOMOUS_PHASE_SEQUENCE[i + 1]?.role ?? "end"} (${result.handoffArtifact})`);
+            io.log(`  ✓ handoff → ${sequence[i + 1]?.role ?? "end"} (${result.handoffArtifact})`);
         }
         if (result.reviewArtifact) {
-            const nextPhase = AUTONOMOUS_PHASE_SEQUENCE[i + 1]?.phase;
+            const nextPhase = 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(`  Approve: orchestra workflow gate-approve --run ${current.id} --gate ${def.phase}->${nextPhase} --approver <name> --rationale "<text>"`);
             io.log(``);
             io.log(`╔══ GATE PAUSE: ${def.phase.toUpperCase()} → ${nextPhase?.toUpperCase()} ══════════════════════`);
             io.log(`║  Run:    ${current.id}`);
@@ -1304,6 +1039,8 @@ async function executePhases(cwd, run, startIndex, io) {
             io.log(`║  Review: ${result.reviewArtifact}`);
             io.log(`║`);
             io.log(`║  To approve, run:`);
+            io.log(`║    orchestra workflow gate-approve --run ${current.id} --gate ${def.phase}->${nextPhase} --approver <name> --rationale "<text>"`);
+            io.log(`║  Then resume:`);
             io.log(`║    orchestra workflow run --task ${current.taskId} --resume ${current.id}`);
             io.log(`╚══════════════════════════════════════════════════════════════`);
             return current;
@@ -1313,7 +1050,7 @@ async function executePhases(cwd, run, startIndex, io) {
         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
+            i = devPhaseIndex - 1; // will be incremented to developer at top of loop
             continue;
         }
         // Release phase: auto-create PR if configured
@@ -1344,18 +1081,29 @@ async function executePhases(cwd, run, startIndex, io) {
                 }
             }
         }
+        if (runDeadlineMs !== undefined && Date.now() > runDeadlineMs) {
+            const reason = `wall-clock timeout after ${timeoutOptions.runTimeoutMinutes} minutes`;
+            io.log(`✗ ${reason}`);
+            await recordWorkflowTimeout(cwd, current, {
+                phase: def.phase,
+                reason,
+                timeoutMinutes: timeoutOptions.runTimeoutMinutes,
+            });
+            current = await markRunFailed(cwd, current, reason);
+            return current;
+        }
     }
     current = await markRunDone(cwd, current);
     return current;
 }
-async function workflowDryRun(options, io, taskId, gates, maxIterations) {
+async function workflowDryRun(options, io, taskId, gates, maxIterations, phaseSelection) {
     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];
+    for (let i = 0; i < phaseSelection.sequence.length; i++) {
+        const def = phaseSelection.sequence[i];
+        const next = phaseSelection.sequence[i + 1];
         const transitionKey = next ? `${def.phase}→${next.phase}` : "";
         const gateLabel = gates === "all"
             ? "gate=yes"
@@ -1364,235 +1112,21 @@ async function workflowDryRun(options, io, taskId, gates, maxIterations) {
                 : "gate=no";
         io.log(`  ${def.phase} (${def.role})  ${gateLabel}`);
     }
+    if (phaseSelection.skipped.length > 0) {
+        io.log(``);
+        io.log(`Skipped: ${phaseSelection.skipped.map((phase) => phase.phase).join(", ")}`);
+    }
     if (options.json) {
         io.log(JSON.stringify({
             dryRun: true,
             taskId,
             gates,
             maxIterations,
-            phases: AUTONOMOUS_PHASE_SEQUENCE,
+            phases: phaseSelection.sequence,
+            skipped: phaseSelection.skipped,
         }, 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}`);
-    }
-}
-// --- Velocity command ---
-export async function velocityCommand(options, io) {
-    const cwd = process.cwd();
-    if (typeof options.sprints === "string") {
-        const limit = Number(options.sprints);
-        if (!Number.isInteger(limit) || limit <= 0) {
-            throw new Error("--sprints must be a positive integer");
-        }
-        const report = await velocityTrend(cwd, limit);
-        if (options.json) {
-            io.log(JSON.stringify(report, null, 2));
-            return;
-        }
-        io.log(`Sprint Velocity Report`);
-        io.log(`  Trend: ${report.trend}`);
-        for (const sprint of report.sprints) {
-            io.log(`  ${sprint.sprintId}  ${sprint.storiesCompleted} stories  ${sprint.pointsCompleted} pts`);
-        }
-        return;
-    }
-    const report = await computeVelocity(cwd);
-    if (options.json) {
-        io.log(JSON.stringify(report, null, 2));
-        return;
-    }
-    io.log(`Velocity Report`);
-    io.log(`  Stories completed: ${report.totalStoriesCompleted}`);
-    io.log(`  Points completed:  ${report.totalPointsCompleted}`);
-    io.log(`  Avg actual days:   ${report.avgActualDaysPerStory !== null ? report.avgActualDaysPerStory + "d" : "n/a"}`);
-    io.log(`  vs Solo estimate:  ${report.avgVsSoloPct !== null ? report.avgVsSoloPct + "%" : "n/a"}`);
-    io.log(`  vs AI estimate:    ${report.avgVsAiUnguidedPct !== null ? report.avgVsAiUnguidedPct + "%" : "n/a"}`);
-    io.log(`  Trend:             ${report.trend}`);
-    if (report.weeks.length > 0) {
-        io.log(`\nWeekly breakdown:`);
-        for (const week of report.weeks) {
-            io.log(`  ${week.week}  ${week.storiesCompleted} stories  ${week.pointsCompleted} pts`);
-        }
-    }
-}
-// --- Sprint command ---
-export async function sprintCommand(subcommand, options, io) {
-    const cwd = process.cwd();
-    if (subcommand === "start") {
-        const id = requireArg(options, "id");
-        const taskIds = requireArg(options, "tasks")
-            .split(",")
-            .map((taskId) => taskId.trim())
-            .filter(Boolean);
-        const sprint = await startSprint(cwd, id, taskIds);
-        if (options.json) {
-            io.log(JSON.stringify(sprint, null, 2));
-            return;
-        }
-        io.log(`Sprint started: ${sprint.id} (${sprint.taskIds.length} tasks)`);
-        return;
-    }
-    if (subcommand === "close") {
-        const id = requireArg(options, "id");
-        const sprint = await closeSprint(cwd, id);
-        if (options.json) {
-            io.log(JSON.stringify(sprint, null, 2));
-            return;
-        }
-        io.log(`Sprint closed: ${sprint.id}`);
-        return;
-    }
-    throw new Error(`unknown sprint command: ${subcommand ?? ""}`.trim());
-}
-// --- Calibration command ---
-export async function calibrationCommand(options, io) {
-    const report = await calibrationReport(process.cwd());
-    const roleFilter = typeof options.role === "string" ? options.role : null;
-    const filtered = roleFilter
-        ? { roles: report.roles.filter((role) => role.role === roleFilter) }
-        : report;
-    if (options.json) {
-        io.log(JSON.stringify(filtered, null, 2));
-        return;
-    }
-    io.log(`Calibration Report`);
-    for (const role of filtered.roles) {
-        io.log(`  ${role.role}  stories=${role.stories}  declared=${role.avgDeclaredDays}d  actual=${role.avgActualDays}d  error=${role.avgErrorPct}%  bias=${role.bias}`);
-    }
-}
-// --- 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),
@@ -1600,6 +1134,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 [];
@@ -1609,6 +1146,16 @@ function parseCsv(value) {
         .map((item) => item.trim())
         .filter(Boolean);
 }
+function csvOption(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    return parseCsv(value);
+}
+function singleValueArrayOption(value) {
+    const option = stringOption(value);
+    return option ? [option] : undefined;
+}
 function stringOption(value) {
     return typeof value === "string" && value.trim() !== "" ? value : undefined;
 }
@@ -1648,18 +1195,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({
@@ -1677,13 +1212,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;
@@ -1732,6 +1260,24 @@ function renderDependencyReport(report) {
             : report.dependencies.map((dependency) => `- ${dependency.id}: ${dependency.status} (${dependency.isComplete ? "complete" : "incomplete"})`)),
     ].join("\n");
 }
+function renderPreRunValidation(report) {
+    const status = report.allowed ? "allowed" : "blocked";
+    const missing = report.missing.length > 0 ? report.missing.join(", ") : "none";
+    return [
+        `Pre-run validation for ${report.taskId}: ${status}`,
+        `- Ready: ${String(report.isReady)}`,
+        `- Bypassed: ${String(report.isBypassed)}`,
+        `- Missing: ${missing}`,
+        `- Task: ${String(report.checks.task)}`,
+        `- Estimate: ${String(report.checks.estimate)}`,
+        `- Workflow run: ${String(report.checks.workflowRun)}`,
+        `- Evidence: ${String(report.checks.evidence)}`,
+        `- Review: ${String(report.checks.review)}`,
+        ...(report.bypassDecisionArtifact
+            ? [`- Bypass decision: ${report.bypassDecisionArtifact}`]
+            : []),
+    ].join("\n");
+}
 function renderTaskGraphPlan(plan) {
     return [
         "Task graph plan",
@@ -1749,6 +1295,28 @@ function renderTaskGraphPlan(plan) {
         ...taskGraphReadyLines(plan.complete),
     ].join("\n");
 }
+function renderTaskGraphDryRunPreview(preview) {
+    return [
+        "Task graph dry run",
+        `- Mode: ${preview.mode}`,
+        `- Would mutate: ${String(preview.wouldMutate)}`,
+        `- Selected: ${preview.selectedTaskIds.join(", ")}`,
+        "",
+        "Tasks:",
+        ...preview.tasks.map((task) => {
+            const budget = task.budget
+                ? ` budget=${task.budget.passed ? "pass" : "fail"} scopes=${task.budget.appliedBudgets.join(",") || "none"}`
+                : " budget=not-configured";
+            return `- ${task.id} ${task.title} (${task.ownerRole}) ${task.provider}/${task.model} fallbacks=${task.fallbacks.join(",") || "none"}${budget}`;
+        }),
+        "",
+        "Locked:",
+        ...taskGraphLockedLines(preview.locked),
+        "",
+        "Blocked:",
+        ...taskGraphBlockedLines(preview.blocked),
+    ].join("\n");
+}
 function renderTaskGraphBatchRun(batch) {
     return [
         "Task graph batch run",
@@ -1820,43 +1388,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}`,
@@ -1973,6 +1504,8 @@ function renderTaskContextMarkdown(context) {
             : context.skills.selected.map((item) => `- ${item.skill.id} (score ${item.score}): ${item.rationale.join("; ")}`)),
         `- Source groups: ${context.skills.sourceGroups.join(", ") || "none"}`,
         "",
+        renderMemoryPacket(context.memory),
+        "",
         "## Decisions",
         ...eventLines(context.decisions),
         "",
@@ -2045,6 +1578,27 @@ function renderPlaywrightPlanMarkdown(plan) {
         "",
     ].join("\n");
 }
+function renderTaskDetails(task) {
+    return [
+        `ID: ${task.id}`,
+        `Title: ${task.title}`,
+        `Owner: ${task.ownerRole}`,
+        `Status: ${task.status}`,
+        `Goal: ${task.goal ?? "—"}`,
+        `Scope: ${task.scope ?? "—"}`,
+        `Acceptance Criteria: ${renderInlineList(task.acceptanceCriteria)}`,
+        `Assumptions: ${renderInlineList(task.assumptions)}`,
+        `Risks: ${renderInlineList(task.risks)}`,
+        `Paths: ${renderInlineList(task.paths)}`,
+        `Test Strategy: ${task.testStrategy ?? "—"}`,
+        `Blocked Reason: ${task.blockedReason ?? "—"}`,
+        `Created: ${task.createdAt}`,
+        `Updated: ${task.updatedAt}`,
+    ];
+}
+function renderInlineList(values) {
+    return values && values.length > 0 ? values.join(", ") : "—";
+}
 function eventLines(events) {
     return events.length === 0
         ? ["- none"]