@orangepro/orangepro-mcp 0.1.0

package/dist/local/util/walk.js

@@ -0,0 +1,174 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { hashBuffer } from "./hash.js";
+const DEFAULT_IGNORE_NAMES = [
+    "node_modules",
+    ".git",
+    ".hg",
+    ".svn",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".nuxt",
+    ".turbo",
+    "coverage",
+    ".orangepro",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".pytest_cache",
+    ".mypy_cache",
+    "vendor",
+    "target",
+    ".gradle",
+    ".idea",
+    ".vscode",
+    ".DS_Store",
+    // Agent/tooling scaffolding and nested worktrees — noise, not the project under test.
+    ".agent-worktrees",
+    ".worktrees",
+    ".claude",
+    ".cursor",
+    ".agent",
+    ".paul",
+    ".omc",
+    ".repowise",
+    ".agent-handoff",
+    // The kit's own exported artifacts must not be re-ingested as source.
+    "orangepro-evidence-pack.json",
+    "orangepro-evidence-pack.md"
+];
+const DEFAULT_IGNORE_MATCHERS = [/(^|\/)[^/]*evidence-pack\.(json|md)$/];
+/**
+ * High file-count ceiling: a pathological-run guard, NOT a tuning knob. The
+ * default is high enough to scan large monorepos (Mattermost-scale) end to end;
+ * lower it via ORANGEPRO_MAX_FILES only to bound an accidental huge directory.
+ */
+export const DEFAULT_MAX_FILES = 100_000;
+const DEFAULT_MAX_FILE_BYTES = 1_000_000;
+/** Load ignore rules from defaults plus `.gitignore` and `.orangeproignore`. */
+export function loadIgnore(root) {
+    const names = new Set(DEFAULT_IGNORE_NAMES);
+    const matchers = [...DEFAULT_IGNORE_MATCHERS];
+    for (const file of [".gitignore", ".orangeproignore"]) {
+        const abs = join(root, file);
+        if (!existsSync(abs))
+            continue;
+        let lines;
+        try {
+            lines = readFileSync(abs, "utf8").split(/\r?\n/);
+        }
+        catch {
+            continue;
+        }
+        for (const raw of lines) {
+            const line = raw.trim();
+            if (!line || line.startsWith("#") || line.startsWith("!"))
+                continue;
+            const cleaned = line.replace(/^\/+/, "").replace(/\/+$/, "");
+            if (!cleaned)
+                continue;
+            if (!cleaned.includes("/") && !cleaned.includes("*")) {
+                names.add(cleaned);
+            }
+            else {
+                matchers.push(globToRegExp(cleaned));
+            }
+        }
+    }
+    return { names, matchers };
+}
+function globToRegExp(glob) {
+    // Use a plain-ASCII sentinel for `**` so the file stays text (no NUL bytes)
+    // and `*` substitution does not re-match the globstar.
+    const GLOBSTAR = "__ORANGEPRO_GLOBSTAR__";
+    const escaped = glob
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*\*/g, GLOBSTAR)
+        .replace(/\*/g, "[^/]*")
+        .split(GLOBSTAR)
+        .join(".*")
+        .replace(/\?/g, "[^/]");
+    return new RegExp(`(^|/)${escaped}(/|$)`);
+}
+function isIgnored(relPath, baseName, rules) {
+    if (rules.names.has(baseName))
+        return true;
+    return rules.matchers.some((m) => m.test(relPath));
+}
+/** Whether a workspace-relative path is ignored (any segment in names, or a matcher hit). */
+export function isPathIgnored(relPath, rules) {
+    if (relPath.split("/").some((segment) => rules.names.has(segment)))
+        return true;
+    return rules.matchers.some((m) => m.test(relPath));
+}
+/**
+ * Recursively walk the workspace, returning content-hashed file records.
+ * Honors ignore rules, size caps, and a global file cap so large or noisy
+ * checkouts stay bounded. Symlinks are not followed.
+ */
+export function walkFiles(root, rules, opts = {}) {
+    const maxFiles = opts.maxFiles ?? DEFAULT_MAX_FILES;
+    const maxFileBytes = opts.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+    const records = [];
+    const visit = (dir, rel) => {
+        if (records.length >= maxFiles)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            if (records.length >= maxFiles)
+                return;
+            const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+            if (isIgnored(childRel, entry.name, rules))
+                continue;
+            const childAbs = join(dir, entry.name);
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory()) {
+                visit(childAbs, childRel);
+            }
+            else if (entry.isFile()) {
+                let size;
+                try {
+                    size = statSync(childAbs).size;
+                }
+                catch {
+                    continue;
+                }
+                if (size > maxFileBytes)
+                    continue;
+                let hash;
+                try {
+                    hash = hashBuffer(readFileSync(childAbs));
+                }
+                catch {
+                    continue;
+                }
+                records.push({ relPath: childRel, absPath: childAbs, size, hash });
+            }
+        }
+    };
+    visit(root, "");
+    return records;
+}
+/**
+ * Like {@link walkFiles}, but also reports whether the file-count cap was hit so
+ * the analyzer can surface scanned-vs-skipped counts instead of silently dropping
+ * files. (walkFiles stops at exactly maxFiles, so reaching it means more remained.)
+ */
+export function walkFilesWithMeta(root, rules, opts = {}) {
+    const max_files = opts.maxFiles ?? DEFAULT_MAX_FILES;
+    // Probe one past the cap so "exactly max_files files" is not misreported as
+    // truncated (only > max_files means files were actually skipped).
+    const probed = walkFiles(root, rules, { ...opts, maxFiles: max_files + 1 });
+    const truncated = probed.length > max_files;
+    return { files: truncated ? probed.slice(0, max_files) : probed, truncated, max_files };
+}

