intentdna 1.7.4 → 1.8.0

package/dist/assets/evidence.js

@@ -0,0 +1,391 @@
+import { readFile, readdir } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { findWorkflowAsset } from "./catalog.js";
+import { getWorkflowAssetMetadata } from "./metadata.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function verdictValue(value) {
+    if (value === "PASS" || value === "CONTINUE" || value === "REQUEST_CHANGES" || value === "BLOCKED")
+        return value;
+    return "UNKNOWN";
+}
+function arrayOfStrings(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function arrayOfRecords(value) {
+    return Array.isArray(value) ? value.filter((entry) => isRecord(entry)) : [];
+}
+function captureFactValue(value) {
+    if (value === "command" || value === "result" || value === "retry" || value === "manual_intervention" || value === "blocker" || value === "handoff")
+        return value;
+    return undefined;
+}
+function captureResultValue(value) {
+    if (value === "success" || value === "failure" || value === "blocked" || value === "skipped" || value === "unknown" || value === "unsupported")
+        return value;
+    return undefined;
+}
+async function readJson(path) {
+    try {
+        return JSON.parse(await readFile(path, "utf-8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function moduleFromFilename(file) {
+    return file.replace(/\.json$/, "");
+}
+function isCanonicalModuleProgressFile(file, record) {
+    const module = stringValue(record.module);
+    return module !== undefined && moduleFromFilename(file) === module;
+}
+function progressMarkdownPath(progressDir, module) {
+    return join(progressDir, `${module}.md`);
+}
+async function pathExists(path) {
+    try {
+        await readFile(path, "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function moduleFromRecord(record, file, progressDir) {
+    const module = stringValue(record.module) ?? moduleFromFilename(file);
+    const markdownPath = progressMarkdownPath(progressDir, module);
+    return {
+        module,
+        verdict: verdictValue(record.verdict),
+        review: stringValue(record.review),
+        moduleComplete: record.module_complete === true,
+        round: typeof record.round === "number" ? record.round : undefined,
+        runId: stringValue(record.run_id),
+        gitHead: stringValue(record.git_head),
+        lastFixCommit: stringValue(record.last_fix_commit),
+        fixedCount: numberValue(record.fixed_count),
+        newRedCount: numberValue(record.new_red_count),
+        blockedCount: numberValue(record.blocked_count),
+        remainingCount: numberValue(record.remaining_count),
+        remainingUnimplementedSkippedCount: numberValue(record.remaining_unimplemented_skipped_count),
+        updatedAt: stringValue(record.updated_at),
+        progressJsonPath: join(progressDir, file),
+        progressMarkdownPath: markdownPath,
+        evidencePaths: arrayOfStrings(record.evidence_paths),
+        failureReason: stringValue(record.failure_reason),
+        nextRoundFocus: stringValue(record.next_round_focus),
+    };
+}
+function evidenceTotals(modules, runtimeArtifacts = [], captureFacts = []) {
+    return {
+        modules: modules.length,
+        pass: modules.filter((module) => module.verdict === "PASS").length,
+        continue: modules.filter((module) => module.verdict === "CONTINUE").length,
+        requestChanges: modules.filter((module) => module.verdict === "REQUEST_CHANGES").length,
+        blocked: modules.filter((module) => module.verdict === "BLOCKED").length,
+        unknown: modules.filter((module) => module.verdict === "UNKNOWN").length,
+        complete: modules.filter((module) => module.moduleComplete).length,
+        remaining: modules.reduce((sum, module) => sum + module.remainingCount, 0),
+        remainingUnimplementedSkipped: modules.reduce((sum, module) => sum + module.remainingUnimplementedSkippedCount, 0),
+        newRed: modules.reduce((sum, module) => sum + module.newRedCount, 0),
+        runtimeArtifacts: runtimeArtifacts.length,
+        agentPrompts: runtimeArtifacts.filter((artifact) => artifact.kind === "agent_prompt").length,
+        skillEntrypoints: runtimeArtifacts.filter((artifact) => artifact.kind === "skill_entrypoint").length,
+        captureFacts: captureFacts.length,
+        captureBlocked: captureFacts.filter((fact) => fact.fact === "blocker" || fact.result === "blocked").length,
+        captureFailures: captureFacts.filter((fact) => fact.result === "failure").length,
+        captureManualInterventions: captureFacts.filter((fact) => fact.fact === "manual_intervention").length,
+        captureRetries: captureFacts.filter((fact) => fact.fact === "retry").length,
+    };
+}
+function sortModules(modules) {
+    const verdictRank = {
+        BLOCKED: 0,
+        REQUEST_CHANGES: 1,
+        CONTINUE: 2,
+        UNKNOWN: 3,
+        PASS: 4,
+    };
+    return [...modules].sort((a, b) => {
+        const verdict = verdictRank[a.verdict] - verdictRank[b.verdict];
+        if (verdict !== 0)
+            return verdict;
+        if (b.remainingCount !== a.remainingCount)
+            return b.remainingCount - a.remainingCount;
+        return a.module.localeCompare(b.module);
+    });
+}
+function frontmatterValue(raw, key) {
+    const match = raw.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+    if (!match)
+        return undefined;
+    return match[1]?.trim().replace(/^["']|["']$/g, "");
+}
+async function readOptional(path) {
+    try {
+        return await readFile(path, "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+}
+async function listClaudeAgentArtifacts(projectPath, warnings) {
+    const agentsDir = join(projectPath, ".claude", "agents");
+    let files = [];
+    try {
+        files = await readdir(agentsDir);
+    }
+    catch {
+        warnings.push(`Claude Code agents directory is not readable: ${agentsDir}`);
+        return [];
+    }
+    const artifacts = [];
+    for (const file of files.filter((entry) => entry.endsWith(".md")).sort()) {
+        const path = join(agentsDir, file);
+        const raw = await readOptional(path);
+        artifacts.push({
+            target: "claude_code",
+            kind: "agent_prompt",
+            name: frontmatterValue(raw ?? "", "name") ?? file.replace(/\.md$/, ""),
+            path,
+            managed: raw?.includes("intentdna:managed") === true,
+            description: frontmatterValue(raw ?? "", "description"),
+        });
+    }
+    return artifacts;
+}
+async function listClaudeSkillArtifacts(projectPath, warnings) {
+    const skillsDir = join(projectPath, ".claude", "skills");
+    const skillMapPath = join(skillsDir, ".intentdna-skill-map.json");
+    const artifacts = [];
+    const rawMap = await readOptional(skillMapPath);
+    if (rawMap) {
+        let parsed;
+        try {
+            parsed = JSON.parse(rawMap);
+        }
+        catch {
+            warnings.push(`Claude Code skill map is not valid JSON: ${skillMapPath}`);
+            parsed = undefined;
+        }
+        artifacts.push({
+            target: "claude_code",
+            kind: "skill_map",
+            name: ".intentdna-skill-map",
+            path: skillMapPath,
+            managed: true,
+        });
+        const skills = isRecord(parsed) ? arrayOfRecords(parsed.skills) : [];
+        for (const skill of skills) {
+            const name = stringValue(skill.name) ?? stringValue(skill.dirName);
+            const dirName = stringValue(skill.dirName) ?? name;
+            if (!name || !dirName)
+                continue;
+            const skillPath = join(skillsDir, dirName, "SKILL.md");
+            const rawSkill = await readOptional(skillPath);
+            artifacts.push({
+                target: "claude_code",
+                kind: "skill_entrypoint",
+                name,
+                path: skillPath,
+                managed: rawSkill?.includes("intentdna:managed") === true,
+                source: stringValue(skill.source),
+                roles: arrayOfStrings(skill.roles),
+                consumes: arrayOfRecords(skill.consumes).length,
+                produces: arrayOfRecords(skill.produces).length,
+                bodyPath: stringValue(skill.bodyPath) ? join(skillsDir, stringValue(skill.bodyPath)) : undefined,
+            });
+        }
+        return artifacts;
+    }
+    let entries = [];
+    try {
+        entries = await readdir(skillsDir);
+    }
+    catch {
+        warnings.push(`Claude Code skills directory is not readable: ${skillsDir}`);
+        return artifacts;
+    }
+    for (const entry of entries.filter((name) => !name.startsWith(".")).sort()) {
+        const skillPath = join(skillsDir, entry, "SKILL.md");
+        const rawSkill = await readOptional(skillPath);
+        if (!rawSkill)
+            continue;
+        artifacts.push({
+            target: "claude_code",
+            kind: "skill_entrypoint",
+            name: frontmatterValue(rawSkill, "name") ?? entry,
+            path: skillPath,
+            managed: rawSkill.includes("intentdna:managed"),
+            description: frontmatterValue(rawSkill, "description"),
+        });
+    }
+    return artifacts;
+}
+async function listRuntimeArtifacts(projectPath, warnings) {
+    const artifacts = [
+        ...await listClaudeAgentArtifacts(projectPath, warnings),
+        ...await listClaudeSkillArtifacts(projectPath, warnings),
+    ];
+    return artifacts.sort((a, b) => a.target.localeCompare(b.target) ||
+        a.kind.localeCompare(b.kind) ||
+        a.name.localeCompare(b.name));
+}
+function envValue(name) {
+    const value = process.env[name]?.trim();
+    return value && value.length > 0 ? value : undefined;
+}
+function captureDir(projectDir) {
+    return join(projectDir, ".dna", "evidence", "capture");
+}
+function captureFromRecord(record, path) {
+    if (record.schema_version !== "intentdna.evidence_capture.v1")
+        return undefined;
+    const fact = captureFactValue(record.fact);
+    if (!fact)
+        return undefined;
+    const eventId = stringValue(record.event_id);
+    const capturedAt = stringValue(record.captured_at);
+    const summary = stringValue(record.summary);
+    if (!eventId || !capturedAt || !summary)
+        return undefined;
+    return {
+        eventId,
+        capturedAt,
+        source: stringValue(record.source) ?? "unknown",
+        workflowAsset: stringValue(record.workflow_asset) ?? "unknown",
+        workflowId: stringValue(record.workflow_id) ?? "unknown",
+        runId: stringValue(record.run_id) ?? "unknown",
+        stepId: stringValue(record.step_id) ?? "unknown",
+        fact,
+        summary,
+        command: stringValue(record.command),
+        result: captureResultValue(record.result),
+        evidenceRefs: arrayOfRecords(record.evidence_refs)
+            .map((ref) => ({ type: stringValue(ref.type) ?? "unknown", ref: stringValue(ref.ref) ?? "unknown" })),
+        path,
+    };
+}
+function captureMatchesAsset(capture, asset) {
+    if (!asset)
+        return false;
+    const names = new Set([
+        asset.name,
+        asset.id,
+        asset.dnaId,
+        ...asset.workflows.map((workflow) => workflow.id),
+        ...asset.workflows.map((workflow) => workflow.name),
+    ].filter((value) => typeof value === "string" && value.length > 0));
+    return names.has(capture.workflowAsset) || names.has(capture.workflowId);
+}
+async function readEvidenceCaptures(projectDir, asset, warnings) {
+    const dir = captureDir(projectDir);
+    let files = [];
+    try {
+        files = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const captures = [];
+    for (const file of files.filter((entry) => /^\d{4}-\d{2}-\d{2}\.jsonl$/.test(entry)).sort()) {
+        const path = join(dir, file);
+        let raw = "";
+        try {
+            raw = await readFile(path, "utf-8");
+        }
+        catch {
+            warnings.push(`C5 evidence capture file is not readable: ${path}`);
+            continue;
+        }
+        const lines = raw.split("\n");
+        for (let i = 0; i < lines.length; i += 1) {
+            const line = lines[i]?.trim();
+            if (!line)
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                const capture = isRecord(parsed) ? captureFromRecord(parsed, `${path}#L${i + 1}`) : undefined;
+                if (capture && captureMatchesAsset(capture, asset))
+                    captures.push(capture);
+            }
+            catch {
+                warnings.push(`C5 evidence capture line is not valid JSON: ${path}#L${i + 1}`);
+            }
+        }
+    }
+    return captures.sort((a, b) => b.capturedAt.localeCompare(a.capturedAt));
+}
+function resolveDogfoodSource(dogfood, options) {
+    const projectPath = options?.dogfoodProjectPath ?? envValue("INTENTDNA_DOGFOOD_PROJECT_PATH") ?? dogfood.projectPath;
+    const progressDirValue = options?.dogfoodProgressDir ?? envValue("INTENTDNA_DOGFOOD_PROGRESS_DIR") ?? dogfood.progressDir ?? ".dna/fix-progress";
+    const progressDir = isAbsolute(progressDirValue) ? progressDirValue : join(projectPath, progressDirValue);
+    return { projectPath, progressDir };
+}
+export async function buildWorkflowAssetEvidenceIndex(name, options) {
+    const asset = await findWorkflowAsset(name, { projectDir: options?.projectDir });
+    if (!asset)
+        return undefined;
+    const projectDir = options?.projectDir ?? process.cwd();
+    const warnings = [];
+    const captureFacts = await readEvidenceCaptures(projectDir, asset, warnings);
+    const metadata = getWorkflowAssetMetadata(asset.name);
+    if (!metadata?.dogfood) {
+        return {
+            asset: asset.name,
+            projectPath: "",
+            progressDir: "",
+            sourceDescription: undefined,
+            totals: evidenceTotals([], [], captureFacts),
+            modules: [],
+            runtimeArtifacts: [],
+            captureFacts,
+            warnings: ["No dogfood progress source is registered for this asset.", ...warnings],
+        };
+    }
+    const source = resolveDogfoodSource(metadata.dogfood, options);
+    const modules = [];
+    let files = [];
+    try {
+        files = await readdir(source.progressDir);
+    }
+    catch {
+        warnings.push(`Dogfood progress directory is not readable: ${source.progressDir}`);
+    }
+    for (const file of files.filter((entry) => /^[A-Za-z0-9_-]+\.json$/.test(entry)).sort()) {
+        const parsed = await readJson(join(source.progressDir, file));
+        if (!isRecord(parsed) || typeof parsed.verdict !== "string")
+            continue;
+        if (!isCanonicalModuleProgressFile(file, parsed))
+            continue;
+        const module = moduleFromRecord(parsed, file, source.progressDir);
+        if (module.progressMarkdownPath && !await pathExists(module.progressMarkdownPath)) {
+            module.progressMarkdownPath = undefined;
+        }
+        modules.push(module);
+    }
+    if (modules.length === 0 && warnings.length === 0) {
+        warnings.push(`No module progress JSON files were found in ${source.progressDir}.`);
+    }
+    const runtimeArtifacts = await listRuntimeArtifacts(source.projectPath, warnings);
+    const sortedModules = sortModules(modules);
+    return {
+        asset: asset.name,
+        projectPath: source.projectPath,
+        progressDir: source.progressDir,
+        sourceDescription: metadata.dogfood.description,
+        totals: evidenceTotals(sortedModules, runtimeArtifacts, captureFacts),
+        modules: sortedModules,
+        runtimeArtifacts,
+        captureFacts,
+        warnings,
+    };
+}

package/dist/assets/index.d.ts

@@ -0,0 +1,4 @@
+export { findWorkflowAsset, listWorkflowAssets, type WorkflowAssetControllerSummary, type WorkflowAssetCascadeSummary, type WorkflowAssetEvolutionSummary, type WorkflowAssetRoleSummary, type WorkflowAssetStepSummary, type WorkflowAssetSummary, type WorkflowAssetWorkflowSummary, } from "./catalog.js";
+export { activeEvidenceFollowupRoute, activeEvidenceFollowupReviewRoute, activeEvidenceModules, buildWorkflowAssetCandidateBacklog, type ActiveEvidenceFollowupReviewRoute, type ActiveEvidenceFollowupRouteStatus, type AssetCandidateBacklog, type AssetCandidateReviewPacket, type AssetCandidateType, type AssetWorkflowCandidate, type WorkflowCandidateAction, type WorkflowCandidateActionPathStatus, type WorkflowCandidateActionPathStep, type WorkflowCandidateActionPathStepId, type WorkflowCandidateEditOperation, } from "./candidates.js";
+export { buildWorkflowAssetEvidenceIndex, type WorkflowAssetEvidenceCapture, type WorkflowAssetEvidenceIndex, type WorkflowAssetEvidenceModule, type WorkflowAssetEvidenceVerdict, } from "./evidence.js";
+export { getWorkflowAssetMetadata, WORKFLOW_ASSET_METADATA, type WorkflowAssetEvidenceLink, type WorkflowAssetMetadata, } from "./metadata.js";

package/dist/assets/index.js

@@ -0,0 +1,4 @@
+export { findWorkflowAsset, listWorkflowAssets, } from "./catalog.js";
+export { activeEvidenceFollowupRoute, activeEvidenceFollowupReviewRoute, activeEvidenceModules, buildWorkflowAssetCandidateBacklog, } from "./candidates.js";
+export { buildWorkflowAssetEvidenceIndex, } from "./evidence.js";
+export { getWorkflowAssetMetadata, WORKFLOW_ASSET_METADATA, } from "./metadata.js";

package/dist/assets/metadata.d.ts

@@ -0,0 +1,19 @@
+export interface WorkflowAssetEvidenceLink {
+    label: string;
+    path: string;
+    kind: "doc" | "dogfood" | "reference";
+    description?: string;
+}
+export interface WorkflowAssetDogfoodSource {
+    projectPath: string;
+    progressDir?: string;
+    description?: string;
+}
+export interface WorkflowAssetMetadata {
+    template: string;
+    positioning?: string;
+    dogfood?: WorkflowAssetDogfoodSource;
+    evidence?: readonly WorkflowAssetEvidenceLink[];
+}
+export declare const WORKFLOW_ASSET_METADATA: readonly WorkflowAssetMetadata[];
+export declare function getWorkflowAssetMetadata(template: string): WorkflowAssetMetadata | undefined;

package/dist/assets/metadata.js

@@ -0,0 +1,227 @@
+export const WORKFLOW_ASSET_METADATA = [
+    {
+        template: "flutter-rewrite",
+        positioning: "Dogfood-proven Flutter v1 to v2 behavior-preserving rewrite workflow.",
+        dogfood: {
+            projectPath: "/Users/samuel/lawark/lwk_flutter_v2-rewrite",
+            progressDir: ".dna/fix-progress",
+            description: "Real Claude Code dogfood project with module-level fix-loop progress JSON.",
+        },
+        evidence: [
+            {
+                label: "Flutter rewrite workflow asset",
+                path: "docs/archive/2026H1/references/flutter-rewrite-workflow-asset.md",
+                kind: "dogfood",
+                description: "IntentDNA-owned import of the dogfood workflow asset, excluding OMC logs.",
+            },
+        ],
+    },
+    {
+        template: "flutter-rewrite-new",
+        positioning: "Draft next-generation governed rewrite workflow shape.",
+        evidence: [
+            {
+                label: "Product spine route",
+                path: "docs/archive/2026H1/references/intentdna-product-spine.md",
+                kind: "reference",
+                description: "Route correction that frames governed workflow assets as the product spine.",
+            },
+        ],
+    },
+    {
+        template: "flutter-behavior-lock",
+        positioning: "Reusable behavior-lock workflow for capturing v1 module behavior as docs/tests before risky rewrite or refactor.",
+        evidence: [
+            {
+                label: "Flutter rewrite behavior docs",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/docs/behavior",
+                kind: "reference",
+                description: "Dogfood behavior documents created before repair work to lock source behavior at module/action level.",
+            },
+            {
+                label: "Flutter rewrite fix progress",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/fix-progress",
+                kind: "reference",
+                description: "Module progress evidence showing behavior lock as a repeated precondition for risky rewrite and fix loops.",
+            },
+        ],
+    },
+    {
+        template: "workflow-evidence-review",
+        positioning: "Reusable manager review gate for workflow evidence before adoption, evolution, rollout, or runtime sync.",
+        evidence: [
+            {
+                label: "Flutter rewrite dogfood progress",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/fix-progress",
+                kind: "reference",
+                description: "Module-level progress JSON, review verdicts, diagnosis specs, and test logs used to gate adoption/evolution/sync.",
+            },
+            {
+                label: "IntentDNA product spine",
+                path: "docs/archive/2026H1/references/intentdna-product-spine.md",
+                kind: "reference",
+                description: "Route alignment that defines evidence-backed workflow assets, manager review, and human-reviewed evolution.",
+            },
+        ],
+    },
+    {
+        template: "flutter-rewrite-diagnosis-review",
+        positioning: "Reusable diagnosis plus reviewer gate for risky rewrite work before any implementation edit.",
+        evidence: [
+            {
+                label: "Flutter rewrite diagnosis specs",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/specs",
+                kind: "reference",
+                description: "Dogfood diagnosis specs and review verdicts that gate implementation.",
+            },
+            {
+                label: "Flutter rewrite progress evidence",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/fix-progress",
+                kind: "reference",
+                description: "Module-level progress JSON and test logs showing diagnosis/review as a repeated workflow pattern.",
+            },
+        ],
+    },
+    {
+        template: "flutter-rewrite-fix-review-loop",
+        positioning: "Reusable diagnosis-backed fix, independent review, verification, and manager route loop for risky rewrite slices.",
+        evidence: [
+            {
+                label: "Flutter rewrite fix-loop progress",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/fix-progress",
+                kind: "reference",
+                description: "Module-level progress JSON and test logs showing the fix/review/verify loop across dogfood modules.",
+            },
+            {
+                label: "Flutter rewrite diagnosis specs",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/specs",
+                kind: "reference",
+                description: "Approved diagnosis and review artifacts consumed by the fix loop before implementation.",
+            },
+        ],
+    },
+    {
+        template: "workflow-blocked-scope-triage",
+        positioning: "Reusable triage gate for blocked, skipped, removed, infra, or intentionally deferred scope before manager review and rollout.",
+        evidence: [
+            {
+                label: "Flutter rewrite blocked scope evidence",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/fix-progress",
+                kind: "reference",
+                description: "Dogfood module progress where blocked or skipped work had to be separated from remaining implementation work.",
+            },
+            {
+                label: "Flutter rewrite workflow blocked item policy",
+                path: "src/templates/flutter-rewrite.dna.yaml",
+                kind: "reference",
+                description: "Existing full rewrite policy for remaining_unimplemented_skipped_count, blocked_count, and PASS/CONTINUE classification.",
+            },
+        ],
+    },
+    {
+        template: "workflow-cross-boundary-resource-approval",
+        positioning: "Reusable approval route for shared resource, localization, config, policy, or cross-module changes that exceed the current workflow scope.",
+        evidence: [
+            {
+                label: "Flutter rewrite Pay i18n blocker",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/fix-progress/Pay.json",
+                kind: "reference",
+                description: "Dogfood Pay progress where preserving payment_tips_prefix localization required shared lwk_i18n work outside feature_pay and needed human approval.",
+            },
+            {
+                label: "Flutter rewrite dogfood blocked evidence",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/fix-progress",
+                kind: "reference",
+                description: "Module-level dogfood evidence showing needs_human/outside_diagnosis work must route through approval before implementation, rollout, sync, or completion claims.",
+            },
+        ],
+    },
+    {
+        template: "workflow-completion-audit",
+        positioning: "Reusable completion gate for proving PASS/CONTINUE/BLOCKED from diagnosis, current verification, red classification, skipped comparison, and progress evidence.",
+        evidence: [
+            {
+                label: "Flutter rewrite module completion evidence",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/fix-progress",
+                kind: "reference",
+                description: "Dogfood module completion reports that compare diagnosis baselines, current summaries, red classifications, skipped tests, and progress JSON before PASS decisions.",
+            },
+            {
+                label: "Flutter rewrite diagnosis baselines",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/specs",
+                kind: "reference",
+                description: "Diagnosis baselines that define actionable UNIMPLEMENTED/BUG work versus TEST_BUG, INFRA, REMOVED, or approved blocked scope.",
+            },
+        ],
+    },
+    {
+        template: "workflow-verification-command-routing",
+        positioning: "Reusable verification route gate for choosing the authoritative command root/scope and capturing canonical machine evidence before completion, adoption, rollout, or sync.",
+        evidence: [
+            {
+                label: "Flutter rewrite ACTS verification route evidence",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/fix-progress/ACTS.md",
+                kind: "reference",
+                description: "Dogfood note showing wrong-root flutter test output was not valid behavior evidence; the accepted route ran from the v2 project root and produced machine summaries.",
+            },
+            {
+                label: "Flutter rewrite Gallery verification route evidence",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/fix-progress/Gallery.md",
+                kind: "reference",
+                description: "Dogfood note showing final Gallery verification required the feature_gallery package root rather than the standalone behavior-test directory.",
+            },
+            {
+                label: "Flutter rewrite AAC canonical verification evidence",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/fix-progress/AAC.md",
+                kind: "reference",
+                description: "Dogfood completion evidence requiring command status, machine log, parsed summary, red classification, and skipped-test checks before PASS.",
+            },
+        ],
+    },
+    {
+        template: "workflow-runtime-smoke-review",
+        positioning: "Reusable runtime smoke gate for proving a synced or distributed surface is actually usable before wider rollout.",
+        evidence: [
+            {
+                label: "Flutter rewrite ACTS e2e runtime evidence",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/.dna/fix-progress",
+                kind: "reference",
+                description: "Dogfood ACTS e2e artifacts including screenshots, UI XML, UI summaries, logcat captures, crash dialogs, route probes, and login/fullscreen blockers.",
+            },
+            {
+                label: "IntentDNA release deploy runbook",
+                path: "docs/archive/2026H1/workflows/release-runbook.md",
+                kind: "reference",
+                description: "Release gate that requires deployed URL verification when web/public surfaces changed.",
+            },
+        ],
+    },
+    {
+        template: "workflow-module-inventory",
+        positioning: "Reusable module/page/action inventory workflow for broad migrations before behavior locks, diagnosis, fixes, rollout, or sync.",
+        evidence: [
+            {
+                label: "Flutter rewrite Phase 0 global scan",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/docs/refactoring-workflow-v2.md",
+                kind: "reference",
+                description: "Dogfood workflow doctrine that starts with global module/page/action inventory before per-module behavior locks and fixes.",
+            },
+            {
+                label: "Flutter rewrite v1 feature inventory",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/docs/v1-feature-inventory.md",
+                kind: "reference",
+                description: "Real module inventory created to guide behavior docs, priorities, and per-module rewrite execution.",
+            },
+            {
+                label: "Flutter rewrite behavior document set",
+                path: "/Users/samuel/lawark/lwk_flutter_v2-rewrite/docs/behavior",
+                kind: "reference",
+                description: "Per-module behavior documents produced from inventory before diagnosis and fix loops.",
+            },
+        ],
+    },
+];
+const WORKFLOW_ASSET_METADATA_BY_TEMPLATE = new Map(WORKFLOW_ASSET_METADATA.map((entry) => [entry.template, entry]));
+export function getWorkflowAssetMetadata(template) {
+    return WORKFLOW_ASSET_METADATA_BY_TEMPLATE.get(template);
+}