intentdna 1.7.4 → 1.8.0

package/dist/cli/commands/assets.js

@@ -0,0 +1,2871 @@
+/**
+ * dna assets — read-only workflow asset inventory.
+ */
+import { activeEvidenceFollowupReviewRoute, activeEvidenceFollowupRoute, buildWorkflowAssetEvidenceIndex, buildWorkflowAssetCandidateBacklog, findWorkflowAsset, listWorkflowAssets, } from "../../assets/index.js";
+import { WORKFLOW_ASSET_IDS, WORKFLOW_SUGGESTION_IDS } from "../../templates/metadata.js";
+function formatCounts(asset) {
+    return `workflows=${asset.workflows.length} controllers=${asset.controllers.length} roles=${asset.roles.length} evidence=${asset.evidence.length}`;
+}
+function stepKey(workflowId, stepId) {
+    return `${workflowId}/${stepId}`;
+}
+function compactStep(step) {
+    if (!step)
+        return "missing";
+    const deps = step.dependsOn.length > 0 ? ` after=${step.dependsOn.join(",")}` : "";
+    return `${step.id} -> ${step.role}${deps} handoff=${step.consumes}/${step.produces} checkpoints=${step.checkpoints}`;
+}
+function changedStepFields(from, to) {
+    const fields = [];
+    if (from.role !== to.role)
+        fields.push("role");
+    if (from.description !== to.description)
+        fields.push("description");
+    if (from.dependsOn.join("\0") !== to.dependsOn.join("\0"))
+        fields.push("depends_on");
+    if (from.consumes !== to.consumes || from.produces !== to.produces)
+        fields.push("handoff");
+    if (from.checkpoints !== to.checkpoints)
+        fields.push("checkpoints");
+    return fields;
+}
+function comparableGovernance(asset) {
+    return {
+        managementStatus: asset.status.managementStatus,
+        evidencePosture: asset.status.evidencePosture,
+        configurationPosture: asset.status.configurationPosture,
+        cascadePosture: asset.status.cascadePosture,
+        cascadeInherits: asset.cascade.inherits,
+        cascadePriority: asset.cascade.priority,
+        evolutionPosture: asset.status.evolutionPosture,
+        declaredMarkers: asset.evolution.declaredMarkers,
+    };
+}
+function assetDiffReceiptPath(from, to) {
+    const slug = `${from}-to-${to}`.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "asset-diff";
+    return `.dna/reports/asset-diff-${slug}.json`;
+}
+function assetDiffReviewEvidence(from, to) {
+    const receiptPathHint = assetDiffReceiptPath(from, to);
+    return {
+        mode: "local_asset_diff_review_evidence",
+        authority: "manager_review_handoff_only",
+        receiptCommand: `dna assets diff ${from} ${to} --json > ${receiptPathHint}`,
+        receiptPathHint,
+        boundaries: [
+            "Asset diff review evidence is local manager handoff only; it does not adopt, bind, rollout, sync, publish, or approve runtime behavior.",
+            "High-risk diffs still require explicit manager rationale before adoption or organization binding.",
+            "Runtime sync remains a separate local dna action after adoption, organization binding, and rollout review.",
+        ],
+    };
+}
+function assetDiffChangeExplanation(from, to, steps) {
+    const activeFollowupSource = to.name === `${from.name}-active-followup`;
+    if (!activeFollowupSource)
+        return [];
+    const modifiedCheckpointSteps = steps.filter((step) => step.change === "modified" &&
+        step.fields.length === 1 &&
+        step.fields[0] === "checkpoints" &&
+        step.from?.checkpoints !== step.to?.checkpoints);
+    const lines = [
+        `${to.name} is a saved unfinished-work draft for ${from.name}, not a deletion, upgrade, or replacement of the source asset.`,
+        "It exists because dogfood evidence still has open work, so baseline promotion, organization binding, rollout, runtime sync, and marker mutation must stop at review first.",
+    ];
+    if (modifiedCheckpointSteps.length > 0) {
+        lines.push(`The concrete workflow improvement is ${modifiedCheckpointSteps.length} added evidence checkpoint(s): ${modifiedCheckpointSteps.map((step) => `${step.workflow}/${step.id} ${step.from?.checkpoints ?? 0}->${step.to?.checkpoints ?? 0}`).join(", ")}.`);
+        lines.push("That checkpoint makes the fix loop prove unfinished dogfood work before anyone claims the original workflow is fully stable.");
+    }
+    return lines;
+}
+function buildAssetDiff(from, to) {
+    const workflows = [];
+    const steps = [];
+    const fromWorkflows = new Map(from.workflows.map((workflow) => [workflow.id, workflow]));
+    const toWorkflows = new Map(to.workflows.map((workflow) => [workflow.id, workflow]));
+    const workflowIds = [...new Set([...fromWorkflows.keys(), ...toWorkflows.keys()])].sort();
+    for (const workflowId of workflowIds) {
+        const fromWorkflow = fromWorkflows.get(workflowId);
+        const toWorkflow = toWorkflows.get(workflowId);
+        if (!fromWorkflow && toWorkflow) {
+            workflows.push({ id: workflowId, change: "added", toStepCount: toWorkflow.stepCount });
+            for (const step of toWorkflow.steps)
+                steps.push({ id: step.id, workflow: workflowId, change: "added", to: step, fields: ["step"] });
+            continue;
+        }
+        if (fromWorkflow && !toWorkflow) {
+            workflows.push({ id: workflowId, change: "removed", fromStepCount: fromWorkflow.stepCount });
+            for (const step of fromWorkflow.steps)
+                steps.push({ id: step.id, workflow: workflowId, change: "removed", from: step, fields: ["step"] });
+            continue;
+        }
+        if (!fromWorkflow || !toWorkflow)
+            continue;
+        const fromSteps = new Map(fromWorkflow.steps.map((step) => [stepKey(workflowId, step.id), step]));
+        const toSteps = new Map(toWorkflow.steps.map((step) => [stepKey(workflowId, step.id), step]));
+        const stepKeys = [...new Set([...fromSteps.keys(), ...toSteps.keys()])].sort();
+        let modified = false;
+        for (const key of stepKeys) {
+            const fromStep = fromSteps.get(key);
+            const toStep = toSteps.get(key);
+            if (!fromStep && toStep) {
+                modified = true;
+                steps.push({ id: toStep.id, workflow: workflowId, change: "added", to: toStep, fields: ["step"] });
+                continue;
+            }
+            if (fromStep && !toStep) {
+                modified = true;
+                steps.push({ id: fromStep.id, workflow: workflowId, change: "removed", from: fromStep, fields: ["step"] });
+                continue;
+            }
+            if (!fromStep || !toStep)
+                continue;
+            const fields = changedStepFields(fromStep, toStep);
+            if (fields.length > 0) {
+                modified = true;
+                steps.push({ id: toStep.id, workflow: workflowId, change: "modified", from: fromStep, to: toStep, fields });
+            }
+        }
+        if (modified || fromWorkflow.stepCount !== toWorkflow.stepCount || fromWorkflow.description !== toWorkflow.description) {
+            workflows.push({
+                id: workflowId,
+                change: "modified",
+                fromStepCount: fromWorkflow.stepCount,
+                toStepCount: toWorkflow.stepCount,
+            });
+        }
+    }
+    const fromGovernance = comparableGovernance(from);
+    const toGovernance = comparableGovernance(to);
+    const governance = Object.keys({ ...fromGovernance, ...toGovernance })
+        .sort()
+        .filter((field) => JSON.stringify(fromGovernance[field]) !== JSON.stringify(toGovernance[field]))
+        .map((field) => ({ field, from: fromGovernance[field], to: toGovernance[field] }));
+    const summary = {
+        workflowsAdded: workflows.filter((item) => item.change === "added").length,
+        workflowsRemoved: workflows.filter((item) => item.change === "removed").length,
+        workflowsModified: workflows.filter((item) => item.change === "modified").length,
+        stepsAdded: steps.filter((item) => item.change === "added").length,
+        stepsRemoved: steps.filter((item) => item.change === "removed").length,
+        stepsModified: steps.filter((item) => item.change === "modified").length,
+        governanceChanges: governance.length,
+    };
+    const riskNotes = [
+        ...(summary.workflowsRemoved > 0 ? [`${summary.workflowsRemoved} workflow(s) removed; manager must confirm this does not drop required behavior before adoption.`] : []),
+        ...(summary.stepsRemoved > 0 ? [`${summary.stepsRemoved} step(s) removed; compare removed handoffs/checkpoints against current runtime evidence.`] : []),
+        ...(summary.governanceChanges > 0 ? [`${summary.governanceChanges} governance field(s) changed; inspect cascade/evolution posture before rollout.`] : []),
+    ];
+    const riskLevel = summary.workflowsRemoved > 0 || summary.stepsRemoved > 0
+        ? "high"
+        : summary.governanceChanges > 0 || summary.workflowsAdded > 0 || summary.stepsAdded > 0
+            ? "medium"
+            : "low";
+    const reviewDecision = {
+        status: "manager_review_required",
+        riskLevel,
+        riskNotes,
+        reason: riskLevel === "high"
+            ? "Structural removals require explicit manager acceptance before the proposed asset version can be adopted or bound."
+            : "Diff review is the manager gate before the proposed asset version can be accepted into an organization route.",
+        acceptanceCommand: `dna assets adoption ${to.name}`,
+        orgBindCommand: `dna org bind --asset ${to.name} --status active --sync-target codex`,
+        rolloutCommand: "dna org rollout",
+        syncCommand: "dna sync --codex",
+    };
+    return {
+        from: from.name,
+        to: to.name,
+        summary,
+        workflows,
+        steps,
+        governance,
+        changeExplanation: assetDiffChangeExplanation(from, to, steps),
+        reviewDecision,
+        reviewEvidence: assetDiffReviewEvidence(from.name, to.name),
+        acceptanceChecklist: [
+            "The workflow change matches the stated intent and does not remove required behavior without an explicit reason.",
+            ...(riskLevel === "high" ? ["High-risk removals have explicit manager rationale before adoption or organization binding."] : []),
+            "Evidence links are inspectable and strong enough for manager review.",
+            "Cascade inheritance and preview-first evolution remain visible before runtime sync.",
+            "Acceptance continues through adoption review, organization binding, rollout, and only then runtime sync.",
+        ],
+        nextActions: [
+            `Review proposed asset details: dna assets inspect ${to.name} --evidence`,
+            `If manager accepts this diff, run adoption review: ${reviewDecision.acceptanceCommand}`,
+            `Record accepted version in the organization route: ${reviewDecision.orgBindCommand}`,
+            `Review rollout readiness before runtime sync: ${reviewDecision.rolloutCommand}`,
+            `Sync only after review, adoption, binding, and rollout: ${reviewDecision.syncCommand}`,
+        ],
+    };
+}
+function writeAssetDiff(diff) {
+    process.stderr.write(`Workflow asset diff: ${diff.from} -> ${diff.to}\n`);
+    process.stderr.write(`Workflows: +${diff.summary.workflowsAdded} -${diff.summary.workflowsRemoved} ~${diff.summary.workflowsModified}\n`);
+    process.stderr.write(`Steps: +${diff.summary.stepsAdded} -${diff.summary.stepsRemoved} ~${diff.summary.stepsModified}\n`);
+    process.stderr.write(`Governance changes: ${diff.summary.governanceChanges}\n`);
+    if (diff.changeExplanation.length > 0) {
+        process.stderr.write("\nWhat changed and why:\n");
+        for (const line of diff.changeExplanation)
+            process.stderr.write(`  - ${line}\n`);
+    }
+    if (diff.workflows.length > 0) {
+        process.stderr.write("\nWorkflow changes:\n");
+        for (const workflow of diff.workflows) {
+            process.stderr.write(`  - [${workflow.change}] ${workflow.id}`);
+            if (workflow.fromStepCount !== undefined || workflow.toStepCount !== undefined) {
+                process.stderr.write(` steps=${workflow.fromStepCount ?? "none"} -> ${workflow.toStepCount ?? "none"}`);
+            }
+            process.stderr.write("\n");
+        }
+    }
+    if (diff.steps.length > 0) {
+        process.stderr.write("\nStep changes:\n");
+        for (const step of diff.steps) {
+            process.stderr.write(`  - [${step.change}] ${step.workflow}/${step.id}`);
+            if (step.fields.length > 0)
+                process.stderr.write(` fields=${step.fields.join(",")}`);
+            process.stderr.write("\n");
+            if (step.change === "modified") {
+                process.stderr.write(`    from: ${compactStep(step.from)}\n`);
+                process.stderr.write(`    to:   ${compactStep(step.to)}\n`);
+            }
+            else if (step.to) {
+                process.stderr.write(`    to:   ${compactStep(step.to)}\n`);
+            }
+            else if (step.from) {
+                process.stderr.write(`    from: ${compactStep(step.from)}\n`);
+            }
+        }
+    }
+    if (diff.governance.length > 0) {
+        process.stderr.write("\nGovernance changes:\n");
+        for (const change of diff.governance) {
+            process.stderr.write(`  - ${change.field}: ${JSON.stringify(change.from)} -> ${JSON.stringify(change.to)}\n`);
+        }
+    }
+    process.stderr.write("\nReview decision:\n");
+    process.stderr.write(`  - status: ${diff.reviewDecision.status}\n`);
+    process.stderr.write(`  - risk: ${diff.reviewDecision.riskLevel}\n`);
+    for (const note of diff.reviewDecision.riskNotes)
+        process.stderr.write(`    - ${note}\n`);
+    process.stderr.write(`  - reason: ${diff.reviewDecision.reason}\n`);
+    process.stderr.write(`  - adoption review: ${diff.reviewDecision.acceptanceCommand}\n`);
+    process.stderr.write(`  - org bind: ${diff.reviewDecision.orgBindCommand}\n`);
+    process.stderr.write(`  - rollout: ${diff.reviewDecision.rolloutCommand}\n`);
+    process.stderr.write(`  - sync after rollout: ${diff.reviewDecision.syncCommand}\n`);
+    process.stderr.write("\nReview evidence:\n");
+    process.stderr.write(`  - mode: ${diff.reviewEvidence.mode}\n`);
+    process.stderr.write(`  - authority: ${diff.reviewEvidence.authority}\n`);
+    process.stderr.write(`  - receipt command: ${diff.reviewEvidence.receiptCommand}\n`);
+    process.stderr.write(`  - receipt path: ${diff.reviewEvidence.receiptPathHint}\n`);
+    for (const boundary of diff.reviewEvidence.boundaries)
+        process.stderr.write(`    - ${boundary}\n`);
+    process.stderr.write("\nAcceptance checklist:\n");
+    for (const item of diff.acceptanceChecklist)
+        process.stderr.write(`  - ${item}\n`);
+    process.stderr.write("\nNext actions:\n");
+    for (const action of diff.nextActions)
+        process.stderr.write(`  - ${action}\n`);
+}
+function buildGovernanceReview(asset, evidence, assets = [asset], evidenceSourceAsset = asset) {
+    const nextActions = [];
+    if (!asset.status.hasCascade) {
+        nextActions.push("Declare cascade inheritance before distributing this asset across projects or teams.");
+    }
+    const evidenceGate = buildGovernanceEvidenceGate(asset, evidence, evidenceSourceAsset);
+    const followupRoute = evidenceGate.status === "open"
+        ? activeEvidenceFollowupReviewRoute(evidenceSourceAsset.name, assets, evidence)
+        : undefined;
+    const routedEvidenceGate = followupRoute
+        ? { ...evidenceGate, nextCommand: followupRoute.currentCommand }
+        : evidenceGate;
+    const draftCommand = evidenceSuggestionDraftCommand(asset, evidence, `${asset.name}-v2`);
+    const evidenceAllowsMutation = evidenceGate.status === "clear";
+    const decision = !asset.status.hasCascade
+        ? "declare_cascade"
+        : !evidenceAllowsMutation
+            ? "review_evidence_first"
+            : !asset.status.configured
+                ? "configure_asset"
+                : "preview_evolution";
+    const nextCommand = decision === "declare_cascade"
+        ? `dna assets inspect ${asset.name} --evidence`
+        : decision === "configure_asset"
+            ? `dna init --template ${asset.name}`
+            : decision === "review_evidence_first"
+                ? routedEvidenceGate.nextCommand ?? `dna assets suggestions ${asset.name}`
+                : asset.evolution.previewCommand;
+    if (evidenceGate.status === "open") {
+        nextActions.push(`Review evidence-backed follow-up before marker mutation: ${routedEvidenceGate.nextCommand}`);
+        if (followupRoute) {
+            nextActions.push(`Review candidate diff before adoption/sync: ${followupRoute.diffCommand}`);
+        }
+        else if (draftCommand) {
+            nextActions.push(`Review suggested workflow action before adoption/sync: ${draftCommand}`);
+        }
+        else {
+            nextActions.push(`No template improvement suggestion is ready yet; continue from evidence review: dna assets suggestions ${asset.name}`);
+        }
+    }
+    else {
+        if (!asset.status.configured) {
+            nextActions.push(`Configure this asset in the project: dna init --template ${asset.name}`);
+        }
+        nextActions.push(`Review marker changes before mutation: ${asset.evolution.previewCommand}`);
+        nextActions.push(`Apply evolution only through an explicit reviewed sync path: ${asset.evolution.mutatingCommand}`);
+    }
+    return {
+        asset: asset.name,
+        displayName: asset.displayName,
+        managerGates: buildManagerGates({
+            asset,
+            evidenceStatus: evidenceGate.status,
+            evidenceNextCommand: routedEvidenceGate.nextCommand,
+            evidenceAllowsMutation,
+        }),
+        reviewPacket: {
+            cascadeReady: asset.status.hasCascade,
+            evolutionReady: asset.evolution.reviewMode === "preview_first",
+            evidenceAllowsMutation,
+            syncAllowed: asset.status.configured && evidenceAllowsMutation,
+            compilerEffect: asset.status.hasCascade
+                ? `Compiler merges inherited layers (${asset.cascade.inherits.length > 0 ? asset.cascade.inherits.join(", ") : "none"}) before runtime artifacts are generated.`
+                : "Compiler treats this as a standalone asset until cascade inheritance is declared.",
+            mutationBoundary: evidenceAllowsMutation
+                ? `Evolution remains preview-first; review ${asset.evolution.previewCommand} before explicit mutation through ${asset.evolution.mutatingCommand}.`
+                : "Evolution and runtime sync are blocked by active evidence; create a reviewed workflow draft before marker mutation.",
+            decision,
+            nextCommand,
+        },
+        evidenceGate: routedEvidenceGate,
+        cascade: {
+            posture: asset.status.cascadePosture,
+            declared: asset.cascade.declared,
+            layerType: asset.cascade.type,
+            priority: asset.cascade.priority,
+            inherits: asset.cascade.inherits,
+            explanation: asset.cascade.declared
+                ? "Cascade is declared in the workflow asset. The compiler merges inherited DNA layers before runtime artifacts are generated."
+                : "Cascade is not declared; the asset behaves as a standalone template until an org/project layer is attached.",
+        },
+        evolution: {
+            posture: asset.status.evolutionPosture,
+            reviewMode: asset.evolution.reviewMode,
+            declaredMarkers: asset.evolution.declaredMarkers,
+            markerIds: asset.evolution.markerIds,
+            outcomeStore: asset.evolution.outcomeStore,
+            previewCommand: asset.evolution.previewCommand,
+            mutatingCommand: asset.evolution.mutatingCommand,
+            explanation: "Evolution is preview-first. Outcomes can suggest marker changes, but policy mutation requires human review and an explicit sync/evolve path.",
+        },
+        implementationRefs: [
+            {
+                layer: "asset_template",
+                path: asset.path,
+                role: "Declares workflows, cascade inheritance, evidence links, and preview-first evolution posture for this asset.",
+            },
+            {
+                layer: "cascade_compiler",
+                path: "src/compiler/cascade.ts",
+                role: "Merges inherited DNA layers before compile/sync so workflow governance is not duplicated inside harness adapters.",
+            },
+            {
+                layer: "evolution_engine",
+                path: "src/evolution/",
+                role: "Collects outcomes and produces previewable marker changes; mutation remains explicit and human-reviewed.",
+            },
+            {
+                layer: "dogfood_evidence",
+                path: evidence?.progressDir ?? "unavailable",
+                role: evidence
+                    ? "Provides module progress JSON used to gate suggestions, marker mutation, and runtime sync."
+                    : "No evidence index is available yet; governance must stay preview-only.",
+            },
+            {
+                layer: "runtime_sync",
+                path: "src/cli/commands/sync.ts",
+                role: "Installs runtime artifacts after review; governance decisions stay in dna core/runtime rather than dashboard or Obsidian.",
+            },
+        ],
+        nextActions,
+    };
+}
+function buildGovernanceEvidenceGate(asset, evidence, evidenceSourceAsset = asset) {
+    if (!evidence) {
+        return {
+            status: "unknown",
+            modules: 0,
+            pass: 0,
+            continue: 0,
+            blocked: 0,
+            remaining: 0,
+            explanation: "No dogfood evidence index is available for this asset; keep evolution preview-only until evidence is reviewed.",
+            nextCommand: `dna assets evidence ${evidenceSourceAsset.name}`,
+        };
+    }
+    const open = evidence.totals.continue > 0 || evidence.totals.blocked > 0 || evidence.totals.remaining > 0;
+    const sourcePrefix = evidenceSourceAsset.name === asset.name
+        ? "Dogfood evidence"
+        : `Source dogfood evidence for ${evidenceSourceAsset.name}`;
+    return {
+        status: open ? "open" : "clear",
+        modules: evidence.totals.modules,
+        pass: evidence.totals.pass,
+        continue: evidence.totals.continue,
+        blocked: evidence.totals.blocked,
+        remaining: evidence.totals.remaining,
+        explanation: open
+            ? `${sourcePrefix} still has active work; review suggestions and draft workflow changes before any marker mutation or runtime sync.`
+            : `${sourcePrefix} has no active remaining work; marker previews can be reviewed explicitly before mutation.`,
+        nextCommand: open ? `dna assets suggestions ${evidenceSourceAsset.name}` : asset.evolution.previewCommand,
+    };
+}
+function describeCascadeInheritance(asset) {
+    const inheritance = asset.cascade.inherits.length > 0 ? `inherits ${asset.cascade.inherits.join(", ")}` : "inherits none";
+    return asset.cascade.priority !== undefined ? `${inheritance} at priority ${asset.cascade.priority}` : inheritance;
+}
+function findPredecessorAsset(asset, assets) {
+    const activeFollowupMatch = /^(.*)-active-followup$/.exec(asset.name);
+    if (activeFollowupMatch) {
+        return assets.find((candidate) => candidate.name === activeFollowupMatch[1]);
+    }
+    const versionMatch = /^(.*)-v\d+$/.exec(asset.name);
+    if (versionMatch) {
+        return assets.find((candidate) => candidate.name === versionMatch[1]);
+    }
+    return undefined;
+}
+function evidenceIndexOpen(evidence) {
+    return !!evidence && (evidence.totals.continue > 0 ||
+        evidence.totals.blocked > 0 ||
+        evidence.totals.requestChanges > 0 ||
+        evidence.totals.remaining > 0);
+}
+function buildAdoptionReview(asset, assets = [asset], predecessorEvidence) {
+    const predecessor = findPredecessorAsset(asset, assets);
+    const predecessorDiff = predecessor ? buildAssetDiff(predecessor, asset) : undefined;
+    const predecessorAcceptanceRequired = predecessorDiff ? predecessorDiff.reviewDecision.riskLevel !== "low" : false;
+    const predecessorEvidenceOpen = evidenceIndexOpen(predecessorEvidence);
+    const openPredecessorEvidence = predecessorEvidenceOpen ? predecessorEvidence : undefined;
+    const evidenceDescriptions = asset.evidence
+        .map((link) => link.description)
+        .filter((description) => typeof description === "string" && description.length > 0);
+    const checks = [
+        {
+            id: "workflow",
+            label: "Workflow",
+            status: asset.status.hasWorkflow ? "pass" : "warn",
+            detail: asset.status.hasWorkflow
+                ? `${asset.workflows.length} workflow(s), ${asset.workflows.reduce((sum, workflow) => sum + workflow.stepCount, 0)} step(s)`
+                : "No workflow steps are declared yet.",
+        },
+        {
+            id: "controller",
+            label: "Controller",
+            status: asset.status.hasController ? "pass" : "warn",
+            detail: asset.status.hasController
+                ? `${asset.controllers.length} controller(s) declared`
+                : "No controller is declared for repeatable execution.",
+        },
+        {
+            id: "cascade",
+            label: "Cascade",
+            status: asset.status.hasCascade ? "pass" : "warn",
+            detail: asset.status.hasCascade
+                ? describeCascadeInheritance(asset)
+                : "No inheritance layer is declared; keep this local until org/project inheritance is explicit.",
+        },
+        {
+            id: "evolution",
+            label: "Evolution",
+            status: asset.evolution.reviewMode === "preview_first" ? "pass" : "warn",
+            detail: `review mode=${asset.evolution.reviewMode}; preview=${asset.evolution.previewCommand}`,
+        },
+        {
+            id: "evidence",
+            label: "Evidence",
+            status: asset.status.hasEvidence && !predecessorEvidenceOpen ? "pass" : "warn",
+            detail: openPredecessorEvidence && predecessor
+                ? `Source evidence for ${predecessor.name} is still open: modules=${openPredecessorEvidence.totals.modules}; continue=${openPredecessorEvidence.totals.continue}; blocked=${openPredecessorEvidence.totals.blocked + openPredecessorEvidence.totals.requestChanges}; remaining=${openPredecessorEvidence.totals.remaining}. Keep ${asset.name} as a review draft until diff, rationale, adoption, organization binding, and rollout are explicitly accepted.`
+                : asset.status.hasEvidence
+                    ? `${asset.evidence.length} evidence/reference link(s); posture=${asset.status.evidencePosture}${evidenceDescriptions.length > 0 ? `; ${evidenceDescriptions.join("; ")}` : ""}`
+                    : "No evidence is linked; do not present this asset as proven yet.",
+        },
+        ...(predecessorDiff ? [{
+                id: "diff_acceptance",
+                label: "Diff acceptance",
+                status: predecessorAcceptanceRequired ? "warn" : "pass",
+                detail: predecessorAcceptanceRequired
+                    ? `${predecessorDiff.reviewDecision.riskLevel}-risk predecessor diff requires explicit manager rationale before adoption, organization binding, rollout, or sync.`
+                    : "Predecessor diff is low risk; keep the receipt with the adoption review packet.",
+            }] : []),
+        {
+            id: "project_config",
+            label: "Project config",
+            status: asset.status.configured ? "pass" : "warn",
+            detail: asset.status.configured
+                ? `configured at ${asset.status.configPaths.join(", ")}`
+                : "not configured in this project yet",
+        },
+    ];
+    const hardWarnings = checks.filter((check) => check.status === "warn" && check.id !== "project_config");
+    const recommendation = hardWarnings.length === 0
+        ? "ready_to_adopt"
+        : asset.status.hasWorkflow && asset.status.hasController
+            ? "review_first"
+            : "not_ready";
+    return {
+        asset: asset.name,
+        displayName: asset.displayName,
+        recommendation,
+        summary: recommendation === "ready_to_adopt"
+            ? "This asset has the minimum workflow, controller, cascade, evolution, and evidence signals needed for explicit project adoption."
+            : predecessorEvidenceOpen
+                ? "This asset is structurally reviewable, but source dogfood evidence is still open; keep it as a review draft until manager rationale, adoption, organization binding, and rollout gates are explicitly accepted."
+                : predecessorAcceptanceRequired
+                    ? "This asset is structurally reviewable, but the predecessor diff requires explicit manager rationale before adoption, organization binding, rollout, or sync."
+                    : recommendation === "review_first"
+                        ? "This asset can be reviewed, but at least one governance or evidence signal should be fixed before broad rollout."
+                        : "This asset is not ready for adoption because the executable workflow shape is incomplete.",
+        predecessorDiff: predecessorDiff
+            ? {
+                from: predecessorDiff.from,
+                command: `dna assets diff ${predecessorDiff.from} ${predecessorDiff.to}`,
+                riskLevel: predecessorDiff.reviewDecision.riskLevel,
+                riskNotes: predecessorDiff.reviewDecision.riskNotes,
+                acceptanceRequired: predecessorDiff.reviewDecision.riskLevel !== "low",
+                reason: predecessorDiff.reviewDecision.reason,
+                receiptCommand: predecessorDiff.reviewEvidence.receiptCommand,
+                receiptPathHint: predecessorDiff.reviewEvidence.receiptPathHint,
+            }
+            : undefined,
+        checks,
+        adoptionPath: [
+            ...(predecessorDiff ? [{
+                    id: "diff",
+                    command: `dna assets diff ${predecessorDiff.from} ${predecessorDiff.to}`,
+                    purpose: "Review predecessor changes and record manager rationale before adoption, organization binding, or sync.",
+                }] : []),
+            {
+                id: "inspect",
+                command: `dna assets inspect ${asset.name} --evidence`,
+                purpose: "Read the workflow steps, roles, controllers, cascade, and evidence links.",
+            },
+            {
+                id: "governance",
+                command: `dna assets governance ${asset.name}`,
+                purpose: "Confirm inheritance and preview-first evolution before any mutation.",
+            },
+            {
+                id: "evolution-preview",
+                command: asset.evolution.previewCommand,
+                purpose: "Preview marker changes; do not persist them from this review step.",
+            },
+            {
+                id: "org-bind",
+                command: `dna org bind --asset ${asset.name} --status active --sync-target codex`,
+                purpose: "Record manager adoption in the organization profile only after diff and adoption review are accepted.",
+            },
+            {
+                id: "configure",
+                command: `dna init --template ${asset.name}`,
+                purpose: "Generate project DNA config only after adoption is accepted.",
+            },
+            {
+                id: "sync",
+                command: "dna sync --codex",
+                purpose: "Install runtime artifacts after review, adoption, and configuration.",
+            },
+        ],
+    };
+}
+function compactEvidenceModule(module) {
+    const remaining = module.remainingCount > 0 ? ` remaining=${module.remainingCount}` : "";
+    const blocked = module.blockedCount > 0 ? ` blocked=${module.blockedCount}` : "";
+    const red = module.newRedCount > 0 ? ` new_red=${module.newRedCount}` : "";
+    return `${module.module}: ${module.verdict}${module.moduleComplete ? " complete" : " incomplete"}${remaining}${blocked}${red}`;
+}
+function withCurrentActiveFollowupEvidence(asset, evidence) {
+    if (!evidence || !asset.name.endsWith("-active-followup"))
+        return asset;
+    const active = activeEvidenceModules(evidence);
+    if (active.length === 0)
+        return asset;
+    const description = `Candidate active-followup-${evidence.asset}: ${active.length} active module(s): ${active.slice(0, 5).map(compactEvidenceModule).join("; ")}`;
+    return {
+        ...asset,
+        evidence: asset.evidence.map((link) => link.label === `Active dogfood evidence: ${evidence.asset}`
+            ? { ...link, description }
+            : link),
+    };
+}
+async function normalizeAssetForReview(asset, projectDir) {
+    const match = /^(.*)-active-followup$/.exec(asset.name);
+    if (!match)
+        return asset;
+    const evidence = await buildWorkflowAssetEvidenceIndex(match[1], { projectDir });
+    return withCurrentActiveFollowupEvidence(asset, evidence);
+}
+function suggestionId(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "suggestion";
+}
+function suggestionReviewCommand(params) {
+    return `dna workflow review-suggestion --from-template ${params.asset} --workflow ${params.workflow ?? "fix"} --suggestion ${params.suggestionId} --decision ${params.decision ?? "accept"}`;
+}
+function suggestionDraftCommand(params) {
+    return `dna workflow improve-from-suggestions --from-template ${params.asset} --workflow ${params.workflow ?? "fix"} --suggestion ${params.suggestionId} --save-template ${params.saveTemplate}`;
+}
+function suggestionAdoptionAsset(suggestion) {
+    if (suggestion.id === WORKFLOW_SUGGESTION_IDS.crossBoundaryResourceApproval)
+        return WORKFLOW_ASSET_IDS.crossBoundaryResourceApproval;
+    if (suggestion.id === WORKFLOW_SUGGESTION_IDS.blockedTriage)
+        return WORKFLOW_ASSET_IDS.blockedScopeTriage;
+    return undefined;
+}
+function suggestionAction(params) {
+    if (params.suggestion.id === WORKFLOW_SUGGESTION_IDS.activeFollowup) {
+        const route = activeEvidenceFollowupRoute(params.asset);
+        return {
+            kind: "draft",
+            command: route.command,
+            assetName: route.assetName,
+        };
+    }
+    const adoptionAsset = suggestionAdoptionAsset(params.suggestion);
+    if (adoptionAsset) {
+        return {
+            kind: "adoption",
+            command: `dna assets adoption ${adoptionAsset}`,
+            assetName: adoptionAsset,
+        };
+    }
+    return {
+        kind: "draft",
+        command: suggestionDraftCommand({
+            asset: params.asset,
+            suggestionId: params.suggestion.id,
+            saveTemplate: params.saveTemplate,
+            workflow: params.workflow,
+        }),
+    };
+}
+function suggestionActionCommand(params) {
+    return suggestionAction(params).command;
+}
+function buildSuggestionImprovementRoute(params) {
+    const nextVersion = `${params.asset.name}-v2`;
+    const action = params.draftSuggestion
+        ? suggestionAction({
+            asset: params.asset.name,
+            suggestion: params.draftSuggestion,
+            saveTemplate: nextVersion,
+        })
+        : undefined;
+    const reviewCommand = !params.activeFollowup
+        && params.draftSuggestion
+        && action?.kind === "draft"
+        && params.draftSuggestion.id !== WORKFLOW_SUGGESTION_IDS.activeFollowup
+        ? suggestionReviewCommand({
+            asset: params.asset.name,
+            suggestionId: params.draftSuggestion.id,
+            workflow: "fix",
+            decision: "accept",
+        })
+        : undefined;
+    const templateCommand = reviewCommand ??
+        params.activeFollowup?.currentCommand ??
+        action?.command ??
+        `dna workflow edit-plan "Describe the reviewed workflow change" --from-template ${params.asset.name} --save-template ${nextVersion}`;
+    const organizationCommand = params.activeFollowup?.bindCommand ??
+        `dna org bind --asset ${action?.assetName ?? nextVersion} --status active --sync-target codex`;
+    const templateWrites = reviewCommand ? true : (params.activeFollowup?.currentWrites ?? (action ? action.kind === "draft" : true));
+    return [
+        {
+            id: "evidence",
+            label: "Read dogfood evidence",
+            command: `dna assets evidence ${params.asset.name}`,
+            purpose: "Use canonical dogfood progress as the source of improvement instead of chat memory or loose notes.",
+            owner: "dna_core",
+            writes: false,
+        },
+        {
+            id: "template",
+            label: "Promote into workflow asset",
+            command: templateCommand,
+            purpose: "Turn concrete dogfood problems into a reviewed template version or reusable workflow asset before adoption.",
+            owner: "dna_core",
+            writes: templateWrites,
+        },
+        {
+            id: "infra",
+            label: "Escalate repeated gaps to dna infra",
+            command: `dna assets governance ${params.asset.name}`,
+            purpose: "If multiple templates need the same support, keep the capability in dna core rather than copy-pasting prompt logic into each workflow.",
+            owner: "dna_core",
+            writes: false,
+        },
+        {
+            id: "organization",
+            label: "Review organization rollout",
+            command: organizationCommand,
+            purpose: "Managers accept the reviewed asset version into the organization route before rollout and runtime sync.",
+            owner: "manager",
+            writes: true,
+        },
+        {
+            id: "evolution",
+            label: "Preview evolution only after review",
+            command: params.asset.evolution.previewCommand,
+            purpose: "Evolution is preview-first; marker mutation waits for reviewed evidence, adopted asset changes, and explicit sync/evolve.",
+            owner: "dna_core",
+            writes: false,
+        },
+    ];
+}
+function firstDraftableSuggestion(suggestions) {
+    return suggestions.find((suggestion) => suggestion.type === "template_improvement" ||
+        suggestion.id === WORKFLOW_SUGGESTION_IDS.c5CapturedRunFacts);
+}
+function evidenceSuggestionDraftCommand(asset, evidence, saveTemplate) {
+    if (!evidence || asset.status.evidencePosture !== "dogfood_linked")
+        return undefined;
+    const suggestion = firstDraftableSuggestion(buildAssetSuggestions(asset, evidence).suggestions);
+    return suggestion ? suggestionActionCommand({ asset: asset.name, suggestion, saveTemplate }) : undefined;
+}
+function activeEvidenceModules(index) {
+    return index.modules.filter((module) => module.verdict !== "PASS" ||
+        !module.moduleComplete ||
+        module.remainingCount > 0 ||
+        module.newRedCount > 0);
+}
+function compactEvidenceCapture(capture) {
+    const result = capture.result ? `/${capture.result}` : "";
+    const scope = [capture.workflowId, capture.stepId].filter((value) => value && value !== "unknown").join(":");
+    const prefix = `${capture.capturedAt.slice(0, 10)} ${capture.fact}${result}${scope ? ` ${scope}` : ""}`;
+    return `${prefix}: ${capture.summary}`.slice(0, 240);
+}
+function c5GapCaptures(index) {
+    return index.captureFacts.filter((capture) => capture.fact === "blocker" ||
+        capture.fact === "manual_intervention" ||
+        capture.fact === "retry" ||
+        capture.result === "blocked" ||
+        capture.result === "failure" ||
+        capture.result === "unsupported");
+}
+function c5EvidenceRefs(captures) {
+    const refs = captures.flatMap((capture) => [
+        { type: "capture_event", ref: capture.path },
+        ...capture.evidenceRefs,
+    ]);
+    const seen = new Set();
+    return refs.filter((ref) => {
+        const key = `${ref.type}:${ref.ref}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function c5CaptureBootstrapCommands(assetName) {
+    return [
+        `dna init --template ${assetName}`,
+        "dna sync --codex --dry-run",
+        "dna sync --codex",
+        `dna workflow suggestions ${assetName} --json`,
+        `dna workflow mine ${assetName} --json`,
+    ];
+}
+function uniqueEvidenceRefs(refs, limit = 12) {
+    const seen = new Set();
+    const unique = [];
+    for (const ref of refs) {
+        const key = `${ref.type}:${ref.ref}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(ref);
+        if (unique.length >= limit)
+            break;
+    }
+    return unique;
+}
+function dogfoodEvidenceRefs(modules) {
+    return uniqueEvidenceRefs(modules.flatMap((module) => [
+        { type: "dogfood_progress", ref: module.progressJsonPath },
+        ...module.evidencePaths.slice(0, 2).map((ref) => ({ type: "dogfood_evidence", ref })),
+    ]));
+}
+function suggestionEvidenceRefs(suggestion, index) {
+    if (suggestion.evidenceRefs)
+        return suggestion.evidenceRefs;
+    if (suggestion.id === "c5-capture-empty-state") {
+        return [{ type: "local_evidence_store", ref: `${index.projectPath}/.dna/evidence/capture` }];
+    }
+    const modules = suggestion.sourceModules.length > 0
+        ? index.modules.filter((module) => suggestion.sourceModules.includes(module.module))
+        : index.modules;
+    if (modules.length > 0)
+        return dogfoodEvidenceRefs(modules);
+    if (index.warnings.length > 0) {
+        return index.warnings.map((warning) => ({ type: "evidence_warning", ref: warning }));
+    }
+    return [{ type: "local_evidence_store", ref: `${index.projectPath}/.dna/evidence/capture` }];
+}
+function adoptionSuggestionCommands(sourceAsset, candidateAsset) {
+    return [
+        `dna assets lineage ${sourceAsset}`,
+        `dna assets evidence ${sourceAsset}`,
+        `dna assets inspect ${candidateAsset} --evidence`,
+        `dna assets governance ${candidateAsset}`,
+        `dna assets adoption ${candidateAsset}`,
+    ];
+}
+function defaultSuggestionCommands(params) {
+    const adoptionAsset = suggestionAdoptionAsset(params.suggestion);
+    if (adoptionAsset)
+        return adoptionSuggestionCommands(params.asset.name, adoptionAsset);
+    if (params.suggestion.id === WORKFLOW_SUGGESTION_IDS.activeFollowup) {
+        const route = activeEvidenceFollowupRoute(params.asset.name);
+        return [
+            `dna assets evidence ${params.asset.name}`,
+            route.command,
+            `dna assets diff ${params.asset.name} ${route.assetName}`,
+            `dna assets adoption ${route.assetName}`,
+        ];
+    }
+    if (params.suggestion.type === "template_improvement") {
+        const reviewCommand = suggestionReviewCommand({
+            asset: params.asset.name,
+            suggestionId: params.suggestion.id,
+            workflow: "fix",
+            decision: "accept",
+        });
+        return [
+            `dna assets evidence ${params.asset.name} --json`,
+            reviewCommand,
+            suggestionDraftCommand({
+                asset: params.asset.name,
+                suggestionId: params.suggestion.id,
+                saveTemplate: `${params.asset.name}-v2`,
+                workflow: "fix",
+            }),
+            `dna assets diff ${params.asset.name} ${params.asset.name}-v2`,
+            `dna assets adoption ${params.asset.name}-v2`,
+        ];
+    }
+    if (params.suggestion.type === "continue_execution") {
+        return [
+            `dna assets evidence ${params.asset.name} --json`,
+            `continue governed workflow focus for ${params.suggestion.sourceModules[0] ?? params.asset.name}`,
+        ];
+    }
+    if (params.suggestion.type === "governance_review") {
+        return [
+            `dna assets evidence ${params.asset.name}`,
+            `dna assets adoption ${params.asset.name}`,
+            `dna assets governance ${params.asset.name}`,
+            params.asset.evolution.previewCommand,
+        ];
+    }
+    return [
+        `dna assets evidence ${params.asset.name} --json`,
+        `dna workflow suggestions ${params.asset.name} --json`,
+    ];
+}
+function defaultMutationBoundary(suggestion) {
+    if (suggestion.mutationBoundary)
+        return suggestion.mutationBoundary;
+    if (suggestion.type === "continue_execution") {
+        return "Continue suggestions are operational guidance only; they do not edit workflow assets, mutate policy, adopt templates, bind organizations, sync runtime artifacts, upload reports, or create runtime authority.";
+    }
+    if (suggestion.type === "template_improvement") {
+        return "Template improvement suggestions are review paths only; drafts or adoption reviews require explicit follow-up commands and never auto-adopt, bind, sync, upload, or mutate runtime policy.";
+    }
+    if (suggestion.type === "governance_review") {
+        return "Governance suggestions are read-only review or preview steps; evolution marker mutation, organization binding, and runtime sync stay behind explicit human-reviewed commands.";
+    }
+    return "Evidence suggestions are read-only; evidence can inform reviewed changes but never edits workflow assets, mutates policy, adopts templates, binds organizations, syncs runtime artifacts, uploads reports, or creates runtime authority.";
+}
+function completeSuggestionReviewFields(params) {
+    return {
+        ...params.suggestion,
+        evidenceRefs: suggestionEvidenceRefs(params.suggestion, params.index),
+        nextCommands: params.suggestion.nextCommands ?? defaultSuggestionCommands({
+            asset: params.asset,
+            suggestion: params.suggestion,
+        }),
+        mutationBoundary: defaultMutationBoundary(params.suggestion),
+    };
+}
+export function buildAssetSuggestions(asset, index, assets = [asset]) {
+    const suggestions = [];
+    const active = activeEvidenceModules(index);
+    const c5Gaps = c5GapCaptures(index);
+    for (const module of active.slice(0, 5)) {
+        suggestions.push({
+            id: `continue-${suggestionId(module.module)}`,
+            type: "continue_execution",
+            severity: module.verdict === "BLOCKED" || module.verdict === "REQUEST_CHANGES" ? "warn" : "info",
+            title: `Continue ${module.module} with the existing governed workflow`,
+            evidence: compactEvidenceModule(module),
+            rationale: module.nextRoundFocus ?? module.failureReason ?? "Dogfood evidence shows this module still has unresolved work.",
+            sourceModules: [module.module],
+            nextAction: `Run dna assets evidence ${asset.name} and continue the fix-loop focus for ${module.module}.`,
+        });
+    }
+    if (active.length > 0) {
+        const route = activeEvidenceFollowupRoute(asset.name);
+        suggestions.push({
+            id: "template-active-followup",
+            type: "template_improvement",
+            severity: "warn",
+            title: "Draft a reviewed active-evidence follow-up workflow",
+            evidence: active.slice(0, 5).map(compactEvidenceModule).join("; "),
+            rationale: "Open dogfood evidence should become an explicit follow-up workflow asset before baseline promotion, organization binding, rollout, runtime sync, or marker mutation.",
+            sourceModules: active.map((module) => module.module),
+            nextAction: `Draft reviewed follow-up: ${route.command}`,
+        });
+    }
+    if (c5Gaps.length > 0) {
+        const evidenceCommand = `dna assets evidence ${asset.name} --json`;
+        const suggestionsCommand = `dna workflow suggestions ${asset.name} --json`;
+        const reviewCommand = suggestionReviewCommand({
+            asset: asset.name,
+            suggestionId: WORKFLOW_SUGGESTION_IDS.c5CapturedRunFacts,
+            workflow: "fix",
+            decision: "accept",
+        });
+        const draftCommand = suggestionDraftCommand({
+            asset: asset.name,
+            suggestionId: WORKFLOW_SUGGESTION_IDS.c5CapturedRunFacts,
+            saveTemplate: `${asset.name}-v2`,
+            workflow: "fix",
+        });
+        suggestions.push({
+            id: WORKFLOW_SUGGESTION_IDS.c5CapturedRunFacts,
+            type: "evidence_improvement",
+            severity: "warn",
+            title: "Review captured local run facts before changing the workflow asset",
+            evidence: c5Gaps.slice(0, 5).map(compactEvidenceCapture).join("; "),
+            evidenceRefs: c5EvidenceRefs(c5Gaps),
+            rationale: "C5 hook evidence shows blocked, failed, retry, unsupported, or human-intervention facts. Evidence can suggest a reviewed change, but it must not mutate policy or templates automatically.",
+            sourceModules: [],
+            nextAction: `Review and accept the C5-backed suggestion before drafting: ${reviewCommand}`,
+            nextCommands: [
+                evidenceCommand,
+                suggestionsCommand,
+                reviewCommand,
+                draftCommand,
+                `record explicit manager rationale for any C5-derived change to ${asset.name}`,
+            ],
+            mutationBoundary: "C5 captured facts are local review evidence only; they do not edit templates, mutate policy, adopt assets, bind organizations, sync runtime artifacts, upload cloud reports, or create runtime authority.",
+        });
+    }
+    if (index.totals.captureFacts === 0) {
+        const commands = c5CaptureBootstrapCommands(asset.name);
+        suggestions.push({
+            id: "c5-capture-empty-state",
+            type: "evidence_improvement",
+            severity: "info",
+            title: "Run the workflow locally to create C5 capture facts",
+            evidence: "No local C5 capture facts were found under .dna/evidence/capture for this asset.",
+            rationale: "P3 needs local run facts before the IMPROVE loop can suggest changes from actual usage. Start with local init/sync, run the workflow in the harness, then return to suggestions and mining for review-only output.",
+            sourceModules: [],
+            nextAction: `Create local capture evidence, then rerun dna workflow suggestions ${asset.name} --json.`,
+            nextCommands: commands,
+            mutationBoundary: "This suggestion is guidance only. init/sync may write local runtime artifacts, but evidence still creates suggestions only and never edits workflow assets, mutates policy, adopts templates, binds organizations, uploads reports, or creates runtime authority.",
+        });
+    }
+    const modelFocused = active.filter((module) => /model|behavior lock|placeholder|assert/i.test(`${module.nextRoundFocus ?? ""} ${module.failureReason ?? ""}`));
+    if (modelFocused.length > 0) {
+        suggestions.push({
+            id: WORKFLOW_SUGGESTION_IDS.modelVerifier,
+            type: "template_improvement",
+            severity: "info",
+            title: "Consider a reviewed verifier step for model behavior locks",
+            evidence: modelFocused.map(compactEvidenceModule).join("; "),
+            rationale: "Dogfood evidence points to remaining behavior-lock/model assertion work. This is a candidate workflow/template improvement, not an automatic mutation.",
+            sourceModules: modelFocused.map((module) => module.module),
+            nextAction: `Review and accept the model-verifier suggestion before drafting: ${suggestionReviewCommand({ asset: asset.name, workflow: "fix", suggestionId: WORKFLOW_SUGGESTION_IDS.modelVerifier, decision: "accept" })}`,
+        });
+    }
+    const crossBoundaryFocused = index.modules.filter((module) => /i18n|localization|translation|shared|cross[- ]boundary|outside[_ ]diagnosis|outside[_ ]scope/i.test(`${module.module} ${module.nextRoundFocus ?? ""} ${module.failureReason ?? ""}`));
+    if (crossBoundaryFocused.length > 0) {
+        suggestions.push({
+            id: WORKFLOW_SUGGESTION_IDS.crossBoundaryResourceApproval,
+            type: "template_improvement",
+            severity: "info",
+            title: "Adopt the reusable cross-boundary resource approval workflow asset",
+            evidence: crossBoundaryFocused.slice(0, 5).map(compactEvidenceModule).join("; "),
+            rationale: "Dogfood evidence includes shared-resource, localization, or outside-diagnosis work that should be routed through explicit approval before implementation, rollout, sync, or completion claims.",
+            sourceModules: crossBoundaryFocused.map((module) => module.module),
+            nextAction: `Review and adopt: dna assets adoption ${WORKFLOW_ASSET_IDS.crossBoundaryResourceApproval}`,
+        });
+    }
+    const historicalBlocked = index.modules.filter((module) => module.blockedCount > 0);
+    if (historicalBlocked.length > 0) {
+        suggestions.push({
+            id: WORKFLOW_SUGGESTION_IDS.blockedTriage,
+            type: "template_improvement",
+            severity: "info",
+            title: "Adopt the reusable blocked-scope triage workflow asset",
+            evidence: historicalBlocked.slice(0, 5).map(compactEvidenceModule).join("; "),
+            rationale: `Some dogfood modules recorded blocked items. This pattern has been extracted as ${WORKFLOW_ASSET_IDS.blockedScopeTriage} so teams can classify blocked, skipped, removed, infra, and deferred work before manager review or rollout.`,
+            sourceModules: historicalBlocked.map((module) => module.module),
+            nextAction: `Review and adopt: dna assets adoption ${WORKFLOW_ASSET_IDS.blockedScopeTriage}`,
+        });
+    }
+    if (index.warnings.length > 0) {
+        suggestions.push({
+            id: "evidence-source-repair",
+            type: "evidence_improvement",
+            severity: "warn",
+            title: "Repair or review dogfood evidence source registration",
+            evidence: index.warnings.join("; "),
+            rationale: "Evolution suggestions are only useful when evidence sources are readable and canonical.",
+            sourceModules: [],
+            nextAction: `Run dna assets evidence ${asset.name} and fix the registered dogfood source before using suggestions.`,
+        });
+    }
+    if (suggestions.length === 0 && index.totals.modules > 0) {
+        suggestions.push({
+            id: "capture-stable-pattern",
+            type: "governance_review",
+            severity: "info",
+            title: "Capture the stable dogfood pattern as reviewed asset knowledge",
+            evidence: `${index.totals.pass}/${index.totals.modules} PASS, remaining=${index.totals.remaining}`,
+            rationale: "Dogfood evidence is stable enough to preserve the current behavior-lock, diagnosis, fix, and review structure as the baseline for future workflow versions.",
+            sourceModules: index.modules.map((module) => module.module),
+            nextAction: `Run dna assets adoption ${asset.name} before binding or syncing this asset in a project.`,
+        });
+    }
+    if (index.totals.remaining > 0) {
+        suggestions.push({
+            id: "do-not-auto-evolve",
+            type: "governance_review",
+            severity: "warn",
+            title: "Do not apply evolution automatically while evidence remains active",
+            evidence: `${index.totals.remaining} remaining item(s), continue=${index.totals.continue}, blocked=${index.totals.blocked + index.totals.requestChanges}`,
+            rationale: "Remaining dogfood work should become reviewed workflow changes or next-run focus, not automatic policy mutation.",
+            sourceModules: active.map((module) => module.module),
+            nextAction: `Preview only: ${asset.evolution.previewCommand}. Use ${asset.evolution.mutatingCommand} only after human review.`,
+        });
+    }
+    const completedSuggestions = suggestions.map((suggestion) => completeSuggestionReviewFields({
+        asset,
+        index,
+        suggestion,
+    }));
+    const activeFollowup = active.length > 0 ? activeEvidenceFollowupReviewRoute(asset.name, assets, index) : undefined;
+    const draftSuggestion = firstDraftableSuggestion(completedSuggestions);
+    const nextCommands = [
+        `dna assets evidence ${asset.name}`,
+    ];
+    if (activeFollowup) {
+        nextCommands.push(activeFollowup.currentCommand);
+        nextCommands.push(activeFollowup.diffCommand);
+        nextCommands.push(activeFollowup.adoptionCommand);
+    }
+    else if (draftSuggestion) {
+        const action = suggestionAction({
+            asset: asset.name,
+            suggestion: draftSuggestion,
+            saveTemplate: `${asset.name}-v2`,
+        });
+        if (action.kind === "draft" && draftSuggestion.id !== WORKFLOW_SUGGESTION_IDS.activeFollowup) {
+            nextCommands.push(suggestionReviewCommand({
+                asset: asset.name,
+                suggestionId: draftSuggestion.id,
+                workflow: "fix",
+                decision: "accept",
+            }));
+        }
+        nextCommands.push(action.command);
+        if (action.kind === "adoption" && action.assetName) {
+            nextCommands.push(`dna assets governance ${action.assetName}`);
+            nextCommands.push(`dna assets lineage ${action.assetName}`);
+        }
+    }
+    nextCommands.push(`dna assets adoption ${asset.name}`);
+    nextCommands.push(`dna assets governance ${asset.name}`);
+    if (index.totals.captureFacts === 0) {
+        nextCommands.push(...c5CaptureBootstrapCommands(asset.name));
+    }
+    const improvementRoute = buildSuggestionImprovementRoute({ asset, activeFollowup, draftSuggestion });
+    return {
+        asset: asset.name,
+        displayName: asset.displayName,
+        mode: "suggestions_only",
+        evidence: {
+            source: index.sourceDescription,
+            modules: index.totals.modules,
+            pass: index.totals.pass,
+            continue: index.totals.continue,
+            blocked: index.totals.blocked + index.totals.requestChanges,
+            remaining: index.totals.remaining,
+            captureFacts: index.totals.captureFacts,
+            captureBlocked: index.totals.captureBlocked,
+            captureFailures: index.totals.captureFailures,
+            captureManualInterventions: index.totals.captureManualInterventions,
+            captureRetries: index.totals.captureRetries,
+            warnings: index.warnings,
+        },
+        suggestions: completedSuggestions,
+        improvementRoute,
+        nextCommands: [...new Set(nextCommands)],
+        mutation: {
+            writes: false,
+            note: "Suggestions are read-only. They do not edit templates, org profiles, evolution markers, or runtime sync artifacts.",
+        },
+    };
+}
+function lifecycleEvidence(asset, evidence) {
+    if (!evidence) {
+        return {
+            status: "unknown",
+            modules: 0,
+            pass: 0,
+            blocked: 0,
+            remaining: 0,
+            nextCommand: `dna assets evidence ${asset.name}`,
+        };
+    }
+    const open = evidence.totals.continue > 0 || evidence.totals.blocked > 0 || evidence.totals.requestChanges > 0 || evidence.totals.remaining > 0;
+    return {
+        status: open ? "open" : "clear",
+        source: evidence.sourceDescription,
+        modules: evidence.totals.modules,
+        pass: evidence.totals.pass,
+        blocked: evidence.totals.blocked + evidence.totals.requestChanges,
+        remaining: evidence.totals.remaining,
+        nextCommand: open ? `dna assets suggestions ${asset.name}` : asset.evolution.previewCommand,
+    };
+}
+function buildManagerGates(params) {
+    const { asset, evidenceStatus, evidenceNextCommand, evidenceAllowsMutation } = params;
+    const evidenceCommand = evidenceNextCommand ?? `dna assets evidence ${asset.name}`;
+    const syncAllowed = asset.status.configured && evidenceAllowsMutation;
+    const syncDecision = !evidenceAllowsMutation
+        ? "blocked_by_evidence"
+        : !asset.status.configured
+            ? "configure_asset"
+            : "ready_to_sync";
+    const syncNextCommand = !evidenceAllowsMutation
+        ? evidenceCommand
+        : !asset.status.configured
+            ? `dna init --template ${asset.name}`
+            : "dna sync --codex";
+    return [
+        {
+            id: "cascade",
+            label: "Cascade compile gate",
+            status: asset.status.hasCascade ? "pass" : "blocked",
+            owner: "dna_core",
+            decision: asset.status.hasCascade ? "cascade_ready" : "declare_cascade",
+            reason: asset.status.hasCascade
+                ? `Compiler can merge inherited layers (${asset.cascade.inherits.length > 0 ? asset.cascade.inherits.join(", ") : "none"}) before runtime artifacts are generated.`
+                : "No cascade inheritance is declared, so this asset should stay local until its inherited layer is explicit.",
+            nextCommand: asset.status.hasCascade ? `dna assets governance ${asset.name}` : `dna assets inspect ${asset.name} --evidence`,
+            writes: false,
+        },
+        {
+            id: "evidence",
+            label: "Evidence gate",
+            status: evidenceStatus === "clear" ? "pass" : evidenceStatus === "open" ? "blocked" : "review",
+            owner: "dna_core",
+            decision: evidenceStatus === "clear" ? "evidence_clear" : evidenceStatus === "open" ? "review_evidence_first" : "collect_evidence",
+            reason: evidenceStatus === "clear"
+                ? "Dogfood evidence has no active remaining work; evolution can be previewed before explicit mutation."
+                : evidenceStatus === "open"
+                    ? "Dogfood evidence is still active, so suggestions and reviewed drafts must come before marker mutation or runtime sync."
+                    : "No dogfood evidence index is available; keep this asset preview-only until evidence is reviewed.",
+            nextCommand: evidenceCommand,
+            writes: false,
+        },
+        {
+            id: "evolution",
+            label: "Evolution gate",
+            status: asset.evolution.reviewMode === "preview_first" ? "pass" : "review",
+            owner: "dna_core",
+            decision: asset.evolution.reviewMode === "preview_first" ? "preview_first" : "review_evolution_policy",
+            reason: asset.evolution.reviewMode === "preview_first"
+                ? "Evolution can suggest marker changes, but mutation stays behind explicit human-reviewed sync."
+                : "Evolution policy is not preview-first, so manager review is required before it can become an org asset.",
+            nextCommand: asset.evolution.previewCommand,
+            writes: false,
+        },
+        {
+            id: "sync",
+            label: "Runtime sync gate",
+            status: syncAllowed ? "pass" : "blocked",
+            owner: "runtime",
+            decision: syncDecision,
+            reason: syncAllowed
+                ? "Project configuration and evidence gates allow runtime artifact sync."
+                : !evidenceAllowsMutation
+                    ? "Runtime sync is blocked until active evidence is resolved or converted into a reviewed draft."
+                    : "Runtime sync is blocked until the asset is configured in the project.",
+            nextCommand: syncNextCommand,
+            writes: syncAllowed,
+        },
+        {
+            id: "deploy",
+            label: "Public deploy gate",
+            status: "conditional",
+            owner: "release",
+            decision: "only_for_web_public_changes",
+            reason: "Run Vercel CLI deployment and deployed URL verification only when changed files affect web, dashboard, blog, or other public deployed surfaces.",
+            nextCommand: "dna release deploy-plan",
+            writes: false,
+        },
+    ];
+}
+function buildAssetLifecyclePath(params) {
+    const { asset, evidenceStatus, targetVersion, suggestionCommand, draftCommand, diffCommand, adoptionCommand, orgBindCommand, configureCommand, syncCommand, followupReviewable, evidenceActionWrites, evolutionPreviewCommand, releaseCommand, } = params;
+    const evidenceOpen = evidenceStatus === "open";
+    const evidenceClear = evidenceStatus === "clear";
+    const evidenceKnown = evidenceOpen || evidenceClear;
+    const canReviewVersion = evidenceClear || followupReviewable;
+    const canBind = evidenceClear || followupReviewable;
+    const canSync = evidenceClear && asset.status.configured;
+    return [
+        {
+            id: "select_asset",
+            label: "Select workflow asset",
+            command: "dna assets library",
+            purpose: "Choose the reusable workflow asset before creating a new workflow from scratch.",
+            owner: "user",
+            writes: false,
+            status: "done",
+            sourceIds: ["systemRoute.select"],
+            next: `Review governance for ${asset.name}.`,
+        },
+        {
+            id: "review_governance",
+            label: "Review governance",
+            command: `dna assets governance ${asset.name}`,
+            purpose: "Check cascade, evidence posture, evolution boundary, and runtime readiness before mutation.",
+            owner: "dna_core",
+            writes: false,
+            status: asset.status.hasCascade ? "done" : "current",
+            sourceIds: ["managerGates.cascade", "systemRoute.govern"],
+            next: evidenceKnown ? "Handle dogfood evidence." : "Collect evidence before adoption or sync.",
+        },
+        {
+            id: "handle_evidence",
+            label: "Handle evidence",
+            command: evidenceOpen ? draftCommand : evidenceClear ? suggestionCommand : `dna assets evidence ${asset.name}`,
+            purpose: evidenceOpen
+                ? "Save active dogfood evidence as a reviewed unfinished-work draft before promotion, rollout, or sync."
+                : evidenceClear
+                    ? "Evidence is clear; suggestions remain available as a read-only improvement source."
+                    : "Collect canonical dogfood evidence before shaping a managed asset version.",
+            owner: "dna_core",
+            writes: evidenceOpen ? evidenceActionWrites : false,
+            status: evidenceOpen || !evidenceKnown ? "current" : "done",
+            sourceIds: ["managerGates.evidence", "evidence", "stages.evidence", "stages.suggestions", "stages.draft"],
+            next: evidenceOpen ? "Review the saved unfinished-work draft before manager adoption." : "Shape or review the target asset version.",
+        },
+        {
+            id: "shape_version",
+            label: "Shape version",
+            command: diffCommand,
+            purpose: `Make ${targetVersion} reviewable by comparing workflow and governance changes against ${asset.name}.`,
+            owner: "dna_core",
+            writes: false,
+            status: canReviewVersion ? "available" : evidenceOpen ? "later" : "blocked",
+            sourceIds: ["systemRoute.improve", "stages.diff"],
+            next: canReviewVersion ? "Send the reviewed version to manager review." : "Resolve evidence before version review.",
+        },
+        {
+            id: "manager_review",
+            label: "Manager review",
+            command: adoptionCommand,
+            purpose: "Review adoption readiness before organization binding, rollout, runtime sync, or release.",
+            owner: "manager",
+            writes: false,
+            status: canReviewVersion ? "available" : "blocked",
+            sourceIds: ["systemRoute.review", "stages.adoption"],
+            next: canReviewVersion ? "Accept or reject the reviewed asset version." : "Wait for a reviewable asset version.",
+        },
+        {
+            id: "adopt_and_bind",
+            label: "Adopt and bind",
+            command: orgBindCommand,
+            purpose: "Record the manager-approved asset version in the organization profile before downstream distribution.",
+            owner: "manager",
+            writes: canBind,
+            status: canBind ? "available" : "blocked",
+            sourceIds: ["systemRoute.bind", "stages.org-bind"],
+            next: canBind ? `Configure ${targetVersion} for the project.` : "Manager review must pass before organization binding.",
+        },
+        {
+            id: "rollout_and_sync",
+            label: "Roll out and sync",
+            command: canSync ? syncCommand : configureCommand,
+            purpose: "Configure the accepted asset and sync runtime artifacts only after review and organization binding.",
+            owner: "runtime",
+            writes: canBind,
+            status: canSync ? "available" : canBind ? "current" : "blocked",
+            sourceIds: ["managerGates.sync", "systemRoute.rollout", "systemRoute.sync", "stages.configure", "stages.sync"],
+            next: canSync ? "Run runtime sync, then evaluate release/deploy gate if public surfaces changed." : "Configure the accepted asset before runtime sync.",
+        },
+        {
+            id: "evolve_or_release",
+            label: "Evolve or release",
+            command: evidenceClear ? evolutionPreviewCommand : releaseCommand,
+            purpose: "Preview evolution changes and run the release deploy-plan gate; Vercel CLI deploy runs only when deploy-plan requires a deployed URL.",
+            owner: "release",
+            writes: false,
+            status: evidenceClear ? "conditional" : "blocked",
+            sourceIds: ["managerGates.evolution", "managerGates.deploy", "systemRoute.deploy", "evolution"],
+            next: evidenceClear ? `${releaseCommand} <changed-files>; deploy with Vercel CLI only if the gate requires it.` : "Resolve evidence and adoption gates before evolution or release.",
+        },
+    ];
+}
+function buildAssetLifecycle(asset, evidence, assets = [asset]) {
+    const evidenceGate = lifecycleEvidence(asset, evidence);
+    const evidenceOpen = evidenceGate.status === "open";
+    const activeFollowup = evidenceOpen ? activeEvidenceFollowupReviewRoute(asset.name, assets, evidence) : undefined;
+    const nextVersion = `${asset.name}-v2`;
+    const targetVersion = activeFollowup?.candidateAssetName ?? nextVersion;
+    const intakeCommand = `dna workflow intake "Describe the working method you want to govern"`;
+    const suggestionCommand = `dna assets suggestions ${asset.name}`;
+    const fallbackEditCommand = `dna workflow edit-plan "Describe the reviewed workflow change" --from-template ${asset.name} --save-template ${nextVersion}`;
+    const suggestion = evidence && asset.status.evidencePosture === "dogfood_linked"
+        ? firstDraftableSuggestion(buildAssetSuggestions(asset, evidence).suggestions)
+        : undefined;
+    const improvementAction = suggestion
+        ? suggestionAction({ asset: asset.name, suggestion, saveTemplate: nextVersion })
+        : { kind: "draft", command: fallbackEditCommand };
+    const draftCommand = activeFollowup?.currentCommand ?? improvementAction.command;
+    const diffCommand = `dna assets diff ${asset.name} ${targetVersion}`;
+    const adoptionCommand = `dna assets adoption ${targetVersion}`;
+    const orgBindCommand = `dna org bind --asset ${targetVersion} --status active --sync-target codex`;
+    const configureCommand = `dna init --template ${targetVersion}`;
+    const syncCommand = "dna sync --codex";
+    const followupReviewable = activeFollowup?.status === "draft_reviewable";
+    const evidenceActionWrites = activeFollowup
+        ? activeFollowup.currentWrites
+        : evidenceOpen
+            ? improvementAction.kind === "draft"
+            : false;
+    const stages = [
+        {
+            id: "cascade",
+            label: "Compile cascade",
+            command: `dna assets governance ${asset.name}`,
+            purpose: "Confirm inherited DNA layers and compiler effect before runtime artifacts are generated.",
+            writes: false,
+        },
+        {
+            id: "evidence",
+            label: "Read dogfood evidence",
+            command: `dna assets evidence ${asset.name}`,
+            purpose: "Inspect canonical progress evidence from dogfood instead of relying on chat memory.",
+            writes: false,
+        },
+        {
+            id: "suggestions",
+            label: "Create improvement candidates",
+            command: suggestionCommand,
+            purpose: "Turn dogfood evidence into human-reviewed suggestions without editing templates or markers.",
+            writes: false,
+        },
+        {
+            id: "draft",
+            label: activeFollowup
+                ? activeFollowup.status === "draft_missing" ? "Save unfinished work" : "Review unfinished-work draft"
+                : improvementAction.kind === "adoption" ? "Review extracted workflow asset" : "Draft next workflow asset",
+            command: draftCommand,
+            purpose: activeFollowup
+                ? activeFollowup.status === "draft_missing"
+                    ? "Save active dogfood evidence as a reviewable unfinished-work draft before baseline promotion, marker mutation, rollout, or sync."
+                    : "Continue through the existing unfinished-work draft review route before baseline promotion, marker mutation, rollout, or sync."
+                : improvementAction.kind === "adoption"
+                    ? "Review and adopt the extracted reusable workflow asset instead of drafting a duplicate project template."
+                    : "Materialize an accepted suggestion as a reviewable project template version.",
+            writes: activeFollowup ? activeFollowup.currentWrites : improvementAction.kind === "draft",
+        },
+        {
+            id: "diff",
+            label: "Review version diff",
+            command: diffCommand,
+            purpose: "Compare workflow and governance changes before adoption.",
+            writes: false,
+        },
+        {
+            id: "adoption",
+            label: "Review adoption readiness",
+            command: adoptionCommand,
+            purpose: "Check workflow, controller, cascade, evolution, evidence, and project configuration readiness.",
+            writes: false,
+        },
+        {
+            id: "org-bind",
+            label: "Bind accepted version",
+            command: orgBindCommand,
+            purpose: "Record manager adoption in the organization profile before runtime sync.",
+            writes: true,
+        },
+        {
+            id: "configure",
+            label: "Configure project asset",
+            command: configureCommand,
+            purpose: "Generate project DNA config for the reviewed asset version.",
+            writes: true,
+        },
+        {
+            id: "sync",
+            label: "Sync runtime surface",
+            command: syncCommand,
+            purpose: "Install runtime artifacts only after review, adoption, binding, and configuration.",
+            writes: true,
+        },
+    ];
+    const currentGate = evidenceGate.status === "open"
+        ? {
+            decision: "review_evidence",
+            reason: followupReviewable
+                ? "Dogfood evidence still has active work; review the existing unfinished-work draft before baseline promotion, marker mutation, rollout, or sync."
+                : "Dogfood evidence still has active work; save a reviewed unfinished-work draft before baseline promotion, marker mutation, rollout, or sync.",
+            nextCommand: draftCommand,
+        }
+        : !asset.status.configured
+            ? {
+                decision: "configure_asset",
+                reason: "Evidence is clear, but this asset is not configured in the current project yet.",
+                nextCommand: `dna init --template ${asset.name}`,
+            }
+            : {
+                decision: "preview_evolution",
+                reason: "Evidence is clear and the asset is configured; preview evolution before any explicit mutation.",
+                nextCommand: asset.evolution.previewCommand,
+            };
+    const routedEvidenceGate = activeFollowup
+        ? { ...evidenceGate, nextCommand: activeFollowup.currentCommand }
+        : evidenceGate;
+    return {
+        asset: asset.name,
+        displayName: asset.displayName,
+        mode: "workflow_asset_lifecycle",
+        summary: "Cascade defines what gets compiled, evidence defines what should improve, and evolution stays preview-first until a reviewed asset version is adopted and synced.",
+        managerGates: buildManagerGates({
+            asset,
+            evidenceStatus: evidenceGate.status,
+            evidenceNextCommand: routedEvidenceGate.nextCommand,
+            evidenceAllowsMutation: evidenceGate.status === "clear",
+        }),
+        assetPath: buildAssetLifecyclePath({
+            asset,
+            evidenceStatus: evidenceGate.status,
+            targetVersion,
+            suggestionCommand,
+            draftCommand,
+            diffCommand,
+            adoptionCommand,
+            orgBindCommand,
+            configureCommand,
+            syncCommand,
+            followupReviewable,
+            evidenceActionWrites,
+            evolutionPreviewCommand: asset.evolution.previewCommand,
+            releaseCommand: "dna release deploy-plan",
+        }),
+        systemRoute: {
+            principle: "Users describe work in natural language; dna core turns it into reviewable workflow assets, manager gates, and explicit runtime sync.",
+            phases: [
+                {
+                    id: "describe",
+                    label: "Describe workflow",
+                    command: intakeCommand,
+                    purpose: "Start from the user's working method, not from a canvas or harness-specific setup.",
+                    writes: false,
+                    owner: "user",
+                },
+                {
+                    id: "select",
+                    label: "Select or draft asset",
+                    command: "dna assets library",
+                    purpose: "Reuse a proven asset when possible; draft only when no managed asset fits.",
+                    writes: false,
+                    owner: "dna_core",
+                },
+                {
+                    id: "govern",
+                    label: "Inspect governance",
+                    command: `dna assets governance ${asset.name}`,
+                    purpose: "Make cascade, evidence gate, and preview-first evolution visible before adoption.",
+                    writes: false,
+                    owner: "dna_core",
+                },
+                {
+                    id: "improve",
+                    label: activeFollowup
+                        ? activeFollowup.status === "draft_missing" ? "Save unfinished work" : "Review unfinished-work draft"
+                        : improvementAction.kind === "adoption" ? "Review extracted asset" : "Draft improvement",
+                    command: draftCommand,
+                    purpose: activeFollowup
+                        ? activeFollowup.status === "draft_missing"
+                            ? "Save open dogfood evidence as a reviewable unfinished-work draft before organization binding or sync."
+                            : "Use the existing unfinished-work draft review route before organization binding or sync."
+                        : improvementAction.kind === "adoption"
+                            ? "Use a built-in reusable asset that was extracted from dogfood evidence."
+                            : "Turn dogfood evidence or natural-language edits into a reviewable next asset version.",
+                    writes: activeFollowup ? activeFollowup.currentWrites : improvementAction.kind === "draft",
+                    owner: "dna_core",
+                },
+                {
+                    id: "review",
+                    label: "Manager review",
+                    command: diffCommand,
+                    purpose: "Review workflow and governance changes before adoption or rollout.",
+                    writes: false,
+                    owner: "manager",
+                },
+                {
+                    id: "bind",
+                    label: "Bind accepted asset",
+                    command: orgBindCommand,
+                    purpose: "Record the manager-approved asset version in the organization profile.",
+                    writes: true,
+                    owner: "manager",
+                },
+                {
+                    id: "rollout",
+                    label: "Check rollout readiness",
+                    command: "dna org rollout",
+                    purpose: "Confirm target-level readiness before downstream distribution.",
+                    writes: false,
+                    owner: "manager",
+                },
+                {
+                    id: "sync",
+                    label: "Sync harness surface",
+                    command: syncCommand,
+                    purpose: "Generate runtime artifacts for Codex or Claude only after review gates pass.",
+                    writes: true,
+                    owner: "runtime",
+                },
+                {
+                    id: "deploy",
+                    label: "Deploy public surface",
+                    command: "dna release deploy-plan",
+                    purpose: "Plan Vercel CLI deployment and deployed URL verification only when web, dashboard, blog, or other public deployed surfaces changed.",
+                    writes: false,
+                    owner: "release",
+                },
+            ],
+            boundaries: [
+                "dna CLI/core/runtime owns product behavior and governance decisions.",
+                "Claude Code and Codex are harness surfaces/adapters, not the governance source of truth.",
+                "Obsidian/wiki is internal project memory, not product runtime or user-facing architecture.",
+                "Dashboard is a projection surface; it must not become the workflow creation control plane.",
+                "Vercel deployment is required only for changed web/public deployed surfaces, followed by deployed URL verification.",
+            ],
+        },
+        cascade: {
+            layerType: asset.cascade.type,
+            inherits: asset.cascade.inherits,
+            priority: asset.cascade.priority,
+            compilerEffect: asset.status.hasCascade
+                ? `Compiler merges inherited layers (${asset.cascade.inherits.length > 0 ? asset.cascade.inherits.join(", ") : "none"}) before runtime artifacts are generated.`
+                : "No cascade inheritance is declared; the asset is standalone until inheritance is added.",
+        },
+        evidence: routedEvidenceGate,
+        evolution: {
+            reviewMode: asset.evolution.reviewMode,
+            previewCommand: asset.evolution.previewCommand,
+            mutatingCommand: asset.evolution.mutatingCommand,
+            mutationBoundary: "Lifecycle is read-only. Evidence can produce suggestions and reviewed drafts; marker mutation and runtime sync remain explicit human-reviewed commands.",
+        },
+        stages,
+        currentGate,
+        nextCommands: [...new Set([currentGate.nextCommand, ...stages.slice(0, 6).map((stage) => stage.command)])],
+    };
+}
+function evidenceReviewSummary(index) {
+    return {
+        asset: index.asset,
+        modules: index.totals.modules,
+        pass: index.totals.pass,
+        continue: index.totals.continue,
+        requestChanges: index.totals.requestChanges,
+        blocked: index.totals.blocked,
+        complete: index.totals.complete,
+        remaining: index.totals.remaining,
+        remainingUnimplementedSkipped: index.totals.remainingUnimplementedSkipped,
+        newRed: index.totals.newRed,
+        nextFocus: index.modules
+            .filter((module) => module.verdict !== "PASS" || !module.moduleComplete || module.remainingCount > 0)
+            .slice(0, 5)
+            .map((module) => {
+            const remaining = module.remainingCount > 0 ? ` remaining=${module.remainingCount}` : "";
+            const focus = module.nextRoundFocus ? ` next=${module.nextRoundFocus}` : "";
+            return `${module.module}: ${module.verdict}${remaining}${focus}`;
+        }),
+        warnings: index.warnings,
+    };
+}
+function hasRegisteredDogfoodProgress(index) {
+    return index.progressDir.length > 0;
+}
+function assetLibraryGroupId(asset) {
+    if (asset.status.managementStatus === "dogfood_ready")
+        return "dogfood_proven";
+    if (asset.status.managementStatus === "asset_ready")
+        return "ready_assets";
+    return "draft_or_template";
+}
+function assetLibraryItem(asset) {
+    const nextCommands = [
+        `dna assets inspect ${asset.name} --evidence`,
+        `dna assets governance ${asset.name}`,
+        `dna assets adoption ${asset.name}`,
+    ];
+    if (asset.status.evidencePosture === "dogfood_linked") {
+        nextCommands.push(`dna assets suggestions ${asset.name}`);
+    }
+    if (!asset.status.configured) {
+        nextCommands.push(`dna init --template ${asset.name}`);
+    }
+    return {
+        asset: asset.name,
+        displayName: asset.displayName,
+        source: asset.source,
+        purpose: asset.purpose,
+        maturity: asset.maturity,
+        fit: asset.fit,
+        notFor: asset.notFor,
+        inputs: asset.inputs,
+        outputs: asset.outputs,
+        lineage: asset.lineage,
+        positioning: asset.positioning,
+        status: asset.status.managementStatus,
+        evidence: asset.status.evidencePosture,
+        cascade: asset.status.cascadePosture,
+        evolution: asset.status.evolutionPosture,
+        configuration: asset.status.configurationPosture,
+        configured: asset.status.configured,
+        workflows: asset.workflows.length,
+        controllers: asset.controllers.length,
+        roles: asset.roles.length,
+        nextCommands,
+    };
+}
+function assetLibrarySort(a, b) {
+    const rank = {
+        dogfood_ready: 0,
+        asset_ready: 1,
+        template_only: 2,
+    };
+    const byStatus = rank[a.status.managementStatus] - rank[b.status.managementStatus];
+    if (byStatus !== 0)
+        return byStatus;
+    if (a.status.hasEvidence !== b.status.hasEvidence)
+        return a.status.hasEvidence ? -1 : 1;
+    return a.name.localeCompare(b.name);
+}
+function buildAssetLibrary(assets) {
+    const definitions = [
+        {
+            id: "dogfood_proven",
+            label: "Dogfood-proven",
+            description: "Assets backed by real project evidence. Review evidence before broad sync or evolution.",
+        },
+        {
+            id: "ready_assets",
+            label: "Ready assets",
+            description: "Assets with reusable workflow shape ready for adoption review.",
+        },
+        {
+            id: "draft_or_template",
+            label: "Draft/template assets",
+            description: "Useful starting points that still need review, evidence, or governance hardening.",
+        },
+    ];
+    const groups = definitions.map((definition) => ({ ...definition, items: [] }));
+    const byId = new Map(groups.map((group) => [group.id, group]));
+    for (const asset of [...assets].sort(assetLibrarySort)) {
+        byId.get(assetLibraryGroupId(asset))?.items.push(assetLibraryItem(asset));
+    }
+    return {
+        mode: "workflow_asset_library",
+        totals: {
+            assets: assets.length,
+            dogfoodReady: assets.filter((asset) => asset.status.managementStatus === "dogfood_ready").length,
+            assetReady: assets.filter((asset) => asset.status.managementStatus === "asset_ready").length,
+            templateOnly: assets.filter((asset) => asset.status.managementStatus === "template_only").length,
+            evidenceLinked: assets.filter((asset) => asset.status.hasEvidence).length,
+            configured: assets.filter((asset) => asset.status.configured).length,
+        },
+        governanceChain: {
+            principle: "Dogfood problems become reusable workflow assets; workflow asset gaps become dna core governance gates before org rollout, sync, or deploy.",
+            steps: [
+                {
+                    id: "inventory",
+                    asset: "workflow-module-inventory",
+                    label: "Inventory before execution",
+                    command: "dna assets adoption workflow-module-inventory",
+                    purpose: "Scan modules, pages, actions, evidence gaps, and priorities before per-module behavior locks or fixes start.",
+                },
+                {
+                    id: "behavior-lock",
+                    asset: WORKFLOW_ASSET_IDS.behaviorLock,
+                    label: "Lock behavior first",
+                    command: `dna assets adoption ${WORKFLOW_ASSET_IDS.behaviorLock}`,
+                    purpose: "Capture source behavior as docs and tests before risky rewrite, refactor, diagnosis, or fix work starts.",
+                },
+                {
+                    id: "diagnosis",
+                    asset: WORKFLOW_ASSET_IDS.rewriteDiagnosisReview,
+                    label: "Classify before editing",
+                    command: `dna assets adoption ${WORKFLOW_ASSET_IDS.rewriteDiagnosisReview}`,
+                    purpose: "Require evidence-only diagnosis and independent review before implementation starts.",
+                },
+                {
+                    id: "fix-review",
+                    asset: WORKFLOW_ASSET_IDS.rewriteFixReviewLoop,
+                    label: "Fix, review, verify",
+                    command: `dna assets adoption ${WORKFLOW_ASSET_IDS.rewriteFixReviewLoop}`,
+                    purpose: "Run the smallest diagnosis-approved fix with independent review and fresh verification.",
+                },
+                {
+                    id: "verification-routing",
+                    asset: WORKFLOW_ASSET_IDS.verificationCommandRouting,
+                    label: "Route verification command",
+                    command: `dna assets adoption ${WORKFLOW_ASSET_IDS.verificationCommandRouting}`,
+                    purpose: "Choose the authoritative command root/scope and capture canonical machine evidence before completion or rollout decisions.",
+                },
+                {
+                    id: "evidence",
+                    asset: "workflow-evidence-review",
+                    label: "Review evidence authority",
+                    command: "dna assets adoption workflow-evidence-review",
+                    purpose: "Separate canonical evidence from weak notes before adoption, evolution, rollout, or sync.",
+                },
+                {
+                    id: "blocked-scope",
+                    asset: WORKFLOW_ASSET_IDS.blockedScopeTriage,
+                    label: "Triage blocked scope",
+                    command: `dna assets adoption ${WORKFLOW_ASSET_IDS.blockedScopeTriage}`,
+                    purpose: "Classify blocked, skipped, removed, infra, deferred, and remaining work before manager review.",
+                },
+                {
+                    id: "completion",
+                    asset: "workflow-completion-audit",
+                    label: "Prove completion",
+                    command: "dna assets adoption workflow-completion-audit",
+                    purpose: "Prove PASS/CONTINUE/BLOCKED with diagnosis, current verification, red classification, skipped comparison, and progress evidence.",
+                },
+                {
+                    id: "runtime-smoke",
+                    asset: "workflow-runtime-smoke-review",
+                    label: "Smoke runtime surface",
+                    command: "dna assets adoption workflow-runtime-smoke-review",
+                    purpose: "Prove the synced or distributed runtime surface is actually usable before wider rollout.",
+                },
+            ].filter((step) => assets.some((asset) => asset.name === step.asset)),
+            boundaries: [
+                "Obsidian/wiki remains internal project memory; product governance uses workflow assets and machine-readable evidence.",
+                "Dashboard remains a read-only projection of this chain, not a workflow builder or policy source.",
+                "Runtime targets such as Codex, Claude, web, and mobile receive synced artifacts; dna core keeps governance truth.",
+            ],
+        },
+        groups,
+    };
+}
+function writeAssetLibrary(library) {
+    process.stderr.write("Workflow asset library\n");
+    process.stderr.write(`Assets: ${library.totals.assets}\n`);
+    process.stderr.write(`Dogfood ready: ${library.totals.dogfoodReady}\n`);
+    process.stderr.write(`Asset ready: ${library.totals.assetReady}\n`);
+    process.stderr.write(`Template only: ${library.totals.templateOnly}\n`);
+    process.stderr.write(`Evidence linked: ${library.totals.evidenceLinked}\n`);
+    process.stderr.write(`Configured: ${library.totals.configured}\n`);
+    process.stderr.write("\nWorkflow governance chain\n");
+    process.stderr.write(`${library.governanceChain.principle}\n`);
+    for (const step of library.governanceChain.steps) {
+        process.stderr.write(`  - ${step.id}. ${step.label}: ${step.asset}\n`);
+        process.stderr.write(`    ${step.command}\n`);
+        process.stderr.write(`    ${step.purpose}\n`);
+    }
+    process.stderr.write("  Boundaries:\n");
+    for (const boundary of library.governanceChain.boundaries)
+        process.stderr.write(`    - ${boundary}\n`);
+    for (const group of library.groups) {
+        process.stderr.write(`\n${group.label} (${group.items.length})\n`);
+        process.stderr.write(`${group.description}\n`);
+        if (group.items.length === 0) {
+            process.stderr.write("  - none\n");
+            continue;
+        }
+        for (const item of group.items) {
+            const label = item.displayName ? `${item.asset} (${item.displayName})` : item.asset;
+            process.stderr.write(`  - ${label}: ${item.status}, evidence=${item.evidence}, cascade=${item.cascade}, evolution=${item.evolution}, config=${item.configuration}, workflows=${item.workflows}, controllers=${item.controllers}\n`);
+            if (item.positioning)
+                process.stderr.write(`    positioning: ${item.positioning}\n`);
+            process.stderr.write(`    maturity: ${item.maturity}; source=${item.source}\n`);
+            if (item.purpose)
+                process.stderr.write(`    purpose: ${item.purpose}\n`);
+            for (const command of item.nextCommands)
+                process.stderr.write(`    next: ${command}\n`);
+        }
+    }
+}
+function nextEvidenceFocus(index) {
+    return index.modules
+        .filter((module) => module.verdict !== "PASS" || !module.moduleComplete || module.remainingCount > 0 || module.newRedCount > 0)
+        .slice(0, 5)
+        .map((module) => {
+        const remaining = module.remainingCount > 0 ? ` remaining=${module.remainingCount}` : "";
+        const focus = module.nextRoundFocus ? ` next=${module.nextRoundFocus}` : "";
+        return `${module.module}: ${module.verdict}${remaining}${focus}`;
+    });
+}
+function buildLineageReview(asset, evidence) {
+    const suggestedDraftName = `${asset.name}-v2`;
+    const fallbackEditCommand = `dna workflow edit-plan "Describe the reviewed workflow change" --from-template ${asset.name} --save-template ${suggestedDraftName}`;
+    const suggestion = evidence && asset.status.evidencePosture === "dogfood_linked"
+        ? firstDraftableSuggestion(buildAssetSuggestions(asset, evidence).suggestions)
+        : undefined;
+    const lineageAction = suggestion
+        ? suggestionAction({ asset: asset.name, suggestion, saveTemplate: suggestedDraftName })
+        : { kind: "draft", command: fallbackEditCommand };
+    const suggestedActionCommand = lineageAction.command;
+    const versionReviewCommand = `dna assets diff ${asset.name} ${suggestedDraftName}`;
+    const adoptionCommand = `dna assets adoption ${suggestedDraftName}`;
+    const orgBindCommand = `dna org bind --asset ${suggestedDraftName} --status active --sync-target codex`;
+    const syncCommand = "dna sync --codex";
+    const dogfood = evidence && asset.status.evidencePosture === "dogfood_linked"
+        ? {
+            source: evidence.sourceDescription,
+            projectPath: evidence.projectPath,
+            progressDir: evidence.progressDir,
+            modules: evidence.totals.modules,
+            pass: evidence.totals.pass,
+            continue: evidence.totals.continue,
+            blocked: evidence.totals.blocked + evidence.totals.requestChanges,
+            remaining: evidence.totals.remaining,
+            nextFocus: nextEvidenceFocus(evidence),
+            warnings: evidence.warnings,
+        }
+        : undefined;
+    return {
+        asset: asset.name,
+        displayName: asset.displayName,
+        mode: "workflow_asset_lineage",
+        origin: {
+            source: asset.source,
+            path: asset.path,
+            dnaId: asset.dnaId,
+            namespace: asset.namespace,
+            version: asset.version,
+            contentHash: asset.contentHash,
+            positioning: asset.positioning,
+        },
+        capability: {
+            workflows: asset.workflows.map((workflow) => ({ id: workflow.id, name: workflow.name, steps: workflow.stepCount })),
+            controllers: asset.controllers.map((controller) => ({ id: controller.id, kind: controller.kind })),
+            roles: asset.roles.map((role) => role.id),
+        },
+        cascade: {
+            declared: asset.cascade.declared,
+            layerType: asset.cascade.type,
+            inherits: asset.cascade.inherits,
+            priority: asset.cascade.priority,
+            compileMeaning: asset.cascade.declared
+                ? `Compiler merges inherited layers (${asset.cascade.inherits.length > 0 ? asset.cascade.inherits.join(", ") : "none"}) before runtime artifacts are generated.`
+                : "Compiler treats this as a standalone asset until cascade inheritance is declared.",
+        },
+        evidence: {
+            posture: asset.status.evidencePosture,
+            links: asset.evidence.map((link) => ({ label: link.label, kind: link.kind, path: link.path })),
+            dogfood,
+        },
+        evolution: {
+            posture: asset.status.evolutionPosture,
+            reviewMode: asset.evolution.reviewMode,
+            previewCommand: asset.evolution.previewCommand,
+            mutatingCommand: asset.evolution.mutatingCommand,
+            suggestedActionCommand,
+            suggestedActionKind: lineageAction.kind,
+            versionReviewCommand,
+            adoptionCommand,
+            orgBindCommand,
+            syncCommand,
+            mutationBoundary: "Lineage is read-only. Evidence can suggest a draft version, but policy/runtime mutation requires diff review, adoption review, org binding, and explicit sync.",
+        },
+        nextCommands: [
+            `dna assets inspect ${asset.name} --evidence`,
+            `dna assets governance ${asset.name}`,
+            asset.status.evidencePosture === "dogfood_linked" ? `dna assets suggestions ${asset.name}` : `dna workflow edit-plan "Describe the reviewed workflow change" --from-template ${asset.name} --save-template ${suggestedDraftName}`,
+            suggestedActionCommand,
+            versionReviewCommand,
+            adoptionCommand,
+            orgBindCommand,
+            syncCommand,
+        ],
+    };
+}
+function writeLineageReview(review) {
+    const label = review.displayName ? `${review.asset} (${review.displayName})` : review.asset;
+    process.stderr.write(`Workflow asset lineage: ${label}\n`);
+    process.stderr.write("\nOrigin:\n");
+    process.stderr.write(`  - source: ${review.origin.source}\n`);
+    process.stderr.write(`  - path: ${review.origin.path}\n`);
+    if (review.origin.dnaId)
+        process.stderr.write(`  - dna id: ${review.origin.dnaId}\n`);
+    if (review.origin.namespace)
+        process.stderr.write(`  - namespace: ${review.origin.namespace}\n`);
+    if (review.origin.version)
+        process.stderr.write(`  - version: ${review.origin.version}\n`);
+    process.stderr.write(`  - content hash: ${review.origin.contentHash}\n`);
+    if (review.origin.positioning)
+        process.stderr.write(`  - positioning: ${review.origin.positioning}\n`);
+    process.stderr.write("\nCapability:\n");
+    process.stderr.write(`  - workflows: ${review.capability.workflows.length}\n`);
+    for (const workflow of review.capability.workflows) {
+        process.stderr.write(`    - ${workflow.id}: ${workflow.name} (${workflow.steps} step(s))\n`);
+    }
+    process.stderr.write(`  - controllers: ${review.capability.controllers.length}\n`);
+    for (const controller of review.capability.controllers) {
+        process.stderr.write(`    - ${controller.id}: ${controller.kind}\n`);
+    }
+    process.stderr.write(`  - roles: ${review.capability.roles.length > 0 ? review.capability.roles.join(", ") : "none"}\n`);
+    process.stderr.write("\nCascade lineage:\n");
+    process.stderr.write(`  - declared: ${review.cascade.declared ? "yes" : "no"}\n`);
+    if (review.cascade.layerType)
+        process.stderr.write(`  - layer type: ${review.cascade.layerType}\n`);
+    if (review.cascade.priority !== undefined)
+        process.stderr.write(`  - priority: ${review.cascade.priority}\n`);
+    process.stderr.write(`  - inherits: ${review.cascade.inherits.length > 0 ? review.cascade.inherits.join(", ") : "none"}\n`);
+    process.stderr.write(`  - meaning: ${review.cascade.compileMeaning}\n`);
+    process.stderr.write("\nEvidence lineage:\n");
+    process.stderr.write(`  - posture: ${review.evidence.posture}\n`);
+    if (review.evidence.links.length === 0) {
+        process.stderr.write("  - links: none\n");
+    }
+    else {
+        for (const link of review.evidence.links)
+            process.stderr.write(`  - ${link.label} [${link.kind}]: ${link.path}\n`);
+    }
+    if (review.evidence.dogfood) {
+        const dogfood = review.evidence.dogfood;
+        if (dogfood.source)
+            process.stderr.write(`  - dogfood source: ${dogfood.source}\n`);
+        process.stderr.write(`  - dogfood project: ${dogfood.projectPath}\n`);
+        process.stderr.write(`  - progress dir: ${dogfood.progressDir}\n`);
+        process.stderr.write(`  - modules: ${dogfood.pass}/${dogfood.modules} PASS, continue=${dogfood.continue}, blocked=${dogfood.blocked}, remaining=${dogfood.remaining}\n`);
+        for (const focus of dogfood.nextFocus)
+            process.stderr.write(`    next focus: ${focus}\n`);
+        for (const warning of dogfood.warnings)
+            process.stderr.write(`    warning: ${warning}\n`);
+    }
+    process.stderr.write("\nEvolution route:\n");
+    process.stderr.write(`  - posture: ${review.evolution.posture}\n`);
+    process.stderr.write(`  - review mode: ${review.evolution.reviewMode}\n`);
+    process.stderr.write(`  - preview: ${review.evolution.previewCommand}\n`);
+    process.stderr.write(`  - explicit mutation: ${review.evolution.mutatingCommand}\n`);
+    process.stderr.write(`  - suggested action (${review.evolution.suggestedActionKind}): ${review.evolution.suggestedActionCommand}\n`);
+    process.stderr.write(`  - review diff: ${review.evolution.versionReviewCommand}\n`);
+    process.stderr.write(`  - adoption review: ${review.evolution.adoptionCommand}\n`);
+    process.stderr.write(`  - org bind: ${review.evolution.orgBindCommand}\n`);
+    process.stderr.write(`  - sync after review: ${review.evolution.syncCommand}\n`);
+    process.stderr.write(`  - boundary: ${review.evolution.mutationBoundary}\n`);
+    process.stderr.write("\nNext commands:\n");
+    for (const command of review.nextCommands)
+        process.stderr.write(`  - ${command}\n`);
+}
+async function buildAssetReview(assets, projectDir) {
+    const evidence = [];
+    for (const asset of assets.filter((candidate) => candidate.status.managementStatus === "dogfood_ready")) {
+        const index = await buildWorkflowAssetEvidenceIndex(asset.name, { projectDir });
+        if (index && hasRegisteredDogfoodProgress(index))
+            evidence.push(evidenceReviewSummary(index));
+    }
+    const totals = {
+        assets: assets.length,
+        configured: assets.filter((asset) => asset.status.configured).length,
+        available: assets.filter((asset) => !asset.status.configured).length,
+        dogfoodReady: assets.filter((asset) => asset.status.managementStatus === "dogfood_ready").length,
+        missingWorkflow: assets.filter((asset) => !asset.status.hasWorkflow).length,
+        missingController: assets.filter((asset) => !asset.status.hasController).length,
+        missingCascade: assets.filter((asset) => !asset.status.hasCascade).length,
+        missingEvidence: assets.filter((asset) => !asset.status.hasEvidence).length,
+        previewEvolution: assets.filter((asset) => asset.status.evolutionPosture === "preview_supported").length,
+        dogfoodEvidenceModules: evidence.reduce((sum, summary) => sum + summary.modules, 0),
+        dogfoodEvidencePass: evidence.reduce((sum, summary) => sum + summary.pass, 0),
+        dogfoodEvidenceContinue: evidence.reduce((sum, summary) => sum + summary.continue, 0),
+        dogfoodEvidenceBlocked: evidence.reduce((sum, summary) => sum + summary.blocked + summary.requestChanges, 0),
+        dogfoodEvidenceRemaining: evidence.reduce((sum, summary) => sum + summary.remaining, 0),
+    };
+    const items = [];
+    for (const asset of assets) {
+        if (!asset.status.configured && (asset.status.hasEvidence || asset.status.managementStatus === "dogfood_ready")) {
+            items.push({
+                asset: asset.name,
+                displayName: asset.displayName,
+                severity: "info",
+                message: "Evidence-linked asset is available but not configured in this project.",
+                nextAction: `Run dna init --template ${asset.name} when this workflow should govern the project.`,
+            });
+        }
+        if (!asset.status.hasWorkflow) {
+            items.push({
+                asset: asset.name,
+                displayName: asset.displayName,
+                severity: "warn",
+                message: "No workflow steps are defined.",
+                nextAction: "Describe the repeatable work method as steps before treating this as a workflow asset.",
+            });
+        }
+        if (!asset.status.hasCascade) {
+            items.push({
+                asset: asset.name,
+                displayName: asset.displayName,
+                severity: "warn",
+                message: "No cascade inheritance is declared.",
+                nextAction: "Attach species/project/org inheritance before distributing this asset broadly.",
+            });
+        }
+        if (!asset.status.hasEvidence) {
+            items.push({
+                asset: asset.name,
+                displayName: asset.displayName,
+                severity: "warn",
+                message: "No evidence/reference links are registered.",
+                nextAction: "Link dogfood, reference, or decision evidence before presenting this as proven.",
+            });
+        }
+    }
+    for (const summary of evidence) {
+        for (const warning of summary.warnings) {
+            items.push({
+                asset: summary.asset,
+                severity: "warn",
+                message: warning,
+                nextAction: "Fix the registered dogfood progress source or remove the dogfood-ready claim.",
+            });
+        }
+        if (summary.continue > 0 || summary.requestChanges > 0 || summary.blocked > 0 || summary.remaining > 0) {
+            items.push({
+                asset: summary.asset,
+                severity: "info",
+                message: `Dogfood evidence is active: ${summary.pass}/${summary.modules} PASS, ${summary.remaining} remaining.`,
+                nextAction: summary.nextFocus[0] ?? `Run dna assets evidence ${summary.asset} for module-level next focus.`,
+            });
+        }
+    }
+    return { totals, evidence, items };
+}
+function prioritizedAssets(assets) {
+    return assets
+        .filter((asset) => asset.status.managementStatus === "dogfood_ready" || asset.status.hasEvidence)
+        .sort((a, b) => {
+        if (a.status.managementStatus === "dogfood_ready" && b.status.managementStatus !== "dogfood_ready")
+            return -1;
+        if (b.status.managementStatus === "dogfood_ready" && a.status.managementStatus !== "dogfood_ready")
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+}
+function writeAssetReview(review, assets) {
+    process.stderr.write("Workflow asset review\n");
+    process.stderr.write(`Assets: ${review.totals.assets}\n`);
+    process.stderr.write(`Configured: ${review.totals.configured}\n`);
+    process.stderr.write(`Available only: ${review.totals.available}\n`);
+    process.stderr.write(`Dogfood ready: ${review.totals.dogfoodReady}\n`);
+    process.stderr.write(`Missing workflow: ${review.totals.missingWorkflow}\n`);
+    process.stderr.write(`Missing controller: ${review.totals.missingController}\n`);
+    process.stderr.write(`Missing cascade: ${review.totals.missingCascade}\n`);
+    process.stderr.write(`Missing evidence: ${review.totals.missingEvidence}\n`);
+    process.stderr.write(`Preview-first evolution: ${review.totals.previewEvolution}\n`);
+    process.stderr.write(`Dogfood evidence modules: ${review.totals.dogfoodEvidenceModules}\n`);
+    process.stderr.write(`Dogfood evidence PASS: ${review.totals.dogfoodEvidencePass}\n`);
+    process.stderr.write(`Dogfood evidence CONTINUE: ${review.totals.dogfoodEvidenceContinue}\n`);
+    process.stderr.write(`Dogfood evidence blocked/request changes: ${review.totals.dogfoodEvidenceBlocked}\n`);
+    process.stderr.write(`Dogfood evidence remaining: ${review.totals.dogfoodEvidenceRemaining}\n`);
+    const focusAssets = prioritizedAssets(assets);
+    if (focusAssets.length > 0) {
+        process.stderr.write("\nFocus assets:\n");
+        for (const asset of focusAssets.slice(0, 5)) {
+            const label = asset.displayName ? `${asset.name} (${asset.displayName})` : asset.name;
+            process.stderr.write(`  - ${label}: ${asset.status.managementStatus}, ${asset.status.configurationPosture}, ${asset.status.evidencePosture}, cascade=${asset.status.cascadePosture}, evolution=${asset.status.evolutionPosture}\n`);
+            if (!asset.status.configured) {
+                process.stderr.write(`    next: Run dna init --template ${asset.name} when this workflow should govern the project.\n`);
+            }
+            else if (asset.evolution.reviewMode === "preview_first") {
+                process.stderr.write(`    next: Review ${asset.evolution.previewCommand} before applying any marker mutation.\n`);
+            }
+        }
+    }
+    if (review.evidence.length > 0) {
+        process.stderr.write("\nDogfood evidence:\n");
+        for (const evidence of review.evidence) {
+            process.stderr.write(`  - ${evidence.asset}: ${evidence.pass}/${evidence.modules} PASS, continue=${evidence.continue}, blocked=${evidence.blocked + evidence.requestChanges}, remaining=${evidence.remaining}\n`);
+            for (const focus of evidence.nextFocus.slice(0, 3)) {
+                process.stderr.write(`    next: ${focus}\n`);
+            }
+        }
+    }
+    if (review.items.length === 0) {
+        process.stderr.write("\nNo review items.\n");
+        return;
+    }
+    const visibleItems = review.items.slice(0, 12);
+    process.stderr.write("\nTop review items:\n");
+    process.stderr.write(`Showing: ${visibleItems.length}/${review.items.length}\n`);
+    for (const item of visibleItems) {
+        const label = item.displayName ? `${item.asset} (${item.displayName})` : item.asset;
+        process.stderr.write(`  - [${item.severity}] ${label}: ${item.message}\n`);
+        process.stderr.write(`    next: ${item.nextAction}\n`);
+    }
+    if (visibleItems.length < review.items.length) {
+        process.stderr.write(`  ... ${review.items.length - visibleItems.length} more item(s). Use --json for the full review payload.\n`);
+    }
+}
+function writeManagerGates(gates) {
+    process.stderr.write("\nManager gates:\n");
+    for (const gate of gates) {
+        process.stderr.write(`  - [${gate.status}] ${gate.id}: ${gate.decision}\n`);
+        process.stderr.write(`    owner: ${gate.owner}\n`);
+        process.stderr.write(`    writes: ${gate.writes ? "yes" : "no"}\n`);
+        process.stderr.write(`    next: ${gate.nextCommand}\n`);
+        process.stderr.write(`    reason: ${gate.reason}\n`);
+    }
+}
+function writeGovernanceReview(review) {
+    const label = review.displayName ? `${review.asset} (${review.displayName})` : review.asset;
+    process.stderr.write(`Workflow asset governance: ${label}\n`);
+    writeManagerGates(review.managerGates);
+    process.stderr.write("\nGovernance review packet:\n");
+    process.stderr.write(`  - cascade ready: ${review.reviewPacket.cascadeReady ? "yes" : "no"}\n`);
+    process.stderr.write(`  - evolution ready: ${review.reviewPacket.evolutionReady ? "yes" : "no"}\n`);
+    process.stderr.write(`  - evidence allows mutation: ${review.reviewPacket.evidenceAllowsMutation ? "yes" : "no"}\n`);
+    process.stderr.write(`  - sync allowed: ${review.reviewPacket.syncAllowed ? "yes" : "no"}\n`);
+    process.stderr.write(`  - decision: ${review.reviewPacket.decision}\n`);
+    process.stderr.write(`  - next: ${review.reviewPacket.nextCommand}\n`);
+    process.stderr.write(`  - compiler effect: ${review.reviewPacket.compilerEffect}\n`);
+    process.stderr.write(`  - mutation boundary: ${review.reviewPacket.mutationBoundary}\n`);
+    process.stderr.write("\nEvidence gate:\n");
+    process.stderr.write(`  - status: ${review.evidenceGate.status}\n`);
+    process.stderr.write(`  - modules: ${review.evidenceGate.modules}\n`);
+    process.stderr.write(`  - pass: ${review.evidenceGate.pass}\n`);
+    process.stderr.write(`  - continue: ${review.evidenceGate.continue}\n`);
+    process.stderr.write(`  - blocked: ${review.evidenceGate.blocked}\n`);
+    process.stderr.write(`  - remaining: ${review.evidenceGate.remaining}\n`);
+    if (review.evidenceGate.nextCommand)
+        process.stderr.write(`  - next: ${review.evidenceGate.nextCommand}\n`);
+    process.stderr.write(`  - meaning: ${review.evidenceGate.explanation}\n`);
+    process.stderr.write("\nCascade:\n");
+    process.stderr.write(`  - posture: ${review.cascade.posture}\n`);
+    process.stderr.write(`  - declared: ${review.cascade.declared ? "yes" : "no"}\n`);
+    if (review.cascade.layerType)
+        process.stderr.write(`  - layer type: ${review.cascade.layerType}\n`);
+    if (review.cascade.priority !== undefined)
+        process.stderr.write(`  - priority: ${review.cascade.priority}\n`);
+    process.stderr.write(`  - inherits: ${review.cascade.inherits.length > 0 ? review.cascade.inherits.join(", ") : "none"}\n`);
+    process.stderr.write(`  - meaning: ${review.cascade.explanation}\n`);
+    process.stderr.write("\nEvolution:\n");
+    process.stderr.write(`  - posture: ${review.evolution.posture}\n`);
+    process.stderr.write(`  - review mode: ${review.evolution.reviewMode}\n`);
+    process.stderr.write(`  - declared markers: ${review.evolution.declaredMarkers}\n`);
+    process.stderr.write(`  - marker ids: ${review.evolution.markerIds.length > 0 ? review.evolution.markerIds.join(", ") : "none"}\n`);
+    process.stderr.write(`  - outcome store: ${review.evolution.outcomeStore}\n`);
+    process.stderr.write(`  - preview: ${review.evolution.previewCommand}\n`);
+    process.stderr.write(`  - explicit mutation: ${review.evolution.mutatingCommand}\n`);
+    process.stderr.write(`  - meaning: ${review.evolution.explanation}\n`);
+    process.stderr.write("\nImplementation references:\n");
+    for (const ref of review.implementationRefs) {
+        process.stderr.write(`  - ${ref.layer}: ${ref.path}\n`);
+        process.stderr.write(`    ${ref.role}\n`);
+    }
+    process.stderr.write("\nNext actions:\n");
+    for (const action of review.nextActions)
+        process.stderr.write(`  - ${action}\n`);
+}
+function writeAdoptionReview(review) {
+    const label = review.displayName ? `${review.asset} (${review.displayName})` : review.asset;
+    process.stderr.write(`Workflow asset adoption review: ${label}\n`);
+    process.stderr.write(`Recommendation: ${review.recommendation}\n`);
+    process.stderr.write(`Summary: ${review.summary}\n`);
+    if (review.predecessorDiff) {
+        process.stderr.write("\nPredecessor diff gate:\n");
+        process.stderr.write(`  - from: ${review.predecessorDiff.from}\n`);
+        process.stderr.write(`  - command: ${review.predecessorDiff.command}\n`);
+        process.stderr.write(`  - risk: ${review.predecessorDiff.riskLevel}\n`);
+        process.stderr.write(`  - acceptance required: ${review.predecessorDiff.acceptanceRequired ? "yes" : "no"}\n`);
+        process.stderr.write(`  - receipt command: ${review.predecessorDiff.receiptCommand}\n`);
+        process.stderr.write(`  - receipt path: ${review.predecessorDiff.receiptPathHint}\n`);
+        for (const note of review.predecessorDiff.riskNotes)
+            process.stderr.write(`    - ${note}\n`);
+        process.stderr.write(`  - reason: ${review.predecessorDiff.reason}\n`);
+    }
+    process.stderr.write("\nChecks:\n");
+    for (const check of review.checks) {
+        process.stderr.write(`  - [${check.status}] ${check.label}: ${check.detail}\n`);
+    }
+    process.stderr.write("\nAdoption path:\n");
+    for (const step of review.adoptionPath) {
+        process.stderr.write(`  - ${step.command}\n`);
+        process.stderr.write(`    ${step.purpose}\n`);
+    }
+}
+function writeAssetSuggestions(review) {
+    const label = review.displayName ? `${review.asset} (${review.displayName})` : review.asset;
+    process.stderr.write(`Workflow asset suggestions: ${label}\n`);
+    process.stderr.write(`Mode: ${review.mode}\n`);
+    if (review.evidence.source)
+        process.stderr.write(`Evidence source: ${review.evidence.source}\n`);
+    process.stderr.write(`Dogfood evidence: ${review.evidence.pass}/${review.evidence.modules} PASS, continue=${review.evidence.continue}, blocked=${review.evidence.blocked}, remaining=${review.evidence.remaining}\n`);
+    process.stderr.write(`C5 capture facts: ${review.evidence.captureFacts}, blocked=${review.evidence.captureBlocked}, failures=${review.evidence.captureFailures}, manual=${review.evidence.captureManualInterventions}, retries=${review.evidence.captureRetries}\n`);
+    if (review.evidence.warnings.length > 0) {
+        process.stderr.write("\nEvidence warnings:\n");
+        for (const warning of review.evidence.warnings)
+            process.stderr.write(`  - ${warning}\n`);
+    }
+    process.stderr.write("\nSuggestions:\n");
+    for (const suggestion of review.suggestions) {
+        process.stderr.write(`  - [${suggestion.severity}] ${suggestion.title}\n`);
+        process.stderr.write(`    type: ${suggestion.type}\n`);
+        process.stderr.write(`    evidence: ${suggestion.evidence}\n`);
+        if (suggestion.evidenceRefs && suggestion.evidenceRefs.length > 0) {
+            process.stderr.write("    evidence refs:\n");
+            for (const ref of suggestion.evidenceRefs.slice(0, 5))
+                process.stderr.write(`      - ${ref.type}: ${ref.ref}\n`);
+            if (suggestion.evidenceRefs.length > 5)
+                process.stderr.write(`      - ... ${suggestion.evidenceRefs.length - 5} more\n`);
+        }
+        process.stderr.write(`    rationale: ${suggestion.rationale}\n`);
+        process.stderr.write(`    next: ${suggestion.nextAction}\n`);
+        if (suggestion.nextCommands && suggestion.nextCommands.length > 0) {
+            process.stderr.write("    next commands:\n");
+            for (const command of suggestion.nextCommands)
+                process.stderr.write(`      - ${command}\n`);
+        }
+        if (suggestion.mutationBoundary)
+            process.stderr.write(`    mutation boundary: ${suggestion.mutationBoundary}\n`);
+    }
+    process.stderr.write("\nImprovement route:\n");
+    for (const step of review.improvementRoute) {
+        process.stderr.write(`  - ${step.id}. ${step.label} (${step.owner}; writes: ${step.writes ? "yes" : "no"})\n`);
+        process.stderr.write(`    command: ${step.command}\n`);
+        process.stderr.write(`    why: ${step.purpose}\n`);
+    }
+    process.stderr.write("\nNext commands:\n");
+    for (const command of review.nextCommands)
+        process.stderr.write(`  - ${command}\n`);
+    process.stderr.write("\nMutation boundary:\n");
+    process.stderr.write(`  - writes: ${review.mutation.writes ? "yes" : "no"}\n`);
+    process.stderr.write(`  - ${review.mutation.note}\n`);
+}
+function writeAssetCandidateBacklog(backlog) {
+    process.stderr.write("Workflow candidate backlog\n");
+    process.stderr.write(`Mode: ${backlog.mode}\n`);
+    process.stderr.write(`Scope: ${backlog.scope}\n`);
+    if (backlog.focusAsset)
+        process.stderr.write(`Focus asset: ${backlog.focusAsset}\n`);
+    process.stderr.write(`Assets scanned: ${backlog.summary.assetsScanned}\n`);
+    process.stderr.write(`Dogfood assets: ${backlog.summary.dogfoodAssets}\n`);
+    process.stderr.write(`Evidence modules: ${backlog.summary.pass}/${backlog.summary.evidenceModules} PASS\n`);
+    process.stderr.write(`Active modules: ${backlog.summary.activeModules}\n`);
+    process.stderr.write(`C5 capture facts: ${backlog.summary.captureFacts} (gaps=${backlog.summary.captureGaps})\n`);
+    process.stderr.write(`Candidates: ${backlog.summary.candidates}\n`);
+    process.stderr.write("\nCandidate review packet:\n");
+    process.stderr.write(`  current: ${backlog.reviewPacket.currentState}\n`);
+    process.stderr.write(`  decision: ${backlog.reviewPacket.decision}\n`);
+    process.stderr.write(`  primary action: ${backlog.reviewPacket.primaryAction}\n`);
+    process.stderr.write(`  reason: ${backlog.reviewPacket.reason}\n`);
+    process.stderr.write("  allowed now:\n");
+    for (const item of backlog.reviewPacket.allowedNow)
+        process.stderr.write(`    - ${item}\n`);
+    process.stderr.write("  blocked now:\n");
+    for (const item of backlog.reviewPacket.blockedNow)
+        process.stderr.write(`    - ${item}\n`);
+    process.stderr.write("  review path:\n");
+    for (const command of backlog.reviewPacket.reviewPath)
+        process.stderr.write(`    - ${command}\n`);
+    process.stderr.write("\nCandidates:\n");
+    if (backlog.candidates.length === 0) {
+        process.stderr.write("  - none\n");
+    }
+    else {
+        for (const candidate of backlog.candidates) {
+            process.stderr.write(`  - [${candidate.priority}] ${candidate.title}\n`);
+            process.stderr.write(`    id: ${candidate.id}\n`);
+            process.stderr.write(`    type: ${candidate.type}\n`);
+            process.stderr.write(candidate.type === "active_evidence_followup"
+                ? `    saved draft: ${candidate.candidateAssetName} (unfinished work; source asset is preserved)\n`
+                : `    candidate asset: ${candidate.candidateAssetName}\n`);
+            process.stderr.write(`    source asset: ${candidate.sourceAsset}\n`);
+            process.stderr.write(`    source workflows: ${candidate.sourceWorkflows.length > 0 ? candidate.sourceWorkflows.join(", ") : "none"}\n`);
+            process.stderr.write(`    evidence: ${candidate.evidence}\n`);
+            process.stderr.write(`    rationale: ${candidate.rationale}\n`);
+            if (candidate.plainLanguage) {
+                process.stderr.write("    plain meaning:\n");
+                process.stderr.write(`      label: ${candidate.plainLanguage.label}\n`);
+                process.stderr.write(`      purpose: ${candidate.plainLanguage.purpose}\n`);
+                process.stderr.write(`      improvement: ${candidate.plainLanguage.workflowImprovement}\n`);
+                if (candidate.type === "active_evidence_followup") {
+                    process.stderr.write(`      why follow-up: ${candidate.plainLanguage.purpose}\n`);
+                    process.stderr.write("      not a deletion: the source asset stays available until an explicit diff, adoption, organization bind, and rollout review accept the draft.\n");
+                }
+                process.stderr.write("      preserves:\n");
+                for (const item of candidate.plainLanguage.preserves)
+                    process.stderr.write(`        - ${item}\n`);
+                process.stderr.write("      required before use:\n");
+                for (const item of candidate.plainLanguage.requiredBeforeUse)
+                    process.stderr.write(`        - ${item}\n`);
+            }
+            process.stderr.write(`    next: ${candidate.nextCommand}\n`);
+            process.stderr.write(`    boundary: ${candidate.mutationBoundary}\n`);
+            if (candidate.continuityBoundary)
+                process.stderr.write(`    continuity: ${candidate.continuityBoundary}\n`);
+            process.stderr.write("    action path:\n");
+            for (const step of candidate.actionPath) {
+                process.stderr.write(`      - ${step.id}: ${step.status} writes=${step.writes ? "yes" : "no"} command=${step.command}\n`);
+                process.stderr.write(`        ${step.purpose}\n`);
+            }
+            for (const command of candidate.reviewCommands.slice(0, 4))
+                process.stderr.write(`    review: ${command}\n`);
+        }
+    }
+    process.stderr.write("\nNext commands:\n");
+    for (const command of backlog.nextCommands)
+        process.stderr.write(`  - ${command}\n`);
+    process.stderr.write("\nMutation boundary:\n");
+    process.stderr.write(`  - writes: ${backlog.mutation.writes ? "yes" : "no"}\n`);
+    process.stderr.write(`  - ${backlog.mutation.note}\n`);
+}
+function writeAssetLifecycle(review) {
+    const label = review.displayName ? `${review.asset} (${review.displayName})` : review.asset;
+    process.stderr.write(`Workflow asset lifecycle: ${label}\n`);
+    process.stderr.write(`Mode: ${review.mode}\n`);
+    process.stderr.write(`Summary: ${review.summary}\n`);
+    writeManagerGates(review.managerGates);
+    process.stderr.write("\nSystem route:\n");
+    process.stderr.write(`  - principle: ${review.systemRoute.principle}\n`);
+    for (const phase of review.systemRoute.phases) {
+        process.stderr.write(`  - ${phase.id}. ${phase.label}\n`);
+        process.stderr.write(`    command: ${phase.command}\n`);
+        process.stderr.write(`    owner: ${phase.owner}\n`);
+        process.stderr.write(`    writes: ${phase.writes ? "yes" : "no"}\n`);
+        process.stderr.write(`    purpose: ${phase.purpose}\n`);
+    }
+    process.stderr.write("  - boundaries:\n");
+    for (const boundary of review.systemRoute.boundaries)
+        process.stderr.write(`    - ${boundary}\n`);
+    process.stderr.write("\nAsset path:\n");
+    for (const step of review.assetPath) {
+        process.stderr.write(`  - ${step.id}: ${step.status} owner=${step.owner} writes=${step.writes ? "yes" : "no"}\n`);
+        process.stderr.write(`    label: ${step.label}\n`);
+        process.stderr.write(`    command: ${step.command}\n`);
+        process.stderr.write(`    next: ${step.next}\n`);
+        process.stderr.write(`    purpose: ${step.purpose}\n`);
+        process.stderr.write(`    sources: ${step.sourceIds.join(", ")}\n`);
+    }
+    process.stderr.write("\nCascade stack:\n");
+    if (review.cascade.layerType)
+        process.stderr.write(`  - layer type: ${review.cascade.layerType}\n`);
+    if (review.cascade.priority !== undefined)
+        process.stderr.write(`  - priority: ${review.cascade.priority}\n`);
+    process.stderr.write(`  - inherits: ${review.cascade.inherits.length > 0 ? review.cascade.inherits.join(", ") : "none"}\n`);
+    process.stderr.write(`  - compiler effect: ${review.cascade.compilerEffect}\n`);
+    process.stderr.write("\nEvidence loop:\n");
+    process.stderr.write(`  - status: ${review.evidence.status}\n`);
+    if (review.evidence.source)
+        process.stderr.write(`  - source: ${review.evidence.source}\n`);
+    process.stderr.write(`  - modules: ${review.evidence.pass}/${review.evidence.modules} PASS\n`);
+    process.stderr.write(`  - blocked: ${review.evidence.blocked}\n`);
+    process.stderr.write(`  - remaining: ${review.evidence.remaining}\n`);
+    process.stderr.write(`  - next: ${review.evidence.nextCommand}\n`);
+    process.stderr.write("\nEvolution boundary:\n");
+    process.stderr.write(`  - review mode: ${review.evolution.reviewMode}\n`);
+    process.stderr.write(`  - preview: ${review.evolution.previewCommand}\n`);
+    process.stderr.write(`  - explicit mutation: ${review.evolution.mutatingCommand}\n`);
+    process.stderr.write(`  - boundary: ${review.evolution.mutationBoundary}\n`);
+    process.stderr.write("\nCurrent gate:\n");
+    process.stderr.write(`  - decision: ${review.currentGate.decision}\n`);
+    process.stderr.write(`  - reason: ${review.currentGate.reason}\n`);
+    process.stderr.write(`  - next: ${review.currentGate.nextCommand}\n`);
+    process.stderr.write("\nLifecycle stages:\n");
+    for (const stage of review.stages) {
+        process.stderr.write(`  - ${stage.id}. ${stage.label}\n`);
+        process.stderr.write(`    command: ${stage.command}\n`);
+        process.stderr.write(`    writes: ${stage.writes ? "yes" : "no"}\n`);
+        process.stderr.write(`    purpose: ${stage.purpose}\n`);
+    }
+    process.stderr.write("\nNext commands:\n");
+    for (const command of review.nextCommands)
+        process.stderr.write(`  - ${command}\n`);
+}
+function writeEvidenceIndex(index) {
+    process.stderr.write(`Workflow asset evidence: ${index.asset}\n`);
+    if (index.sourceDescription)
+        process.stderr.write(`Source: ${index.sourceDescription}\n`);
+    if (index.projectPath)
+        process.stderr.write(`Project: ${index.projectPath}\n`);
+    if (index.progressDir)
+        process.stderr.write(`Progress dir: ${index.progressDir}\n`);
+    process.stderr.write(`Modules: ${index.totals.modules}\n`);
+    process.stderr.write(`PASS: ${index.totals.pass}\n`);
+    process.stderr.write(`CONTINUE: ${index.totals.continue}\n`);
+    process.stderr.write(`REQUEST_CHANGES: ${index.totals.requestChanges}\n`);
+    process.stderr.write(`BLOCKED: ${index.totals.blocked}\n`);
+    process.stderr.write(`UNKNOWN: ${index.totals.unknown}\n`);
+    process.stderr.write(`Complete: ${index.totals.complete}\n`);
+    process.stderr.write(`Remaining: ${index.totals.remaining}\n`);
+    process.stderr.write(`Remaining UNIMPLEMENTED skipped: ${index.totals.remainingUnimplementedSkipped}\n`);
+    process.stderr.write(`New red: ${index.totals.newRed}\n`);
+    process.stderr.write(`Runtime artifacts: ${index.totals.runtimeArtifacts}\n`);
+    process.stderr.write(`Agent prompts: ${index.totals.agentPrompts}\n`);
+    process.stderr.write(`Skill entrypoints: ${index.totals.skillEntrypoints}\n`);
+    process.stderr.write(`C5 capture facts: ${index.totals.captureFacts}\n`);
+    process.stderr.write(`C5 blocked facts: ${index.totals.captureBlocked}\n`);
+    process.stderr.write(`C5 failure facts: ${index.totals.captureFailures}\n`);
+    process.stderr.write(`C5 manual interventions: ${index.totals.captureManualInterventions}\n`);
+    process.stderr.write(`C5 retries: ${index.totals.captureRetries}\n`);
+    if (index.warnings.length > 0) {
+        process.stderr.write("\nWarnings:\n");
+        for (const warning of index.warnings)
+            process.stderr.write(`  - ${warning}\n`);
+    }
+    if (index.runtimeArtifacts.length > 0) {
+        process.stderr.write("\nRuntime artifacts:\n");
+        for (const artifact of index.runtimeArtifacts.slice(0, 20)) {
+            const managed = artifact.managed ? "managed" : "unmanaged";
+            const source = artifact.source ? ` source=${artifact.source}` : "";
+            const roles = artifact.roles && artifact.roles.length > 0 ? ` roles=${artifact.roles.join(",")}` : "";
+            const handoff = artifact.consumes !== undefined || artifact.produces !== undefined
+                ? ` handoff=${artifact.consumes ?? 0}/${artifact.produces ?? 0}`
+                : "";
+            process.stderr.write(`  - ${artifact.target}/${artifact.kind}: ${artifact.name} ${managed}${source}${roles}${handoff}\n`);
+            process.stderr.write(`    path: ${artifact.path}\n`);
+            if (artifact.bodyPath)
+                process.stderr.write(`    body: ${artifact.bodyPath}\n`);
+            if (artifact.description)
+                process.stderr.write(`    description: ${artifact.description}\n`);
+        }
+        if (index.runtimeArtifacts.length > 20) {
+            process.stderr.write(`  ... ${index.runtimeArtifacts.length - 20} more runtime artifact(s). Use --json for full details.\n`);
+        }
+    }
+    if (index.captureFacts.length > 0) {
+        process.stderr.write("\nC5 capture facts:\n");
+        for (const capture of index.captureFacts.slice(0, 20)) {
+            const result = capture.result ? ` result=${capture.result}` : "";
+            process.stderr.write(`  - ${capture.capturedAt}: ${capture.fact}${result} workflow=${capture.workflowId} step=${capture.stepId}\n`);
+            process.stderr.write(`    summary: ${capture.summary}\n`);
+            process.stderr.write(`    path: ${capture.path}\n`);
+        }
+        if (index.captureFacts.length > 20) {
+            process.stderr.write(`  ... ${index.captureFacts.length - 20} more capture fact(s). Use --json for full details.\n`);
+        }
+    }
+    if (index.modules.length > 0) {
+        process.stderr.write("\nModules:\n");
+        for (const module of index.modules.slice(0, 20)) {
+            const complete = module.moduleComplete ? "complete" : "incomplete";
+            const remaining = module.remainingCount > 0 ? ` remaining=${module.remainingCount}` : "";
+            const skipped = module.remainingUnimplementedSkippedCount > 0 ? ` unimplemented_skipped=${module.remainingUnimplementedSkippedCount}` : "";
+            process.stderr.write(`  - ${module.module}: ${module.verdict} ${complete} round=${module.round ?? "unknown"} fixed=${module.fixedCount}${remaining}${skipped}\n`);
+            if (module.nextRoundFocus)
+                process.stderr.write(`    next: ${module.nextRoundFocus}\n`);
+            if (module.failureReason)
+                process.stderr.write(`    failure: ${module.failureReason}\n`);
+            process.stderr.write(`    progress: ${module.progressJsonPath}\n`);
+        }
+        if (index.modules.length > 20) {
+            process.stderr.write(`  ... ${index.modules.length - 20} more module(s). Use --json for full evidence paths.\n`);
+        }
+    }
+}
+function writeAssetHeader(asset) {
+    process.stderr.write(`Asset: ${asset.name}\n`);
+    if (asset.dnaId)
+        process.stderr.write(`DNA id: ${asset.dnaId}\n`);
+    process.stderr.write(`Source: ${asset.source}\n`);
+    process.stderr.write(`Path: ${asset.path}\n`);
+    if (asset.displayName)
+        process.stderr.write(`Name: ${asset.displayName}\n`);
+    if (asset.namespace)
+        process.stderr.write(`Namespace: ${asset.namespace}\n`);
+    if (asset.version)
+        process.stderr.write(`Version: ${asset.version}\n`);
+    process.stderr.write(`Content hash: ${asset.contentHash}\n`);
+    if (asset.positioning)
+        process.stderr.write(`Positioning: ${asset.positioning}\n`);
+    if (asset.keywords.length > 0)
+        process.stderr.write(`Keywords: ${asset.keywords.join(", ")}\n`);
+    process.stderr.write(`Status: ${asset.status.managementStatus} (${asset.status.evidencePosture})\n`);
+    process.stderr.write(`Project config: ${asset.status.configurationPosture}\n`);
+    process.stderr.write(`Cascade: ${asset.status.cascadePosture}\n`);
+    process.stderr.write(`Evolution: ${asset.status.evolutionPosture}\n`);
+}
+function writeAssetStructure(asset) {
+    process.stderr.write(`\nWorkflows (${asset.workflows.length}):\n`);
+    for (const workflow of asset.workflows) {
+        process.stderr.write(`  - ${workflow.id}: ${workflow.name} (${workflow.stepCount} step(s))`);
+        if (workflow.description)
+            process.stderr.write(` — ${workflow.description}`);
+        process.stderr.write("\n");
+    }
+    process.stderr.write(`\nControllers (${asset.controllers.length}):\n`);
+    for (const controller of asset.controllers) {
+        const rounds = controller.maxRounds !== undefined ? ` max_rounds=${controller.maxRounds}` : "";
+        process.stderr.write(`  - ${controller.id}: ${controller.kind}${rounds}`);
+        if (controller.progressArtifactPath)
+            process.stderr.write(` progress=${controller.progressArtifactPath}`);
+        process.stderr.write("\n");
+    }
+    process.stderr.write(`\nRoles (${asset.roles.length}):\n`);
+    for (const role of asset.roles) {
+        const writes = role.writeScope.length > 0 ? role.writeScope.join(", ") : "none";
+        process.stderr.write(`  - ${role.id}: write=${writes}`);
+        if (role.description)
+            process.stderr.write(` — ${role.description}`);
+        process.stderr.write("\n");
+    }
+}
+function writeAssetEvidence(asset) {
+    process.stderr.write(`\nEvidence links (${asset.evidence.length}):\n`);
+    if (asset.evidence.length === 0) {
+        process.stderr.write("  - none registered\n");
+        return;
+    }
+    for (const evidence of asset.evidence) {
+        process.stderr.write(`  - ${evidence.label} [${evidence.kind}]: ${evidence.path}`);
+        if (evidence.description)
+            process.stderr.write(` — ${evidence.description}`);
+        process.stderr.write("\n");
+    }
+}
+function writeAssetGovernance(asset) {
+    process.stderr.write("\nCascade:\n");
+    process.stderr.write(`  - posture: ${asset.status.cascadePosture}\n`);
+    if (asset.cascade.type)
+        process.stderr.write(`  - layer type: ${asset.cascade.type}\n`);
+    if (asset.cascade.priority !== undefined)
+        process.stderr.write(`  - priority: ${asset.cascade.priority}\n`);
+    process.stderr.write(`  - inherits: ${asset.cascade.inherits.length > 0 ? asset.cascade.inherits.join(", ") : "none"}\n`);
+    process.stderr.write("\nEvolution:\n");
+    process.stderr.write(`  - posture: ${asset.status.evolutionPosture}\n`);
+    process.stderr.write(`  - review mode: ${asset.evolution.reviewMode}\n`);
+    process.stderr.write(`  - declared markers: ${asset.evolution.declaredMarkers}\n`);
+    if (asset.evolution.markerIds.length > 0) {
+        process.stderr.write(`  - marker ids: ${asset.evolution.markerIds.join(", ")}\n`);
+    }
+    process.stderr.write(`  - outcome store: ${asset.evolution.outcomeStore}\n`);
+    process.stderr.write(`  - preview: ${asset.evolution.previewCommand}\n`);
+    process.stderr.write(`  - explicit mutation: ${asset.evolution.mutatingCommand}\n`);
+}
+function writeAssetStatus(asset) {
+    process.stderr.write(`Asset: ${asset.name}\n`);
+    if (asset.displayName)
+        process.stderr.write(`Name: ${asset.displayName}\n`);
+    process.stderr.write(`Status: ${asset.status.managementStatus}\n`);
+    process.stderr.write(`Evidence posture: ${asset.status.evidencePosture}\n`);
+    process.stderr.write(`Project config: ${asset.status.configurationPosture}\n`);
+    process.stderr.write(`Configured in project: ${asset.status.configured ? "yes" : "no"}\n`);
+    if (asset.status.configPaths.length > 0) {
+        process.stderr.write("Config paths:\n");
+        for (const configPath of asset.status.configPaths)
+            process.stderr.write(`  - ${configPath}\n`);
+    }
+    process.stderr.write(`Workflow defined: ${asset.status.hasWorkflow ? "yes" : "no"}\n`);
+    process.stderr.write(`Controller defined: ${asset.status.hasController ? "yes" : "no"}\n`);
+    process.stderr.write(`Cascade declared: ${asset.status.hasCascade ? "yes" : "no"}\n`);
+    process.stderr.write(`Evolution posture: ${asset.status.evolutionPosture}\n`);
+    process.stderr.write(`Evidence linked: ${asset.status.hasEvidence ? "yes" : "no"}\n`);
+    process.stderr.write(`Counts: ${formatCounts(asset)}\n`);
+    if (asset.status.notes.length > 0) {
+        process.stderr.write("Notes:\n");
+        for (const note of asset.status.notes)
+            process.stderr.write(`  - ${note}\n`);
+    }
+}
+function writeAssetInspection(asset, includeEvidence) {
+    writeAssetHeader(asset);
+    writeAssetGovernance(asset);
+    writeAssetStructure(asset);
+    process.stderr.write("\nSteps:\n");
+    for (const workflow of asset.workflows) {
+        process.stderr.write(`  ${workflow.id}:\n`);
+        for (const step of workflow.steps) {
+            const deps = step.dependsOn.length > 0 ? ` after=${step.dependsOn.join(",")}` : "";
+            const handoff = step.consumes + step.produces > 0 ? ` handoff=${step.consumes}/${step.produces}` : "";
+            const checkpoints = step.checkpoints > 0 ? ` checkpoints=${step.checkpoints}` : "";
+            process.stderr.write(`    - ${step.id} -> ${step.role}${deps}${handoff}${checkpoints}`);
+            if (step.description)
+                process.stderr.write(` — ${step.description}`);
+            process.stderr.write("\n");
+        }
+    }
+    if (includeEvidence)
+        writeAssetEvidence(asset);
+}
+async function loadAsset(name, projectDir) {
+    if (!name)
+        return undefined;
+    return findWorkflowAsset(name, { projectDir });
+}
+export async function runAssets(opts) {
+    const subcommand = opts.subcommand || "list";
+    if (subcommand === "diff") {
+        const from = await loadAsset(opts.name, opts.projectDir);
+        const to = await loadAsset(opts.compareTo, opts.projectDir);
+        if (!opts.name || !opts.compareTo) {
+            process.stderr.write("Usage: dna assets diff <from> <to> [--json]\n");
+            return 2;
+        }
+        if (!from) {
+            process.stderr.write(`Unknown workflow asset: ${opts.name}\n`);
+            return 2;
+        }
+        if (!to) {
+            process.stderr.write(`Unknown workflow asset: ${opts.compareTo}\n`);
+            return 2;
+        }
+        const diff = buildAssetDiff(from, to);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(diff, null, 2) + "\n");
+            return 0;
+        }
+        writeAssetDiff(diff);
+        return 0;
+    }
+    if (subcommand === "evidence") {
+        if (!opts.name) {
+            process.stderr.write("Usage: dna assets evidence <name> [--json]\n");
+            return 2;
+        }
+        const index = await buildWorkflowAssetEvidenceIndex(opts.name, { projectDir: opts.projectDir });
+        if (!index) {
+            process.stderr.write(`Unknown workflow asset: ${opts.name}\n`);
+            return 2;
+        }
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(index, null, 2) + "\n");
+            return 0;
+        }
+        writeEvidenceIndex(index);
+        return 0;
+    }
+    if (subcommand === "review") {
+        const assets = await listWorkflowAssets({ projectDir: opts.projectDir });
+        const review = await buildAssetReview(assets, opts.projectDir);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(review, null, 2) + "\n");
+            return 0;
+        }
+        writeAssetReview(review, assets);
+        return 0;
+    }
+    if (subcommand === "library") {
+        const assets = await listWorkflowAssets({ projectDir: opts.projectDir });
+        const library = buildAssetLibrary(assets);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(library, null, 2) + "\n");
+            return 0;
+        }
+        writeAssetLibrary(library);
+        return 0;
+    }
+    if (subcommand === "candidates") {
+        const backlog = await buildWorkflowAssetCandidateBacklog({
+            name: opts.name,
+            projectDir: opts.projectDir,
+        });
+        if (!backlog) {
+            process.stderr.write(`Unknown workflow asset: ${opts.name}\n`);
+            return 2;
+        }
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(backlog, null, 2) + "\n");
+            return 0;
+        }
+        writeAssetCandidateBacklog(backlog);
+        return 0;
+    }
+    if (subcommand === "lineage") {
+        const asset = await loadAsset(opts.name, opts.projectDir);
+        if (!asset) {
+            process.stderr.write(opts.name ? `Unknown workflow asset: ${opts.name}\n` : "Usage: dna assets lineage <name> [--json]\n");
+            return 2;
+        }
+        const evidence = await buildWorkflowAssetEvidenceIndex(asset.name, { projectDir: opts.projectDir });
+        const review = buildLineageReview(asset, evidence);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(review, null, 2) + "\n");
+            return 0;
+        }
+        writeLineageReview(review);
+        return 0;
+    }
+    if (subcommand === "governance") {
+        const asset = await loadAsset(opts.name, opts.projectDir);
+        if (!asset) {
+            process.stderr.write(opts.name ? `Unknown workflow asset: ${opts.name}\n` : "Usage: dna assets governance <name> [--json]\n");
+            return 2;
+        }
+        const evidence = await buildWorkflowAssetEvidenceIndex(asset.name, { projectDir: opts.projectDir });
+        const assets = await listWorkflowAssets({ projectDir: opts.projectDir });
+        const predecessor = findPredecessorAsset(asset, assets);
+        const sourceEvidence = predecessor
+            ? await buildWorkflowAssetEvidenceIndex(predecessor.name, { projectDir: opts.projectDir })
+            : evidence;
+        const review = buildGovernanceReview(asset, sourceEvidence, assets, predecessor ?? asset);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(review, null, 2) + "\n");
+            return 0;
+        }
+        writeGovernanceReview(review);
+        return 0;
+    }
+    if (subcommand === "lifecycle") {
+        const asset = await loadAsset(opts.name, opts.projectDir);
+        if (!asset) {
+            process.stderr.write(opts.name ? `Unknown workflow asset: ${opts.name}\n` : "Usage: dna assets lifecycle <name> [--json]\n");
+            return 2;
+        }
+        const evidence = await buildWorkflowAssetEvidenceIndex(asset.name, { projectDir: opts.projectDir });
+        const assets = await listWorkflowAssets({ projectDir: opts.projectDir });
+        const review = buildAssetLifecycle(asset, evidence, assets);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(review, null, 2) + "\n");
+            return 0;
+        }
+        writeAssetLifecycle(review);
+        return 0;
+    }
+    if (subcommand === "adoption") {
+        const loadedAsset = await loadAsset(opts.name, opts.projectDir);
+        if (!loadedAsset) {
+            process.stderr.write(opts.name ? `Unknown workflow asset: ${opts.name}\n` : "Usage: dna assets adoption <name> [--json]\n");
+            return 2;
+        }
+        const asset = await normalizeAssetForReview(loadedAsset, opts.projectDir);
+        const assets = await Promise.all((await listWorkflowAssets({ projectDir: opts.projectDir }))
+            .map((entry) => normalizeAssetForReview(entry, opts.projectDir)));
+        const predecessor = findPredecessorAsset(asset, assets);
+        const predecessorEvidence = predecessor
+            ? await buildWorkflowAssetEvidenceIndex(predecessor.name, { projectDir: opts.projectDir })
+            : undefined;
+        const review = buildAdoptionReview(asset, assets, predecessorEvidence);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(review, null, 2) + "\n");
+            return 0;
+        }
+        writeAdoptionReview(review);
+        return 0;
+    }
+    if (subcommand === "suggestions") {
+        const asset = await loadAsset(opts.name, opts.projectDir);
+        if (!asset) {
+            process.stderr.write(opts.name ? `Unknown workflow asset: ${opts.name}\n` : "Usage: dna assets suggestions <name> [--json]\n");
+            return 2;
+        }
+        const index = await buildWorkflowAssetEvidenceIndex(asset.name, { projectDir: opts.projectDir });
+        if (!index) {
+            process.stderr.write(`Unknown workflow asset: ${asset.name}\n`);
+            return 2;
+        }
+        const assets = await listWorkflowAssets({ projectDir: opts.projectDir });
+        const review = buildAssetSuggestions(asset, index, assets);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(review, null, 2) + "\n");
+            return 0;
+        }
+        writeAssetSuggestions(review);
+        return 0;
+    }
+    if (subcommand === "list") {
+        const assets = await listWorkflowAssets({ projectDir: opts.projectDir });
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(assets, null, 2) + "\n");
+            return 0;
+        }
+        process.stderr.write(`Workflow assets (${assets.length}):\n`);
+        for (const asset of assets) {
+            const ns = asset.namespace ? ` ns=${asset.namespace}` : "";
+            const version = asset.version ? ` v${asset.version}` : "";
+            process.stderr.write(`  - ${asset.name} [${asset.source}]${ns}${version} ${asset.status.configurationPosture} ${formatCounts(asset)}`);
+            if (asset.displayName)
+                process.stderr.write(` — ${asset.displayName}`);
+            process.stderr.write("\n");
+        }
+        return 0;
+    }
+    if (subcommand === "show") {
+        const loadedAsset = await loadAsset(opts.name, opts.projectDir);
+        if (!loadedAsset) {
+            process.stderr.write(opts.name ? `Unknown workflow asset: ${opts.name}\n` : "Usage: dna assets show <name>\n");
+            return 2;
+        }
+        const asset = await normalizeAssetForReview(loadedAsset, opts.projectDir);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(asset, null, 2) + "\n");
+            return 0;
+        }
+        writeAssetHeader(asset);
+        writeAssetGovernance(asset);
+        writeAssetStructure(asset);
+        if (opts.evidence)
+            writeAssetEvidence(asset);
+        return 0;
+    }
+    if (subcommand === "status") {
+        if (opts.name) {
+            const loadedAsset = await loadAsset(opts.name, opts.projectDir);
+            if (!loadedAsset) {
+                process.stderr.write(`Unknown workflow asset: ${opts.name}\n`);
+                return 2;
+            }
+            const asset = await normalizeAssetForReview(loadedAsset, opts.projectDir);
+            if (opts.json) {
+                process.stdout.write(JSON.stringify({ asset: asset.name, status: asset.status }, null, 2) + "\n");
+                return 0;
+            }
+            writeAssetStatus(asset);
+            if (opts.evidence)
+                writeAssetEvidence(asset);
+            return 0;
+        }
+        const assets = await listWorkflowAssets({ projectDir: opts.projectDir });
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(assets.map((asset) => ({
+                asset: asset.name,
+                displayName: asset.displayName,
+                status: asset.status,
+                counts: {
+                    workflows: asset.workflows.length,
+                    controllers: asset.controllers.length,
+                    roles: asset.roles.length,
+                    evidence: asset.evidence.length,
+                },
+            })), null, 2) + "\n");
+            return 0;
+        }
+        process.stderr.write(`Workflow asset status (${assets.length}):\n`);
+        for (const asset of assets) {
+            process.stderr.write(`  - ${asset.name}: ${asset.status.managementStatus} ${asset.status.evidencePosture} ${asset.status.configurationPosture} ${formatCounts(asset)}\n`);
+        }
+        return 0;
+    }
+    if (subcommand === "inspect") {
+        const loadedAsset = await loadAsset(opts.name, opts.projectDir);
+        if (!loadedAsset) {
+            process.stderr.write(opts.name ? `Unknown workflow asset: ${opts.name}\n` : "Usage: dna assets inspect <name>\n");
+            return 2;
+        }
+        const asset = await normalizeAssetForReview(loadedAsset, opts.projectDir);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(asset, null, 2) + "\n");
+            return 0;
+        }
+        writeAssetInspection(asset, opts.evidence ?? false);
+        return 0;
+    }
+    process.stderr.write("Usage: dna assets <list|library|candidates|lineage|show|inspect|status|review|governance|lifecycle|adoption|suggestions|diff|evidence> [name] [--evidence] [--json]\n");
+    return 2;
+}