intentdna 1.7.4 → 1.8.0

package/dist/cli/commands/guide.js

@@ -0,0 +1,1747 @@
+/**
+ * dna guide - product route navigator for workflow governance.
+ */
+import { activeEvidenceFollowupReviewRoute, buildWorkflowAssetCandidateBacklog, buildWorkflowAssetEvidenceIndex, listWorkflowAssets, } from "../../assets/index.js";
+import { readOrganizationProfile, reviewOrganization } from "../../organization/index.js";
+import { WORKFLOW_ASSET_IDS, WORKFLOW_SUGGESTION_IDS } from "../../templates/metadata.js";
+const LOCAL_REPORT_PACKAGE_PATH = ".dna/reports/latest-report-package.json";
+const LOCAL_REPORT_ENVELOPE_PATH = ".dna/reports/ingest/local-envelope.json";
+const LOCAL_REPORT_SIGN_COMMAND = `dna report sign --package ${LOCAL_REPORT_PACKAGE_PATH} --output ${LOCAL_REPORT_ENVELOPE_PATH} --json`;
+const LOCAL_REPORT_VERIFY_COMMAND = `dna report verify ${LOCAL_REPORT_ENVELOPE_PATH} --json`;
+function preferredAsset(assets, name) {
+    if (name)
+        return assets.find((asset) => asset.name === name);
+    return assets.find((asset) => asset.name === WORKFLOW_ASSET_IDS.default) ?? assets[0];
+}
+function syncTargets(review) {
+    if (!review)
+        return [];
+    return [...new Set(review.projects.flatMap((project) => project.syncTargets))];
+}
+function syncCommand(targets) {
+    return targets.some((target) => target === "codex" || target === "codex_cli") ? "dna sync --codex" : "dna sync";
+}
+function syncDryRunCommand(targets) {
+    return `${syncCommand(targets)} --dry-run`;
+}
+function commandQuote(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function routeInputs(opts) {
+    return contextualRouteInputs(opts);
+}
+function contextualRouteInputs(opts, profile) {
+    const project = profile?.projects[0];
+    return {
+        organizationName: opts.name?.trim() || profile?.organization.name || "My Org",
+        projectName: opts.project?.trim() || project?.name || "My Project",
+        workflowGoal: opts.goal?.trim() || "Rewrite module with logic equivalence",
+        syncTarget: opts.syncTarget?.trim() || project?.syncTargets[0] || "codex",
+    };
+}
+function saveTemplateName(assetName, suffix) {
+    return `${assetName}-${suffix}`;
+}
+function templateIdForAsset(assetName) {
+    return `template_${assetName.replaceAll("-", "_")}`;
+}
+function evolutionPreviewCommand(assetName, asset) {
+    return asset?.evolution.previewCommand ?? `dna evolve ${asset?.dnaId ?? templateIdForAsset(assetName)}`;
+}
+function evidenceDraftSuggestionId(evidence) {
+    if (!evidence)
+        return undefined;
+    const active = evidence.modules.filter((module) => module.verdict !== "PASS" ||
+        !module.moduleComplete ||
+        module.remainingCount > 0 ||
+        module.newRedCount > 0);
+    const modelFocused = active.some((module) => /model|behavior lock|placeholder|assert/i.test(`${module.nextRoundFocus ?? ""} ${module.failureReason ?? ""}`));
+    if (modelFocused)
+        return WORKFLOW_SUGGESTION_IDS.modelVerifier;
+    if (evidence.modules.some((module) => module.blockedCount > 0))
+        return WORKFLOW_SUGGESTION_IDS.blockedTriage;
+    return undefined;
+}
+function suggestionDraftCommand(assetName, evidence) {
+    const suggestionId = evidenceDraftSuggestionId(evidence);
+    if (!suggestionId)
+        return undefined;
+    if (suggestionId === WORKFLOW_SUGGESTION_IDS.blockedTriage)
+        return `dna assets adoption ${WORKFLOW_ASSET_IDS.blockedScopeTriage}`;
+    return `dna workflow review-suggestion --from-template ${assetName} --workflow fix --suggestion ${suggestionId} --decision accept`;
+}
+function suggestionAcceptedDraftCommand(assetName, evidence) {
+    const suggestionId = evidenceDraftSuggestionId(evidence);
+    if (!suggestionId || suggestionId === WORKFLOW_SUGGESTION_IDS.blockedTriage)
+        return undefined;
+    return `dna workflow improve-from-suggestions --from-template ${assetName} --workflow fix --suggestion ${suggestionId} --save-template ${assetName}-v2`;
+}
+function guideActiveCandidate(candidate) {
+    if (!candidate)
+        return undefined;
+    return {
+        id: candidate.id,
+        type: candidate.type,
+        priority: candidate.priority,
+        title: candidate.title,
+        candidateAssetName: candidate.candidateAssetName,
+        sourceAsset: candidate.sourceAsset,
+        evidence: candidate.evidence,
+        nextCommand: candidate.nextCommand,
+        actionKind: candidate.action.kind,
+        actionPath: candidate.actionPath,
+        mutationBoundary: candidate.mutationBoundary,
+        plainLanguage: candidate.plainLanguage,
+        continuityBoundary: candidate.continuityBoundary,
+    };
+}
+function activeCandidateCommand(candidate) {
+    if (!candidate || candidate.type !== "active_evidence_followup")
+        return undefined;
+    return candidate.nextCommand;
+}
+function activeCandidateCurrentCommand(candidate, route) {
+    if (!candidate || candidate.type !== "active_evidence_followup")
+        return undefined;
+    return route?.currentCommand ?? candidate.nextCommand;
+}
+function activeCandidateWrites(candidate, route) {
+    if (route)
+        return route.currentWrites;
+    return candidate?.actionKind !== undefined && candidate.actionKind !== "review";
+}
+function currentJourneyId(stage) {
+    if (stage === "organization_setup")
+        return "organization";
+    if (stage === "asset_configuration" || stage === "evidence_review")
+        return "asset_library";
+    if (stage === "asset_binding" || stage === "manager_review")
+        return "manager_review";
+    return "runtime_distribution";
+}
+function journeyStatus(params) {
+    if (params.id === params.current)
+        return "current";
+    if (params.id === "organization")
+        return params.hasOrganization ? "ready" : "current";
+    if (params.id === "asset_library")
+        return params.hasOrganization ? "ready" : "blocked";
+    if (params.id === "workflow_authoring")
+        return "ready";
+    if (params.id === "manager_review")
+        return params.hasOrganization ? "ready" : "blocked";
+    if (params.id === "runtime_distribution")
+        return params.readyForRuntime ? "ready" : "blocked";
+    if (params.id === "improvement_loop")
+        return params.evidenceOpen ? "current" : "later";
+    return "later";
+}
+function journeySteps(params) {
+    const project = commandQuote(params.inputs.projectName);
+    const organization = commandQuote(params.inputs.organizationName);
+    const goal = commandQuote(params.inputs.workflowGoal);
+    const current = currentJourneyId(params.recommendation.stage);
+    const hasOrganization = params.state.organization.configured;
+    const assetConfigured = params.state.asset?.configured === true;
+    const evidenceOpen = evidenceGate(params.state.evidence) === "open";
+    const readyForRuntime = params.recommendation.stage === "runtime_sync";
+    const status = (id) => journeyStatus({
+        id,
+        current,
+        hasOrganization,
+        assetConfigured,
+        evidenceOpen,
+        readyForRuntime,
+    });
+    const sync = syncCommand(params.targets.length > 0 ? params.targets : [params.inputs.syncTarget]);
+    const improvementCommand = activeCandidateCurrentCommand(params.activeCandidate, params.activeCandidateRoute)
+        ?? suggestionDraftCommand(params.assetName, params.evidence)
+        ?? `dna assets suggestions ${params.assetName}`;
+    const improvementWrites = activeCandidateCurrentCommand(params.activeCandidate, params.activeCandidateRoute) !== undefined
+        ? activeCandidateWrites(params.activeCandidate, params.activeCandidateRoute)
+        : false;
+    return [
+        {
+            id: "organization",
+            label: "Create the governed workspace",
+            command: `dna org intake ${project} --name ${organization} --asset ${params.assetName} --sync-target ${params.inputs.syncTarget}`,
+            purpose: "Represent the organization, project, workflow asset, and sync target before rollout or runtime install.",
+            owner: "manager",
+            writes: false,
+            status: status("organization"),
+            answers: "Where does this workflow asset live, who owns it, and which runtime target can receive it?",
+            next: hasOrganization ? "Review asset posture and configuration." : "Run the reviewed dna org init command from org intake.",
+        },
+        {
+            id: "asset_library",
+            label: "Choose or improve a workflow asset",
+            command: `dna assets lifecycle ${params.assetName}`,
+            purpose: "Inspect lineage, cascade, evidence, candidates, suggestions, adoption, and sync posture in one place.",
+            owner: "dna_core",
+            writes: false,
+            status: status("asset_library"),
+            answers: "Is there a reusable workflow asset, what evidence backs it, and what version should be reviewed next?",
+            next: assetConfigured ? "Move to manager review or evidence triage." : "Use dna org configure-plan before rollout or sync.",
+        },
+        {
+            id: "workflow_authoring",
+            label: "Describe or edit the workflow without a canvas",
+            command: `dna workflow route ${goal} --name ${organization} --project ${project} --sync-target ${params.inputs.syncTarget}`,
+            purpose: "Turn natural language into reuse, draft, edit-plan, diff, adoption, organization, rollout, and sync steps.",
+            owner: "user",
+            writes: false,
+            status: status("workflow_authoring"),
+            answers: "How do I create or adjust a workflow through text, examples, operations, and reviewable versions?",
+            next: `Save reviewed drafts with --save-template, then compare with dna assets diff ${params.assetName} ${params.assetName}-v2.`,
+        },
+        {
+            id: "manager_review",
+            label: "Review system status before action",
+            command: "dna org review",
+            purpose: "Show configured assets, evidence gates, sync readiness, blockers, release gate, and manager next commands.",
+            owner: "manager",
+            writes: false,
+            status: status("manager_review"),
+            answers: "Can this workflow be adopted, configured, rolled out, synced, or should evidence be handled first?",
+            next: evidenceOpen ? "Close or triage evidence before rollout." : "Use dna org rollout when manager gates are clear.",
+        },
+        {
+            id: "runtime_distribution",
+            label: "Sync only after rollout is ready",
+            command: "dna org rollout",
+            purpose: `Review target-level readiness before running ${sync}; deploy web/public surfaces only through release deploy-plan.`,
+            owner: "runtime",
+            writes: false,
+            status: status("runtime_distribution"),
+            answers: "Which targets are ready, partial, or blocked, and what sync command is allowed now?",
+            next: readyForRuntime ? `${sync}, then run runtime smoke review.` : "Resolve org rollout blockers before sync.",
+        },
+        {
+            id: "improvement_loop",
+            label: "Feed dogfood evidence back into assets",
+            command: improvementCommand,
+            purpose: "Convert repeated dogfood/runtime findings into human-reviewed workflow suggestions, drafts, diffs, and adoption paths.",
+            owner: "dna_core",
+            writes: improvementWrites,
+            status: status("improvement_loop"),
+            answers: "What should be improved from real runs without automatically mutating policy?",
+            next: "Accept a suggestion into a draft version, review diff/adoption, bind it, then rollout again.",
+        },
+    ];
+}
+function operatingPaths(params) {
+    const goal = commandQuote(params.inputs.workflowGoal);
+    const project = commandQuote(params.inputs.projectName);
+    const organization = commandQuote(params.inputs.organizationName);
+    const evidenceOpen = evidenceGate(params.state.evidence) === "open";
+    const hasOrganization = params.state.organization.configured;
+    const activeCommand = activeCandidateCurrentCommand(params.activeCandidate, params.activeCandidateRoute);
+    const currentStage = params.recommendation.stage;
+    const assetStatus = evidenceOpen || currentStage === "asset_configuration" ? "current" : "ready";
+    const managerStatus = hasOrganization ? currentStage === "asset_binding" || currentStage === "manager_review" ? "current" : "ready" : "blocked";
+    return [
+        {
+            id: "user_path",
+            label: "User path",
+            command: `dna workflow route ${goal} --name ${organization} --project ${project} --sync-target ${params.inputs.syncTarget}`,
+            purpose: "Let users describe, draft, edit, review, distribute, and improve workflows without a canvas.",
+            owner: "user",
+            writes: false,
+            status: "ready",
+            surface: "workflow_route",
+            source: "workflow_route.userPath",
+            answers: "What do I want this workflow to do, and should I reuse, draft, or edit a governed asset?",
+            handoff: `When a workflow asset is selected or drafted, continue with dna assets lifecycle ${params.assetName}.`,
+            boundary: "No canvas, dashboard write-back, Obsidian mutation, or harness-specific setup is required.",
+        },
+        {
+            id: "asset_path",
+            label: "Asset path",
+            command: `dna assets lifecycle ${params.assetName}`,
+            purpose: "Manage the workflow asset through governance, evidence, version shaping, manager review, binding, rollout, sync, and release gates.",
+            owner: "dna_core",
+            writes: false,
+            status: assetStatus,
+            surface: "asset_lifecycle",
+            source: "assets_lifecycle.assetPath",
+            answers: "What asset version is safe to review next, and which gates block rollout or sync?",
+            handoff: activeCommand
+                ? `Current dogfood evidence should continue through the reviewed follow-up route: ${activeCommand}.`
+                : "When the asset version is reviewable, continue with dna org review.",
+            boundary: "Templates carry workflow shape; shared governance gates stay in dna CLI/core/runtime.",
+        },
+        {
+            id: "manager_path",
+            label: "Manager path",
+            command: "dna org review",
+            purpose: "Let managers review system state, evidence gates, configured assets, rollout readiness, runtime sync, and release gate.",
+            owner: "manager",
+            writes: false,
+            status: managerStatus,
+            surface: "organization_review",
+            source: "org_review.managerPath",
+            answers: "Can this system roll out, sync, or release now, and what must be handled first?",
+            handoff: evidenceOpen ? `Return to ${activeCommand ?? `dna assets suggestions ${params.assetName}`} before rollout or sync.` : "Use dna org rollout before runtime sync.",
+            boundary: "Manager review is read-only; rollout, sync, and Vercel deployment remain explicit downstream actions.",
+        },
+    ];
+}
+function knowledgeLinks() {
+    return [
+        {
+            id: "product_skeleton",
+            label: "IntentDNA product skeleton",
+            path: "wiki/IntentDNA Product Skeleton.md",
+            role: "internal_memory",
+            status: "active",
+            useFor: "Recover the current project route, product objects, boundaries, operating paths, and next gaps.",
+            boundary: "Obsidian/wiki is project memory only; it does not define runtime state, policy truth, or dashboard authority.",
+        },
+        {
+            id: "product_spine_doc",
+            label: "Product spine reference",
+            path: "docs/archive/2026H1/references/intentdna-product-spine.md",
+            role: "reference",
+            status: "active",
+            useFor: "Audit the long-form product route, execution lanes, drift risks, and completion direction.",
+            boundary: "Reference docs guide implementation choices; executable behavior must still live in dna CLI/core/runtime.",
+        },
+        {
+            id: "workflow_route",
+            label: "Workflow governance route note",
+            path: "wiki/IntentDNA Workflow Governance Route.md",
+            role: "internal_memory",
+            status: "active",
+            useFor: "Recover how user_path, asset_path, and manager_path connect in project work.",
+            boundary: "Route notes explain the spine; commands and tests remain authoritative for product behavior.",
+        },
+        {
+            id: "flutter_rewrite_asset",
+            label: "Flutter rewrite workflow asset note",
+            path: "wiki/Flutter Rewrite Workflow Asset.md",
+            role: "internal_memory",
+            status: "active",
+            useFor: "Connect dogfood learning back to reusable workflow assets and template improvements.",
+            boundary: "The note summarizes dogfood; canonical evidence remains in the dogfood project and dna asset evidence index.",
+        },
+        {
+            id: "dogfood_evidence",
+            label: "Flutter rewrite dogfood evidence",
+            path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/fix-progress",
+            role: "dogfood_evidence",
+            status: "reference",
+            useFor: "Mine real run evidence for workflow candidates, blocked modules, and improvement suggestions.",
+            boundary: "Dogfood evidence informs workflow assets; OMC/Claude logs are not product architecture or governance truth.",
+        },
+    ];
+}
+function foundationSteps(params) {
+    const sync = syncCommand(params.targets.length > 0 ? params.targets : [params.inputs.syncTarget]);
+    const evidence = params.state.evidence;
+    const evidenceStatus = evidenceGate(evidence);
+    const assetConfigured = params.state.asset?.configured === true;
+    const hasOrganization = params.state.organization.configured;
+    const configuredSignal = assetConfigured ? "asset configured" : "asset not configured";
+    const evidenceSignal = evidence
+        ? `${evidence.pass}/${evidence.modules} PASS, blocked=${evidence.blocked}, remaining=${evidence.remaining}`
+        : "no evidence index";
+    const cascadeSignal = params.state.asset
+        ? `cascade=${params.state.asset.cascade}`
+        : "cascade=unknown";
+    const evolutionSignal = params.state.asset
+        ? `evolution=${params.state.asset.evolution}`
+        : "evolution=unknown";
+    return [
+        {
+            id: "workflow_assets",
+            label: "Workflow assets",
+            command: `dna assets lifecycle ${params.assetName}`,
+            purpose: "Turn useful work methods into governed assets before organization binding, rollout, or runtime sync.",
+            owner: "dna_core",
+            writes: false,
+            status: "ready",
+            signal: configuredSignal,
+            next: "Use lifecycle, lineage, candidates, diff, and adoption to manage asset versions.",
+        },
+        {
+            id: "cascade_compiler",
+            label: "Cascade compiler",
+            command: `dna assets governance ${params.assetName}`,
+            purpose: "Compile inherited layers and explain winning constraints before edits, sync, or evolution mutation.",
+            owner: "dna_core",
+            writes: false,
+            status: params.state.asset ? "ready" : "blocked",
+            signal: cascadeSignal,
+            next: "Keep cascade decisions in dna core; adapters only receive compiled runtime artifacts.",
+        },
+        {
+            id: "evolution_preview",
+            label: "Self-evolution preview",
+            command: evolutionPreviewCommand(params.assetName, params.asset),
+            purpose: "Preview outcome-derived marker changes without automatically mutating workflow policy.",
+            owner: "dna_core",
+            writes: false,
+            status: evidenceStatus === "open" ? "blocked" : "ready",
+            signal: evolutionSignal,
+            next: evidenceStatus === "open"
+                ? "Resolve or convert active dogfood evidence into a reviewed draft before marker mutation."
+                : "Review marker preview before any explicit evolve/sync mutation.",
+        },
+        {
+            id: "verification_routing",
+            label: "Verification command routing",
+            command: `dna assets adoption ${WORKFLOW_ASSET_IDS.verificationCommandRouting}`,
+            purpose: "Choose the authoritative command root, scope, and machine-readable evidence path before completion or rollout decisions.",
+            owner: "dna_core",
+            writes: false,
+            status: "ready",
+            signal: "wrong-root and weak verification are governed before evidence review",
+            next: "Use verification routing when tests/analyze/build commands could run from the wrong root, wrong package, or weak partial scope.",
+        },
+        {
+            id: "evidence_gate",
+            label: "Evidence gate",
+            command: `dna assets evidence ${params.assetName}`,
+            purpose: "Use dogfood/runtime evidence to block premature rollout, sync, or evolution mutation.",
+            owner: "dna_core",
+            writes: false,
+            status: evidenceStatus === "open" ? "open" : evidenceStatus === "clear" ? "ready" : "blocked",
+            signal: evidenceSignal,
+            next: evidenceStatus === "open"
+                ? `Run dna assets candidates ${params.assetName} or dna assets suggestions ${params.assetName}.`
+                : "Keep evidence attached to review packets and manager gates.",
+        },
+        {
+            id: "organization_rollout",
+            label: "Organization rollout",
+            command: "dna org rollout",
+            purpose: "Let managers review configured assets, active bindings, target readiness, and blockers before sync.",
+            owner: "manager",
+            writes: false,
+            status: hasOrganization ? "ready" : "blocked",
+            signal: hasOrganization ? `sync_targets=${params.state.organization.syncTargets.join(",") || "none"}` : "organization missing",
+            next: hasOrganization ? "Use rollout before runtime sync." : "Create the organization route first.",
+        },
+        {
+            id: "runtime_adapter",
+            label: "Runtime adapter",
+            command: sync,
+            purpose: "Install Codex, Claude, or future harness artifacts as thin adapter mappings from dna governance truth.",
+            owner: "runtime",
+            writes: true,
+            status: hasOrganization && assetConfigured && evidenceStatus !== "open" ? "ready" : "blocked",
+            signal: `target=${params.targets.length > 0 ? params.targets.join(",") : params.inputs.syncTarget}`,
+            next: "Do not put workflow semantics into adapters; keep allow/warn/block/evidence decisions in dna core.",
+        },
+        {
+            id: "release_gate",
+            label: "Vercel release gate",
+            command: "dna release deploy-plan",
+            purpose: "Deploy and verify public web surfaces only when changed files require a deployed URL.",
+            owner: "release",
+            writes: false,
+            status: "ready",
+            signal: "deploy only for web/public surfaces",
+            next: "Run Vercel CLI deploy and deployed URL verification only when deploy-plan opens the gate.",
+        },
+        {
+            id: "knowledge_base",
+            label: "Internal knowledge base",
+            command: "wiki/IntentDNA Product Skeleton.md",
+            purpose: "Use Obsidian/wiki for project memory and thought capture, not as product runtime or governance truth.",
+            owner: "internal_memory",
+            writes: false,
+            status: "reference",
+            signal: "Obsidian/wiki is internal memory",
+            next: "Keep product behavior in dna CLI/core/runtime and link wiki notes back to code-backed routes.",
+        },
+    ];
+}
+function localQuickstartSteps(assetName, targets, inputs) {
+    const intendedTargets = targets.length > 0 ? targets : [inputs.syncTarget];
+    const sync = syncCommand(intendedTargets);
+    const syncDryRun = syncDryRunCommand(intendedTargets);
+    const harness = intendedTargets.some((target) => target === "codex" || target === "codex_cli")
+        ? "Run the workflow in Codex using the synced project instructions and hooks"
+        : intendedTargets.some((target) => target === "claude" || target === "claude_code")
+            ? "Run the workflow in Claude Code using the synced project instructions and hooks"
+            : "Run the workflow in the selected harness using the synced project instructions and hooks";
+    return [
+        {
+            id: "choose_template",
+            label: "Choose template",
+            command: `dna templates show ${assetName}`,
+            purpose: "Inspect purpose, fit, supported harnesses, install route, and evidence posture before writing project config.",
+            owner: "user",
+            writes: false,
+            acceptance: "User can identify why this workflow asset fits the project before initialization.",
+            verification: {
+                command: `dna templates show ${assetName}`,
+                expected: "Template output shows purpose, supported harnesses, install command, and evidence posture.",
+                evidence: "Marketplace metadata is inspectable before any project files are written.",
+            },
+            boundary: "Marketplace/template metadata helps selection only; it does not approve, install, or execute the workflow.",
+        },
+        {
+            id: "init_template",
+            label: "Initialize local DNA config",
+            command: `dna init --template ${assetName}`,
+            purpose: "Create local .dna configuration from the selected workflow asset so the project has runtime input.",
+            owner: "dna_core",
+            writes: true,
+            acceptance: `.dna/configs/${assetName}.yaml exists with source template metadata.`,
+            verification: {
+                command: `test -f .dna/configs/${assetName}.yaml`,
+                expected: "Exit code 0 and local config file exists.",
+                evidence: "Project has a local DNA config derived from the selected template.",
+            },
+            boundary: "Initialization is local file setup and does not require Online, Supabase, or cloud credentials.",
+        },
+        {
+            id: "sync_dry_run",
+            label: "Preview runtime sync",
+            command: syncDryRun,
+            purpose: "Show planned harness artifacts before writing instructions, hooks, skills, plugins, or registry entries.",
+            owner: "runtime",
+            writes: false,
+            acceptance: "Dry-run output explains planned files without mutating the project.",
+            verification: {
+                command: syncDryRun,
+                expected: "Output is a dry-run plan and .dna/compiled/ir.json is not written.",
+                evidence: "User can review harness artifact changes before mutation.",
+            },
+            boundary: "Dry-run is distribution preview only; it does not run the workflow or make allow/warn/block/validate decisions.",
+        },
+        {
+            id: "sync_runtime",
+            label: "Sync runtime artifacts",
+            command: sync,
+            purpose: "Install the reviewed local DNA artifacts into the selected harness surface.",
+            owner: "runtime",
+            writes: true,
+            acceptance: "Sync completes and registry-backed status/doctor can inspect IntentDNA-owned artifacts.",
+            verification: {
+                command: "dna sync status --json",
+                expected: "schema_version=intentdna.sync_status.v1 with totals.missing=0 and totals.drifted=0.",
+                evidence: "IntentDNA-owned harness artifacts are registry-tracked and locally inspectable.",
+            },
+            boundary: "Sync installs and injects artifacts only; workflow execution remains in the harness and governance remains local.",
+        },
+        {
+            id: "run_harness",
+            label: "Run workflow in harness",
+            command: harness,
+            purpose: "Use Codex, Claude Code, or another synced harness to perform the actual AI work method.",
+            owner: "user",
+            writes: true,
+            acceptance: "Harness run produces local runtime evidence that can be packaged by dna report commands.",
+            verification: {
+                command: "dna report package --json",
+                expected: "status=written after local runtime evidence exists; empty packages stay local and honest.",
+                evidence: "Local report packaging is the evidence handoff; Online and marketplace do not execute the workflow.",
+            },
+            boundary: "Online and marketplace do not execute workflows; dna-hook/local runtime evidence remains runtime truth.",
+        },
+        {
+            id: "package_report",
+            label: "Package local evidence",
+            command: "dna report package --json",
+            purpose: "Collect local runtime evidence into a reviewable report package before signing or optional upload.",
+            owner: "dna_core",
+            writes: true,
+            acceptance: "Command returns status=written with package.schema_version=intentdna.report_package.v1 and writes .dna/reports/latest-report-package.json.",
+            verification: {
+                command: "dna report package --json",
+                expected: "mode=intentdna_report_package_result, status=written, package.schema_version=intentdna.report_package.v1.",
+                evidence: "A local report package exists without network upload or cloud authority.",
+            },
+            boundary: "Packaging reads local evidence only; it does not upload, execute workflows, or grant runtime authority.",
+        },
+        {
+            id: "sign_report",
+            label: "Sign local evidence",
+            command: LOCAL_REPORT_SIGN_COMMAND,
+            purpose: "Wrap the just-written local report package in a signed ingest envelope for local verification or optional future upload.",
+            owner: "dna_core",
+            writes: true,
+            acceptance: `Command returns intentdna.report_ingest_envelope.v1 and writes ${LOCAL_REPORT_ENVELOPE_PATH} without printing secrets.`,
+            verification: {
+                command: LOCAL_REPORT_SIGN_COMMAND,
+                expected: "schema_version=intentdna.report_ingest_envelope.v1, package_ref.path points at the latest local report package, and transport.network_performed=false.",
+                evidence: "Signed local envelope is bound to the explicit package artifact and ready for local verification or optional future upload.",
+            },
+            boundary: "Signing is local verifier evidence only; it does not create cloud trust or backend state.",
+        },
+        {
+            id: "verify_report",
+            label: "Verify signed evidence",
+            command: LOCAL_REPORT_VERIFY_COMMAND,
+            purpose: "Verify the signed envelope and package hash before treating evidence as review input.",
+            owner: "dna_core",
+            writes: false,
+            acceptance: "Receipt is intentdna.report_ingest_receipt.v1 with runtime_authority=false and trusted_cloud_ingestion=false.",
+            verification: {
+                command: LOCAL_REPORT_VERIFY_COMMAND,
+                expected: "status=verified, runtime_authority=false, trusted_cloud_ingestion=false.",
+                evidence: "Local envelope integrity is proven while cloud trust remains explicitly false.",
+            },
+            boundary: "Verification proves local envelope integrity, not cloud ingestion, org approval, or runtime policy authority.",
+        },
+        {
+            id: "sync_status",
+            label: "Inspect synced artifacts",
+            command: "dna sync status --json",
+            purpose: "List registry-tracked IntentDNA artifacts and confirm the local install remains inspectable.",
+            owner: "dna_core",
+            writes: false,
+            acceptance: "Status reports registry artifacts without modifying project files.",
+            verification: {
+                command: "dna sync status --json",
+                expected: "totals.artifacts>0 after sync, totals.missing=0, totals.drifted=0.",
+                evidence: "Local registry can explain what IntentDNA installed.",
+            },
+            boundary: "Status is local artifact projection only; it is not online readiness or workflow approval.",
+        },
+        {
+            id: "sync_doctor",
+            label: "Check sync drift",
+            command: "dna sync doctor --json",
+            purpose: "Detect missing or drifted IntentDNA-owned artifacts before rerun, cleanup, or review.",
+            owner: "dna_core",
+            writes: false,
+            acceptance: "Doctor reports missing and drifted counts for registry-backed artifacts.",
+            verification: {
+                command: "dna sync doctor --json",
+                expected: "ok=true with totals.missing=0 and totals.drifted=0 on a clean local sync.",
+                evidence: "Drift/missing checks are local and registry-backed.",
+            },
+            boundary: "Doctor checks local files only and does not overwrite user-owned configuration.",
+        },
+        {
+            id: "sync_remove_preview",
+            label: "Preview safe cleanup",
+            command: "dna sync remove --dry-run",
+            purpose: "Show which hash-matching IntentDNA-owned or diagnostic artifacts can be removed safely.",
+            owner: "dna_core",
+            writes: false,
+            acceptance: "Dry-run prints a removal plan and leaves the registry plus project files in place.",
+            verification: {
+                command: "dna sync remove --dry-run",
+                expected: "Prints a dry-run registry remove plan and leaves .dna/sync/registry.json in place.",
+                evidence: "Cleanup remains preview-first and preserves user-owned or merge-preserve files.",
+            },
+            boundary: "Removal stays conservative; user-owned and merge-preserve surfaces are skipped unless proven safe.",
+        },
+    ];
+}
+function spinePhases(assetName, targets, inputs, asset) {
+    const intendedTargets = targets.length > 0 ? targets : [inputs.syncTarget];
+    const sync = syncCommand(intendedTargets);
+    const goal = commandQuote(inputs.workflowGoal);
+    const project = commandQuote(inputs.projectName);
+    const organization = commandQuote(inputs.organizationName);
+    return [
+        {
+            id: "describe",
+            label: "Describe workflow naturally",
+            command: `dna workflow intake ${goal}`,
+            purpose: "Start from the user's working method and decide reuse versus draft before any canvas, YAML, or runtime install.",
+            owner: "user",
+            writes: false,
+        },
+        {
+            id: "lock",
+            label: "Lock behavior as evidence",
+            command: "dna assets adoption flutter-behavior-lock",
+            purpose: "Use a behavior-lock workflow to capture source behavior as docs/tests before risky rewrite or refactor work.",
+            owner: "dna_core",
+            writes: false,
+            requiredWhen: "risky_rewrite_or_refactor",
+        },
+        {
+            id: "asset",
+            label: "Choose or inspect workflow asset",
+            command: `dna assets lineage ${assetName}`,
+            purpose: "Reuse a proven asset when possible, or use lineage to understand the asset before drafting the next version.",
+            owner: "dna_core",
+            writes: false,
+        },
+        {
+            id: "cascade",
+            label: "Review cascade and governance",
+            command: `dna assets governance ${assetName}`,
+            purpose: "Check inherited layers, winning constraints, evidence posture, and preview-first evolution before editing or rollout.",
+            owner: "dna_core",
+            writes: false,
+        },
+        {
+            id: "edit",
+            label: "Edit or draft workflow asset",
+            command: `dna workflow edit-plan "Describe the reviewed workflow change" --from-template ${assetName} --save-template ${assetName}-v2`,
+            purpose: "Adjust steps, roles, boundaries, handoffs, and verifiers through a reviewable edit plan instead of drawing a canvas.",
+            owner: "dna_core",
+            writes: true,
+        },
+        {
+            id: "review",
+            label: "Review asset version",
+            command: `dna assets diff ${assetName} ${assetName}-v2`,
+            purpose: "Let a manager review workflow and governance changes before organization binding or rollout.",
+            owner: "manager",
+            writes: false,
+        },
+        {
+            id: "verify",
+            label: "Route verification command",
+            command: `dna assets adoption ${WORKFLOW_ASSET_IDS.verificationCommandRouting}`,
+            purpose: "Plan and review the authoritative command root/scope before accepting verification evidence for completion, rollout, or sync.",
+            owner: "dna_core",
+            writes: false,
+            requiredWhen: "verification_root_or_scope_is_ambiguous",
+        },
+        {
+            id: "organize",
+            label: "Bind asset to organization",
+            command: `dna org bind --asset ${assetName}-v2 --status active --sync-target ${inputs.syncTarget}`,
+            purpose: "Record the accepted asset version in the organization route before runtime distribution.",
+            owner: "manager",
+            writes: true,
+        },
+        {
+            id: "configure",
+            label: "Configure declared assets",
+            command: "dna org configure-plan",
+            purpose: "Review or apply explicit dna init commands for organization-declared assets missing project config.",
+            owner: "dna_core",
+            writes: false,
+        },
+        {
+            id: "rollout",
+            label: "Review rollout readiness",
+            command: "dna org rollout",
+            purpose: "Show ready and blocked assets by target before downstream sync or team distribution.",
+            owner: "manager",
+            writes: false,
+        },
+        {
+            id: "sync",
+            label: "Sync to runtime surface",
+            command: sync,
+            purpose: "Install generated instructions, hooks, skills, or Codex artifacts while keeping governance decisions in dna core.",
+            owner: "runtime",
+            writes: true,
+        },
+        {
+            id: "deploy",
+            label: "Deploy public surface when changed",
+            command: "dna release deploy-plan",
+            purpose: "Plan Vercel CLI deployment and deployed URL verification only when web, dashboard, blog, or public review surfaces changed.",
+            owner: "release",
+            writes: false,
+            requiredWhen: "web_public_surface_changed",
+        },
+        {
+            id: "improve",
+            label: "Feed dogfood evidence back",
+            command: `dna assets suggestions ${assetName}`,
+            purpose: "Turn repeated run evidence into human-reviewed improvement suggestions before drafting the next asset version.",
+            owner: "dna_core",
+            writes: false,
+        },
+        {
+            id: "evolve",
+            label: "Preview self-evolution",
+            command: evolutionPreviewCommand(assetName, asset),
+            purpose: "Preview marker changes from recorded outcomes; mutation remains explicit through dna sync --evolve after review.",
+            owner: "dna_core",
+            writes: false,
+            requiredWhen: "execution_outcomes_recorded",
+        },
+    ];
+}
+function routeSteps(assetName, targets, inputs, evidence, asset, activeCandidate, activeCandidateRoute) {
+    const sync = syncCommand(targets);
+    const goal = commandQuote(inputs.workflowGoal);
+    const project = commandQuote(inputs.projectName);
+    const organization = commandQuote(inputs.organizationName);
+    const draftSuggestionCommand = activeCandidateCurrentCommand(activeCandidate, activeCandidateRoute)
+        ?? suggestionDraftCommand(assetName, evidence)
+        ?? `dna assets suggestions ${assetName}`;
+    const evolveCommand = evolutionPreviewCommand(assetName, asset);
+    return [
+        {
+            id: "library",
+            label: "Browse workflow assets",
+            command: "dna assets library",
+            purpose: "Choose a proven, ready, or draft workflow asset before configuring or syncing it.",
+        },
+        {
+            id: "behavior-lock",
+            label: "Review behavior-lock asset",
+            command: "dna assets adoption flutter-behavior-lock",
+            purpose: "Promote the dogfood-proven pattern of locking behavior as evidence before risky rewrite or refactor work.",
+        },
+        {
+            id: "lineage",
+            label: "Understand asset lineage",
+            command: `dna assets lineage ${assetName}`,
+            purpose: "See the asset origin, cascade inheritance, evidence, and human-reviewed evolution route.",
+        },
+        {
+            id: "lifecycle",
+            label: "See governance lifecycle",
+            command: `dna assets lifecycle ${assetName}`,
+            purpose: "Connect cascade, dogfood evidence, suggestions, reviewed drafts, adoption, org binding, and sync in one route.",
+        },
+        {
+            id: "candidates",
+            label: "Find workflow candidates",
+            command: `dna assets candidates ${assetName}`,
+            purpose: "Turn dogfood evidence into a candidate backlog for promoting or extracting reusable workflow assets.",
+        },
+        {
+            id: "evidence-review-asset",
+            label: "Review evidence workflow asset",
+            command: "dna assets adoption workflow-evidence-review",
+            purpose: "Reuse the built-in evidence review workflow instead of drafting duplicate per-source evidence-review templates.",
+        },
+        {
+            id: "verification-routing-asset",
+            label: "Review verification routing workflow asset",
+            command: `dna assets adoption ${WORKFLOW_ASSET_IDS.verificationCommandRouting}`,
+            purpose: "Reuse the built-in verification routing workflow before treating a test/analyze/build result as authoritative evidence.",
+        },
+        {
+            id: "blocked-scope-asset",
+            label: "Review blocked-scope workflow asset",
+            command: `dna assets adoption ${WORKFLOW_ASSET_IDS.blockedScopeTriage}`,
+            purpose: "Reuse the built-in blocked, skipped, removed, infra, or deferred scope triage workflow before manager review or rollout.",
+        },
+        {
+            id: "completion-audit-asset",
+            label: "Review completion audit workflow asset",
+            command: "dna assets adoption workflow-completion-audit",
+            purpose: "Reuse the built-in completion audit workflow before claiming PASS, adoption, rollout, evolution mutation, or sync.",
+        },
+        {
+            id: "runtime-smoke-asset",
+            label: "Review runtime smoke workflow asset",
+            command: "dna assets adoption workflow-runtime-smoke-review",
+            purpose: "Reuse the built-in runtime smoke workflow after sync or rollout before wider distribution.",
+        },
+        {
+            id: "intake",
+            label: "Review workflow request",
+            command: `dna workflow intake ${goal}`,
+            purpose: "Turn a natural-language workflow request into a reuse-vs-author decision before writing templates or syncing runtime.",
+        },
+        {
+            id: "org-intake",
+            label: "Plan organization setup",
+            command: `dna org intake ${project} --name ${organization} --asset ${assetName} --sync-target ${inputs.syncTarget}`,
+            purpose: "Review the organization/project, asset binding, and sync target before writing .dna/org.yaml.",
+        },
+        {
+            id: "organization",
+            label: "Create organization/project",
+            command: `dna org init --name ${organization} --project ${project} --asset ${assetName} --sync-target ${inputs.syncTarget}`,
+            purpose: "Declare where workflow assets live and which runtime targets will receive them.",
+        },
+        {
+            id: "draft",
+            label: "Author workflow",
+            command: `dna workflow authoring-packet ${goal} --json`,
+            purpose: "Give an external agent the C3 contract for interview, YAML authoring, deterministic validation, and explicit human save.",
+            scaffoldFallback: `dna workflow draft ${goal} --example rewrite_governance --strictness high --save-template ${saveTemplateName(assetName, "draft")}`,
+        },
+        {
+            id: "edit",
+            label: "Edit workflow by operation",
+            command: `dna workflow edit-plan "Add equivalence verifier after rewrite" --from-template ${assetName} --operation add_verifier --target-step rewrite --save-template ${assetName}-v2`,
+            purpose: "Preview step insertion, verifier changes, boundary tightening, splits, or role replacement before mutation.",
+        },
+        {
+            id: "governance",
+            label: "Review asset governance",
+            command: `dna assets governance ${assetName}`,
+            purpose: "Check cascade inheritance and preview-first evolution before distributing or mutating the asset.",
+        },
+        {
+            id: "diff",
+            label: "Review version diff",
+            command: `dna assets diff ${assetName} ${assetName}-v2`,
+            purpose: "Compare workflow and governance changes before configuring the proposed asset version.",
+        },
+        {
+            id: "adoption",
+            label: "Review adoption readiness",
+            command: `dna assets adoption ${assetName}-v2`,
+            purpose: "Check workflow, controller, cascade, evolution, evidence, and project configuration readiness before adoption.",
+        },
+        {
+            id: "bind",
+            label: "Bind accepted asset version",
+            command: `dna org bind --asset ${assetName}-v2 --status active --sync-target codex`,
+            purpose: "Adopt the reviewed asset version in the organization profile before runtime sync.",
+        },
+        {
+            id: "configure",
+            label: "Configure organization assets",
+            command: "dna org configure-plan",
+            purpose: "Show explicit project configuration commands for declared assets before rollout or sync.",
+        },
+        {
+            id: "rollout",
+            label: "Review rollout readiness",
+            command: "dna org rollout",
+            purpose: "Show which organization assets are ready to sync or blocked before downstream distribution.",
+        },
+        {
+            id: "sync",
+            label: "Sync to runtime surface",
+            command: sync,
+            purpose: "Install generated instructions, hooks, skills, or Codex artifacts while keeping governance in dna core.",
+        },
+        {
+            id: "evidence",
+            label: "Check evidence",
+            command: `dna assets evidence ${assetName}`,
+            purpose: "Review dogfood/runtime evidence without treating chat history or Obsidian as product truth.",
+        },
+        {
+            id: "suggestions",
+            label: "Review improvement suggestions",
+            command: `dna assets suggestions ${assetName}`,
+            purpose: "Turn dogfood evidence into human-reviewed workflow/template improvement candidates without mutating policy.",
+        },
+        {
+            id: "improve",
+            label: "Review improvement suggestion",
+            command: draftSuggestionCommand,
+            purpose: "Record the K4 accept/reject/defer receipt before any improve-from-suggestions draft, adoption, rollout, or sync.",
+        },
+        {
+            id: "evolution-preview",
+            label: "Preview self-evolution",
+            command: evolveCommand,
+            purpose: "Review outcome-derived marker changes without persisting them; explicit mutation stays behind dna sync --evolve.",
+        },
+        {
+            id: "review",
+            label: "Manager review",
+            command: "dna org review",
+            purpose: "See declared assets, configured assets, sync targets, missing setup, and evidence totals.",
+        },
+    ];
+}
+function entrypoints(assetName, targets, inputs) {
+    const intendedTargets = targets.length > 0 ? targets : [inputs.syncTarget];
+    const sync = syncCommand(intendedTargets);
+    const goal = commandQuote(inputs.workflowGoal);
+    const project = commandQuote(inputs.projectName);
+    const organization = commandQuote(inputs.organizationName);
+    return [
+        {
+            id: "author_workflow",
+            label: "Describe or edit a workflow",
+            command: `dna workflow route ${goal} --name ${organization} --project ${project} --sync-target ${inputs.syncTarget}`,
+            purpose: "Use natural language to choose reuse versus draft, then route edits through reviewable asset versions.",
+            owner: "user",
+            writes: false,
+            when: "You know the work method but do not want a canvas or harness-specific setup.",
+            outcome: "A no-canvas authoring route with draft, edit, review, organization, rollout, sync, deploy, and improvement gates.",
+        },
+        {
+            id: "setup_organization",
+            label: "Create or update organization route",
+            command: `dna org intake ${project} --name ${organization} --asset ${assetName} --sync-target ${inputs.syncTarget}`,
+            purpose: "Plan organization/project/asset/sync-target binding before writing .dna/org.yaml.",
+            owner: "manager",
+            writes: false,
+            when: "A team or project needs a governed place to adopt workflow assets.",
+            outcome: "A reviewed organization setup command, followed by configure-plan, rollout, and review.",
+        },
+        {
+            id: "manage_assets",
+            label: "Manage workflow assets",
+            command: `dna assets lifecycle ${assetName}`,
+            purpose: "Inspect lineage, cascade, evidence, suggestions, version review, adoption, organization binding, and sync in one lifecycle.",
+            owner: "dna_core",
+            writes: false,
+            when: "You need to understand or improve an existing workflow asset.",
+            outcome: "A reviewable asset-management path instead of hidden harness logic.",
+        },
+        {
+            id: "manager_review",
+            label: "Review system status",
+            command: "dna org review",
+            purpose: "Show organization assets, configuration gaps, evidence gates, sync readiness, and manager next actions.",
+            owner: "manager",
+            writes: false,
+            when: "A manager needs to decide whether the system can roll out or needs more work.",
+            outcome: "A read-only manager summary with blockers, ready assets, and next commands.",
+        },
+        {
+            id: "runtime_distribution",
+            label: "Prepare runtime distribution",
+            command: "dna org rollout",
+            purpose: `Check target-level readiness before running ${sync}.`,
+            owner: "runtime",
+            writes: false,
+            when: "Accepted assets should be distributed to Codex, Claude, or another runtime surface.",
+            outcome: "A ready/partial/blocked rollout plan; sync only after gates pass.",
+        },
+    ];
+}
+function personaPaths(assetName, targets, inputs) {
+    const intendedTargets = targets.length > 0 ? targets : [inputs.syncTarget];
+    const sync = syncCommand(intendedTargets);
+    const syncDryRun = syncDryRunCommand(intendedTargets);
+    const goal = commandQuote(inputs.workflowGoal);
+    const project = commandQuote(inputs.projectName);
+    const organization = commandQuote(inputs.organizationName);
+    return [
+        {
+            id: "developer",
+            label: "Developer local quickstart",
+            question: "How do I run one governed workflow in my local project?",
+            firstCommands: [
+                `dna templates show ${assetName}`,
+                `dna init --template ${assetName}`,
+                syncDryRun,
+                sync,
+                "dna report package --json",
+                LOCAL_REPORT_SIGN_COMMAND,
+                LOCAL_REPORT_VERIFY_COMMAND,
+            ],
+            acceptance: "A selected workflow asset is initialized, synced into the harness, run in Codex or Claude Code, then packaged, signed, and verified locally.",
+            boundary: "Local dna/dna-hook remain runtime truth; Online, marketplace, and Supabase do not execute workflows or decide allow/warn/block/validate.",
+            blockedBy: [],
+        },
+        {
+            id: "team_lead_manager",
+            label: "Team lead or manager rollout review",
+            question: "Which workflow assets are active, stale, blocked, or ready to roll out?",
+            firstCommands: [
+                `dna org intake ${project} --name ${organization} --asset ${assetName} --sync-target ${inputs.syncTarget}`,
+                "dna org review",
+                `dna assets lifecycle ${assetName}`,
+                "dna org rollout",
+            ],
+            acceptance: "Manager can see organization scope, asset posture, evidence gaps, rollout blockers, and the next local command before any sync.",
+            boundary: "Manager review is read-only local organization evidence; it is not authenticated org-private SaaS visibility and does not install files.",
+            blockedBy: [],
+        },
+        {
+            id: "template_author",
+            label: "Template author asset lifecycle",
+            question: "How do I turn a repeated AI work method into a reusable workflow asset?",
+            firstCommands: [
+                `dna workflow intake ${goal} --json`,
+                `dna workflow route ${goal} --name ${organization} --project ${project} --sync-target ${inputs.syncTarget}`,
+                `dna workflow authoring-packet ${goal} --json`,
+                `dna workflow draft ${goal} --json # scaffold fallback only`,
+                `dna workflow edit-plan --from-template ${assetName} "Describe the reviewed workflow change" --json`,
+                `dna assets governance ${assetName} --json`,
+            ],
+            acceptance: "Author can move from work-method description through external-agent YAML authoring and dna validate to reviewable asset/version evidence without bypassing adoption, diff, or rollout gates.",
+            boundary: "Marketplace publication distributes workflow assets and install plans; it does not approve, install, execute, or replace the runtime workflow.",
+            blockedBy: [],
+        },
+        {
+            id: "security_admin",
+            label: "Security or admin authority check",
+            question: "Where are authority, secrets, audit, and cloud trust boundaries?",
+            firstCommands: [
+                "dna cloud credential-check --json",
+                "dna cloud contract-check --json",
+                "dna cloud edge-check --json",
+                "dna cloud deploy-plan --json",
+                "dna cloud smoke-plan --json",
+            ],
+            acceptance: "Admin can distinguish local verifier evidence from trusted cloud ingestion and see which live deployment inputs remain gated.",
+            boundary: "Supabase is auth, persistence, storage, transport, and audit, not governance authority; secrets stay server-side and never in browser-facing code.",
+            blockedBy: [
+                "server-only Supabase/Vercel secrets",
+                "bootstrap admin/org/project inputs",
+                "billing and retention acknowledgement",
+                "live users/orgs for RLS and receipt smoke",
+            ],
+        },
+    ];
+}
+function nextCommands(params) {
+    const commands = [params.recommendation.command];
+    const project = commandQuote(params.inputs.projectName);
+    const goal = commandQuote(params.inputs.workflowGoal);
+    const evidenceOpen = params.evidence
+        ? params.evidence.totals.continue > 0 ||
+            params.evidence.totals.requestChanges > 0 ||
+            params.evidence.totals.blocked > 0 ||
+            params.evidence.totals.remaining > 0
+        : false;
+    if (!params.hasOrganization) {
+        commands.push("dna assets library", "dna assets adoption flutter-behavior-lock", `dna assets lineage ${params.assetName}`, `dna assets lifecycle ${params.assetName}`, `dna assets candidates ${params.assetName}`, "dna assets lineage workflow-evidence-review", "dna assets adoption workflow-evidence-review", `dna assets adoption ${WORKFLOW_ASSET_IDS.verificationCommandRouting}`, `dna workflow intake ${goal}`, `dna workflow authoring-packet ${goal} --json`, `dna org intake ${project} --name ${commandQuote(params.inputs.organizationName)} --asset ${params.assetName} --sync-target ${params.inputs.syncTarget}`, `dna workflow draft ${goal} --example rewrite_governance --strictness high --save-template ${saveTemplateName(params.assetName, "draft")} # scaffold fallback only`, `dna assets governance ${params.assetName}`);
+        return [...new Set(commands)];
+    }
+    if (evidenceOpen) {
+        const suggestionReview = suggestionDraftCommand(params.assetName, params.evidence);
+        const acceptedDraft = suggestionAcceptedDraftCommand(params.assetName, params.evidence);
+        const activePathCommands = params.activeCandidateRoute?.reviewCommands
+            .filter((command) => command !== params.recommendation.command)
+            ?? params.activeCandidate?.actionPath
+                .map((step) => step.command)
+                .filter((command) => command !== params.recommendation.command)
+            ?? [];
+        commands.push(...activePathCommands, `dna assets lineage ${params.assetName}`, `dna assets governance ${params.assetName}`, `dna assets candidates ${params.assetName}`, "dna assets adoption flutter-behavior-lock", `dna assets adoption ${WORKFLOW_ASSET_IDS.verificationCommandRouting}`, `dna assets evidence ${params.assetName}`, suggestionReview ?? `dna assets suggestions ${params.assetName}`, ...(acceptedDraft ? [acceptedDraft] : []), "dna org rollout", "dna org review");
+        if (!params.assetConfigured) {
+            commands.push("dna org configure-plan");
+            return [...new Set(commands)];
+        }
+        return [...new Set(commands)];
+    }
+    if (!params.assetConfigured) {
+        commands.push("dna org configure-plan", "dna org configure-plan --apply", `dna assets lineage ${params.assetName}`, `dna assets governance ${params.assetName}`, `dna assets adoption ${params.assetName}`, "dna org rollout", "dna org review");
+        return [...new Set(commands)];
+    }
+    const suggestionReview = suggestionDraftCommand(params.assetName, params.evidence);
+    const acceptedDraft = suggestionAcceptedDraftCommand(params.assetName, params.evidence);
+    commands.push(`dna assets lineage ${params.assetName}`, `dna assets governance ${params.assetName}`, `dna assets candidates ${params.assetName}`, `dna assets evidence ${params.assetName}`, suggestionReview ?? `dna assets suggestions ${params.assetName}`, ...(acceptedDraft ? [acceptedDraft] : []), "dna org rollout", syncCommand(params.targets), "dna org review");
+    return [...new Set(commands)];
+}
+function evidenceGate(evidence) {
+    if (!evidence)
+        return "unknown";
+    return evidence.continue > 0 || evidence.blocked > 0 || evidence.remaining > 0 ? "open" : "clear";
+}
+function buildTrack(params) {
+    const checkpoints = [
+        `organization=${params.state.organization.configured ? "configured" : "missing"}`,
+        `asset=${params.state.asset?.configured ? "configured" : "not_configured"}`,
+        `evidence=${evidenceGate(params.state.evidence)}`,
+        `sync_targets=${params.state.organization.syncTargets.length > 0 ? params.state.organization.syncTargets.join(",") : "none"}`,
+    ];
+    if (params.state.evidence) {
+        checkpoints.push(`dogfood=${params.state.evidence.pass}/${params.state.evidence.modules} PASS remaining=${params.state.evidence.remaining}`);
+    }
+    return {
+        asset: params.assetName,
+        currentStage: params.recommendation.stage,
+        currentCommand: params.recommendation.command,
+        currentWrites: params.recommendation.writes,
+        evidenceGate: evidenceGate(params.state.evidence),
+        checkpoints,
+        afterCurrent: params.nextCommands.filter((command) => command !== params.recommendation.command).slice(0, 4),
+        activeCandidate: params.activeCandidate,
+        activeCandidateRoute: params.activeCandidateRoute,
+    };
+}
+function quickstartRecommendation(firstStep) {
+    return {
+        stage: "local_quickstart",
+        label: "Start the local no-cloud quickstart",
+        command: firstStep.command,
+        reason: "quickstart is intentionally scoped to the shortest local route: choose a workflow asset, initialize dna, sync the harness, run locally, then package/sign/verify local evidence.",
+        writes: firstStep.writes,
+    };
+}
+function quickstartCommands(steps) {
+    return steps.map((step) => step.command);
+}
+function buildQuickstartReview(guide, syncTarget) {
+    return {
+        schema_version: "intentdna.local_quickstart.v1",
+        mode: "local_quickstart",
+        projectDir: guide.state.projectDir,
+        asset: guide.track.asset,
+        syncTarget,
+        commandEffects: {
+            read_only_guidance: true,
+            mutation_performed: false,
+            network_performed: false,
+            online_required: false,
+            cloud_required: false,
+            runtime_authority: false,
+            initializes_project: false,
+            syncs_harness: false,
+            signs_or_uploads_evidence: false,
+        },
+        current: guide.recommendation,
+        warnings: guide.state.warnings,
+        steps: guide.localQuickstart,
+        nextCommands: guide.localQuickstart.map((step) => step.command),
+        acceptance: [
+            "Local route works without Online, Supabase, live credentials, or browser auth.",
+            "User can choose a workflow asset, initialize local dna, preview sync, sync runtime artifacts, run in the harness, then package/sign/verify evidence locally.",
+            "No secrets are printed and no online/cloud authority is introduced.",
+            "dna sync remains install/distribution only; workflow execution happens in Codex, Claude Code, or the selected harness.",
+        ],
+        verificationGates: [
+            "dna templates show <asset>",
+            "dna init --template <asset>",
+            "dna sync --dry-run or dna sync --codex --dry-run",
+            "dna sync or dna sync --codex",
+            "dna report package --json",
+            LOCAL_REPORT_SIGN_COMMAND,
+            LOCAL_REPORT_VERIFY_COMMAND,
+            "dna sync status --json",
+            "dna sync doctor --json",
+            "dna sync remove --dry-run",
+        ],
+        boundaries: [
+            "local dna and dna-hook remain runtime truth.",
+            "Online is optional projection and does not execute workflows or make allow/warn/block/validate decisions.",
+            "Marketplace/template metadata helps selection only; it does not approve, install, execute, or replace runtime workflows.",
+            "Supabase is not required for this quickstart and is not governance authority.",
+            "MCP remains hidden transport, not a product UI step.",
+        ],
+        outOfScope: [
+            "Live Supabase deployment, cloud upload, receipt smoke, account onboarding, or org-private publishing.",
+            "Adopting, binding, rolling out, replacing, or deleting workflow assets.",
+            `Reviewing unfinished dogfood follow-up drafts such as ${WORKFLOW_ASSET_IDS.rewriteActiveFollowup}.`,
+            "Vercel deployment or public web release evidence unless web/public files changed.",
+        ],
+    };
+}
+function buildBriefReview(guide) {
+    const active = guide.track.activeCandidate;
+    return {
+        schema_version: "intentdna.route_guide_brief.v1",
+        mode: "route_guide_brief",
+        projectDir: guide.state.projectDir,
+        asset: guide.track.asset,
+        current: guide.recommendation,
+        state: {
+            organization_configured: guide.state.organization.configured,
+            organization_name: guide.state.organization.name,
+            asset_configured: guide.state.asset?.configured,
+            sync_targets: guide.state.organization.syncTargets,
+            evidence: guide.state.evidence,
+            warnings: guide.state.warnings,
+        },
+        checkpoints: guide.track.checkpoints,
+        afterCurrent: guide.track.afterCurrent,
+        activeCandidate: active ? {
+            id: active.id,
+            candidateAssetName: active.candidateAssetName,
+            sourceAsset: active.sourceAsset,
+            evidence: active.evidence,
+            nextCommand: active.nextCommand,
+            plainLanguage: active.plainLanguage,
+            continuityBoundary: active.continuityBoundary,
+            mutationBoundary: active.mutationBoundary,
+        } : undefined,
+        localQuickstart: guide.localQuickstart.map((step) => ({
+            id: step.id,
+            label: step.label,
+            command: step.command,
+            writes: step.writes,
+        })),
+        nextCommands: guide.nextCommands.slice(0, 8),
+        boundaries: [
+            "dna CLI/core/runtime owns product behavior and governance decisions.",
+            "Local quickstart works without Online or Supabase credentials.",
+            "Online and marketplace do not execute workflows or make allow/warn/block/validate decisions.",
+            "Supabase is not required for local quickstart and is not governance authority.",
+            "MCP remains hidden transport, not a product UI step.",
+        ],
+    };
+}
+function assetBindingStatus(review, assetName) {
+    if (!review)
+        return "missing";
+    for (const project of review.profile.projects) {
+        const binding = project.assets.find((entry) => entry.asset === assetName);
+        if (binding)
+            return binding.status;
+    }
+    return "missing";
+}
+function buildRecommendation(params) {
+    if (!params.hasOrganization) {
+        return {
+            stage: "organization_setup",
+            label: "Create the organization/project profile first",
+            command: `dna org init --name ${commandQuote(params.inputs.organizationName)} --project ${commandQuote(params.inputs.projectName)} --asset ${params.assetName} --sync-target ${params.inputs.syncTarget}`,
+            reason: "There is no .dna/org.yaml yet, so assets and sync targets have nowhere to be governed.",
+            writes: true,
+        };
+    }
+    if (params.evidence && (params.evidence.continue > 0 || params.evidence.blocked > 0 || params.evidence.remaining > 0)) {
+        const activeCommand = activeCandidateCurrentCommand(params.activeCandidate, params.activeCandidateRoute);
+        return {
+            stage: "evidence_review",
+            label: params.activeCandidateRoute?.status === "draft_reviewable"
+                ? "Review the unfinished-work draft before adoption"
+                : params.activeCandidateRoute?.status === "draft_structural_drift"
+                    ? "Repair the unfinished-work draft before adoption"
+                    : activeCommand
+                        ? "Save or inspect unfinished dogfood work before rollout or sync"
+                        : "Review dogfood evidence before changing or syncing the asset",
+            command: activeCommand ?? `dna assets suggestions ${params.assetName}`,
+            reason: params.activeCandidateRoute
+                ? `Dogfood evidence still has continue=${params.evidence.continue}, blocked=${params.evidence.blocked}, remaining=${params.evidence.remaining}; ${params.activeCandidateRoute.reason}`
+                : activeCommand
+                    ? `Dogfood evidence still has continue=${params.evidence.continue}, blocked=${params.evidence.blocked}, remaining=${params.evidence.remaining}; save it as reviewed unfinished work first.`
+                    : `Dogfood evidence still has continue=${params.evidence.continue}, blocked=${params.evidence.blocked}, remaining=${params.evidence.remaining}.`,
+            writes: activeCommand ? activeCandidateWrites(params.activeCandidate, params.activeCandidateRoute) : false,
+        };
+    }
+    if (!params.assetConfigured) {
+        return {
+            stage: "asset_configuration",
+            label: "Review organization configuration plan",
+            command: "dna org configure-plan",
+            reason: "The organization exists, but at least one declared asset has not been materialized into this project yet.",
+            writes: false,
+        };
+    }
+    if (params.bindingStatus !== "active" || params.targets.length === 0) {
+        return {
+            stage: "asset_binding",
+            label: "Bind the accepted asset version before sync",
+            command: `dna org bind --asset ${params.assetName} --status active --sync-target ${params.inputs.syncTarget}`,
+            reason: params.bindingStatus === "missing"
+                ? "The project has a configured asset, but the organization profile has not adopted it."
+                : "The organization binding is not active or has no sync target yet.",
+            writes: true,
+        };
+    }
+    if (params.targets.length > 0) {
+        return {
+            stage: "runtime_sync",
+            label: "Sync the reviewed asset to the runtime surface",
+            command: syncCommand(params.targets),
+            reason: "Organization, asset configuration, active binding, and sync target are present.",
+            writes: true,
+        };
+    }
+    return {
+        stage: "manager_review",
+        label: "Review organization status",
+        command: "dna org review",
+        reason: "No higher-priority setup, evidence, or sync action was detected.",
+        writes: false,
+    };
+}
+async function buildGuide(opts) {
+    const projectDir = opts.projectDir ?? process.cwd();
+    const [profile, assets] = await Promise.all([
+        readOrganizationProfile({ projectDir }),
+        listWorkflowAssets({ projectDir }),
+    ]);
+    const inputs = contextualRouteInputs(opts, profile.profile);
+    const review = profile.profile ? await reviewOrganization({ projectDir }) : undefined;
+    const selected = preferredAsset(assets, opts.asset);
+    const assetName = selected?.name ?? opts.asset ?? WORKFLOW_ASSET_IDS.default;
+    const targets = syncTargets(review);
+    const [evidence, candidateBacklog] = selected
+        ? await Promise.all([
+            buildWorkflowAssetEvidenceIndex(selected.name, { projectDir }),
+            buildWorkflowAssetCandidateBacklog({ name: selected.name, projectDir }),
+        ])
+        : [undefined, undefined];
+    const activeCandidate = guideActiveCandidate(candidateBacklog?.candidates.find((candidate) => candidate.type === "active_evidence_followup")
+        ?? candidateBacklog?.candidates[0]);
+    const activeCandidateRoute = activeCandidate?.type === "active_evidence_followup"
+        ? activeEvidenceFollowupReviewRoute(activeCandidate.sourceAsset, assets, evidence)
+        : undefined;
+    const evidenceSummary = evidence ? {
+        modules: evidence.totals.modules,
+        pass: evidence.totals.pass,
+        continue: evidence.totals.continue,
+        blocked: evidence.totals.blocked,
+        remaining: evidence.totals.remaining,
+        source: evidence.sourceDescription,
+    } : undefined;
+    const localQuickstartTargets = opts.quickstart ? [inputs.syncTarget] : targets;
+    const localQuickstart = localQuickstartSteps(assetName, localQuickstartTargets, inputs);
+    const routeRecommendation = buildRecommendation({
+        hasOrganization: profile.profile !== undefined,
+        assetName,
+        assetConfigured: selected?.status.configured ?? false,
+        targets,
+        bindingStatus: assetBindingStatus(review, assetName),
+        evidence: evidenceSummary,
+        inputs,
+        activeCandidate,
+        activeCandidateRoute,
+    });
+    const recommendation = opts.quickstart
+        ? quickstartRecommendation(localQuickstart[0])
+        : routeRecommendation;
+    const warnings = [];
+    if (opts.asset && !selected)
+        warnings.push(`Requested asset is not in the catalog: ${opts.asset}`);
+    if (!profile.profile)
+        warnings.push("No organization profile yet; start with dna org init.");
+    if (selected && !selected.status.configured)
+        warnings.push(`Asset ${selected.name} is available but not configured in this project.`);
+    const state = {
+        projectDir,
+        organization: {
+            profilePath: profile.path,
+            configured: profile.profile !== undefined,
+            name: profile.profile?.organization.name,
+            projects: review?.totals.projects ?? 0,
+            syncTargets: targets,
+        },
+        asset: selected ? {
+            name: selected.name,
+            displayName: selected.displayName,
+            configured: selected.status.configured,
+            cascade: selected.status.cascadePosture,
+            evolution: selected.status.evolutionPosture,
+            evidence: selected.status.evidencePosture,
+        } : undefined,
+        evidence: evidenceSummary,
+        warnings,
+    };
+    const route = routeSteps(assetName, targets, inputs, evidence, selected, activeCandidate, activeCandidateRoute);
+    const commands = opts.quickstart
+        ? quickstartCommands(localQuickstart)
+        : nextCommands({
+            hasOrganization: profile.profile !== undefined,
+            assetName,
+            assetConfigured: selected?.status.configured ?? false,
+            targets,
+            recommendation,
+            inputs,
+            evidence,
+            activeCandidate,
+            activeCandidateRoute,
+        });
+    return {
+        mode: "route_guide",
+        state,
+        recommendation,
+        track: buildTrack({
+            assetName,
+            state,
+            recommendation,
+            nextCommands: commands,
+            activeCandidate,
+            activeCandidateRoute,
+        }),
+        boundaries: [
+            "dna CLI/core/runtime owns product behavior and governance decisions.",
+            "Claude Code, Codex, and future harnesses are runtime surfaces and adapters.",
+            "Dashboard is read-only projection, not a workflow builder or policy source.",
+            "Obsidian/wiki is internal project memory and route recovery, not product runtime.",
+            "Web/public surface changes require Vercel CLI deployment and deployed URL verification.",
+        ],
+        journey: journeySteps({
+            assetName,
+            targets,
+            inputs,
+            state,
+            recommendation,
+            evidence,
+            activeCandidate,
+            activeCandidateRoute,
+        }),
+        operatingPaths: operatingPaths({
+            assetName,
+            inputs,
+            state,
+            recommendation,
+            activeCandidate,
+            activeCandidateRoute,
+        }),
+        knowledgeLinks: knowledgeLinks(),
+        foundation: foundationSteps({
+            assetName,
+            targets,
+            inputs,
+            state,
+            asset: selected,
+        }),
+        localQuickstart,
+        entrypoints: entrypoints(assetName, targets, inputs),
+        personaPaths: personaPaths(assetName, targets, inputs),
+        spine: spinePhases(assetName, targets, inputs, selected),
+        route,
+        nextCommands: commands,
+    };
+}
+function quickstartSyncTarget(guide, opts) {
+    return opts.syncTarget?.trim() || guide.state.organization.syncTargets[0] || "codex";
+}
+function writeBriefGuide(guide) {
+    process.stderr.write("IntentDNA current track\n");
+    process.stderr.write(`Project: ${guide.state.projectDir}\n`);
+    process.stderr.write(`Focus asset: ${guide.track.asset}\n`);
+    process.stderr.write(`Current stage: ${guide.track.currentStage}\n`);
+    process.stderr.write(`Current command: ${guide.track.currentCommand}\n`);
+    process.stderr.write(`Why: ${guide.recommendation.reason}\n`);
+    process.stderr.write(`Writes: ${guide.track.currentWrites ? "yes" : "no"}\n`);
+    process.stderr.write(`Spine: ${guide.spine.map((step) => step.id).join(" -> ")}\n`);
+    if (guide.state.evidence) {
+        process.stderr.write(`Dogfood: ${guide.state.evidence.pass}/${guide.state.evidence.modules} PASS, continue=${guide.state.evidence.continue}, blocked=${guide.state.evidence.blocked}, remaining=${guide.state.evidence.remaining}\n`);
+    }
+    process.stderr.write("\nCheckpoints:\n");
+    for (const checkpoint of guide.track.checkpoints)
+        process.stderr.write(`  - ${checkpoint}\n`);
+    process.stderr.write("\nDo now:\n");
+    process.stderr.write(`  - ${guide.track.currentCommand}\n`);
+    process.stderr.write("\nPersona onboarding:\n");
+    for (const path of guide.personaPaths) {
+        process.stderr.write(`  - ${path.id}: ${path.label}\n`);
+        process.stderr.write(`    asks: ${path.question}\n`);
+        process.stderr.write(`    first: ${path.firstCommands[0]}\n`);
+        process.stderr.write(`    accept: ${path.acceptance}\n`);
+        process.stderr.write(`    boundary: ${path.boundary}\n`);
+        if (path.blockedBy.length > 0)
+            process.stderr.write(`    blocked_by: ${path.blockedBy.join("; ")}\n`);
+    }
+    if (guide.track.afterCurrent.length > 0) {
+        process.stderr.write("\nAfter that:\n");
+        for (const command of guide.track.afterCurrent)
+            process.stderr.write(`  - ${command}\n`);
+    }
+    process.stderr.write("\nLocal quickstart:\n");
+    for (const step of guide.localQuickstart) {
+        process.stderr.write(`  - ${step.id}: ${step.command}\n`);
+        process.stderr.write(`    writes: ${step.writes ? "yes" : "no"}\n`);
+        process.stderr.write(`    accept: ${step.acceptance}\n`);
+        process.stderr.write(`    verify: ${step.verification.command}\n`);
+        process.stderr.write(`    expect: ${step.verification.expected}\n`);
+        process.stderr.write(`    boundary: ${step.boundary}\n`);
+    }
+    if (guide.track.activeCandidate) {
+        const candidate = guide.track.activeCandidate;
+        process.stderr.write("\nActive candidate:\n");
+        process.stderr.write(`  - ${candidate.id}: ${candidate.candidateAssetName}\n`);
+        process.stderr.write("    kind: saved unfinished-work draft; source asset is preserved\n");
+        process.stderr.write(`    evidence: ${candidate.evidence}\n`);
+        process.stderr.write(`    next: ${candidate.nextCommand}\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`);
+            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(`    boundary: ${candidate.mutationBoundary}\n`);
+        if (candidate.continuityBoundary)
+            process.stderr.write(`    continuity: ${candidate.continuityBoundary}\n`);
+    }
+    process.stderr.write("\nBoundaries:\n");
+    process.stderr.write("  - dna owns governance behavior; harnesses are runtime surfaces.\n");
+    process.stderr.write("  - Local quickstart works without Online or Supabase credentials.\n");
+    process.stderr.write("  - Obsidian/wiki is internal project memory, not product runtime.\n");
+    process.stderr.write("  - Dashboard stays read-only projection.\n");
+    process.stderr.write("  - Vercel runs only when dna release deploy-plan opens the deploy gate.\n");
+}
+function writeQuickstart(review) {
+    process.stderr.write("IntentDNA local quickstart\n");
+    process.stderr.write(`Project: ${review.projectDir}\n`);
+    process.stderr.write(`Asset: ${review.asset}\n`);
+    process.stderr.write(`Sync target: ${review.syncTarget}\n`);
+    process.stderr.write("Command effects: read-only guidance, no files written, no network, no runtime authority\n");
+    process.stderr.write(`Current command: ${review.current.command}\n`);
+    process.stderr.write(`Why: ${review.current.reason}\n`);
+    process.stderr.write(`Writes: ${review.current.writes ? "yes" : "no"}\n`);
+    if (review.warnings.length > 0) {
+        process.stderr.write("\nWarnings:\n");
+        for (const warning of review.warnings)
+            process.stderr.write(`  - ${warning}\n`);
+    }
+    process.stderr.write("\nSteps:\n");
+    for (const step of review.steps) {
+        process.stderr.write(`  ${step.id}. ${step.label}\n`);
+        process.stderr.write(`     ${step.command}\n`);
+        process.stderr.write(`     owner=${step.owner} writes=${step.writes ? "yes" : "no"}\n`);
+        process.stderr.write(`     accept: ${step.acceptance}\n`);
+        process.stderr.write(`     verify: ${step.verification.command}\n`);
+        process.stderr.write(`     expect: ${step.verification.expected}\n`);
+        process.stderr.write(`     boundary: ${step.boundary}\n`);
+    }
+    process.stderr.write("\nAcceptance:\n");
+    for (const item of review.acceptance)
+        process.stderr.write(`  - ${item}\n`);
+    process.stderr.write("\nBoundaries:\n");
+    for (const boundary of review.boundaries)
+        process.stderr.write(`  - ${boundary}\n`);
+    process.stderr.write("\nOut of scope:\n");
+    for (const item of review.outOfScope)
+        process.stderr.write(`  - ${item}\n`);
+}
+function writeActiveCandidate(candidate) {
+    if (!candidate)
+        return;
+    process.stderr.write("\nActive candidate:\n");
+    process.stderr.write(`  id: ${candidate.id}\n`);
+    process.stderr.write(`  type: ${candidate.type}\n`);
+    process.stderr.write(`  priority: ${candidate.priority}\n`);
+    process.stderr.write(`  saved draft: ${candidate.candidateAssetName} (unfinished work; source asset is preserved)\n`);
+    process.stderr.write(`  evidence: ${candidate.evidence}\n`);
+    process.stderr.write(`  next: ${candidate.nextCommand}\n`);
+    process.stderr.write(`  action: ${candidate.actionKind}\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`);
+        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(`  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`);
+    }
+}
+function writeGuide(guide) {
+    process.stderr.write("IntentDNA route guide\n");
+    process.stderr.write(`Project: ${guide.state.projectDir}\n`);
+    process.stderr.write(`Organization profile: ${guide.state.organization.configured ? "configured" : "missing"} (${guide.state.organization.profilePath})\n`);
+    if (guide.state.organization.name)
+        process.stderr.write(`Organization: ${guide.state.organization.name}\n`);
+    process.stderr.write(`Sync targets: ${guide.state.organization.syncTargets.length > 0 ? guide.state.organization.syncTargets.join(", ") : "none"}\n`);
+    if (guide.state.asset) {
+        const label = guide.state.asset.displayName ? `${guide.state.asset.name} (${guide.state.asset.displayName})` : guide.state.asset.name;
+        process.stderr.write(`Focus asset: ${label}\n`);
+        process.stderr.write(`Asset configured: ${guide.state.asset.configured ? "yes" : "no"}\n`);
+        process.stderr.write(`Cascade: ${guide.state.asset.cascade}\n`);
+        process.stderr.write(`Evolution: ${guide.state.asset.evolution}\n`);
+        process.stderr.write(`Evidence: ${guide.state.asset.evidence}\n`);
+    }
+    else {
+        process.stderr.write("Focus asset: unavailable\n");
+    }
+    if (guide.state.evidence) {
+        process.stderr.write(`Evidence modules: ${guide.state.evidence.modules} pass=${guide.state.evidence.pass} continue=${guide.state.evidence.continue} blocked=${guide.state.evidence.blocked} remaining=${guide.state.evidence.remaining}\n`);
+    }
+    process.stderr.write("\nStart here:\n");
+    for (const entry of guide.entrypoints) {
+        process.stderr.write(`  ${entry.id}. ${entry.label}\n`);
+        process.stderr.write(`     ${entry.command}\n`);
+        process.stderr.write(`     when: ${entry.when}\n`);
+        process.stderr.write(`     outcome: ${entry.outcome}\n`);
+        process.stderr.write(`     owner=${entry.owner} writes=${entry.writes ? "yes" : "no"}\n`);
+    }
+    process.stderr.write("\nPersona onboarding:\n");
+    for (const path of guide.personaPaths) {
+        process.stderr.write(`  ${path.id}. ${path.label}\n`);
+        process.stderr.write(`     asks: ${path.question}\n`);
+        process.stderr.write("     first commands:\n");
+        for (const command of path.firstCommands)
+            process.stderr.write(`       - ${command}\n`);
+        process.stderr.write(`     accept: ${path.acceptance}\n`);
+        process.stderr.write(`     boundary: ${path.boundary}\n`);
+        if (path.blockedBy.length > 0)
+            process.stderr.write(`     blocked_by: ${path.blockedBy.join("; ")}\n`);
+    }
+    process.stderr.write("\nSimple path:\n");
+    for (const step of guide.journey) {
+        process.stderr.write(`  ${step.id}. ${step.label}\n`);
+        process.stderr.write(`     status=${step.status} owner=${step.owner} writes=${step.writes ? "yes" : "no"}\n`);
+        process.stderr.write(`     ${step.command}\n`);
+        process.stderr.write(`     answers: ${step.answers}\n`);
+        process.stderr.write(`     next: ${step.next}\n`);
+    }
+    process.stderr.write("\nOperating paths:\n");
+    for (const path of guide.operatingPaths) {
+        process.stderr.write(`  ${path.id}. ${path.label}\n`);
+        process.stderr.write(`     status=${path.status} owner=${path.owner} writes=${path.writes ? "yes" : "no"} source=${path.source}\n`);
+        process.stderr.write(`     ${path.command}\n`);
+        process.stderr.write(`     answers: ${path.answers}\n`);
+        process.stderr.write(`     handoff: ${path.handoff}\n`);
+        process.stderr.write(`     boundary: ${path.boundary}\n`);
+    }
+    process.stderr.write("\nKnowledge links:\n");
+    for (const link of guide.knowledgeLinks) {
+        process.stderr.write(`  ${link.id}. ${link.label}\n`);
+        process.stderr.write(`     role=${link.role} status=${link.status}\n`);
+        process.stderr.write(`     ${link.path}\n`);
+        process.stderr.write(`     use: ${link.useFor}\n`);
+        process.stderr.write(`     boundary: ${link.boundary}\n`);
+    }
+    writeActiveCandidate(guide.track.activeCandidate);
+    process.stderr.write("\nGovernance foundation:\n");
+    for (const step of guide.foundation) {
+        process.stderr.write(`  ${step.id}. ${step.label}\n`);
+        process.stderr.write(`     status=${step.status} owner=${step.owner} writes=${step.writes ? "yes" : "no"}\n`);
+        process.stderr.write(`     ${step.command}\n`);
+        process.stderr.write(`     signal: ${step.signal}\n`);
+        process.stderr.write(`     next: ${step.next}\n`);
+    }
+    process.stderr.write("\nLocal quickstart:\n");
+    for (const step of guide.localQuickstart) {
+        process.stderr.write(`  ${step.id}. ${step.label}\n`);
+        process.stderr.write(`     owner=${step.owner} writes=${step.writes ? "yes" : "no"}\n`);
+        process.stderr.write(`     ${step.command}\n`);
+        process.stderr.write(`     accept: ${step.acceptance}\n`);
+        process.stderr.write(`     verify: ${step.verification.command}\n`);
+        process.stderr.write(`     expect: ${step.verification.expected}\n`);
+        process.stderr.write(`     evidence: ${step.verification.evidence}\n`);
+        process.stderr.write(`     boundary: ${step.boundary}\n`);
+    }
+    process.stderr.write("\nRecommended next step:\n");
+    process.stderr.write(`  Stage: ${guide.recommendation.stage}\n`);
+    process.stderr.write(`  Action: ${guide.recommendation.label}\n`);
+    process.stderr.write(`  Command: ${guide.recommendation.command}\n`);
+    process.stderr.write(`  Reason: ${guide.recommendation.reason}\n`);
+    process.stderr.write(`  Writes: ${guide.recommendation.writes ? "yes" : "no"}\n`);
+    if (guide.state.warnings.length > 0) {
+        process.stderr.write("\nWarnings:\n");
+        for (const warning of guide.state.warnings)
+            process.stderr.write(`  - ${warning}\n`);
+    }
+    process.stderr.write("\nBoundaries:\n");
+    for (const boundary of guide.boundaries)
+        process.stderr.write(`  - ${boundary}\n`);
+    process.stderr.write("\nProduct spine:\n");
+    for (const phase of guide.spine) {
+        const requiredWhen = phase.requiredWhen ? ` required_when=${phase.requiredWhen}` : "";
+        process.stderr.write(`  ${phase.id}. ${phase.label}\n`);
+        process.stderr.write(`     ${phase.command}\n`);
+        process.stderr.write(`     ${phase.purpose}\n`);
+        process.stderr.write(`     owner=${phase.owner} writes=${phase.writes ? "yes" : "no"}${requiredWhen}\n`);
+    }
+    process.stderr.write("\nRoute:\n");
+    for (const step of guide.route) {
+        process.stderr.write(`  ${step.id}. ${step.label}\n`);
+        process.stderr.write(`     ${step.command}\n`);
+        if (step.scaffoldFallback)
+            process.stderr.write(`     scaffold fallback: ${step.scaffoldFallback}\n`);
+        process.stderr.write(`     ${step.purpose}\n`);
+    }
+    process.stderr.write("\nNext commands:\n");
+    for (const command of guide.nextCommands)
+        process.stderr.write(`  - ${command}\n`);
+}
+export async function runGuide(opts) {
+    const guide = await buildGuide(opts);
+    if (opts.quickstart) {
+        const quickstart = buildQuickstartReview(guide, quickstartSyncTarget(guide, opts));
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(quickstart, null, 2) + "\n");
+            return 0;
+        }
+        writeQuickstart(quickstart);
+        return 0;
+    }
+    if (opts.json) {
+        process.stdout.write(JSON.stringify(opts.brief ? buildBriefReview(guide) : guide, null, 2) + "\n");
+        return 0;
+    }
+    if (opts.brief) {
+        writeBriefGuide(guide);
+        return 0;
+    }
+    writeGuide(guide);
+    return 0;
+}