@jterrats/open-orchestra 0.4.1 → 0.4.2-beta.2

package/dist/commands.js

@@ -1,22 +1,25 @@
-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 { 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 { addEvidence, addPlaywrightEvidence, addTask, checkReadiness, checkTaskDependencies, claimLock, createHandoff, evaluateWorkflowGate, executeNextReadyTask, executePlanWithBudgetPreflight, executeReadyTaskBatch, generateExecutionPlan, generatePlaywrightTestPlan, generatePullRequestSummary, generateTaskGraphPlan, getWorkflowStatus, getWorkflowSummary, getTaskContext, getWorkflowConfig, listEvidence, listDecisions, listLocks, listReviews, listRoles, listTasks, recordReview, recordDecision, releaseLock, updateTask, } from "./workflow-services.js";
+import { 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 { getWebServerAddress, startWebApiServer } from "./web-api.js";
 import { decideTaskDelegation } from "./delegation-decision.js";
 import { listCollaborationFlows, recommendCollaborationFlow, } from "./collaboration-flows.js";
 import { listWorkflowTemplates, renderWorkflowTemplates, selectWorkflowTemplates, validateWorkflowTemplates, } from "./workflow-templates.js";
 import { parseRuntimeTarget } from "./runtime-adapters.js";
+import { importSetupAgentsArtifacts } from "./setup-agents-import.js";
 export { instructionsApplyCommand, instructionsBlockCommand, instructionsImportsCommand, instructionsStaleCommand, } from "./instruction-commands.js";
 export { benchmarkCommand, estimateCommand } from "./metrics-commands.js";
 export { burndownCommand, calibrationCommand, sprintCommand, velocityCommand, } from "./sprint-commands.js";
 export { approvalsApproveCommand, approvalsListCommand, approvalsRejectCommand, approvalsShowCommand, budgetCheckCommand, configShowCommand, modelCompleteFakeCommand, modelProvidersCommand, modelProvenanceAddCommand, modelProvenanceListCommand, modelSetRoleCommand, usageCommand, } from "./model-commands.js";
 export { commandsManifestCommand, protocolBlockCommand, protocolRenderCommand, runtimeAdaptersCommand, runtimeBootstrapCommand, runtimeBriefCommand, runtimeDelegatePlanCommand, runtimeHandoffCommand, } from "./runtime-commands.js";
-export { lessonsAddCommand, lessonsListCommand, lessonsPromoteCommand, skillsListCommand, skillsPlanCommand, skillsRenderCommand, skillsValidateCommand, sourcesListCommand, } from "./skills-commands.js";
-export { diagramsLintCommand, mcpOAuthProxyEvaluateCommand, } from "./tool-commands.js";
+export { 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) {
@@ -63,6 +66,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));
@@ -113,8 +133,27 @@ export async function taskAddCommand(options, io) {
     const task = await addTask(input);
     io.log(`Added task ${task.id}`);
 }
+export async function setupAgentsImportCommand(options, io) {
+    const report = await importSetupAgentsArtifacts(removeUndefined({
+        source: stringOption(options.source),
+    }));
+    if (options.json) {
+        io.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    io.log(`Imported setup-agents artifacts from ${report.sourceRoot}`);
+    io.log(`Profiles: ${report.profiles.imported.length} imported, ${report.profiles.conflicts.length} conflicts`);
+    io.log(`Tasks: ${report.tasks.imported.length} imported, ${report.tasks.skipped.length} skipped, ${report.tasks.conflicts.length} conflicts`);
+    const evidenceCount = report.evidence.imported.reduce((total, item) => total + item.ids.length, 0);
+    const handoffCount = report.handoffs.imported.reduce((total, item) => total + item.ids.length, 0);
+    io.log(`References: ${evidenceCount} evidence, ${handoffCount} handoffs preserved`);
+}
 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;
@@ -127,6 +166,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) {
@@ -146,6 +246,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"]),
     }));
@@ -168,6 +277,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));
@@ -176,6 +294,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));
@@ -248,6 +375,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}`);
 }
@@ -360,13 +488,49 @@ export async function delegationDecideCommand(options, io) {
     io.log(renderDelegationDecisionMarkdown(decision));
 }
 export async function contextCommand(options, io) {
-    const context = await getTaskContext(requireArg(options, "task"));
+    const context = await getTaskContext(requireArg(options, "task"), process.cwd(), {
+        tokenBudget: numberOption(options.budget, 3000),
+    });
     if (options.json) {
         io.log(JSON.stringify(context, null, 2));
         return;
     }
     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) {
@@ -377,7 +541,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;
@@ -470,11 +639,14 @@ export async function workflowTemplateSelectCommand(options, io) {
     }
 }
 export async function workflowTemplateRenderCommand(options, io) {
-    const context = await getTaskContext(requireArg(options, "task"));
+    const context = await getTaskContext(requireArg(options, "task"), process.cwd(), {
+        tokenBudget: numberOption(options.budget, 2500),
+    });
     const rendered = renderWorkflowTemplates({
         task: context.task,
         target: parseSkillRenderTarget(stringOption(options.target) ?? "generic"),
         templates: context.workflowTemplates,
+        contextBudget: context.contextBudget,
     });
     if (options.json) {
         io.log(JSON.stringify(rendered, null, 2));
@@ -489,12 +661,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;
@@ -503,21 +685,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));
@@ -535,7 +735,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;
@@ -551,17 +753,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}`);
@@ -572,9 +792,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,
@@ -585,8 +802,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));
@@ -610,11 +828,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) {
@@ -628,14 +847,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) {
@@ -646,17 +876,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)}`);
@@ -682,7 +1010,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)
@@ -690,6 +1018,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") {
@@ -705,15 +1044,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}`);
@@ -721,6 +1060,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;
@@ -730,7 +1071,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
@@ -761,18 +1102,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"
@@ -781,13 +1133,18 @@ 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));
     }
 }
@@ -810,6 +1167,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;
 }
@@ -914,6 +1281,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",
@@ -931,6 +1316,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",
@@ -1097,6 +1504,11 @@ function renderTaskContextMarkdown(context) {
         `- Locks: ${context.locks.length}`,
         `- Risks: ${context.risks.length}`,
         `- Delegation: ${context.delegation?.recommendation ?? "not decided"}`,
+        `- Estimated tokens: ${context.contextBudget.estimatedTokens}/${context.contextBudget.tokenBudget}`,
+        `- Trimmed: ${context.contextBudget.trimmed}`,
+        "",
+        "## Context Budget",
+        ...context.contextBudget.sections.map((section) => `- ${section.section}: kept ${section.keptCount}/${section.originalCount}, dropped ${section.droppedCount}`),
         "",
         "## Collaboration Flow",
         ...(context.collaborationFlow
@@ -1118,6 +1530,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),
         "",
@@ -1190,6 +1604,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"]