intentdna 1.7.5 → 1.8.0

package/dist/assets/candidates.js

@@ -0,0 +1,1249 @@
+import { listWorkflowAssets, } from "./catalog.js";
+import { buildWorkflowAssetEvidenceIndex, } from "./evidence.js";
+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 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");
+}
+export function activeEvidenceModules(index) {
+    return index.modules.filter((module) => module.verdict !== "PASS" ||
+        !module.moduleComplete ||
+        module.remainingCount > 0 ||
+        module.newRedCount > 0);
+}
+function totalFixed(index) {
+    return index.modules.reduce((sum, module) => sum + module.fixedCount, 0);
+}
+function sourceModules(index) {
+    return index.modules.map((module) => module.module);
+}
+function activeFollowupNonReplacementNote(sourceAsset, followupAsset) {
+    return `${followupAsset} is a saved draft for unfinished ${sourceAsset} evidence; it does not replace, delete, or auto-adopt ${sourceAsset}.`;
+}
+function activeFollowupContinuityBoundary(sourceAsset, followupAsset) {
+    return [
+        activeFollowupNonReplacementNote(sourceAsset, followupAsset),
+        `${sourceAsset} remains the original workflow asset.`,
+        "flutter-rewrite-fix-review-loop remains the reusable fix loop asset.",
+        "Use the saved draft only to review unfinished dogfood evidence before any explicit adoption, organization binding, rollout, or runtime sync.",
+    ].join(" ");
+}
+function activeFollowupPlainLanguage(sourceAsset, followupAsset) {
+    return {
+        label: "saved unfinished-work draft",
+        purpose: "Make unfinished dogfood evidence explicit for manager review before stability, rollout, sync, publication readiness, or evolution claims.",
+        workflowImprovement: "Adds a concrete evidence checkpoint to the existing workflow route so active unfinished work is inspected, diffed, and accepted before anyone treats the source asset as stable.",
+        preserves: [
+            `${sourceAsset} remains the original workflow asset.`,
+            "flutter-rewrite-fix-review-loop remains the reusable fix loop asset.",
+            `${followupAsset} is only a review draft until a manager accepts it through diff, adoption, bind, and rollout gates.`,
+        ],
+        requiredBeforeUse: [
+            `dna assets diff ${sourceAsset} ${followupAsset}`,
+            `record explicit manager rationale for dna assets diff ${sourceAsset} ${followupAsset}`,
+            `dna assets adoption ${followupAsset}`,
+            `dna org bind --asset ${followupAsset} --status active --sync-target codex`,
+            "dna org rollout",
+        ],
+    };
+}
+function capturedRunFactPlainLanguage(sourceAsset) {
+    return {
+        label: "captured run facts review",
+        purpose: "Turn local hook-observed failures, blockers, retries, unsupported paths, or human interventions into a review queue before changing the workflow.",
+        workflowImprovement: "Keeps real run friction visible in workflow mining so the next edit starts from evidence instead of guesswork.",
+        preserves: [
+            `${sourceAsset} remains unchanged until a reviewed edit plan or authored draft is explicitly saved and accepted.`,
+            "C5 facts stay local evidence; they do not become policy, adoption, rollout, sync, or runtime authority.",
+            "C4 RuntimeDecisionEvent remains the provenance source for runtime decisions.",
+        ],
+        requiredBeforeUse: [
+            `dna assets evidence ${sourceAsset} --json`,
+            `dna workflow suggestions ${sourceAsset} --json`,
+            "record explicit manager rationale before any accepted asset change",
+            `dna assets diff ${sourceAsset} <reviewed-candidate>`,
+            "explicit adoption, organization binding, rollout, and runtime sync only after review",
+        ],
+    };
+}
+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 c5CaptureBootstrapPlainLanguage(sourceAsset) {
+    return {
+        label: "local C5 evidence bootstrap",
+        purpose: "Make the empty evidence state actionable by telling the user how to run the workflow locally before mining improvements.",
+        workflowImprovement: "Prevents workflow mining from feeling like an internal dogfood report when there are no local hook-captured facts yet.",
+        preserves: [
+            `${sourceAsset} remains unchanged; this candidate does not create, delete, replace, adopt, bind, or sync an asset by itself.`,
+            "Local init/sync are explicit later commands that install runtime artifacts only when the user runs them.",
+            "C5 facts still become suggestions and review queues only; they never become policy or runtime authority automatically.",
+        ],
+        requiredBeforeUse: c5CaptureBootstrapCommands(sourceAsset),
+    };
+}
+function sourceWorkflows(asset, ids) {
+    const available = new Set(asset.workflows.map((workflow) => workflow.id));
+    return ids.filter((id) => available.has(id));
+}
+function candidateReviewCommands(params) {
+    return [...new Set([
+            `dna assets lineage ${params.sourceAsset}`,
+            `dna assets evidence ${params.sourceAsset}`,
+            params.nextCommand,
+            `dna assets diff ${params.sourceAsset} ${params.candidateAssetName}`,
+            `record explicit manager rationale for dna assets diff ${params.sourceAsset} ${params.candidateAssetName}`,
+            `dna assets adoption ${params.candidateAssetName}`,
+            `dna org bind --asset ${params.candidateAssetName} --status active --sync-target codex`,
+            "dna org rollout",
+        ])];
+}
+function reviewAction(command, reason) {
+    return { kind: "review", command, reason };
+}
+function templateIdForAsset(assetName) {
+    return `template_${assetName.replaceAll("-", "_")}`;
+}
+function candidateActionPath(candidate) {
+    const createsDraft = candidate.action.kind !== "review";
+    const sameAsset = candidate.sourceAsset === candidate.candidateAssetName;
+    const steps = [
+        {
+            id: "source_lineage",
+            label: "Inspect source asset lineage",
+            command: `dna assets lineage ${candidate.sourceAsset}`,
+            purpose: "Confirm the source workflow asset, cascade, evidence, and evolution route before acting on the candidate.",
+            writes: false,
+            status: "ready",
+        },
+        {
+            id: "source_evidence",
+            label: "Inspect dogfood evidence",
+            command: `dna assets evidence ${candidate.sourceAsset}`,
+            purpose: "Check the dogfood modules and active blockers that justify this candidate.",
+            writes: false,
+            status: "ready",
+        },
+        {
+            id: "candidate_action",
+            label: createsDraft ? "Create reviewable candidate draft" : "Review existing candidate asset",
+            command: candidate.nextCommand,
+            purpose: createsDraft
+                ? "Turn evidence into an explicit workflow asset draft or edit-plan version before diff, adoption, rollout, sync, or evolution."
+                : "Review the existing or built-in candidate asset before organization binding, rollout, sync, or evolution.",
+            writes: createsDraft,
+            status: "current",
+        },
+    ];
+    if (createsDraft) {
+        steps.push({
+            id: "candidate_inspect",
+            label: "Inspect candidate draft",
+            command: `dna assets inspect ${candidate.candidateAssetName} --evidence`,
+            purpose: "Read the saved candidate asset draft and linked evidence before comparing it.",
+            writes: false,
+            status: "later",
+        }, {
+            id: "candidate_governance",
+            label: "Review candidate cascade and governance",
+            command: `dna assets governance ${candidate.candidateAssetName}`,
+            purpose: "Check cascade inheritance, controllers, evidence posture, and evolution posture before adoption.",
+            writes: false,
+            status: "later",
+        }, {
+            id: "candidate_diff",
+            label: "Compare source and candidate",
+            command: `dna assets diff ${candidate.sourceAsset} ${candidate.candidateAssetName}`,
+            purpose: "Review what changed before adoption or organization binding.",
+            writes: false,
+            status: "later",
+        }, {
+            id: "adoption_review",
+            label: "Review adoption readiness",
+            command: `dna assets adoption ${candidate.candidateAssetName}`,
+            purpose: "Check workflow shape, cascade, evidence, configuration, and governance before adoption.",
+            writes: false,
+            status: "later",
+        });
+    }
+    else if (!sameAsset) {
+        steps.push({
+            id: "candidate_inspect",
+            label: "Inspect candidate asset",
+            command: `dna assets inspect ${candidate.candidateAssetName} --evidence`,
+            purpose: "Inspect the existing candidate asset before adoption or organization binding.",
+            writes: false,
+            status: "ready",
+        }, {
+            id: "candidate_governance",
+            label: "Review candidate cascade and governance",
+            command: `dna assets governance ${candidate.candidateAssetName}`,
+            purpose: "Check cascade inheritance, controllers, evidence posture, and evolution posture before adoption.",
+            writes: false,
+            status: "ready",
+        });
+    }
+    steps.push({
+        id: "evolution_preview",
+        label: "Preview self-evolution markers",
+        command: `dna evolve ${templateIdForAsset(candidate.candidateAssetName)}`,
+        purpose: "Review outcome-derived marker changes without persisting them; mutation stays behind explicit dna sync --evolve after human review.",
+        writes: false,
+        status: "later",
+    }, {
+        id: "organization_bind",
+        label: "Bind accepted asset to organization",
+        command: `dna org bind --asset ${candidate.candidateAssetName} --status active --sync-target codex`,
+        purpose: "Record the accepted candidate asset in the organization route before runtime distribution.",
+        writes: true,
+        status: "later",
+    }, {
+        id: "rollout_review",
+        label: "Review rollout readiness",
+        command: "dna org rollout",
+        purpose: "Check target-level ready, partial, and blocked distribution before runtime sync.",
+        writes: false,
+        status: "later",
+    });
+    return steps;
+}
+function activeFollowupActionPath(route) {
+    const steps = [
+        {
+            id: "source_lineage",
+            label: "Inspect source asset lineage",
+            command: `dna assets lineage ${route.sourceAsset}`,
+            purpose: "Confirm the source workflow asset, cascade, evidence, and evolution route before acting on the saved draft.",
+            writes: false,
+            status: "ready",
+        },
+        {
+            id: "source_evidence",
+            label: "Inspect dogfood evidence",
+            command: `dna assets evidence ${route.sourceAsset}`,
+            purpose: "Check the dogfood modules and active blockers that justify this saved draft.",
+            writes: false,
+            status: "ready",
+        },
+    ];
+    if (route.status === "draft_missing") {
+        steps.push({
+            id: "candidate_action",
+            label: "Save unfinished-work draft",
+            command: route.createCommand,
+            purpose: `${activeFollowupNonReplacementNote(route.sourceAsset, route.candidateAssetName)} Create it before diff, adoption, rollout, sync, or evolution.`,
+            writes: true,
+            status: "current",
+        }, {
+            id: "candidate_inspect",
+            label: "Inspect unfinished-work draft",
+            command: route.inspectCommand,
+            purpose: "Read the saved unfinished-work draft and linked evidence before comparing it with the unchanged source asset.",
+            writes: false,
+            status: "later",
+        }, {
+            id: "candidate_governance",
+            label: "Review candidate cascade and governance",
+            command: route.governanceCommand,
+            purpose: "Check cascade inheritance, controllers, evidence posture, and evolution posture before adoption.",
+            writes: false,
+            status: "later",
+        }, {
+            id: "candidate_diff",
+            label: "Compare source and follow-up",
+            command: route.diffCommand,
+            purpose: "Review what changed before adoption or organization binding; this comparison is not a deletion or replacement of the source asset.",
+            writes: false,
+            status: "later",
+        }, {
+            id: "manager_rationale",
+            label: "Record manager rationale",
+            command: `record explicit manager rationale for ${route.diffCommand}`,
+            purpose: "Capture why the diff is acceptable before adoption, organization binding, rollout, or sync.",
+            writes: false,
+            status: "later",
+        }, {
+            id: "adoption_review",
+            label: "Review adoption readiness",
+            command: route.adoptionCommand,
+            purpose: "Check workflow shape, cascade, evidence, configuration, and governance before adoption.",
+            writes: false,
+            status: "later",
+        });
+    }
+    else if (route.status === "draft_incomplete") {
+        steps.push({
+            id: "candidate_inspect",
+            label: "Inspect incomplete unfinished-work draft",
+            command: route.inspectCommand,
+            purpose: "The unfinished-work draft exists but is missing required workflow, controller, cascade, or evidence signals.",
+            writes: false,
+            status: "current",
+        }, {
+            id: "candidate_governance",
+            label: "Review candidate cascade and governance",
+            command: route.governanceCommand,
+            purpose: "Identify the missing governance signals before diff, adoption, rollout, or sync.",
+            writes: false,
+            status: "later",
+        }, {
+            id: "candidate_diff",
+            label: "Compare source and saved draft",
+            command: route.diffCommand,
+            purpose: "Review what changed after the unfinished-work draft becomes complete enough to compare.",
+            writes: false,
+            status: "later",
+        }, {
+            id: "manager_rationale",
+            label: "Record manager rationale",
+            command: `record explicit manager rationale for ${route.diffCommand}`,
+            purpose: "Capture why the diff is acceptable before adoption, organization binding, rollout, or sync.",
+            writes: false,
+            status: "later",
+        }, {
+            id: "adoption_review",
+            label: "Review adoption readiness",
+            command: route.adoptionCommand,
+            purpose: "Check workflow shape, cascade, evidence, configuration, and governance before adoption.",
+            writes: false,
+            status: "later",
+        });
+    }
+    else if (route.status === "draft_structural_drift") {
+        steps.push({
+            id: "candidate_action",
+            label: "Repair preserving unfinished-work draft",
+            command: route.currentCommand,
+            purpose: "The unfinished-work draft exists but drops source workflows; regenerate it from the source asset so review compares a preserving patch, not a feature removal.",
+            writes: true,
+            status: "current",
+        }, {
+            id: "candidate_inspect",
+            label: "Inspect repaired unfinished-work draft",
+            command: route.inspectCommand,
+            purpose: "Read the repaired unfinished-work draft and linked evidence before comparing it with the unchanged source asset.",
+            writes: false,
+            status: "later",
+        }, {
+            id: "candidate_governance",
+            label: "Review candidate cascade and governance",
+            command: route.governanceCommand,
+            purpose: "Check cascade inheritance, controllers, evidence posture, and evolution posture before adoption.",
+            writes: false,
+            status: "later",
+        }, {
+            id: "candidate_diff",
+            label: "Compare source and saved draft",
+            command: route.diffCommand,
+            purpose: "Verify the repaired draft preserves source workflows and only changes the intended unfinished-work checkpoint.",
+            writes: false,
+            status: "later",
+        }, {
+            id: "manager_rationale",
+            label: "Record manager rationale",
+            command: `record explicit manager rationale for ${route.diffCommand}`,
+            purpose: "Capture why the repaired diff is acceptable before adoption, organization binding, rollout, or sync.",
+            writes: false,
+            status: "later",
+        }, {
+            id: "adoption_review",
+            label: "Review adoption readiness",
+            command: route.adoptionCommand,
+            purpose: "Check workflow shape, cascade, evidence, configuration, and governance before adoption.",
+            writes: false,
+            status: "later",
+        });
+    }
+    else {
+        steps.push({
+            id: "candidate_inspect",
+            label: "Inspect unfinished-work draft",
+            command: route.inspectCommand,
+            purpose: "Read the saved unfinished-work draft and linked evidence when deeper review is needed; the source asset remains available.",
+            writes: false,
+            status: "ready",
+        }, {
+            id: "candidate_governance",
+            label: "Review candidate cascade and governance",
+            command: route.governanceCommand,
+            purpose: "Check cascade inheritance, controllers, evidence posture, and evolution posture before adoption.",
+            writes: false,
+            status: "ready",
+        }, {
+            id: "candidate_diff",
+            label: "Compare source and saved draft",
+            command: route.diffCommand,
+            purpose: "Review what changed before adoption or organization binding; this is a review gate, not an automatic replacement.",
+            writes: false,
+            status: "current",
+        }, {
+            id: "manager_rationale",
+            label: "Record manager rationale",
+            command: `record explicit manager rationale for ${route.diffCommand}`,
+            purpose: "Capture why the diff is acceptable before adoption, organization binding, rollout, or sync.",
+            writes: false,
+            status: "later",
+        }, {
+            id: "adoption_review",
+            label: "Review adoption readiness",
+            command: route.adoptionCommand,
+            purpose: "Check workflow shape, cascade, evidence, configuration, and governance before adoption.",
+            writes: false,
+            status: "later",
+        });
+    }
+    steps.push({
+        id: "evolution_preview",
+        label: "Preview self-evolution markers",
+        command: `dna evolve ${templateIdForAsset(route.candidateAssetName)}`,
+        purpose: "Review outcome-derived marker changes without persisting them; mutation stays behind explicit dna sync --evolve after human review.",
+        writes: false,
+        status: "later",
+    }, {
+        id: "organization_bind",
+        label: "Bind accepted asset to organization",
+        command: route.bindCommand,
+        purpose: "Record the accepted unfinished-work draft in the organization route before runtime distribution; binding is explicit and does not erase the source asset.",
+        writes: true,
+        status: "later",
+    }, {
+        id: "rollout_review",
+        label: "Review rollout readiness",
+        command: route.rolloutCommand,
+        purpose: "Check target-level ready, partial, and blocked distribution before runtime sync.",
+        writes: false,
+        status: "later",
+    });
+    return steps;
+}
+function capturedRunFactsActionPath(params) {
+    return [
+        {
+            id: "source_lineage",
+            label: "Inspect source asset lineage",
+            command: `dna assets lineage ${params.sourceAsset}`,
+            purpose: "Confirm which workflow asset the local captured facts matched before acting on them.",
+            writes: false,
+            status: "ready",
+        },
+        {
+            id: "source_evidence",
+            label: "Inspect captured local evidence",
+            command: params.evidenceCommand,
+            purpose: "Review the C5 JSONL facts, redacted summaries, evidence refs, and matched workflow scope before drafting any change.",
+            writes: false,
+            status: "current",
+        },
+        {
+            id: "candidate_action",
+            label: "Review workflow suggestions",
+            command: params.suggestionsCommand,
+            purpose: "Translate captured run facts into human-reviewable suggestions without writing templates, policy, org bindings, or runtime artifacts.",
+            writes: false,
+            status: "later",
+        },
+        {
+            id: "manager_rationale",
+            label: "Record manager rationale",
+            command: `record explicit manager rationale for any C5-derived change to ${params.sourceAsset}`,
+            purpose: "Capture why a C5-derived workflow change is acceptable before diff, adoption, organization binding, rollout, or sync.",
+            writes: false,
+            status: "later",
+        },
+        {
+            id: "adoption_review",
+            label: "Review adoption readiness",
+            command: `dna assets adoption ${params.sourceAsset}`,
+            purpose: "Keep adoption separate from evidence review; C5 facts alone do not make the current asset adopted or rollout-ready.",
+            writes: false,
+            status: "later",
+        },
+    ];
+}
+function c5CaptureBootstrapActionPath(sourceAsset) {
+    return [
+        {
+            id: "source_lineage",
+            label: "Inspect source asset lineage",
+            command: `dna assets lineage ${sourceAsset}`,
+            purpose: "Confirm which workflow asset should govern the local run before creating new C5 evidence.",
+            writes: false,
+            status: "ready",
+        },
+        {
+            id: "source_evidence",
+            label: "Inspect current local evidence",
+            command: `dna assets evidence ${sourceAsset} --json`,
+            purpose: "Confirm the empty C5 capture state before running local setup or sync commands.",
+            writes: false,
+            status: "ready",
+        },
+        {
+            id: "candidate_action",
+            label: "Review empty C5 suggestions",
+            command: `dna workflow suggestions ${sourceAsset} --json`,
+            purpose: "Read the no-facts guidance without writing templates, policy, organization bindings, runtime artifacts, or cloud reports.",
+            writes: false,
+            status: "current",
+        },
+        {
+            id: "local_init",
+            label: "Initialize local workflow asset",
+            command: `dna init --template ${sourceAsset}`,
+            purpose: "Create local DNA configuration only when this asset should govern the project.",
+            writes: true,
+            status: "later",
+        },
+        {
+            id: "sync_dry_run",
+            label: "Preview local runtime sync",
+            command: "dna sync --codex --dry-run",
+            purpose: "Check the harness artifacts that would be installed before writing runtime files.",
+            writes: false,
+            status: "later",
+        },
+        {
+            id: "sync_apply",
+            label: "Install local runtime artifacts",
+            command: "dna sync --codex",
+            purpose: "Install local Codex artifacts so the harness can run under dna/dna-hook runtime truth.",
+            writes: true,
+            status: "later",
+        },
+        {
+            id: "rerun_suggestions",
+            label: "Review evidence-backed suggestions",
+            command: `dna workflow suggestions ${sourceAsset} --json`,
+            purpose: "Return to the read-only suggestion loop after the local run records C5 facts.",
+            writes: false,
+            status: "later",
+        },
+        {
+            id: "rerun_mine",
+            label: "Mine review-only candidates",
+            command: `dna workflow mine ${sourceAsset} --json`,
+            purpose: "Mine candidates from captured facts without saving, adopting, binding, syncing, uploading, or creating runtime authority.",
+            writes: false,
+            status: "later",
+        },
+    ];
+}
+function withActionPath(candidate) {
+    return {
+        ...candidate,
+        actionPath: candidateActionPath(candidate),
+    };
+}
+function draftAction(params) {
+    return {
+        kind: "draft",
+        goal: params.goal,
+        example: params.example,
+        strictness: "high",
+        saveTemplate: params.saveTemplate,
+        command: params.command ?? `dna workflow draft "${params.goal}" --example ${params.example} --strictness high --save-template ${params.saveTemplate}`,
+        scaffold: true,
+        deprecatedPrimaryCreationPath: "dna workflow authoring-packet",
+    };
+}
+function editPlanAction(params) {
+    return {
+        kind: "edit_plan",
+        instruction: params.instruction,
+        fromTemplate: params.fromTemplate,
+        workflow: params.workflow,
+        operation: params.operation,
+        targetStep: params.targetStep,
+        saveTemplate: params.saveTemplate,
+        command: params.command ?? `dna workflow edit-plan "${params.instruction}" --from-template ${params.fromTemplate} --workflow ${params.workflow} --operation ${params.operation} --target-step ${params.targetStep} --save-template ${params.saveTemplate}`,
+    };
+}
+function buildCandidateReviewPacket(params) {
+    const active = params.candidates.find((candidate) => candidate.type === "active_evidence_followup");
+    const first = active ?? params.candidates[0];
+    if (!first) {
+        return {
+            currentState: params.focusAsset ? `no_candidates:${params.focusAsset}` : "no_candidates:all_assets",
+            primaryAction: "dna assets library",
+            decision: "no_candidates",
+            reason: "No dogfood-backed workflow candidates are currently available. Start from the asset library or describe a new workflow intake.",
+            allowedNow: [
+                "Inspect available workflow assets: dna assets library.",
+                "Describe a new working method: dna workflow intake \"Describe the workflow you want to govern\".",
+            ],
+            blockedNow: [
+                "Runtime sync is blocked until a reviewed asset exists, is organization-bound, configured, and rollout-ready.",
+                "Evolution marker mutation is blocked until there is reviewed evidence and an accepted change path.",
+            ],
+            reviewPath: params.nextCommands,
+        };
+    }
+    const activeEvidence = params.summary.activeModules > 0;
+    const capturedRunFacts = first.type === "captured_run_fact_review";
+    const sourceAsset = active?.sourceAsset ?? first.sourceAsset;
+    const activeFollowupNote = activeEvidence
+        ? activeFollowupNonReplacementNote(sourceAsset, active?.candidateAssetName ?? first.candidateAssetName)
+        : undefined;
+    return {
+        currentState: activeEvidence
+            ? `active_evidence:${sourceAsset}`
+            : capturedRunFacts
+                ? `captured_run_facts:${sourceAsset}`
+                : `candidate_review:${params.focusAsset ?? "all_assets"}`,
+        primaryAction: first.nextCommand,
+        decision: activeEvidence ? "review_active_evidence_first" : "review_candidates",
+        reason: activeEvidence
+            ? `Active dogfood evidence must be saved and reviewed as unfinished work, or routed to next-run focus, before baseline promotion, evolution marker mutation, rollout, or runtime sync. ${activeFollowupNote}`
+            : capturedRunFacts
+                ? "Captured local C5 run facts must be reviewed before changing the workflow asset. They can create suggestions, but never automatic policy, template, adoption, rollout, sync, or runtime authority."
+                : "Dogfood evidence is ready to be reviewed as reusable workflow assets or baseline promotion candidates before organization rollout.",
+        allowedNow: [
+            `Inspect source lineage: dna assets lineage ${sourceAsset}.`,
+            capturedRunFacts
+                ? `Inspect captured C5 evidence: dna assets evidence ${sourceAsset} --json.`
+                : `Inspect dogfood evidence: dna assets evidence ${sourceAsset}.`,
+            `Run the primary candidate action: ${first.nextCommand}.`,
+            "Review extracted reusable assets through adoption before org binding.",
+        ],
+        blockedNow: [
+            activeEvidence
+                ? "Baseline promotion is blocked until active dogfood evidence is reviewed through the saved unfinished-work draft; the source asset stays intact while this happens."
+                : capturedRunFacts
+                    ? "C5 evidence review cannot directly promote, adopt, bind, sync, or mutate the workflow asset."
+                    : "Baseline promotion still requires adoption review before org binding.",
+            "Runtime sync is blocked until the selected asset is reviewed, adopted, organization-bound, configured if needed, and rollout-ready.",
+            "Evolution marker mutation is blocked until evidence-backed suggestions are reviewed and accepted.",
+            "Vercel deployment is not a substitute for workflow candidate review, organization rollout, or runtime sync.",
+        ],
+        reviewPath: first.reviewCommands.length > 0 ? first.reviewCommands : params.nextCommands,
+    };
+}
+function fromCandidateCommand(params) {
+    return `dna workflow from-candidate ${params.id} --from-template ${params.sourceAsset} --save-template ${params.saveTemplate}`;
+}
+function candidateBacklogNextCommands(candidates) {
+    const active = candidates.find((candidate) => candidate.type === "active_evidence_followup");
+    const remaining = active ? candidates.filter((candidate) => candidate.id !== active.id) : candidates;
+    const commands = [
+        ...new Set([
+            ...(active ? [active.nextCommand, ...active.reviewCommands] : []),
+            ...remaining.map((candidate) => candidate.nextCommand),
+            ...remaining.flatMap((candidate) => candidate.reviewCommands),
+        ]),
+    ];
+    const limited = commands.slice(0, 12);
+    if (commands.includes("dna org rollout") && !limited.includes("dna org rollout")) {
+        limited[limited.length - 1] = "dna org rollout";
+    }
+    return limited;
+}
+function blockedScopeTriageModules(index) {
+    return index.modules.filter((module) => {
+        const signal = `${module.verdict} ${module.review ?? ""} ${module.failureReason ?? ""} ${module.nextRoundFocus ?? ""}`.toLowerCase();
+        return module.blockedCount > 0 ||
+            module.verdict === "BLOCKED" ||
+            module.verdict === "REQUEST_CHANGES" ||
+            signal.includes("blocked_by_review") ||
+            signal.includes("needs_human") ||
+            signal.includes("outside_diagnosis") ||
+            signal.includes("human approval");
+    });
+}
+function crossBoundaryResourceModules(index) {
+    return index.modules.filter((module) => {
+        const signal = `${module.module} ${module.verdict} ${module.review ?? ""} ${module.failureReason ?? ""} ${module.nextRoundFocus ?? ""}`.toLowerCase();
+        return signal.includes("i18n") ||
+            signal.includes("localization") ||
+            signal.includes("translation") ||
+            signal.includes("shared") ||
+            signal.includes("cross-boundary") ||
+            signal.includes("cross boundary") ||
+            signal.includes("outside_diagnosis") ||
+            signal.includes("outside diagnosis") ||
+            signal.includes("outside_scope") ||
+            signal.includes("outside scope");
+    });
+}
+export function activeEvidenceFollowupRoute(asset) {
+    const candidateId = `active-followup-${asset}`;
+    const assetName = `${asset}-active-followup`;
+    return {
+        candidateId,
+        assetName,
+        command: fromCandidateCommand({ id: candidateId, sourceAsset: asset, saveTemplate: assetName }),
+    };
+}
+function isReviewableFollowupAsset(asset) {
+    return asset.status.hasWorkflow &&
+        asset.status.hasController &&
+        asset.status.hasCascade &&
+        asset.status.hasEvidence;
+}
+function missingSourceWorkflowIds(sourceAsset, candidateAsset) {
+    if (!sourceAsset)
+        return [];
+    const candidateWorkflowIds = new Set(candidateAsset.workflows.map((workflow) => workflow.id));
+    return sourceAsset.workflows
+        .map((workflow) => workflow.id)
+        .filter((workflowId) => !candidateWorkflowIds.has(workflowId));
+}
+function withCurrentFollowupEvidence(asset, sourceAsset, evidenceIndex) {
+    if (!asset || !evidenceIndex)
+        return asset;
+    const active = activeEvidenceModules(evidenceIndex);
+    if (active.length === 0)
+        return asset;
+    const description = `Saved unfinished-work draft from active ${sourceAsset} evidence: ${active.length} active module(s): ${active.slice(0, 5).map(compactEvidenceModule).join("; ")}`;
+    return {
+        ...asset,
+        evidence: asset.evidence.map((link) => link.label === `Active dogfood evidence: ${sourceAsset}`
+            ? { ...link, description }
+            : link),
+    };
+}
+export function activeEvidenceFollowupReviewRoute(sourceAsset, assets, evidenceIndex) {
+    const route = activeEvidenceFollowupRoute(sourceAsset);
+    const sourceAssetSummary = assets.find((asset) => asset.name === sourceAsset);
+    const candidateAsset = withCurrentFollowupEvidence(assets.find((asset) => asset.name === route.assetName), sourceAsset, evidenceIndex);
+    const active = evidenceIndex ? activeEvidenceModules(evidenceIndex) : [];
+    const currentEvidence = active.length > 0
+        ? `${active.length} active module(s): ${active.slice(0, 5).map(compactEvidenceModule).join("; ")}`
+        : undefined;
+    const inspectCommand = `dna assets inspect ${route.assetName} --evidence`;
+    const governanceCommand = `dna assets governance ${route.assetName}`;
+    const diffCommand = `dna assets diff ${sourceAsset} ${route.assetName}`;
+    const rationaleCommand = `record explicit manager rationale for ${diffCommand}`;
+    const adoptionCommand = `dna assets adoption ${route.assetName}`;
+    const bindCommand = `dna org bind --asset ${route.assetName} --status active --sync-target codex`;
+    const rolloutCommand = "dna org rollout";
+    const sourceCommands = [
+        `dna assets lineage ${sourceAsset}`,
+        `dna assets evidence ${sourceAsset}`,
+    ];
+    const candidateReviewCommands = [
+        inspectCommand,
+        governanceCommand,
+        diffCommand,
+        rationaleCommand,
+        adoptionCommand,
+        bindCommand,
+        rolloutCommand,
+    ];
+    if (!candidateAsset) {
+        return {
+            candidateId: route.candidateId,
+            sourceAsset,
+            candidateAssetName: route.assetName,
+            status: "draft_missing",
+            currentEvidence,
+            createCommand: route.command,
+            inspectCommand,
+            governanceCommand,
+            diffCommand,
+            adoptionCommand,
+            bindCommand,
+            rolloutCommand,
+            currentCommand: route.command,
+            currentWrites: true,
+            reason: `No unfinished-work draft exists yet, so open dogfood evidence must first be saved for review. ${activeFollowupNonReplacementNote(sourceAsset, route.assetName)}`,
+            reviewCommands: [
+                ...sourceCommands,
+                route.command,
+                ...candidateReviewCommands,
+            ],
+        };
+    }
+    const missingWorkflows = missingSourceWorkflowIds(sourceAssetSummary, candidateAsset);
+    if (missingWorkflows.length > 0) {
+        const repairCommand = `${route.command} --force`;
+        return {
+            candidateId: route.candidateId,
+            sourceAsset,
+            candidateAssetName: route.assetName,
+            status: "draft_structural_drift",
+            candidateAsset,
+            currentEvidence,
+            createCommand: route.command,
+            inspectCommand,
+            governanceCommand,
+            diffCommand,
+            adoptionCommand,
+            bindCommand,
+            rolloutCommand,
+            currentCommand: repairCommand,
+            currentWrites: true,
+            reason: `The unfinished-work draft exists but drops source workflow(s): ${missingWorkflows.join(", ")}; regenerate it as a preserving draft before review. ${activeFollowupNonReplacementNote(sourceAsset, route.assetName)}`,
+            reviewCommands: [
+                ...sourceCommands,
+                repairCommand,
+                ...candidateReviewCommands,
+            ],
+        };
+    }
+    if (!isReviewableFollowupAsset(candidateAsset)) {
+        return {
+            candidateId: route.candidateId,
+            sourceAsset,
+            candidateAssetName: route.assetName,
+            status: "draft_incomplete",
+            candidateAsset,
+            currentEvidence,
+            createCommand: route.command,
+            inspectCommand,
+            governanceCommand,
+            diffCommand,
+            adoptionCommand,
+            bindCommand,
+            rolloutCommand,
+            currentCommand: inspectCommand,
+            currentWrites: false,
+            reason: `The unfinished-work draft exists, but it is missing one or more workflow, controller, cascade, or evidence signals; inspect it before adoption. ${activeFollowupNonReplacementNote(sourceAsset, route.assetName)}`,
+            reviewCommands: [
+                inspectCommand,
+                governanceCommand,
+                diffCommand,
+                rationaleCommand,
+                adoptionCommand,
+                bindCommand,
+                rolloutCommand,
+                ...sourceCommands,
+            ],
+        };
+    }
+    return {
+        candidateId: route.candidateId,
+        sourceAsset,
+        candidateAssetName: route.assetName,
+        status: "draft_reviewable",
+        candidateAsset,
+        currentEvidence,
+        createCommand: route.command,
+        inspectCommand,
+        governanceCommand,
+        diffCommand,
+        adoptionCommand,
+        bindCommand,
+        rolloutCommand,
+        currentCommand: diffCommand,
+        currentWrites: false,
+        reason: `The unfinished-work draft already exists with workflow, controller, cascade, and evidence signals; review its diff before adoption and organization binding. ${activeFollowupNonReplacementNote(sourceAsset, route.assetName)}`,
+        reviewCommands: [
+            diffCommand,
+            rationaleCommand,
+            adoptionCommand,
+            bindCommand,
+            rolloutCommand,
+            inspectCommand,
+            governanceCommand,
+            ...sourceCommands,
+        ],
+    };
+}
+function buildCandidatesForAsset(asset, index, assets) {
+    const c5Gaps = c5GapCaptures(index);
+    if (index.totals.modules === 0 && c5Gaps.length === 0)
+        return [];
+    const candidates = [];
+    const active = activeEvidenceModules(index);
+    const modules = sourceModules(index);
+    const fixed = totalFixed(index);
+    const evidenceOpen = active.length > 0;
+    const passEvidence = `${index.totals.pass}/${index.totals.modules} PASS, active=${active.length}, fixed=${fixed}, remaining=${index.totals.remaining}`;
+    const blockedScopeModules = blockedScopeTriageModules(index);
+    const crossBoundaryModules = crossBoundaryResourceModules(index);
+    if (active.length > 0) {
+        const route = activeEvidenceFollowupReviewRoute(asset.name, assets, index);
+        const action = route.currentWrites
+            ? editPlanAction({
+                instruction: "Require active dogfood evidence follow-up before baseline promotion, organization binding, rollout, or runtime sync. If progress JSON still has BLOCKED, REQUEST_CHANGES, remaining work, outside-diagnosis scope, or needs-human review, route through suggestions and blocked-scope triage before completion claims.",
+                fromTemplate: asset.name,
+                workflow: "fix",
+                operation: "tighten_boundary",
+                targetStep: "verify_report",
+                saveTemplate: route.candidateAssetName,
+                command: route.currentCommand,
+            })
+            : reviewAction(route.currentCommand, route.reason);
+        candidates.push({
+            id: route.candidateId,
+            type: "active_evidence_followup",
+            priority: "high",
+            title: "Review unfinished dogfood work as a saved draft, not a template replacement",
+            candidateAssetName: route.candidateAssetName,
+            sourceAsset: asset.name,
+            evidence: `${active.length} active module(s): ${active.slice(0, 5).map(compactEvidenceModule).join("; ")}`,
+            rationale: `Open evidence should first be saved as a reviewed unfinished-work draft or routed to next-run focus. ${activeFollowupNonReplacementNote(asset.name, route.candidateAssetName)} Extracting reusable workflows before closing active work would weaken the evidence chain.`,
+            sourceModules: active.map((module) => module.module),
+            sourceWorkflows: asset.workflows.map((workflow) => workflow.id),
+            nextCommand: route.currentCommand,
+            reviewCommands: route.reviewCommands,
+            actionPath: activeFollowupActionPath(route),
+            mutationBoundary: `Candidate backlog is read-only; active evidence can produce an explicit reviewable unfinished-work draft through dna workflow from-candidate, not automatic template or policy mutation. ${activeFollowupNonReplacementNote(asset.name, route.candidateAssetName)}`,
+            plainLanguage: activeFollowupPlainLanguage(asset.name, route.candidateAssetName),
+            continuityBoundary: activeFollowupContinuityBoundary(asset.name, route.candidateAssetName),
+            action,
+        });
+    }
+    if (c5Gaps.length > 0) {
+        const evidenceCommand = `dna assets evidence ${asset.name} --json`;
+        const suggestionsCommand = `dna workflow suggestions ${asset.name} --json`;
+        candidates.push({
+            id: `review-captured-run-facts-${asset.name}`,
+            type: "captured_run_fact_review",
+            priority: active.length > 0 ? "medium" : "high",
+            title: "Review captured local run facts before changing the workflow asset",
+            candidateAssetName: asset.name,
+            sourceAsset: asset.name,
+            evidence: c5Gaps.slice(0, 5).map(compactEvidenceCapture).join("; "),
+            rationale: "C5 hook evidence shows blocked, failed, retry, unsupported, or human-intervention facts. Mine should surface those facts for review, but the evidence must not mutate policy, templates, adoption, rollout, sync, or runtime authority automatically.",
+            sourceModules: [],
+            sourceWorkflows: sourceWorkflows(asset, c5Gaps.map((capture) => capture.workflowId)),
+            nextCommand: evidenceCommand,
+            reviewCommands: [
+                `dna assets lineage ${asset.name}`,
+                evidenceCommand,
+                suggestionsCommand,
+                `record explicit manager rationale for any C5-derived change to ${asset.name}`,
+            ],
+            actionPath: capturedRunFactsActionPath({
+                sourceAsset: asset.name,
+                evidenceCommand,
+                suggestionsCommand,
+            }),
+            mutationBoundary: "Candidate backlog is read-only; captured C5 facts create a review queue and suggestions only, not automatic template edits, policy mutation, adoption, organization binding, rollout, runtime sync, cloud upload, or runtime authority.",
+            plainLanguage: capturedRunFactPlainLanguage(asset.name),
+            action: reviewAction(evidenceCommand, "Review captured local facts before drafting any workflow change."),
+        });
+    }
+    if (index.totals.modules === 0)
+        return candidates;
+    const baselineNextCommand = evidenceOpen ? `dna assets suggestions ${asset.name}` : `dna assets adoption ${asset.name}`;
+    candidates.push(withActionPath({
+        id: `stabilize-${asset.name}`,
+        type: "stabilize_current_asset",
+        priority: evidenceOpen ? "medium" : "high",
+        title: evidenceOpen
+            ? "Prepare the current dogfood workflow for baseline promotion after active evidence closes"
+            : "Promote the proven dogfood workflow as the current governed baseline",
+        candidateAssetName: asset.name,
+        sourceAsset: asset.name,
+        evidence: passEvidence,
+        rationale: evidenceOpen
+            ? "Most dogfood modules are already green, but active evidence still blocks direct promotion. Keep the stable baseline candidate visible while routing current work through suggestions first."
+            : "The dogfood loop reached a stable green state. The first valuable asset is the proven workflow itself, adopted through review before organization rollout.",
+        sourceModules: modules,
+        sourceWorkflows: asset.workflows.map((workflow) => workflow.id),
+        nextCommand: baselineNextCommand,
+        reviewCommands: [
+            `dna assets lineage ${asset.name}`,
+            `dna assets lifecycle ${asset.name}`,
+            ...(evidenceOpen ? [`dna assets suggestions ${asset.name}`] : []),
+            `dna assets adoption ${asset.name}`,
+            `dna org bind --asset ${asset.name} --status active --sync-target codex`,
+            "dna org rollout",
+        ],
+        mutationBoundary: "Adoption review is read-only; organization binding and runtime sync remain explicit later commands.",
+        action: reviewAction(baselineNextCommand, evidenceOpen
+            ? "Active evidence blocks baseline adoption until suggestions are reviewed."
+            : "Baseline promotion is an adoption review, not a workflow draft."),
+    }));
+    const behaviorWorkflows = sourceWorkflows(asset, ["behavior-lock"]);
+    if (behaviorWorkflows.length > 0) {
+        const candidateAssetName = asset.name.startsWith("flutter-") ? "flutter-behavior-lock" : `${asset.name}-behavior-lock`;
+        const nextCommand = `dna assets adoption ${candidateAssetName}`;
+        candidates.push(withActionPath({
+            id: `extract-behavior-lock-${asset.name}`,
+            type: "extract_workflow",
+            priority: "high",
+            title: "Extract behavior locking as a reusable workflow asset",
+            candidateAssetName,
+            sourceAsset: asset.name,
+            evidence: passEvidence,
+            rationale: "Dogfood repeatedly depended on locking source behavior before repair. This deserves a smaller reusable workflow users can choose before a full rewrite.",
+            sourceModules: modules,
+            sourceWorkflows: behaviorWorkflows,
+            nextCommand,
+            reviewCommands: candidateReviewCommands({ sourceAsset: asset.name, candidateAssetName, nextCommand }),
+            mutationBoundary: "Extraction is a review path only; existing or drafted assets still need diff/adoption review before org binding.",
+            action: reviewAction(nextCommand, "This candidate already maps to an existing asset; review adoption instead of creating a duplicate draft."),
+        }));
+    }
+    const rescueWorkflows = sourceWorkflows(asset, ["behavior-lock", "diagnosis", "fix"]);
+    if (asset.name.startsWith("flutter-") && rescueWorkflows.length >= 2) {
+        const candidateAssetName = "flutter-refactoring-rescue";
+        const id = `extract-refactoring-rescue-${asset.name}`;
+        const nextCommand = `dna assets adoption ${candidateAssetName}`;
+        candidates.push(withActionPath({
+            id,
+            type: "extract_workflow",
+            priority: "high",
+            title: "Review the Flutter refactoring rescue workflow for migrated-but-broken projects",
+            candidateAssetName,
+            sourceAsset: asset.name,
+            evidence: `${passEvidence}; dogfood route used behavior-lock, diagnosis, serial fix rounds, and rescue_small_steps for migrated Flutter chains.`,
+            rationale: "Dogfood showed a different user entrypoint from a full rewrite: the project is migrated-but-broken, with framework migration already present but feature chains still failing. That route needs a small, comfortable rescue asset where users fix one chain at a time, treat v1 as the oracle, and verify each change before moving on.",
+            sourceModules: modules,
+            sourceWorkflows: rescueWorkflows,
+            nextCommand,
+            reviewCommands: [
+                `dna assets lineage ${asset.name}`,
+                `dna assets evidence ${asset.name}`,
+                `dna assets lineage ${candidateAssetName}`,
+                `dna assets inspect ${candidateAssetName} --evidence`,
+                `dna assets governance ${candidateAssetName}`,
+                nextCommand,
+                `dna org bind --asset ${candidateAssetName} --status active --sync-target codex`,
+                "dna org rollout",
+            ],
+            mutationBoundary: "Refactoring rescue already exists as a built-in asset; this path is review/adoption only and keeps the dogfood rescue route separate from generic rewrite promotion.",
+            action: reviewAction(nextCommand, "Refactoring rescue has already been extracted; review/adopt the asset instead of generating a duplicate draft."),
+        }));
+    }
+    if (crossBoundaryModules.length > 0) {
+        const candidateAssetName = "workflow-cross-boundary-resource-approval";
+        const nextCommand = `dna assets adoption ${candidateAssetName}`;
+        candidates.push(withActionPath({
+            id: `extract-cross-boundary-resource-approval-${asset.name}`,
+            type: "evidence_infrastructure",
+            priority: "high",
+            title: "Review cross-boundary resource approval for shared or localization work",
+            candidateAssetName,
+            sourceAsset: asset.name,
+            evidence: crossBoundaryModules.slice(0, 5).map((module) => `${compactEvidenceModule(module)}${module.failureReason ? ` failure=${module.failureReason}` : ""}`).join("; "),
+            rationale: "Dogfood evidence includes work that crosses the current module, diagnosis, localization, or shared-resource boundary. That should become an explicit approval route before implementation, baseline promotion, rollout, runtime sync, or completion claims.",
+            sourceModules: crossBoundaryModules.map((module) => module.module),
+            sourceWorkflows: asset.workflows.map((workflow) => workflow.id),
+            nextCommand,
+            reviewCommands: [
+                `dna assets lineage ${asset.name}`,
+                `dna assets evidence ${asset.name}`,
+                `dna assets lineage ${candidateAssetName}`,
+                `dna assets inspect ${candidateAssetName} --evidence`,
+                `dna assets governance ${candidateAssetName}`,
+                nextCommand,
+                `dna org bind --asset ${candidateAssetName} --status active --sync-target codex`,
+                "dna org rollout",
+            ],
+            mutationBoundary: "Cross-boundary resource approval already exists as a built-in asset; this path is review/adoption only and does not authorize shared, localization, config, policy, or outside-diagnosis changes without explicit approval.",
+            action: reviewAction(nextCommand, "Cross-boundary resource approval has already been extracted; review/adopt the asset instead of generating a duplicate draft."),
+        }));
+    }
+    if (blockedScopeModules.length > 0) {
+        const candidateAssetName = "workflow-blocked-scope-triage";
+        const nextCommand = `dna assets adoption ${candidateAssetName}`;
+        candidates.push(withActionPath({
+            id: `extract-blocked-scope-triage-${asset.name}`,
+            type: "evidence_infrastructure",
+            priority: "high",
+            title: "Review blocked-scope triage for needs-human or outside-diagnosis evidence",
+            candidateAssetName,
+            sourceAsset: asset.name,
+            evidence: blockedScopeModules.slice(0, 5).map((module) => `${compactEvidenceModule(module)}${module.failureReason ? ` failure=${module.failureReason}` : ""}`).join("; "),
+            rationale: "Dogfood evidence includes blocked, review-gated, needs-human, or outside-diagnosis work. That should become an explicit manager-readable triage route before baseline promotion, adoption, rollout, runtime sync, or completion claims.",
+            sourceModules: blockedScopeModules.map((module) => module.module),
+            sourceWorkflows: asset.workflows.map((workflow) => workflow.id),
+            nextCommand,
+            reviewCommands: [
+                `dna assets lineage ${asset.name}`,
+                `dna assets evidence ${asset.name}`,
+                `dna assets lineage ${candidateAssetName}`,
+                `dna assets inspect ${candidateAssetName} --evidence`,
+                `dna assets governance ${candidateAssetName}`,
+                nextCommand,
+                `dna org bind --asset ${candidateAssetName} --status active --sync-target codex`,
+                "dna org rollout",
+            ],
+            mutationBoundary: "Blocked-scope triage already exists as a built-in asset; this path is review/adoption only and does not auto-approve human, outside-diagnosis, deferred, skipped, or blocked work.",
+            action: reviewAction(nextCommand, "Blocked-scope triage has already been extracted; review/adopt the asset instead of generating a duplicate draft."),
+        }));
+    }
+    const diagnosisWorkflows = sourceWorkflows(asset, ["diagnosis"]);
+    if (diagnosisWorkflows.length > 0) {
+        const candidateAssetName = `${asset.name}-diagnosis-review`;
+        const id = `extract-diagnosis-review-${asset.name}`;
+        const nextCommand = `dna assets adoption ${candidateAssetName}`;
+        candidates.push(withActionPath({
+            id,
+            type: "extract_workflow",
+            priority: "medium",
+            title: "Review the reusable diagnosis plus reviewer gate for module-level rewrites",
+            candidateAssetName,
+            sourceAsset: asset.name,
+            evidence: passEvidence,
+            rationale: "The dogfood workflow separated diagnosis from implementation and review. That pattern has now been extracted as a reusable built-in workflow asset for risky rewrites where the model must classify before editing.",
+            sourceModules: modules,
+            sourceWorkflows: diagnosisWorkflows,
+            nextCommand,
+            reviewCommands: [
+                `dna assets lineage ${asset.name}`,
+                `dna assets evidence ${asset.name}`,
+                `dna assets lineage ${candidateAssetName}`,
+                `dna assets inspect ${candidateAssetName} --evidence`,
+                `dna assets governance ${candidateAssetName}`,
+                nextCommand,
+                `dna org bind --asset ${candidateAssetName} --status active --sync-target codex`,
+                "dna org rollout",
+            ],
+            mutationBoundary: "Diagnosis review workflow has already been extracted into a built-in asset; this path is review/adoption only and does not generate a duplicate draft.",
+            action: reviewAction(nextCommand, "Diagnosis review has already been extracted; review/adopt the asset instead of generating a duplicate draft."),
+        }));
+    }
+    const fixWorkflows = sourceWorkflows(asset, ["fix"]);
+    if (fixWorkflows.length > 0) {
+        const candidateAssetName = `${asset.name}-fix-review-loop`;
+        const id = `extract-fix-review-loop-${asset.name}`;
+        const nextCommand = `dna assets adoption ${candidateAssetName}`;
+        candidates.push(withActionPath({
+            id,
+            type: "extract_workflow",
+            priority: "medium",
+            title: "Review the reusable fix-review-verify loop as a smaller workflow asset",
+            candidateAssetName,
+            sourceAsset: asset.name,
+            evidence: passEvidence,
+            rationale: "The full rewrite asset contains a repeatable inner loop: implement from approved diagnosis, review against v1 behavior, then verify with evidence. That loop has now been extracted as a reusable built-in workflow asset for future refactors outside the full migration path.",
+            sourceModules: modules,
+            sourceWorkflows: fixWorkflows,
+            nextCommand,
+            reviewCommands: [
+                `dna assets lineage ${asset.name}`,
+                `dna assets evidence ${asset.name}`,
+                `dna assets lineage ${candidateAssetName}`,
+                `dna assets inspect ${candidateAssetName} --evidence`,
+                `dna assets governance ${candidateAssetName}`,
+                nextCommand,
+                `dna org bind --asset ${candidateAssetName} --status active --sync-target codex`,
+                "dna org rollout",
+            ],
+            mutationBoundary: "Fix-review loop workflow has already been extracted into a built-in asset; this path is review/adoption only and does not generate a duplicate draft.",
+            action: reviewAction(nextCommand, "Fix-review loop has already been extracted; review/adopt the asset instead of generating a duplicate draft."),
+        }));
+    }
+    const evidenceCandidateName = "workflow-evidence-review";
+    const evidenceCandidateId = `extract-evidence-review-${asset.name}`;
+    const nextCommand = "dna assets adoption workflow-evidence-review";
+    candidates.push(withActionPath({
+        id: evidenceCandidateId,
+        type: "evidence_infrastructure",
+        priority: "medium",
+        title: "Reuse the built-in evidence package review workflow infrastructure",
+        candidateAssetName: evidenceCandidateName,
+        sourceAsset: asset.name,
+        evidence: `${index.totals.modules} module progress JSON file(s), ${index.modules.reduce((sum, module) => sum + module.evidencePaths.length, 0)} linked evidence path(s)`,
+        rationale: "The dogfood proof is not just code changes; it is diagnosis, review verdict, test logs, and progress JSON. That evidence packaging is now the reusable workflow-evidence-review asset, so this candidate should review and adopt it rather than draft a duplicate template.",
+        sourceModules: modules,
+        sourceWorkflows: asset.workflows.map((workflow) => workflow.id),
+        nextCommand,
+        reviewCommands: [
+            `dna assets lineage ${asset.name}`,
+            `dna assets evidence ${asset.name}`,
+            "dna assets lineage workflow-evidence-review",
+            "dna assets inspect workflow-evidence-review --evidence",
+            "dna assets governance workflow-evidence-review",
+            nextCommand,
+            "dna org bind --asset workflow-evidence-review --status active --sync-target codex",
+            "dna org rollout",
+        ],
+        mutationBoundary: "Evidence workflow infrastructure already exists as a built-in asset; this path is review/adoption only and keeps Obsidian/wiki as internal memory, not runtime evidence.",
+        action: reviewAction(nextCommand, "Evidence review has already been extracted into workflow-evidence-review; review/adopt the asset instead of generating a duplicate draft."),
+    }));
+    if (index.totals.captureFacts === 0) {
+        const suggestionsCommand = `dna workflow suggestions ${asset.name} --json`;
+        const bootstrapCommands = c5CaptureBootstrapCommands(asset.name);
+        candidates.push({
+            id: `collect-local-c5-facts-${asset.name}`,
+            type: "captured_run_fact_bootstrap",
+            priority: active.length > 0 ? "low" : "medium",
+            title: "Run the workflow locally before mining C5 improvements",
+            candidateAssetName: asset.name,
+            sourceAsset: asset.name,
+            evidence: "0 local C5 capture facts found under .dna/evidence/capture for this asset.",
+            rationale: "Workflow mining needs local run facts before it can produce evidence-backed improvement candidates from real usage. This candidate keeps the empty state actionable without creating, deleting, replacing, adopting, binding, syncing, uploading, or mutating any workflow asset automatically.",
+            sourceModules: [],
+            sourceWorkflows: asset.workflows.map((workflow) => workflow.id),
+            nextCommand: suggestionsCommand,
+            reviewCommands: [
+                `dna assets lineage ${asset.name}`,
+                `dna assets evidence ${asset.name} --json`,
+                ...bootstrapCommands,
+            ],
+            actionPath: c5CaptureBootstrapActionPath(asset.name),
+            mutationBoundary: "Candidate backlog is read-only. The listed init/sync commands are explicit local follow-up actions; evidence still creates suggestions only and never edits workflow assets, mutates policy, adopts templates, binds organizations, uploads reports, or creates runtime authority.",
+            plainLanguage: c5CaptureBootstrapPlainLanguage(asset.name),
+            action: reviewAction(suggestionsCommand, "Review the empty C5 evidence path before running local init/sync to create facts."),
+        });
+    }
+    return candidates;
+}
+export async function buildWorkflowAssetCandidateBacklog(opts) {
+    const assets = await listWorkflowAssets({ projectDir: opts.projectDir });
+    const selected = opts.name
+        ? assets.filter((asset) => asset.name === opts.name || asset.displayName === opts.name || asset.namespace === opts.name)
+        : assets;
+    if (opts.name && selected.length === 0)
+        return undefined;
+    const evidenceIndexes = [];
+    for (const asset of selected) {
+        const index = await buildWorkflowAssetEvidenceIndex(asset.name, { projectDir: opts.projectDir });
+        if (index)
+            evidenceIndexes.push({ asset, index });
+    }
+    const candidates = evidenceIndexes.flatMap(({ asset, index }) => buildCandidatesForAsset(asset, index, assets));
+    const nextCommands = candidates.length > 0
+        ? candidateBacklogNextCommands(candidates)
+        : [
+            "dna assets library",
+            "dna workflow intake \"Describe the workflow you want to govern\"",
+            "dna workflow authoring-packet \"Describe the workflow you want to govern\" --json",
+            "dna workflow draft \"Describe the workflow you want to govern\" --example dev_pipeline --strictness high --save-template <asset-name> # scaffold fallback only",
+        ];
+    const summary = {
+        assetsScanned: selected.length,
+        dogfoodAssets: selected.filter((asset) => asset.status.evidencePosture === "dogfood_linked" || asset.status.managementStatus === "dogfood_ready").length,
+        evidenceModules: evidenceIndexes.reduce((sum, entry) => sum + entry.index.totals.modules, 0),
+        pass: evidenceIndexes.reduce((sum, entry) => sum + entry.index.totals.pass, 0),
+        activeModules: evidenceIndexes.reduce((sum, entry) => sum + activeEvidenceModules(entry.index).length, 0),
+        captureFacts: evidenceIndexes.reduce((sum, entry) => sum + entry.index.totals.captureFacts, 0),
+        captureGaps: evidenceIndexes.reduce((sum, entry) => sum + c5GapCaptures(entry.index).length, 0),
+        candidates: candidates.length,
+    };
+    return {
+        mode: "workflow_candidate_backlog",
+        scope: opts.name ? "asset" : "all_assets",
+        focusAsset: opts.name,
+        summary,
+        reviewPacket: buildCandidateReviewPacket({
+            focusAsset: opts.name,
+            summary,
+            candidates,
+            nextCommands,
+        }),
+        candidates,
+        nextCommands,
+        mutation: {
+            writes: false,
+            note: "Candidate backlog is read-only. It does not create templates, edit workflow assets, write org profiles, mutate evolution markers, sync runtime artifacts, or treat Obsidian/wiki as product truth.",
+        },
+    };
+}