@jterrats/open-orchestra 0.4.2-beta.1 → 0.5.0-beta.0

package/dist/commands.js

@@ -1,17 +1,14 @@
-import { appendEvent, initWorkspace } from "./workspace.js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { initWorkspace, inspectInitWorkspace } from "./workspace.js";
 import { requireArg } from "./args.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, 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 { addTask, generatePullRequestSummary, getWorkflowStatus, getWorkflowSummary, listRoles, 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 { syncGitHubIssueToTask } from "./github.js";
 import { parseRuntimeTarget } from "./runtime-adapters.js";
+import { importSetupAgentsArtifacts } from "./setup-agents-import.js";
+import { numberOption, parseCsv, removeUndefined, stringOption, targetRootOption, } from "./command-utils.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";
@@ -19,10 +16,17 @@ export { approvalsApproveCommand, approvalsListCommand, approvalsRejectCommand,
 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 { decisionAddCommand, decisionListCommand, evidenceCommand, evidenceListCommand, gateCommand, handoffCommand, readinessCommand, reviewCommand, reviewListCommand, } from "./delivery-commands.js";
+export { graphPlanCommand, graphRunNextCommand, graphRunReadyCommand, lockClaimCommand, lockListCommand, lockReleaseCommand, taskAddCommand, taskArchiveCommand, taskDeleteCommand, taskDepsCommand, taskListCommand, taskShowCommand, taskUpdateCommand, } from "./task-graph-commands.js";
+export { collaborationFlowsCommand, collaborationRecommendCommand, contextCommand, delegationDecideCommand, memoryHookCommand, memoryQueryCommand, planCommand, playwrightEvidenceCommand, playwrightPlanCommand, runCommand, workflowTemplateRenderCommand, workflowTemplateSelectCommand, workflowTemplatesCommand, } from "./planning-commands.js";
 export { telemetryDisableCommand, telemetryEnableCommand, telemetryEvalDatasetCommand, telemetryExportCommand, telemetryStatusCommand, telemetrySubmitCommand, } from "./telemetry-commands.js";
-import { buildPrBody, createPullRequest } from "./github.js";
+export { workflowCancelCommand, workflowClarifyCommand, workflowClarifyListCommand, workflowClarifyRespondCommand, workflowGateApproveCommand, workflowRunCommand, workflowRunListCommand, } from "./workflow-run-commands.js";
 export async function initCommand(options, io) {
-    const root = stringOption(options["target-dir"]) ?? process.cwd();
+    if (options.help || options.h) {
+        io.log(renderInitHelp());
+        return;
+    }
+    const root = targetRootOption(options);
     const input = {
         root,
         force: Boolean(options.force),
@@ -31,27 +35,45 @@ export async function initCommand(options, io) {
     };
     const bootstrapTargetFile = stringOption(options["bootstrap-file"]);
     const runtimeTargets = parseRuntimeTargetOptions(options);
-    const base = await initWorkspace({
+    const preflight = await inspectInitWorkspace({
         ...input,
         ...(bootstrapTargetFile ? { bootstrapTargetFile } : {}),
         ...(runtimeTargets.length > 0 ? { runtimeTargets } : {}),
     });
-    io.log(`Initialized ${base}`);
-    if (options.advisory) {
-        io.log("Advisory mode enabled; root instruction files were not written.");
+    if (options.check || options["dry-run"]) {
+        if (options.json) {
+            io.log(JSON.stringify(preflight, null, 2));
+            return;
+        }
+        io.log(renderInitPreflight(preflight));
+        return;
     }
-    else {
-        io.log("Prompt registry scaffolded in .generated-prompts/");
+    const base = await initWorkspace({
+        ...input,
+        ...(bootstrapTargetFile ? { bootstrapTargetFile } : {}),
+        ...(runtimeTargets.length > 0 ? { runtimeTargets } : {}),
+    });
+    const result = {
+        ...preflight,
+        workflowRoot: base,
+        initialized: true,
+        nextSteps: initNextSteps(preflight.mode, root),
+    };
+    if (options.json) {
+        io.log(JSON.stringify(result, null, 2));
+        return;
     }
-    io.log("Source catalog and agent lessons scaffolded in .agent-workflow/");
-    io.log("Next: add tasks to .agent-workflow/tasks.json and run orchestra status");
+    io.log(renderInitSuccess(result));
 }
 export async function statusCommand(options, io) {
-    const status = await getWorkflowStatus();
+    const root = targetRootOption(options);
+    const status = await getWorkflowStatus(root);
     if (options.json) {
-        io.log(JSON.stringify(status, null, 2));
+        io.log(JSON.stringify({ workspaceRoot: root, ...status }, null, 2));
         return;
     }
+    io.log(`Workspace: ${root}`);
+    io.log(`Mode: ${status.mode ?? "project"}`);
     io.log(`Tasks: ${status.tasks.total}`);
     for (const [name, count] of Object.entries(status.tasks.byStatus)) {
         io.log(`  ${name}: ${count}`);
@@ -64,6 +86,38 @@ export async function statusCommand(options, io) {
         }
     }
 }
+export async function advisoryConvertCommand(options, io) {
+    const root = targetRootOption(options);
+    const taskFile = stringOption(options.file) ??
+        path.join(root, ".agent-workflow", "advisory", "project-task.json");
+    const payload = JSON.parse(await readFile(taskFile, "utf8"));
+    const task = await addTask(removeUndefined({
+        id: stringOption(options.id) ?? requiredString(payload.id, "id"),
+        title: requiredString(payload.title, "title"),
+        ownerRole: requiredString(payload.ownerRole, "ownerRole"),
+        dependencies: [],
+        backlogItem: stringOption(options.backlog),
+        goal: optionalString(payload.goal) ??
+            "Convert advisory findings into a project delivery task",
+        scope: optionalString(payload.scope) ??
+            "Advisory findings, decisions, role guides, and conversion path",
+        acceptanceCriteria: requiredStringArray(payload.acceptanceCriteria, "acceptanceCriteria"),
+        assumptions: optionalStringArray(payload.assumptions) ?? [
+            "Target project repository has been confirmed before conversion.",
+        ],
+        risks: optionalStringArray(payload.risks) ?? [
+            "Advisory findings may require project-owner validation.",
+        ],
+        paths: optionalStringArray(payload.paths) ?? [".agent-workflow/advisory"],
+        testStrategy: optionalString(payload.testStrategy) ??
+            "Review advisory artifacts and attach project evidence.",
+    }), root);
+    if (options.json) {
+        io.log(JSON.stringify({ task, source: taskFile }, null, 2));
+        return;
+    }
+    io.log(`Converted advisory task ${task.id} from ${taskFile}`);
+}
 export async function validateCommand(options, io) {
     if (options["pre-run"]) {
         const report = await validatePreRun(requireArg(options, "task"), removeUndefined({
@@ -82,11 +136,13 @@ export async function validateCommand(options, io) {
         }
         return;
     }
-    const report = await validateWorkspace();
+    const root = targetRootOption(options);
+    const report = await validateWorkspace(root);
     if (options.json) {
-        io.log(JSON.stringify(report, null, 2));
+        io.log(JSON.stringify({ workspaceRoot: root, ...report }, null, 2));
     }
     else {
+        io.log(`Workspace: ${root}`);
         io.log(report.valid ? "Workspace valid" : "Workspace invalid");
         for (const error of report.errors) {
             io.log(`ERROR: ${error}`);
@@ -99,117 +155,138 @@ export async function validateCommand(options, io) {
         throw new Error("workspace validation failed");
     }
 }
-export async function webCommand(options, io) {
-    const serverOptions = {};
-    const host = stringOption(options.host);
-    if (host) {
-        serverOptions.host = host;
-    }
-    if (options.port) {
-        serverOptions.port = numberOption(options.port, 3717);
-    }
-    const server = await startWebApiServer(serverOptions);
-    io.log(`Open Orchestra web API listening at ${getWebServerAddress(server)}`);
-}
-export async function taskAddCommand(options, io) {
-    const input = removeUndefined({
-        id: requireArg(options, "id"),
-        title: requireArg(options, "title"),
-        ownerRole: requireArg(options, "owner"),
-        dependencies: parseCsv(options.depends),
-        backlogItem: stringOption(options.backlog),
-        goal: stringOption(options.goal),
-        scope: stringOption(options.scope),
-        acceptanceCriteria: parseCsv(options.acceptance),
-        assumptions: parseCsv(options.assumptions),
-        risks: parseCsv(options.risks),
-        paths: parseCsv(options.paths),
-        testStrategy: stringOption(options["test-strategy"]),
-        architectureApproval: parseArchitectureApproval(options),
-        qaGate: parseQaGate(options),
-        riskGate: parseRiskGate(options),
-    });
-    const task = await addTask(input);
-    io.log(`Added task ${task.id}`);
-}
-export async function taskListCommand(options, io) {
-    if (options.help || options.h) {
-        io.log("task list [--json] [--status <csv>] [--owner <role>] [--filter <text>] [--top-level] [--include-archived]");
-        return;
+function renderInitHelp() {
+    return `orchestra init
+
+Usage:
+  orchestra init [--force] [--advisory] [--confirm-unknown] [--target-dir <dir>] [--target <csv>] [--bootstrap-file <file>] [--check|--dry-run] [--json]
+
+Examples:
+  orchestra init
+  orchestra init --confirm-unknown
+  orchestra init --target-dir ../my-project
+  orchestra init --target claude,cursor,windsurf
+  orchestra init --advisory
+  orchestra init --check
+  orchestra init --force
+
+After init:
+  orchestra health --json
+  orchestra task add --id <id> --title <title> --owner <role>
+  orchestra status
+  orchestra web`;
+}
+function renderInitPreflight(report) {
+    const lines = [
+        `Workspace: ${report.root}`,
+        `Mode: ${report.mode}`,
+        `Workflow root: ${report.workflowRoot}`,
+        report.workflowExists
+            ? "Workflow state already exists."
+            : "Workflow state will be created.",
+    ];
+    if (report.existingArtifacts.length > 0) {
+        lines.push("Existing managed artifacts:");
+        for (const artifact of report.existingArtifacts) {
+            lines.push(`  ${artifact}`);
+        }
     }
-    const tasks = filterTasks(await listTasks(), options);
-    if (options.json) {
-        io.log(JSON.stringify(tasks, null, 2));
-        return;
+    lines.push(report.force
+        ? "Force: generated files will be refreshed."
+        : "Force: disabled; existing workflow state is preserved.");
+    lines.push("Generated artifacts:");
+    for (const artifact of report.generatedArtifacts) {
+        lines.push(`  ${artifact}`);
+    }
+    return lines.join("\n");
+}
+function renderInitSuccess(result) {
+    const lines = [
+        `Initialized ${result.workflowRoot}`,
+        result.mode === "advisory"
+            ? "Advisory mode enabled; root instruction files were not written unless explicitly targeted."
+            : "Prompt registry scaffolded in .generated-prompts/",
+        "Source catalog and agent lessons scaffolded in .agent-workflow/",
+    ];
+    if (result.force) {
+        lines.push("Force mode refreshed generated workflow artifacts.");
     }
-    if (tasks.length === 0) {
-        io.log("No tasks");
-        return;
+    lines.push("Generated artifacts:");
+    for (const artifact of result.generatedArtifacts) {
+        lines.push(`  ${artifact}`);
     }
-    for (const task of tasks) {
-        io.log(`${task.id} [${task.status}] ${task.title} (${task.ownerRole})`);
+    lines.push("Next steps:");
+    for (const [index, step] of result.nextSteps.entries()) {
+        lines.push(`  ${index + 1}. ${step}`);
     }
+    return lines.join("\n");
 }
-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(", ")}`);
+function initNextSteps(mode, root) {
+    const targetSuffix = root === process.cwd() ? "" : ` --target-dir ${root}`;
+    if (mode === "advisory") {
+        return [
+            `Run orchestra health --json${targetSuffix}`,
+            "Review .agent-workflow/advisory/README.md",
+            "Convert .agent-workflow/advisory/project-task.json with orchestra advisory convert when the target repo is confirmed",
+        ];
     }
-    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();
+    return [
+        `Run orchestra health --json${targetSuffix}`,
+        "Add a task with orchestra task add --id <id> --title <title> --owner <role>",
+        `Check workflow status with orchestra status${targetSuffix}`,
+        "Open the console with orchestra web",
+    ];
 }
-function isTopLevelTask(task) {
-    return !["pm", "po", "architect", "developer", "qa", "release"].some((phase) => task.id.includes(`-${phase}-`));
+function requiredString(value, name) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new Error(`advisory project task missing ${name}`);
+    }
+    return value;
 }
-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}`);
+function optionalString(value) {
+    if (typeof value !== "string" || value.trim() === "") {
+        return undefined;
     }
-    if (options.json) {
-        io.log(JSON.stringify(task, null, 2));
-        return;
+    return value;
+}
+function requiredStringArray(value, name) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw new Error(`advisory project task missing ${name}`);
     }
-    for (const line of renderTaskDetails(task)) {
-        io.log(line);
+    return value;
+}
+function optionalStringArray(value) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        return undefined;
     }
+    return value;
 }
-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;
+export async function webCommand(options, io) {
+    const serverOptions = {};
+    const host = stringOption(options.host);
+    if (host) {
+        serverOptions.host = host;
     }
-    io.log(`Deleted task ${task.id}`);
+    if (options.port) {
+        serverOptions.port = numberOption(options.port, 3717);
+    }
+    const server = await startWebApiServer(serverOptions);
+    io.log(`Open Orchestra web API listening at ${getWebServerAddress(server)}`);
 }
-export async function taskArchiveCommand(options, io) {
-    const task = await archiveTask(requireArg(options, "id"), {
-        force: Boolean(options.force),
-    });
+export async function setupAgentsImportCommand(options, io) {
+    const report = await importSetupAgentsArtifacts(removeUndefined({
+        source: stringOption(options.source),
+    }));
     if (options.json) {
-        io.log(JSON.stringify(task, null, 2));
+        io.log(JSON.stringify(report, null, 2));
         return;
     }
-    io.log(`Archived task ${task.id}`);
+    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 rolesListCommand(options, io) {
     const roles = await listRoles();
@@ -226,225 +303,6 @@ export async function rolesListCommand(options, io) {
         io.log(`${role.id} - ${role.name} (gates: ${gates})`);
     }
 }
-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"]),
-    }));
-    io.log(`Updated task ${id}`);
-}
-export async function taskDepsCommand(options, io) {
-    const report = await checkTaskDependencies(requireArg(options, "id"));
-    if (options.json) {
-        io.log(JSON.stringify(report, null, 2));
-        return;
-    }
-    io.log(renderDependencyReport(report));
-}
-export async function graphPlanCommand(options, io) {
-    const plan = await generateTaskGraphPlan();
-    if (options.json) {
-        io.log(JSON.stringify(plan, null, 2));
-        return;
-    }
-    io.log(renderTaskGraphPlan(plan));
-}
-export async function graphRunNextCommand(options, io) {
-    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));
-        return;
-    }
-    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));
-        return;
-    }
-    io.log(renderTaskGraphBatchRun(batch));
-    if (batch.failure) {
-        throw new Error(`graph batch failed: ${batch.failure.taskId}`);
-    }
-}
-export async function lockListCommand(options, io) {
-    const locks = await listLocks();
-    if (options.json) {
-        io.log(JSON.stringify(locks, null, 2));
-        return;
-    }
-    if (locks.length === 0) {
-        io.log("No locks");
-        return;
-    }
-    for (const lock of locks) {
-        io.log(`${lock.id} ${lock.path} (${lock.taskId}, ${lock.ownerRole})`);
-    }
-}
-export async function lockClaimCommand(options, io) {
-    const lock = await claimLock(removeUndefined({
-        id: stringOption(options.id),
-        taskId: requireArg(options, "task"),
-        ownerRole: requireArg(options, "role"),
-        path: requireArg(options, "path"),
-        reason: requireArg(options, "reason"),
-        expiresAt: stringOption(options.expires),
-    }));
-    io.log(`Claimed lock ${lock.id}`);
-}
-export async function lockReleaseCommand(options, io) {
-    const id = requireArg(options, "id");
-    await releaseLock(id);
-    io.log(`Released lock ${id}`);
-}
-export async function readinessCommand(options, io) {
-    const taskId = requireArg(options, "task");
-    const { task, report } = await checkReadiness(taskId);
-    if (options.markdown) {
-        io.log(renderReadinessMarkdown(task, report));
-        return;
-    }
-    io.log(JSON.stringify(report, null, 2));
-}
-export async function gateCommand(options, io) {
-    const gateId = requireArg(options, "gate");
-    const taskId = requireArg(options, "task");
-    const result = await evaluateWorkflowGate(gateId, taskId);
-    if (options.markdown) {
-        io.log(renderGateMarkdown(result));
-        return;
-    }
-    io.log(JSON.stringify(result, null, 2));
-}
-export async function handoffCommand(options, io) {
-    const { artifact } = await createHandoff(removeUndefined({
-        task: requireArg(options, "task"),
-        from: requireArg(options, "from"),
-        to: requireArg(options, "to"),
-        changed: requireArg(options, "changed"),
-        behavior: requireArg(options, "behavior"),
-        tests: requireArg(options, "tests"),
-        commands: requireArg(options, "commands"),
-        status: stringOption(options.status),
-        gaps: stringOption(options.gaps),
-        risks: stringOption(options.risks),
-        playwright: stringOption(options.playwright),
-        updateOwner: options["update-owner"] ? true : undefined,
-    }));
-    io.log(`Created ${artifact}`);
-}
-export async function reviewCommand(options, io) {
-    const input = {
-        task: requireArg(options, "task"),
-        role: requireArg(options, "role"),
-        result: requireArg(options, "result"),
-        severity: stringOption(options.severity) ?? "info",
-        findings: requireArg(options, "findings"),
-        recommendation: requireArg(options, "recommendation"),
-    };
-    const { artifact } = await recordReview(input);
-    io.log(`Created ${artifact}`);
-}
-export async function decisionAddCommand(options, io) {
-    const decision = await recordDecision({
-        task: requireArg(options, "task"),
-        title: requireArg(options, "title"),
-        context: requireArg(options, "context"),
-        decision: requireArg(options, "decision"),
-        consequences: requireArg(options, "consequences"),
-        status: (stringOption(options.status) ?? "accepted"),
-        owner: requireArg(options, "owner"),
-    });
-    io.log(`Created ${decision.artifact}`);
-}
-export async function decisionListCommand(options, io) {
-    const decisions = await listDecisions(stringOption(options.task));
-    if (options.json) {
-        io.log(JSON.stringify(decisions, null, 2));
-        return;
-    }
-    if (decisions.length === 0) {
-        io.log("No decisions");
-        return;
-    }
-    for (const decision of decisions) {
-        io.log(`${decision.taskId ?? "no-task"} ${decision.actor}: ${decision.summary}`);
-    }
-}
-export async function reviewListCommand(options, io) {
-    const reviews = await listReviews(stringOption(options.task));
-    if (options.json) {
-        io.log(JSON.stringify(reviews, null, 2));
-        return;
-    }
-    if (reviews.length === 0) {
-        io.log("No reviews");
-        return;
-    }
-    for (const review of reviews) {
-        const result = String(review.metadata.result ?? "unknown");
-        const severity = String(review.metadata.severity ?? "unknown");
-        io.log(`${review.taskId ?? "no-task"} ${review.actor} ${result} (${severity})`);
-    }
-}
-export async function evidenceCommand(options, io) {
-    const input = removeUndefined({
-        task: requireArg(options, "task"),
-        role: requireArg(options, "role"),
-        type: requireArg(options, "type"),
-        summary: requireArg(options, "summary"),
-        path: options.path,
-        command: options.command,
-        exitCode: options["exit-code"],
-    });
-    const { artifact } = await addEvidence(input);
-    io.log(`Created ${artifact}`);
-}
-export async function evidenceListCommand(options, io) {
-    const evidence = await listEvidence(stringOption(options.task));
-    if (options.json) {
-        io.log(JSON.stringify(evidence, null, 2));
-        return;
-    }
-    if (evidence.length === 0) {
-        io.log("No evidence");
-        return;
-    }
-    for (const item of evidence) {
-        const type = String(item.metadata.type ?? "unknown");
-        io.log(`${item.taskId ?? "no-task"} ${item.actor} ${type}: ${item.summary}`);
-    }
-}
 export async function summaryCommand(options, io) {
     const summary = await getWorkflowSummary();
     if (options.json) {
@@ -461,671 +319,30 @@ export async function prSummaryCommand(options, io) {
     }
     io.log(renderPullRequestSummaryMarkdown(summary));
 }
-export async function delegationDecideCommand(options, io) {
-    const decision = await decideTaskDelegation(requireArg(options, "task"), process.cwd(), {
-        record: !options["no-record"],
-    });
-    if (options.json) {
-        io.log(JSON.stringify(decision, null, 2));
-        return;
-    }
-    io.log(renderDelegationDecisionMarkdown(decision));
-}
-export async function contextCommand(options, io) {
-    const context = await getTaskContext(requireArg(options, "task"));
-    if (options.json) {
-        io.log(JSON.stringify(context, null, 2));
-        return;
-    }
-    io.log(renderTaskContextMarkdown(context));
-}
-export async function 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) {
-        io.log(JSON.stringify(plan, null, 2));
-        return;
-    }
-    io.log(renderExecutionPlanMarkdown(plan));
-}
-export async function runCommand(options, io) {
-    const taskId = requireArg(options, "task");
-    const run = await executePlanWithBudgetPreflight(taskId, process.cwd(), parseBudgetEscalationDecision(options), 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;
-    }
-    io.log(renderExecutionRunMarkdown(run));
-}
-export async function playwrightPlanCommand(options, io) {
-    const plan = await generatePlaywrightTestPlan(requireArg(options, "task"));
-    if (options.json) {
-        io.log(JSON.stringify(plan, null, 2));
-        return;
-    }
-    io.log(renderPlaywrightPlanMarkdown(plan));
-}
-export async function playwrightEvidenceCommand(options, io) {
-    const { artifact } = await addPlaywrightEvidence(removeUndefined({
-        task: requireArg(options, "task"),
-        kind: requireArg(options, "kind"),
-        path: requireArg(options, "path"),
-        summary: requireArg(options, "summary"),
-        runId: stringOption(options["run-id"]),
+export async function githubSyncCommand(options, io) {
+    const result = await syncGitHubIssueToTask(removeUndefined({
+        issue: Number(requireArg(options, "issue")),
+        taskId: stringOption(options.task),
+        ownerRole: stringOption(options.owner),
+        status: stringOption(options.status),
+        comment: Boolean(options.comment),
+        close: Boolean(options.close),
+        acceptedRisk: stringOption(options["accepted-risk"]),
+        dryRun: Boolean(options["dry-run"]),
+        transport: stringOption(options.transport) === "mcp-skill" ? "mcp-skill" : "gh",
     }));
-    io.log(`Created ${artifact}`);
-}
-export async function collaborationFlowsCommand(options, io) {
-    const flows = listCollaborationFlows();
-    if (options.json) {
-        io.log(JSON.stringify(flows, null, 2));
-        return;
-    }
-    for (const flow of flows) {
-        io.log(flow.id + " - " + flow.name);
-        io.log("  roles: " + flow.roles.join(", "));
-    }
-}
-export async function collaborationRecommendCommand(options, io) {
-    const context = await getTaskContext(requireArg(options, "task"));
-    const recommendation = recommendCollaborationFlow(context.task, [
-        ...context.decisions,
-        ...context.handoffs,
-        ...context.reviews,
-        ...context.evidence,
-        ...context.gates,
-    ]);
-    if (options.json) {
-        io.log(JSON.stringify(recommendation, null, 2));
-        return;
-    }
-    if (!recommendation) {
-        io.log("No collaboration flow recommended");
-        return;
-    }
-    io.log(recommendation.flow.id + " - " + recommendation.flow.name);
-    io.log("Missing artifacts: " +
-        (recommendation.missingArtifacts.join(", ") || "none"));
-    io.log("Reviewers: " + (recommendation.optionalReviewers.join(", ") || "none"));
-}
-export async function workflowTemplatesCommand(options, io) {
-    const templates = listWorkflowTemplates();
-    const validationErrors = validateWorkflowTemplates();
-    if (options.json) {
-        io.log(JSON.stringify({ templates, validationErrors }, null, 2));
-        return;
-    }
-    for (const template of templates) {
-        io.log(template.id + " - " + template.name);
-        io.log("  roles: " + template.roles.join(", "));
-    }
-    if (validationErrors.length > 0) {
-        io.log("Validation errors: " + validationErrors.join("; "));
-    }
-}
-export async function workflowTemplateSelectCommand(options, io) {
-    const context = await getTaskContext(requireArg(options, "task"));
-    const events = [
-        ...context.decisions,
-        ...context.handoffs,
-        ...context.reviews,
-        ...context.evidence,
-        ...context.gates,
-    ];
-    const selection = selectWorkflowTemplates(context.task, events);
-    if (options.json) {
-        io.log(JSON.stringify(selection, null, 2));
-        return;
-    }
-    for (const item of selection) {
-        io.log(item.template.id + " (score " + item.score + ")");
-        io.log("  missing evidence: " + (item.missingEvidence.join(", ") || "none"));
-    }
-}
-export async function workflowTemplateRenderCommand(options, io) {
-    const context = await getTaskContext(requireArg(options, "task"));
-    const rendered = renderWorkflowTemplates({
-        task: context.task,
-        target: parseSkillRenderTarget(stringOption(options.target) ?? "generic"),
-        templates: context.workflowTemplates,
-    });
-    if (options.json) {
-        io.log(JSON.stringify(rendered, null, 2));
-        return;
-    }
-    io.log(rendered.content);
-}
-// --- Autonomous workflow commands ---
-const GATE_MODES = ["none", "phase", "all"];
-export async function workflowRunCommand(options, io) {
-    const cwd = process.cwd();
-    const taskId = requireArg(options, "task");
-    const gates = (stringOption(options.gates) ?? "phase");
-    const maxIterations = numberOption(options["max-iterations"], 5);
-    const 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, phaseSelection);
-    }
-    let run;
-    let startIndex;
-    if (options.resume) {
-        const existing = await readAutonomousRun(cwd, String(options.resume));
-        if (!existing)
-            throw new Error(`workflow run not found: ${String(options.resume)}`);
-        run = existing;
-        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;
-        }
-        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,
-            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, phaseSequenceForRun(run, phaseSelection.sequence), {
-        runTimeoutMinutes: timeoutMinutes,
-        phaseTimeoutMinutes,
-    });
-    const result = { run, file, cwd };
     if (options.json) {
         io.log(JSON.stringify(result, null, 2));
         return;
     }
-    if (run.status === "done") {
-        io.log(`Workflow complete [run=${run.id}]`);
-    }
-    else if (run.status === "paused") {
-        io.log(`Workflow paused — approve gate review then run: orchestra workflow run --task ${taskId} --resume ${run.id}`);
-    }
-    else {
-        io.log(`Workflow ${run.status} [run=${run.id}]`);
-    }
-}
-export async function workflowRunListCommand(options, io) {
-    const cwd = process.cwd();
-    const runs = options.active
-        ? await listActiveAutonomousRuns(cwd)
-        : await listAutonomousRuns(cwd);
-    if (options.json) {
-        io.log(JSON.stringify(runs, null, 2));
-        return;
-    }
-    if (runs.length === 0) {
-        io.log("No workflow runs");
-        return;
-    }
-    for (const run of runs) {
-        const phases = run.phases.map((p) => `${p.phase}:${p.status}`).join(" → ");
-        io.log(`${run.id} [${run.status}] task=${run.taskId} gates=${run.gates}`);
-        if (phases)
-            io.log(`  ${phases}`);
-    }
-}
-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 = await resolveClarificationRole(cwd, requireArg(options, "from"));
-    const to = await resolveClarificationRole(cwd, requireArg(options, "to"));
-    const question = requireArg(options, "question");
-    const run = await readAutonomousRun(cwd, runId);
-    if (!run)
-        throw new Error(`workflow run not found: ${runId}`);
-    // Find the active phase (running or already awaiting_clarification)
-    const activePhaseIdx = run.phases.findIndex((p) => p.role === from &&
-        (p.status === "running" || p.status === "awaiting_clarification"));
-    if (activePhaseIdx === -1) {
-        throw new Error(`no active phase found for role ${from} in run ${runId}`);
-    }
-    const activePhase = run.phases[activePhaseIdx];
-    // Open clarification record
-    const record = await openClarification(cwd, {
-        runId,
-        taskId: run.taskId,
-        fromRole: from,
-        to,
-        question,
-    });
-    // Suspend the phase if it's still running
-    if (activePhase.status === "running") {
-        const 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));
-        return;
-    }
-    io.log(`Clarification ${record.id} opened — waiting for ${record.toRole}`);
-    io.log(`  Question: ${record.question}`);
-    io.log(`  Respond with:`);
-    io.log(`  orchestra workflow clarify-respond --run ${runId} --clarification ${record.id} --answer "<text>"`);
-}
-export async function workflowClarifyRespondCommand(options, io) {
-    const cwd = process.cwd();
-    const runId = requireArg(options, "run");
-    const clarificationId = requireArg(options, "clarification");
-    const answer = requireArg(options, "answer");
-    const run = await readAutonomousRun(cwd, runId);
-    if (!run)
-        throw new Error(`workflow run not found: ${runId}`);
-    const record = await answerClarification(cwd, {
-        id: clarificationId,
-        answer,
-    });
-    // Resume the suspended phase back to running
-    const 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, sequence);
-        }
-    }
-    if (options.json) {
-        io.log(JSON.stringify(record, null, 2));
-        return;
-    }
-    io.log(`Clarification ${record.id} answered`);
-    io.log(`  Answer: ${record.answer}`);
-    io.log(`  Resume with:`);
-    io.log(`  orchestra workflow run --task ${run.taskId} --resume ${runId}`);
-}
-export async function workflowClarifyListCommand(options, io) {
-    const cwd = process.cwd();
-    const runId = 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(runId
-            ? `No clarifications for run ${runId}`
-            : `No clarifications for task ${taskId}`);
-        return;
-    }
-    for (const c of clarifications) {
-        const status = c.status === "answered" ? "✓" : "⏳";
-        io.log(`${status} [${c.id}] ${c.fromRole} → ${c.toRole}`);
-        io.log(`  Q: ${c.question}`);
-        if (c.answer)
-            io.log(`  A: ${c.answer}`);
-    }
-}
-const 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;
-    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, sequence);
-            current = { ...current, phases: [...current.phases, phaseRecord] };
-            if (retryContext) {
-                io.log(`↺ ${def.phase} (${def.role}) retry — QA findings: ${retryContext.slice(0, 80)}`);
-            }
-            else {
-                io.log(`→ ${def.phase} (${def.role}) task=${phaseRecord.taskId}`);
-            }
-        }
-        else if (existing.status === "awaiting_clarification") {
-            io.log(`↺ ${def.phase} (${def.role}) resuming after clarification`);
-        }
-        // QA loop guard
-        if (def.phase === "qa" && current.qaIterations >= current.maxIterations) {
-            io.log(`✗ QA failed after ${current.maxIterations} iterations — workflow blocked`);
-            current = await markRunFailed(cwd, current, `Max QA iterations (${current.maxIterations}) reached`);
-            return current;
-        }
-        const llmResult = await executePhaseWithLlm({
-            root: cwd,
-            run: current,
-            phase: def,
-            phaseIndex: i,
-        }).catch(async (error) => {
-            const message = error instanceof Error ? error.message : String(error);
-            io.log(`✗ ${def.phase} provider execution failed: ${message}`);
-            current = await markRunFailed(cwd, current, message, def.phase);
-            return null;
-        });
-        if (!llmResult)
-            return current;
-        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") {
-            const sizing = await checkArchitectSizing(cwd, current.taskId);
-            if (!sizing.found) {
-                io.log(`⚠ Architect phase requires a sizing decision before handoff to developer.`);
-                io.log(`  Record one with:`);
-                io.log(`  orchestra decision add --task ${current.taskId} --owner architect --title "Story sizing" --decision "<xs|s|m|l|xl> [N points]" --context "..." --consequences "..." --status accepted`);
-                io.log(`  Then resume: orchestra workflow run --task ${current.taskId} --resume ${current.id}`);
-                current = await markRunFailed(cwd, current, "Architect sizing decision required before developer handoff");
-                return current;
-            }
-            io.log(`  ✓ sizing=${sizing.sizing}${sizing.points !== undefined ? ` (${sizing.points} pts)` : ""}`);
-        }
-        const outcome = llmResult.outcome;
-        const result = await closePhase(cwd, current, i, outcome, sequence);
-        current = result.run;
-        if (result.handoffArtifact) {
-            io.log(`  ✓ handoff → ${sequence[i + 1]?.role ?? "end"} (${result.handoffArtifact})`);
-        }
-        if (result.reviewArtifact) {
-            const nextPhase = sequence[i + 1]?.phase;
-            io.log(`  ⏸ gate ${def.phase}→${nextPhase} — review: ${result.reviewArtifact}`);
-            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}`);
-            io.log(`║  Task:   ${current.taskId}`);
-            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;
-        }
-        // QA failure — loop back to developer with findings as context
-        const closedPhase = current.phases.find((p) => p.phase === def.phase && p.status === "qa_failed");
-        if (closedPhase) {
-            qaFailNotes = closedPhase.notes ?? "QA findings — see QA phase artifact";
-            io.log(`  ✗ qa failed (iteration ${current.qaIterations}/${current.maxIterations}) — routing back to developer`);
-            i = devPhaseIndex - 1; // will be incremented to developer at top of loop
-            continue;
-        }
-        // Release phase: auto-create PR if configured
-        if (def.phase === "release") {
-            const config = await getWorkflowConfig(cwd);
-            if (config.github?.autoCreatePr) {
-                try {
-                    const prSummary = await generatePullRequestSummary(current.taskId, cwd);
-                    const prBody = buildPrBody(prSummary, current.qaIterations);
-                    const prTitle = `${current.taskId}: ${prSummary.task.title}`;
-                    const prResult = await createPullRequest({
-                        title: prTitle,
-                        body: prBody,
-                        ...(config.github.baseBranch
-                            ? { baseBranch: config.github.baseBranch }
-                            : {}),
-                    });
-                    await addEvidence({
-                        task: current.taskId,
-                        role: "release_manager",
-                        type: "report",
-                        summary: `PR created: ${prResult.url}`,
-                    }, cwd);
-                    io.log(`  ✓ PR created: ${prResult.url}`);
-                }
-                catch (err) {
-                    io.log(`  ⚠ PR creation failed: ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
-        }
-        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, 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 < 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"
-            : gates === "phase" && gateTransitions.has(transitionKey)
-                ? "gate=yes"
-                : "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: phaseSelection.sequence,
-            skipped: phaseSelection.skipped,
-        }, null, 2));
-    }
+    io.log(`GitHub issue #${result.issue.number} synced to ${result.taskId} (${result.action})`);
+    io.log(`Release readiness: ${result.releaseReadiness.passed ? "passed" : "blocked"}`);
+    if (result.comment !== "skipped")
+        io.log(`Comment ${result.comment}`);
+    if (result.closed)
+        io.log("Issue closed");
+    if (result.dryRun)
+        io.log("Dry run: no mutations were written.");
 }
 function parseRuntimeTargetOptions(options) {
     const targetValues = [
@@ -1134,132 +351,6 @@ 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 [];
-    }
-    return value
-        .split(",")
-        .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;
-}
-function removeUndefined(value) {
-    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
-}
-function parseArchitectureApproval(options) {
-    const approval = removeUndefined({
-        proposal: stringOption(options["architecture-proposal"]),
-        userApproved: options["user-approved"] ? true : undefined,
-        approvedBy: stringOption(options["architecture-approved-by"]),
-        approvedAt: stringOption(options["architecture-approved-at"]),
-    });
-    return Object.keys(approval).length > 0 ? approval : undefined;
-}
-function parseQaGate(options) {
-    const qaGate = removeUndefined({
-        plan: stringOption(options["qa-plan"]),
-        executionStatus: stringOption(options["qa-execution-status"]),
-        deferredRationale: stringOption(options["qa-deferred-rationale"]),
-        deferredOwner: stringOption(options["qa-deferred-owner"]),
-    });
-    return Object.keys(qaGate).length > 0 ? qaGate : undefined;
-}
-function parseRiskGate(options) {
-    const impactAreas = parseCsv(options["risk-areas"]);
-    const riskGate = removeUndefined({
-        impactAreas: impactAreas.length > 0 ? impactAreas : undefined,
-        acceptance: parseRiskAcceptance(options),
-    });
-    return Object.keys(riskGate).length > 0 ? riskGate : undefined;
-}
-function parseRiskAcceptance(options) {
-    const acceptance = removeUndefined({
-        acceptedBy: stringOption(options["risk-accepted-by"]),
-        rationale: stringOption(options["risk-acceptance-rationale"]),
-    });
-    return Object.keys(acceptance).length > 0 ? acceptance : undefined;
-}
-function parseBudgetEscalationDecision(options) {
-    if (options["approve-budget-fallback"]) {
-        return removeUndefined({
-            approved: true,
-            approver: stringOption(options.approver),
-            rationale: stringOption(options.rationale),
-        });
-    }
-    if (options["reject-budget-fallback"]) {
-        return removeUndefined({
-            approved: false,
-            approver: stringOption(options.approver),
-            rationale: stringOption(options.rationale),
-        });
-    }
-    return undefined;
-}
-function numberOption(value, fallback) {
-    if (typeof value !== "string" || value.trim() === "") {
-        return fallback;
-    }
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed)) {
-        throw new Error(`invalid number: ${value}`);
-    }
-    return parsed;
-}
-function renderReadinessMarkdown(task, report) {
-    const status = report.isReady ? "passed" : "blocked";
-    const missing = report.missing.length > 0
-        ? report.missing.map((field) => `- ${field}`).join("\n")
-        : "- none";
-    return [
-        `# Readiness ${task.id}`,
-        "",
-        `Status: ${status}`,
-        "",
-        "Missing fields:",
-        missing,
-        "",
-    ].join("\n");
-}
-function renderGateMarkdown(report) {
-    const status = report.passed ? "passed" : "blocked";
-    const missing = report.missing.length > 0
-        ? report.missing.map((field) => `- ${field}`).join("\n")
-        : "- none";
-    return [
-        `# Gate ${report.gateId}`,
-        "",
-        `Status: ${status}`,
-        "",
-        "Missing fields:",
-        missing,
-        "",
-    ].join("\n");
-}
-function renderDependencyReport(report) {
-    return [
-        `Dependencies for ${report.taskId}: ${report.isSatisfied ? "satisfied" : "blocked"}`,
-        ...(report.dependencies.length === 0
-            ? ["- none"]
-            : report.dependencies.map((dependency) => `- ${dependency.id}: ${dependency.status} (${dependency.isComplete ? "complete" : "incomplete"})`)),
-    ].join("\n");
-}
 function renderPreRunValidation(report) {
     const status = report.allowed ? "allowed" : "blocked";
     const missing = report.missing.length > 0 ? report.missing.join(", ") : "none";
@@ -1278,84 +369,6 @@ function renderPreRunValidation(report) {
             : []),
     ].join("\n");
 }
