@jterrats/open-orchestra 0.1.0 → 0.2.1

package/dist/commands.js

@@ -1,11 +1,47 @@
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
 import { initWorkspace } from "./workspace.js";
 import { requireArg } from "./args.js";
+import { resolveWorkspaceWritePath } from "./fs-utils.js";
 import { addEvidence, addPlaywrightEvidence, addTask, approveApproval, checkUsageBudget, checkReadiness, checkTaskDependencies, claimLock, completeWithProviderFallback, createHandoff, evaluateWorkflowGate, executeNextReadyTask, executePlanWithBudgetPreflight, executeReadyTaskBatch, generateExecutionPlan, generatePlaywrightTestPlan, generatePullRequestSummary, generateTaskGraphPlan, getUsageReport, getWorkflowStatus, getWorkflowSummary, getTaskContext, getWorkflowConfig, listEvidence, listConfiguredModelProviders, listDecisions, listLocks, listApprovals, listReviews, listRoles, listTasks, rejectApproval, recordReview, recordModelProvenance, recordDecision, releaseLock, setRoleModelProvider, showApproval, updateTask, listModelProvenance, } from "./workflow-services.js";
 import { validateWorkspace } from "./workspace-validator.js";
+import { addAgentLesson, listAgentLessons, listSkills, planSkillsForTask, promoteAgentLessons, readSourceOfTruth, recordSkillPlan, recordSkillRender, renderSkills, validateSkills, } from "./skills.js";
 import { getWebServerAddress, startWebApiServer } from "./web-api.js";