package/dist/local/viz/behaviorReportData.js

@@ -0,0 +1,367 @@
+import path from "node:path";
+import { buildRtm } from "../rtm.js";
+import { rankRiskGaps } from "../score/risk.js";
+/** Short human phrase per R-1 needs_setup category, for the "blocked because: …" panel copy. */
+const BLOCK_CATEGORY_LABEL = {
+    module_not_found: "a missing module or dependency in the sandbox",
+    tsconfig_missing: "a monorepo tsconfig the sandbox can't resolve (a parent config the package extends)",
+    experimental_builtin: "an experimental Node builtin that needs a runtime flag",
+    engine_mismatch: "the runner Node being outside the declared engines range",
+    db_or_external: "a database or external service the sandbox lacks"
+};
+/**
+ * Group this run's needs_setup attempts by R-1 category and name the most common one. NOT a new
+ * classifier — it only tallies the category/reason autoProve already returned. Attempts with no
+ * category (unrunnable setup) fall into a generic "setup/runnability" bucket.
+ */
+export function dominantBlockReason(needsSetup) {
+    if (needsSetup.length === 0)
+        return null;
+    const counts = new Map();
+    for (const a of needsSetup) {
+        const key = a.category && BLOCK_CATEGORY_LABEL[a.category] ? a.category : "runnability";
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    let topKey = "runnability";
+    let top = 0;
+    for (const [k, c] of counts) {
+        if (c > top) {
+            top = c;
+            topKey = k;
+        }
+    }
+    return { label: BLOCK_CATEGORY_LABEL[topKey] ?? "setup/runnability of the test in the sandbox", count: top, total: needsSetup.length };
+}
+function nodeFile(node) {
+    if (!node)
+        return "";
+    if (typeof node.properties.file === "string")
+        return node.properties.file;
+    return node.provenance.source_ref ?? "";
+}
+function groupOf(file) {
+    const parts = file.split("/").filter(Boolean);
+    if (parts[0] === "packages" && parts[1])
+        return parts[1];
+    return parts[0] ?? "core";
+}
+function symbolDisplay(id, nodesById) {
+    const node = nodesById.get(id);
+    return node?.title || id.replace(/^sym:/, "").split("#").pop() || id;
+}
+function nodeDescription(id, nodesById) {
+    const node = nodesById.get(id);
+    const candidate = node?.properties.behavior_description ??
+        node?.properties.description ??
+        node?.properties.summary ??
+        node?.properties.intent ??
+        node?.title;
+    return typeof candidate === "string" && candidate.trim() ? candidate.trim() : symbolDisplay(id, nodesById);
+}
+function serviceName(sig) {
+    const base = sig.split(".")[0] || sig;
+    return base.replace(/^.*#/, "");
+}
+function endpointTrigger(node) {
+    if (!node || node.kind !== "Endpoint")
+        return null;
+    const method = typeof node.properties.method === "string" ? node.properties.method : "";
+    const routePath = typeof node.properties.path === "string" ? node.properties.path : "";
+    if (!method && !routePath)
+        return null;
+    return { verb: method || "CALL", path: routePath || "/" };
+}
+/**
+ * Every symbol external_id that appears in a static flow (entry points + hop
+ * endpoints). Display-only: used to split the untested `none` bucket into
+ * "Reachable Untested" (symbol is in a flow) vs "No Signal". Reads existing
+ * flow data; mints nothing and touches no tier classification.
+ */
+function flowSymbolIds(graph) {
+    const ids = new Set();
+    for (const flow of graph.analysis?.flows?.flows ?? []) {
+        ids.add(flow.entry_point.external_id);
+        for (const hop of flow.hops) {
+            ids.add(hop.from);
+            ids.add(hop.to);
+        }
+    }
+    return ids;
+}
+function isNoneTier(tier) {
+    return tier !== "proven" && tier !== "associated" && tier !== "runtime";
+}
+function summaryFromRows(rows, flowIds) {
+    const proven = rows.filter((r) => r.evidence_tier === "proven").length;
+    const associated = rows.filter((r) => r.evidence_tier === "associated" || r.evidence_tier === "runtime").length;
+    const noneRows = rows.filter((r) => isNoneTier(r.evidence_tier));
+    // DISPLAY-ONLY split of `none`: a none-tier symbol that shows up in a static flow is "Reachable Untested".
+    const reachableUntested = noneRows.filter((r) => flowIds.has(r.behavior_id)).length;
+    return { total: rows.length, proven, associated, none: noneRows.length, reachableUntested, noSignal: noneRows.length - reachableUntested };
+}
+/** Verbatim 0-dynamic-proof explainer copy. Rendered only when summary.proven === 0. */
+const ZERO_PROOF_EXPLAINER = {
+    title: "Why dynamic proof is 0",
+    body: [
+        "OrangePro mapped behaviors, flows, and static test links without running your app. Dynamic proof requires executing tests in a sandbox and checking whether a test fails when the target behavior is mutated.",
+        "The statically linked behaviors have test evidence, but they are not verified yet. Treat them as likely covered, not proven.",
+        "OrangePro tries to dynamically prove the top 5 highest-risk behaviors by default. If setup is missing, the report shows the reason, such as missing dependencies, database setup, environment variables, or unsupported test runner configuration."
+    ]
+};
+function pipeline(graph, ledger, summary) {
+    const endpointCount = graph.nodes.filter((n) => n.kind === "Endpoint").length;
+    const implementedIn = graph.edges.filter((e) => e.relationship_type === "IMPLEMENTED_IN").length;
+    const calls = graph.edges.filter((e) => e.relationship_type === "CALLS");
+    const injectedCalls = calls.filter((e) => e.properties?.call_via === "injected");
+    const frameworkCalls = calls.filter((e) => e.evidence_strength === "framework-derived");
+    const flowMeta = graph.analysis?.flows;
+    const flowCount = flowMeta?.total_flows ?? 0;
+    const allSingleHop = flowCount > 0 && (flowMeta?.flows ?? []).every((f) => f.depth <= 1);
+    const truncatedHeavy = flowCount > 0 && (flowMeta?.truncated_flows ?? 0) > flowCount / 2;
+    const proofAttempted = ledger.records.some((r) => r.dynamic_proof?.proof_kind === "dynamic_targeted");
+    return [
+        { key: "behaviors", label: "Behaviors", pr: "#146", on: summary.total > 0 ? "1" : "0" },
+        { key: "endpoints", label: "Endpoint→handler", pr: "#148", on: implementedIn > 0 ? "1" : endpointCount > 0 ? "partial" : "0" },
+        { key: "calls", label: "Hard CALLS (DI)", pr: "#149", on: injectedCalls.length > 0 ? "1" : calls.length > 0 ? "partial" : "0" },
+        { key: "fw", label: "Framework-derived", pr: "#150", on: frameworkCalls.length > 0 ? "1" : "0" },
+        { key: "flows", label: "Flow walker", pr: "#151", on: flowCount > 0 ? (allSingleHop || truncatedHeavy ? "partial" : "1") : "0" },
+        { key: "proof", label: "Dynamic proof", pr: "proof", on: summary.proven > 0 ? "1" : proofAttempted ? "partial" : "0" }
+    ];
+}
+const KEEP_ACTION = "Keep generating tests for high-risk gaps and close each one through the proof handoff; Statically Linked signals stay separate.";
+const HANDOFF_ACTION = "Run OrangePro from a coding agent with a model key; follow the returned proof handoff so the agent generates a runnable test and calls orangepro_prove_loop. Direct CLI users can run prove-loop after writing or choosing a real passing test.";
+function proofGuidance(ledger, summary, dyn) {
+    if (summary.proven > 0) {
+        return {
+            state: "proven",
+            title: "Dynamically Proven is active",
+            body: `${summary.proven.toLocaleString()} behavior${summary.proven === 1 ? "" : "s"} closed with dynamic targeted proof. Each Dynamically Proven row requires a passing baseline, a targeted mutant failure at assertion, and the target running unmocked. Statically Linked signals stay separate.`,
+            action: KEEP_ACTION
+        };
+    }
+    // Prefer THIS RUN's dynamic-proof outcome (names the dominant block reason). Static breadth
+    // — behaviors, flows, Statically Linked signals — is unaffected; only the dynamic pass is small.
+    if (dyn) {
+        if (dyn.attempted === 0) {
+            return {
+                state: "not_started",
+                title: "0 Dynamically Proven — dynamic proof was not attempted",
+                body: "Dynamic proof was not attempted in this run. Static behavior mapping and Statically Linked signals are still available.",
+                action: HANDOFF_ACTION
+            };
+        }
+        const dom = dominantBlockReason(dyn.needsSetup);
+        const allBlocked = dyn.needsSetup.length > 0 && dyn.needsSetup.length >= dyn.attempted;
+        const plural = dyn.attempted === 1 ? "" : "s";
+        if (allBlocked && dom) {
+            return {
+                state: "attempted",
+                title: `0 Dynamically Proven — top ${dyn.attempted} attempted, all setup-blocked`,
+                body: `Dynamic proof attempted ${dyn.attempted} target${plural}; all were blocked by ${dom.label} (${dom.count}/${dom.total}). This is a sandbox setup gap, not a static-test failure — the Statically Linked signals are still shown.`,
+                action: HANDOFF_ACTION
+            };
+        }
+        const because = dom ? ` Blocked because: ${dom.label} (${dom.count}/${dom.total}).` : "";
+        return {
+            state: "attempted",
+            title: `0 Dynamically Proven — top ${dyn.attempted} attempted, 0 closed`,
+            body: `OrangePro mapped this repo statically. Dynamic proof is a targeted verification pass: it runs existing or generated tests, mutates the exact behavior, and promotes only tests that fail at an assertion. This run attempted the top ${dyn.attempted} eligible behavior${plural} and closed 0.${because} Static test signals stay Statically Linked.`,
+            action: HANDOFF_ACTION
+        };
+    }
+    // Standalone report regen (no THIS-RUN data) → derive from the ledger only.
+    const dynamicAttempts = ledger.records.filter((r) => r.dynamic_proof?.proof_kind === "dynamic_targeted");
+    if (dynamicAttempts.length > 0) {
+        return {
+            state: "attempted",
+            title: "0 Dynamically Proven — dynamic proof ran, none closed yet",
+            body: "OrangePro found dynamic proof attempts in the local ledger, but none satisfied the full Dynamically Proven gate. Static tests still show as Statically Linked only.",
+            action: "Use the coding-agent handoff to repair or regenerate the test, then run the provided prove_loop step again."
+        };
+    }
+    return {
+        state: "not_started",
+        title: "0 Dynamically Proven means no dynamic proof has run yet",
+        body: "This report is an analysis pass. It can find behaviors, static test evidence, risk, and reachable flows, but it will not label anything Dynamically Proven until a real test kills a targeted mutant of the behavior.",
+        action: HANDOFF_ACTION
+    };
+}
+function scanBlock(graph, rows) {
+    const services = new Map();
+    for (const row of rows) {
+        const sig = row.behavior || row.code_symbol;
+        const name = serviceName(sig);
+        if (!name)
+            continue;
+        services.set(name, (services.get(name) ?? 0) + 1);
+    }
+    const tests = graph.nodes.filter((n) => n.kind === "TestCase");
+    const integration = tests.filter((n) => n.properties.test_layer === "integration" || n.properties.test_layer === "api" || n.properties.test_layer === "e2e").length;
+    const unit = tests.filter((n) => n.properties.test_layer === "unit" || n.properties.test_layer === "component").length;
+    const denominator = graph.analysis?.denominator;
+    const excludedCount = (denominator?.excluded_boilerplate ?? 0) +
+        (denominator?.excluded_infra ?? 0) +
+        (denominator?.excluded_generated ?? 0) +
+        (denominator?.excluded_test_inferred ?? 0);
+    return {
+        services: [...services.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 50),
+        serviceTotal: services.size,
+        tests: { total: tests.length, integration, unit },
+        excluded: {
+            count: excludedCount > 0 ? String(excludedCount) : "0",
+            text: "non-behavior symbols were excluded from the behavior count — generated code, framework internals, test-inferred flows, and infrastructure plumbing."
+        }
+    };
+}
+function behaviorLists(rows, flowIds) {
+    const groups = new Map();
+    const behaviors = rows.map((row) => {
+        const group = groupOf(row.file);
+        groups.set(group, (groups.get(group) ?? 0) + 1);
+        const tier = row.evidence_tier === "proven" ? "proven" : row.evidence_tier === "associated" || row.evidence_tier === "runtime" ? "assoc" : "none";
+        return {
+            sig: row.behavior || row.code_symbol,
+            group,
+            file: row.file,
+            tier,
+            // DISPLAY-ONLY: whether this symbol appears in a static flow (splits none → Reachable Untested vs No Signal).
+            reachable: flowIds.has(row.behavior_id),
+            desc: row.suggested_next_test || row.test_signal || row.status
+        };
+    });
+    return {
+        behaviorGroups: [...groups.entries()].map(([key, count]) => ({ key, count })).sort((a, b) => b.count - a.count || a.key.localeCompare(b.key)),
+        behaviors
+    };
+}
+function riskBucket(score) {
+    if (score >= 500)
+        return "critical";
+    if (score >= 200)
+        return "high";
+    if (score > 0)
+        return "medium";
+    return null;
+}
+function flowWhy(flow, proof) {
+    const tier = flow.flow_tier === "framework-derived: reachable" ? "framework-derived reachable" : "hard reachable";
+    const proofText = proof === "proven" ? "the entry behavior has dynamic proof" : "no dynamic proof exercises this chain yet";
+    return `This chain is ${tier}; ${proofText}. Reachability is static and is not an execution claim.`;
+}
+function flows(graph, rows, risks) {
+    const nodesById = new Map(graph.nodes.map((n) => [n.external_id, n]));
+    const proven = new Set(rows.filter((r) => r.evidence_tier === "proven").map((r) => r.behavior_id));
+    const riskById = new Map(risks.map((r) => [r.id, r]));
+    return (graph.analysis?.flows?.flows ?? []).map((flow) => {
+        const trigger = endpointTrigger(nodesById.get(flow.entry_point.external_id));
+        const proof = proven.has(flow.entry_point.external_id) || proven.has(flow.hops[0]?.from ?? "") ? "proven" : "none";
+        const steps = [
+            {
+                sig: symbolDisplay(flow.hops[0]?.from ?? flow.entry_point.external_id, nodesById),
+                tier: "hard",
+                edge: null,
+                desc: nodeDescription(flow.hops[0]?.from ?? flow.entry_point.external_id, nodesById)
+            },
+            ...flow.hops.map((hop) => ({
+                sig: symbolDisplay(hop.to, nodesById),
+                tier: hop.evidence_strength,
+                edge: hop.evidence_strength,
+                desc: nodeDescription(hop.to, nodesById)
+            }))
+        ];
+        const services = new Set(steps.map((s) => serviceName(s.sig)).filter(Boolean)).size;
+        const risk = riskById.get(flow.entry_point.external_id) ?? riskById.get(flow.hops[0]?.from ?? "");
+        return {
+            title: flow.entry_point.title || flow.entry_point.external_id,
+            trigger,
+            risk: risk ? riskBucket(risk.risk_score) : null,
+            proof,
+            services,
+            flow_tier: flow.flow_tier,
+            why: flowWhy(flow, proof),
+            steps
+        };
+    });
+}
+/** Report-only reader of analysis.candidate_flows — never touches deterministic flows or tiers. */
+function candidateFlows(graph) {
+    const meta = graph.analysis?.candidate_flows;
+    if (!meta)
+        return null;
+    const nodesById = new Map(graph.nodes.map((n) => [n.external_id, n]));
+    return {
+        proposed: meta.rejections.proposed,
+        accepted: meta.rejections.accepted,
+        model: `${meta.provenance.model_provider}/${meta.provenance.model_name}`,
+        prompt_version: meta.provenance.prompt_version,
+        flows: meta.flows.map((flow) => ({
+            title: flow.title || flow.entry_point.title || flow.entry_point.external_id,
+            confidence: flow.confidence,
+            rationale: flow.rationale ?? "",
+            steps: [
+                {
+                    sig: symbolDisplay(flow.hops[0]?.from ?? flow.entry_point.external_id, nodesById),
+                    desc: nodeDescription(flow.hops[0]?.from ?? flow.entry_point.external_id, nodesById),
+                    hop: null
+                },
+                ...flow.hops.map((hop) => ({
+                    sig: symbolDisplay(hop.to, nodesById),
+                    desc: nodeDescription(hop.to, nodesById),
+                    hop: hop.hop_status
+                }))
+            ]
+        }))
+    };
+}
+function riskRows(risks) {
+    return risks.map((risk, idx) => {
+        const methodMatch = risk.title.match(/^(GET|POST|PUT|PATCH|DELETE)\s+(.+)$/i);
+        const pathMatch = risk.file.match(/\/api\/(.+)$/);
+        const tags = [];
+        const bucket = riskBucket(risk.risk_score);
+        if (bucket)
+            tags.push([`${bucket} risk`, "risk"]);
+        tags.push([`${risk.incoming_refs} incoming refs`, "info"]);
+        if (risk.entry_point)
+            tags.push(["Entry point", "entry"]);
+        return {
+            rank: idx + 1,
+            verb: methodMatch?.[1]?.toUpperCase() ?? (risk.entry_point ? "ENTRY" : "CODE"),
+            path: methodMatch?.[2] ?? (pathMatch ? `/${pathMatch[1]}` : risk.file),
+            desc: risk.reasons.join(" · "),
+            tags,
+            todo: "Write an integration or behavior test that calls this behavior and asserts the observable outcome."
+        };
+    });
+}
+function frameworkLabel(graph) {
+    const frameworks = graph.nodes
+        .filter((n) => n.kind === "Framework")
+        .map((n) => n.title || n.external_id.replace(/^framework:/, ""))
+        .sort();
+    return frameworks.length ? frameworks.slice(0, 4).join(", ") : "Unknown framework";
+}
+export function buildBehaviorReportData(graph, ledger, opts = {}) {
+    const { rows } = buildRtm(graph, ledger);
+    const flowIds = flowSymbolIds(graph);
+    const summary = summaryFromRows(rows, flowIds);
+    const repoRoot = opts.repoRoot ?? graph.workspace.root;
+    const riskGaps = rankRiskGaps(graph, { repoRoot, limit: opts.riskLimit ?? 20 });
+    const lists = behaviorLists(rows, flowIds);
+    return {
+        repo: path.basename(repoRoot || graph.workspace.name || "repo"),
+        scanned: (graph.updated_at || graph.created_at || new Date(0).toISOString()).slice(0, 10),
+        framework: frameworkLabel(graph),
+        analysisKind: summary.proven > 0 ? "static+dynamic" : "static",
+        summary,
+        proofGuidance: proofGuidance(ledger, summary, opts.dynamicProof),
+        pipeline: pipeline(graph, ledger, summary),
+        scan: scanBlock(graph, rows),
+        behaviorGroups: lists.behaviorGroups,
+        behaviors: lists.behaviors,
+        flows: flows(graph, rows, riskGaps),
+        candidateFlows: candidateFlows(graph),
+        risks: riskRows(riskGaps),
+        zeroProofExplainer: summary.proven === 0 ? { title: ZERO_PROOF_EXPLAINER.title, body: [...ZERO_PROOF_EXPLAINER.body] } : null
+    };
+}