-function renderTaskGraphPlan(plan) {
-    return [
-        "Task graph plan",
-        "",
-        "Ready:",
-        ...taskGraphReadyLines(plan.ready),
-        "",
-        "Blocked:",
-        ...taskGraphBlockedLines(plan.blocked),
-        "",
-        "Locked:",
-        ...taskGraphLockedLines(plan.locked),
-        "",
-        "Complete:",
-        ...taskGraphReadyLines(plan.complete),
-    ].join("\n");
-}
-function 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",
-        `- Selected: ${batch.selectedTaskIds.join(", ")}`,
-        `- Completed runs: ${batch.runs.length}`,
-        `- Locked: ${batch.locked.map((task) => task.id).join(", ") || "none"}`,
-        `- Artifact: ${batch.artifact ?? "none"}`,
-        ...(batch.failure
-            ? [`- Failure: ${batch.failure.taskId}: ${batch.failure.error}`]
-            : ["- Failure: none"]),
-    ].join("\n");
-}
-function taskGraphReadyLines(items) {
-    return items.length === 0
-        ? ["- none"]
-        : items.map((item) => `- ${item.id} [${item.status}] ${item.title} (${item.ownerRole})`);
-}
-function taskGraphBlockedLines(items) {
-    return items.length === 0
-        ? ["- none"]
-        : items.map((item) => {
-            const blockers = item.incomplete
-                .map((dependency) => `${dependency.id}:${dependency.status}`)
-                .join(", ");
-            return `- ${item.id} [${item.status}] ${item.title} blocked by ${blockers}`;
-        });
-}
-function taskGraphLockedLines(items) {
-    return items.length === 0
-        ? ["- none"]
-        : items.map((item) => {
-            const locks = item.locks
-                .map((lock) => lock.conflictPath
-                ? `${lock.id}:${lock.path}->${lock.conflictPath}`
-                : `${lock.id}:${lock.path}`)
-                .join(", ");
-            return `- ${item.id} [${item.status}] ${item.title} locked by ${locks}`;
-        });
-}
 function renderSummaryMarkdown(summary) {
     return [
         "# Agent Workflow Summary",
@@ -1444,161 +457,6 @@ function renderPullRequestSummaryMarkdown(summary) {
         "",
     ].join("\n");
 }
-function renderDelegationDecisionMarkdown(decision) {
-    return [
-        `# Delegation Decision: ${decision.taskId}`,
-        "",
-        `- Recommendation: ${decision.recommendation}`,
-        `- Complexity score: ${decision.complexityScore}`,
-        `- Urgency: ${decision.urgency}`,
-        `- Disjoint write scopes: ${String(decision.disjointWriteScopes)}`,
-        "",
-        "## Rationale",
-        ...listOrNone(decision.rationale),
-        "",
-        "## Blocking Conditions",
-        ...listOrNone(decision.blockingConditions),
-        "",
-        "## Context Bundle",
-        ...listOrNone(decision.contextBundle),
-        "",
-        "## Delegates",
-        ...(decision.delegates.length === 0
-            ? ["- none"]
-            : decision.delegates.map((delegate) => `- ${delegate.role} [${delegate.mode}] scopes=${delegate.writeScopes.join(",") || "none"}`)),
-        "",
-        "## Expected Outputs",
-        ...listOrNone(decision.expectedOutputs),
-        "",
-    ].join("\n");
-}
-function renderTaskContextMarkdown(context) {
-    return [
-        `# Task Context: ${context.task.id}`,
-        "",
-        `- Title: ${context.task.title}`,
-        `- Owner: ${context.task.ownerRole}`,
-        `- Status: ${context.task.status}`,
-        `- Dependencies: ${context.dependencies.isSatisfied ? "satisfied" : "blocked"}`,
-        `- Locks: ${context.locks.length}`,
-        `- Risks: ${context.risks.length}`,
-        `- Delegation: ${context.delegation?.recommendation ?? "not decided"}`,
-        "",
-        "## Collaboration Flow",
-        ...(context.collaborationFlow
-            ? [
-                `- ${context.collaborationFlow.flow.id}: ${context.collaborationFlow.flow.name}`,
-                `- Missing artifacts: ${context.collaborationFlow.missingArtifacts.join(", ") || "none"}`,
-                `- Reviewers: ${context.collaborationFlow.optionalReviewers.join(", ") || "none"}`,
-            ]
-            : ["- none"]),
-        "",
-        "## Workflow Templates",
-        ...(context.workflowTemplates.length === 0
-            ? ["- none"]
-            : context.workflowTemplates.map((item) => `- ${item.template.id} (score ${item.score}, missing evidence ${item.missingEvidence.join(", ") || "none"})`)),
-        "",
-        "## Skills",
-        ...(context.skills.selected.length === 0
-            ? ["- none"]
-            : 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),
-        "",
-        "## Handoffs",
-        ...eventLines(context.handoffs),
-        "",
-        "## Reviews",
-        ...eventLines(context.reviews),
-        "",
-        "## Evidence",
-        ...eventLines(context.evidence),
-        "",
-        "## Gates",
-        ...eventLines(context.gates),
-        "",
-        "## Model Provenance",
-        ...(context.modelProvenance.length === 0
-            ? ["- none"]
-            : context.modelProvenance.map((record) => `- ${record.role}: ${record.provider}/${record.model} ${record.responseId}`)),
-        "",
-    ].join("\n");
-}
-function renderExecutionPlanMarkdown(plan) {
-    return [
-        `# Execution Plan: ${plan.taskId}`,
-        "",
-        ...plan.steps.map((step) => {
-            const gate = step.gate ? ` gate=${step.gate}` : "";
-            const dependsOn = step.dependsOn.length > 0
-                ? ` dependsOn=${step.dependsOn.join(",")}`
-                : "";
-            return `- ${step.id}: ${step.role}${gate}${dependsOn} - ${step.action}`;
-        }),
-        "",
-    ].join("\n");
-}
-function renderExecutionRunMarkdown(run) {
-    return [
-        `# Execution Run: ${run.taskId}`,
-        "",
-        `- Provider: ${run.provider}`,
-        `- Model: ${run.model}`,
-        "",
-        ...run.steps.map((step) => `- ${step.id}: ${step.role} ${step.status} ${step.responseId ?? step.error ?? ""}`.trim()),
-        "",
-    ].join("\n");
-}
-function renderPlaywrightPlanMarkdown(plan) {
-    return [
-        `# Playwright Test Plan: ${plan.taskId}`,
-        "",
-        `- Title: ${plan.title}`,
-        `- Target user: ${plan.targetUser}`,
-        "",
-        "## Scenarios",
-        ...plan.scenarios.flatMap((scenario) => [
-            `### ${scenario.name}`,
-            `- Source: ${scenario.source}`,
-            `- Page object: ${scenario.pageObject}`,
-            `- Selectors: ${scenario.selectors.join("; ")}`,
-            `- Assertions: ${scenario.assertions.join("; ")}`,
-            `- Evidence: ${scenario.evidence.join(", ")}`,
-            "",
-        ]),
-        "## Fixtures",
-        ...listOrNone(plan.fixtures),
-        "",
-        "## Notes",
-        ...listOrNone(plan.notes),
-        "",
-    ].join("\n");
-}
-function 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"]