+import { decideTaskDelegation } from "./delegation-decision.js";
+import { lintMermaidDiagram, recordDiagramLintEvidence, } from "./diagram-validation.js";
+import { evaluateMcpOAuthProxy, } from "./mcp-oauth-proxy.js";
+import { detectStaleInstructionFilesFromManifest, resolveInstructionImportsFromFile, updateManagedInstructionFile, } from "./instruction-updates.js";
+import { applyInstructionUpdatesFromManifest } from "./instruction-apply.js";
+import { renderSubagentProtocol, upsertSubagentProtocolBlock, } from "./subagent-protocol.js";
+import { listCollaborationFlows, recommendCollaborationFlow, } from "./collaboration-flows.js";
+import { listWorkflowTemplates, renderWorkflowTemplates, selectWorkflowTemplates, validateWorkflowTemplates, } from "./workflow-templates.js";
+import { listCommandManifest } from "./command-manifest.js";
+import { listRuntimeAdapters, parseRuntimeTarget } from "./runtime-adapters.js";
+import { renderRuntimeBootstrap, upsertRuntimeBootstrapBlock, } from "./runtime-bootstrap.js";
+import { disableTelemetryConsent, enableTelemetryConsent, exportTelemetryDataset, exportTelemetryEvalDataset, getTelemetryConsent, parseTelemetryLevel, requiresSensitiveTelemetryOptIn, submitTelemetryDataset, } from "./telemetry.js";
 export async function initCommand(options, io) {
-    const base = await initWorkspace({ force: Boolean(options.force) });
+    const root = stringOption(options["target-dir"]) ?? process.cwd();
+    const input = {
+        root,
+        force: Boolean(options.force),
+        advisory: Boolean(options.advisory),
+        confirmUnknown: Boolean(options["confirm-unknown"]),
+    };
+    const bootstrapTargetFile = stringOption(options["bootstrap-file"]);
+    const runtimeTargets = parseRuntimeTargetOptions(options);
+    const base = await initWorkspace({
+        ...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.");
+    }
+    else {
+        io.log("Prompt registry scaffolded in .generated-prompts/");
+    }
+    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");
 }
 export async function statusCommand(options, io) {
@@ -166,7 +202,7 @@ export async function lockListCommand(options, io) {
 }
 export async function lockClaimCommand(options, io) {
     const lock = await claimLock(removeUndefined({
-        id: stringOption(options.id) ?? `lock-${Date.now()}`,
+        id: stringOption(options.id),
         taskId: requireArg(options, "task"),
         ownerRole: requireArg(options, "role"),
         path: requireArg(options, "path"),
@@ -363,6 +399,16 @@ 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) {
@@ -485,6 +531,539 @@ export async function modelCompleteFakeCommand(options, io) {
     }
     io.log(`Fake completion used ${result.provider}/${result.model} fallback=${String(result.fallbackUsed)}`);
 }
+export async function telemetryStatusCommand(options, io) {
+    const telemetry = await getTelemetryConsent();
+    if (options.json) {
+        io.log(JSON.stringify(telemetry, null, 2));
+        return;
+    }
+    io.log("Telemetry: " + (telemetry.enabled ? "enabled" : "off"));
+    io.log("Level: " + telemetry.level);
+    io.log("Policy: " + telemetry.policyVersion);
+}
+export async function telemetryEnableCommand(options, io) {
+    const level = parseTelemetryLevel(stringOption(options.level) ?? "metadata");
+    if (requiresSensitiveTelemetryOptIn(level) && !options["confirm-sensitive"]) {
+        throw new Error("prompt-sample and eval-dataset telemetry require --confirm-sensitive");
+    }
+    const telemetry = await enableTelemetryConsent({
+        level,
+        actor: stringOption(options.actor) ?? "user",
+    });
+    if (options.json) {
+        io.log(JSON.stringify(telemetry, null, 2));
+        return;
+    }
+    io.log("Telemetry enabled at level " + telemetry.level);
+}
+export async function telemetryExportCommand(options, io) {
+    const result = await exportTelemetryDataset({
+        dryRun: Boolean(options["dry-run"]),
+    });
+    if (options.json) {
+        io.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    io.log((result.dryRun ? "Telemetry export dry run" : "Telemetry exported") +
+        ": " +
+        result.recordCount +
+        " record(s)");
+    if (result.file) {
+        io.log("File: " + result.file);
+    }
+}
+export async function telemetrySubmitCommand(options, io) {
+    const result = await submitTelemetryDataset({
+        file: requireArg(options, "file"),
+        endpoint: requireArg(options, "endpoint"),
+    });
+    if (options.json) {
+        io.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    io.log("Telemetry submission recorded: " + result.fileHash);
+}
+export async function telemetryEvalDatasetCommand(options, io) {
+    const result = await exportTelemetryEvalDataset({
+        dryRun: Boolean(options["dry-run"]),
+    });
+    if (options.json) {
+        io.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    io.log((result.dryRun ? "Eval dataset dry run" : "Eval dataset exported") +
+        ": " +
+        result.recordCount +
+        " record(s)");
+    if (result.file) {
+        io.log("File: " + result.file);
+    }
+}
+export async function telemetryDisableCommand(options, io) {
+    const telemetry = await disableTelemetryConsent({
+        actor: stringOption(options.actor) ?? "user",
+    });
+    if (options.json) {
+        io.log(JSON.stringify(telemetry, null, 2));
+        return;
+    }
+    io.log("Telemetry disabled");
+}
+export async function instructionsApplyCommand(options, io) {
+    const report = await applyInstructionUpdatesFromManifest({
+        manifestPath: requireArg(options, "manifest"),
+        check: Boolean(options.check),
+        dryRun: Boolean(options["dry-run"]),
+        force: Boolean(options.force),
+    });
+    if (options.json) {
+        io.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    io.log("Instruction update " +
+        report.mode +
+        ": " +
+        report.totals.changed +
+        " changed, " +
+        report.totals.unchanged +
+        " unchanged, " +
+        report.totals.blocked +
+        " blocked");
+    for (const item of report.items) {
+        io.log(item.status +
+            " " +
+            item.filePath +
+            "#" +
+            item.blockId +
+            " - " +
+            item.reason);
+    }
+}
+export async function instructionsStaleCommand(options, io) {
+    const report = await detectStaleInstructionFilesFromManifest({
+        manifestPath: requireArg(options, "manifest"),
+    });
+    if (options.json) {
+        io.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    io.log("Instruction file status:");
+    for (const item of report.items) {
+        io.log(item.status +
+            " " +
+            item.filePath +
+            "#" +
+            item.blockId +
+            " - " +
+            item.reason);
+    }
+}
+export async function instructionsBlockCommand(options, io) {
+    const result = await updateManagedInstructionFile({
+        filePath: resolveWorkspaceWritePath(process.cwd(), requireArg(options, "file")),
+        contentPath: resolveWorkspaceWritePath(process.cwd(), requireArg(options, "content-file")),
+        input: {
+            blockId: requireArg(options, "block"),
+            generator: stringOption(options.generator) ?? "open-orchestra",
+            version: stringOption(options.version) ?? "1",
+            target: parseInstructionTarget(stringOption(options.target) ?? "generic"),
+            sourceManifest: stringOption(options["source-manifest"]) ?? "local",
+        },
+        check: Boolean(options.check),
+        dryRun: Boolean(options["dry-run"]),
+        force: Boolean(options.force),
+    });
+    if (options.json) {
+        io.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (result.drift) {
+        io.log("Drift detected for " + requireArg(options, "block"));
+        return;
+    }
+    io.log(result.changed
+        ? "Instruction block changed"
+        : "Instruction block unchanged");
+}
+export async function instructionsImportsCommand(options, io) {
+    const result = await resolveInstructionImportsFromFile({
+        registryPath: requireArg(options, "registry"),
+        entryId: requireArg(options, "entry"),
+        target: parseInstructionTarget(stringOption(options.target) ?? "generic"),
+    });
+    if (options.json) {
+        io.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    io.log(result.content);
+}
+function parseInstructionTarget(value) {
+    return parseRuntimeTarget(value);
+}
+export async function collaborationFlowsCommand(options, io) {
+    const flows = listCollaborationFlows();
+    if (options.json) {
+        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);
+}
+export async function commandsManifestCommand(options, io) {
+    const manifest = listCommandManifest();
+    if (options.json) {
+        io.log(JSON.stringify(manifest, null, 2));
+        return;
+    }
+    for (const command of manifest) {
+        io.log(command.command + " - " + command.summary);
+    }
+}
+export async function runtimeAdaptersCommand(options, io) {
+    const adapters = listRuntimeAdapters();
+    if (options.json) {
+        io.log(JSON.stringify(adapters, null, 2));
+        return;
+    }
+    for (const adapter of adapters) {
+        io.log(adapter.target +
+            " - " +
+            adapter.label +
+            " (" +
+            adapter.defaultInstructionFiles.join(", ") +
+            ")");
+    }
+}
+export async function runtimeBootstrapCommand(options, io) {
+    const target = parseSkillRenderTarget(stringOption(options.target) ?? "generic");
+    const bootstrap = renderRuntimeBootstrap(target);
+    const filePath = stringOption(options.file);
+    if (filePath) {
+        const resolvedFilePath = resolveWorkspaceWritePath(process.cwd(), path.normalize(filePath));
+        const existing = await readFile(resolvedFilePath, "utf8").catch(() => "");
+        const result = upsertRuntimeBootstrapBlock(existing, bootstrap, {
+            force: Boolean(options.force),
+        });
+        if (!options.check && !options["dry-run"] && !result.drift) {
+            await writeFile(resolvedFilePath, result.content);
+        }
+        if (options.json) {
+            io.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        io.log(result.changed
+            ? "Runtime bootstrap changed"
+            : "Runtime bootstrap unchanged");
+        return;
+    }
+    if (options.json) {
+        io.log(JSON.stringify(bootstrap, null, 2));
+        return;
+    }
+    io.log(bootstrap.content);
+}
+export async function protocolRenderCommand(options, io) {
+    const protocol = await renderSubagentProtocol(removeUndefined({
+        target: parseSkillRenderTarget(stringOption(options.target) ?? "generic"),
+        taskId: stringOption(options.task),
+    }));
+    if (options.json) {
+        io.log(JSON.stringify(protocol, null, 2));
+        return;
+    }
+    io.log(protocol.content);
+}
+export async function protocolBlockCommand(options, io) {
+    const filePath = requireArg(options, "file");
+    const protocol = await renderSubagentProtocol(removeUndefined({
+        target: parseSkillRenderTarget(stringOption(options.target) ?? "generic"),
+        taskId: stringOption(options.task),
+    }));
+    const existing = await readFile(filePath, "utf8").catch(() => "");
+    const result = upsertSubagentProtocolBlock(existing, protocol, {
+        force: Boolean(options.force),
+    });
+    const shouldWrite = !options.check && !options["dry-run"] && !result.drift && result.changed;
+    if (shouldWrite) {
+        await writeFile(filePath, result.content);
+    }
+    if (options.json) {
+        io.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (result.drift) {
+        io.log("Drift detected for subagent protocol block");
+        return;
+    }
+    io.log(result.changed
+        ? "Subagent protocol block changed"
+        : "Subagent protocol block unchanged");
+}
+export async function diagramsLintCommand(options, io) {
+    const result = await lintMermaidDiagram({
+        filePath: requireArg(options, "file"),
+    });
+    const evidence = stringOption(options.task)
+        ? await recordDiagramLintEvidence({
+            taskId: stringOption(options.task) ?? "",
+            result,
+        })
+        : undefined;
+    const output = removeUndefined({ result, evidence });
+    if (options.json) {
+        io.log(JSON.stringify(output, null, 2));
+    }
+    else {
+        io.log(result.valid ? "Mermaid diagram valid" : "Mermaid diagram invalid");
+        if (result.installHint) {
+            io.log(result.installHint);
+        }
+        if (evidence) {
+            io.log("Created " + evidence.artifact);
+        }
+    }
+    if (!result.valid) {
+        throw new Error("diagram lint failed");
+    }
+}
+export async function mcpOAuthProxyEvaluateCommand(options, io) {
+    const evaluation = evaluateMcpOAuthProxy(removeUndefined({
+        enabled: Boolean(options.enable),
+        mode: parseMcpProxyMode(stringOption(options.mode) ?? "stdio-proxy"),
+        serverUrl: requireArg(options, "server-url"),
+        tokenStorage: parseMcpSecretStorage(stringOption(options["token-storage"]) ?? "keychain"),
+        tokenPath: stringOption(options["token-path"]),
+        refreshWindowSeconds: Number(stringOption(options["refresh-window"]) ?? 300),
+        approvedBy: options.approve
+            ? (stringOption(options.approver) ?? "local-user")
+            : undefined,
+    }));
+    if (options.json) {
+        io.log(JSON.stringify(evaluation, null, 2));
+        return;
+    }
+    io.log(evaluation.approved
+        ? "MCP proxy plan approved"
+        : "MCP proxy plan has risks");
+    for (const risk of evaluation.risks) {
+        io.log("RISK: " + risk);
+    }
+}
+function parseMcpProxyMode(value) {
+    if (["stdio-proxy", "direct-http", "tool-native-oauth"].includes(value)) {
+        return value;
+    }
+    throw new Error("unknown MCP proxy mode: " + value);
+}
+function parseMcpSecretStorage(value) {
+    if (["keychain", "libsecret", "windows-credential", "secure-file"].includes(value)) {
+        return value;
+    }
+    throw new Error("unknown MCP secret storage: " + value);
+}
+export async function skillsValidateCommand(options, io) {
+    const report = await validateSkills();
+    if (options.json) {
+        io.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        io.log(report.valid ? "Skills valid" : "Skills invalid");
+        for (const error of report.errors) {
+            io.log(`ERROR: ${error}`);
+        }
+        for (const warning of report.warnings) {
+            io.log(`WARN: ${warning}`);
+        }
+    }
+    if (!report.valid) {
+        throw new Error("skills validation failed");
+    }
+}
+export async function sourcesListCommand(options, io) {
+    const sources = await readSourceOfTruth();
+    if (options.json) {
+        io.log(JSON.stringify(sources, null, 2));
+        return;
+    }
+    for (const source of sources) {
+        io.log(`${source.id ?? "unknown"} - ${source.name ?? "Unnamed source"}`);
+        io.log(`  ${(source.locations ?? []).join(", ")}`);
+    }
+}
+export async function lessonsListCommand(options, io) {
+    const lessons = await listAgentLessons();
+    if (options.json) {
+        io.log(JSON.stringify(lessons, null, 2));
+        return;
+    }
+    if (lessons.length === 0) {
+        io.log("No lessons");
+        return;
+    }
+    for (const lesson of lessons) {
+        io.log(`${lesson.timestamp} ${lesson.operation}: ${lesson.errorSignature}`);
+    }
+}
+export async function lessonsAddCommand(options, io) {
+    const lesson = await addAgentLesson(removeUndefined({
+        taskId: stringOption(options.task),
+        actor: stringOption(options.actor) ?? "parent",
+        operation: requireArg(options, "operation"),
+        failedAction: requireArg(options, "failed-action"),
+        errorSignature: requireArg(options, "error-signature"),
+        rootCause: requireArg(options, "root-cause"),
+        fix: requireArg(options, "fix"),
+        prevention: requireArg(options, "prevention"),
+        appliesTo: parseCsv(options["applies-to"]),
+        verifiedBy: parseCsv(options["verified-by"]),
+    }));
+    if (options.json) {
+        io.log(JSON.stringify(lesson, null, 2));
+        return;
+    }
+    io.log(`Recorded lesson ${lesson.errorSignature}`);
+}
+export async function lessonsPromoteCommand(options, io) {
+    const result = await promoteAgentLessons(removeUndefined({
+        to: parsePromotionTarget(stringOption(options.to) ?? "doc"),
+        filter: stringOption(options.filter),
+    }));
+    if (options.json) {
+        io.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    io.log(`Created ${result.artifact}`);
+    io.log(`Promoted lessons: ${result.lessons.length}`);
+}
+function parsePromotionTarget(value) {
+    if (["skill", "rule", "doc"].includes(value)) {
+        return value;
+    }
+    throw new Error(`unknown promotion target: ${value}`);
+}
+export async function skillsListCommand(options, io) {
+    const skills = listSkills();
+    if (options.json) {
+        io.log(JSON.stringify(skills, null, 2));
+        return;
+    }
+    for (const skill of skills) {
+        io.log(`${skill.id} - ${skill.name} (${skill.loadBudget})`);
+        io.log(`  ${skill.summary}`);
+        io.log(`  sources: ${skill.sourceGroups.join(", ")}`);
+    }
+}
+export async function skillsPlanCommand(options, io) {
+    const plan = await planSkillsForTask(requireArg(options, "task"));
+    await recordSkillPlan(plan);
+    if (options.json) {
+        io.log(JSON.stringify(plan, null, 2));
+        return;
+    }
+    io.log(`Skills for ${plan.taskId}:`);
+    for (const item of plan.selected) {
+        io.log(`  ${item.skill.id} (score ${item.score})`);
+        for (const reason of item.rationale) {
+            io.log(`    - ${reason}`);
+        }
+    }
+    io.log(`Source groups: ${plan.sourceGroups.join(", ")}`);
+}
+export async function skillsRenderCommand(options, io) {
+    const target = parseSkillRenderTarget(stringOption(options.target) ?? "generic");
+    const rendered = await renderSkills({
+        target,
+        taskId: stringOption(options.task),
+        skillIds: parseCsv(options.skills),
+    });
+    await recordSkillRender(rendered);
+    if (options.json) {
+        io.log(JSON.stringify(rendered, null, 2));
+        return;
+    }
+    io.log(rendered.content);
+}
+function parseSkillRenderTarget(value) {
+    return parseRuntimeTarget(value);
+}
+function parseRuntimeTargetOptions(options) {
+    const targetValues = [
+        ...parseCsv(options.target),
+        ...parseCsv(options.targets),
+    ];
+    return [...new Set(targetValues)].map((target) => parseRuntimeTarget(target));
+}
 function parseCsv(value) {
     if (typeof value !== "string" || value.trim() === "") {
         return [];
@@ -759,6 +1338,20 @@ function renderPullRequestSummaryMarkdown(summary) {
         "## Risks",
         ...listOrNone(summary.risks),
         "",
+        "## Review Routing",
+        `- Merge blocked: ${summary.review.mergeBlocked}`,
+        `- Required reviewers: ${summary.review.requiredReviewers.join(", ") || "none"}`,
+        `- Missing reviewers: ${summary.review.missingReviewers.join(", ") || "none"}`,
+        "",
+        "## Review Checklist",
+        ...listOrNone(summary.review.checklist),
+        "",
+        "## Evidence Gaps",
+        ...listOrNone(summary.review.evidenceGaps),
+        "",
+        "## Merge Blockers",
+        ...listOrNone(summary.review.mergeBlockers),
+        "",
         "## Gates",
         ...eventLines(summary.gates),
         "",
@@ -784,6 +1377,34 @@ 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}`,
@@ -794,6 +1415,27 @@ function renderTaskContextMarkdown(context) {
         `- 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"}`,
         "",
         "## Decisions",
         ...eventLines(context.decisions),