@orangepro/orangepro-mcp 0.2.6 → 0.2.8

package/README.md

@@ -32,7 +32,7 @@ The command writes:
 orangepro_generated/         ← contained generated tests; existing source files are untouched
 ```
 
-The report opens on a **system map** of your repo — entry lanes (GraphQL/HTTP/Jobs) flowing into the services they reach, sized by traffic, colored by evidence tier, risk-ringed — identical on every run. Each rerun shows a **delta banner**: what changed since last run, or "No changes — identical graph, identical ranking." Every one of the ~N behaviors gets a plain-English description; every top risk gets a deterministic context line and a state-aware next step.
+The report opens on a **system map** of your repo — entry lanes (GraphQL/HTTP/Jobs) flowing into the services they reach, sized by traffic, colored by evidence tier, risk-ringed — identical on every run. Each completed rerun shows a **delta banner** against the previous completed run. The report discloses when bounded path enumeration prunes additional branch expansions. Every behavior gets a plain-English description; every top risk gets a deterministic context line and a state-aware next step.
 
 Run `opro export` when you want a machine-readable evidence pack.
 <img width="895" height="960" alt="Screenshot 2026-07-08 at 1 18 01 AM" src="https://github.com/user-attachments/assets/73b8a812-2eab-43a1-8aed-4289545e630b" />
@@ -189,7 +189,7 @@ If the environment can't run tests yet (dependencies not installed, runner uncon
 
 ## Test categories
 
-Generation is evidence-gated. A category is produced only when the graph has supporting evidence — never padded with generic filler. These are the local generation buckets. The report additionally shows each risk's **applicable testing categories** (contract, boundary limits, integration flow, state lifecycle, failure recovery, …), derived deterministically from graph facts — covered categories from real attached tests render normally; the rest render locked, meaning "warranted here, generated on the platform," never "hidden tests exist." Neither taxonomy changes evidence tiers.
+Generation is evidence-gated. A category is produced only when the graph has supporting evidence — never padded with generic filler. These are the local generation buckets. The report additionally shows each risk's **applicable testing categories** (contract, boundary limits, integration flow, state lifecycle, failure recovery, …), derived deterministically from graph facts. Categories with generated drafts are highlighted as drafts; they are not coverage or proof, and remaining applicable categories stay outlined. Neither taxonomy changes evidence tiers.
 
 | Category | What it targets |
 |----------|-----------------|

package/dist/local/analyze/analyzer.js

@@ -70,13 +70,8 @@ const BEHAVIOR_SURFACE_FILE_RE = /(^|\/)[^/]*(api|controller|service|handler|res
 const BEHAVIOR_SURFACE_NAME_RE = /(^|[.#])(__init__|handle|handler|route|controller|service|resolver|processor|job|worker|queue|consumer|subscriber|listener|command|gateway|execute|process|consume|dispatch|schedule|upload|download|sync|checkout|charge|refund|capture|authorize|login|logout|register|find|search|list|create|update|delete|remove|archive|enable|disable|validate|get|add|sub|sum|total|save|load|render|run|main|root|child|mul|about|behavior)([A-Z0-9_]|$)/i;
 const CLIENT_FACTORY_NAME_RE = /(^|[.#])get[A-Z0-9_].*Client$/;
 const BEHAVIOR_OWNER_RE = /(Service|Controller|Resolver|Handler|Processor|Job|Worker|Queue|Consumer|Subscriber|Listener|Command|Gateway|Route|Router)$/;
-const UTILITY_DIRECTORY_EXCLUDE_RE = /\/(utils?|helpers?|tools?|loaders?|dml|dal|orchestration|codemods?|oas|models?|migrations?|migration-scripts?|instrumentation|medusa-telemetry|medusa-test-utils|eslint-plugin)\//i;
-const FRAMEWORK_INTERNAL_PATH_EXCLUDE_RE = /\/(http\/(?:routes-loader|routes-finder|routes-sorter|middlewares\/bodyparser)|medusa-app-loader|remote-query\/query)(?:\/|$)/i;
-const CLI_PACKAGE_PATH_EXCLUDE_RE = /\/(?:cli\/[^/]+\/src\/(?:commands|core|reporter)|packages\/[^/]+\/src\/commands)\//i;
-const BACKEND_RUNTIME_PATH_EXCLUDE_RE = /\/(?:packages\/core\/framework\/src|packages\/modules\/(?:workflow-engine-[^/]+|link-modules)\/src)(?:\/|$)/i;
-const UI_PRODUCT_PATH_EXCLUDE_RE = /\/(?:packages\/admin\/(?:dashboard|admin-bundler|admin-vite-plugin)\/src|packages\/design-system\/(?:toolbox|icons)\/src|www\/(?:apps|packages)\/[^/]+\/(?:app|src|providers|components|lib))(?:\/|$)/i;
-const SDK_CLIENT_PATH_EXCLUDE_RE = /\/(?:packages\/core\/js-sdk\/src|packages\/[^/]+\/(?:sdk|client)\/src)(?:\/|$)/i;
-const PLUGIN_ADMIN_PATH_EXCLUDE_RE = /\/(?:plugins\/[^/]+\/src\/admin|admin\/routes)\//i;
+const UTILITY_DIRECTORY_EXCLUDE_RE = /\/(utils?|helpers?|tools?|loaders?|dml|dal|orchestration|codemods?|oas|models?|migrations?|migration-scripts?|instrumentation|eslint-plugin)\//i;
+const PRESENTATION_ASSET_PATH_RE = /\/(?:icons?|assets?)\//i;
 const INFRA_METHOD_SUFFIX_RE = /^get[A-Z0-9_].*(Identifier|RegistrationKey|Config|Registry|Options|Settings|Path|Directory|TmpDir|Program|PackageManager|Command|Expression|Recommendation|CircularReferences|PivotTableName|PropertyName|PropertyKey|UnderlyingType|ComputedColumnRegistry|EntityOverrideRegistry|InverseRegistry|RelativeDate|SelectsAndRelations|SetDifference|ResolvedPlugins|Token|Scope|Module|Column|Pivot|Ttl|Timeout|Interval|Size|Limit|Offset|Prefix|Suffix|Pattern|Handler|Resource)$/;
 const BUILD_BOOTSTRAP_PREFIX_RE = /^(load|build|compile)(Modules?|Routes?|Routers?|Plugins?|Config|Schema|Program|Package|Project|Files?|Commands?|Migrations?|Definitions?|Manifest|Artifacts?)([A-Z0-9_]|$)/;
 // NOTE: the broad `.*Provider.*Service` clause was removed — it over-excluded FUNCTIONAL provider
@@ -106,23 +101,8 @@ function behaviorSurfaceExclusionReason(relPath, name, memberOf) {
     if (UTILITY_DIRECTORY_EXCLUDE_RE.test(path)) {
         return "Utility/model/tooling path — infrastructure plumbing, excluded from the behavior denominator.";
     }
-    if (FRAMEWORK_INTERNAL_PATH_EXCLUDE_RE.test(path)) {
-        return "Framework-internal route/query plumbing — excluded from the behavior denominator.";
-    }
-    if (CLI_PACKAGE_PATH_EXCLUDE_RE.test(path)) {
-        return "CLI developer tooling path — excluded from the behavior denominator.";
-    }
-    if (BACKEND_RUNTIME_PATH_EXCLUDE_RE.test(path)) {
-        return "Framework/runtime/link plumbing path — excluded from backend behavior denominator.";
-    }
-    if (UI_PRODUCT_PATH_EXCLUDE_RE.test(path)) {
-        return "UI/docs/design-system path — excluded from backend behavior denominator.";
-    }
-    if (SDK_CLIENT_PATH_EXCLUDE_RE.test(path)) {
-        return "SDK/client package path — excluded from backend behavior denominator.";
-    }
-    if (PLUGIN_ADMIN_PATH_EXCLUDE_RE.test(path)) {
-        return "Plugin admin UI path — excluded from backend behavior denominator.";
+    if (PRESENTATION_ASSET_PATH_RE.test(path)) {
+        return "Presentation asset/icon path — excluded from the behavior denominator.";
     }
     if (FRAMEWORK_HOOK_METHOD_RE.test(methodName)) {
         return "Framework lifecycle hook — excluded from the behavior denominator.";
@@ -160,6 +140,73 @@ function behaviorSurfaceReason(relPath, name, memberOf) {
     }
     return null;
 }
+const RUNTIME_SOURCE_EXT_RE = /\.(?:[cm]?[jt]sx?)$/i;
+/**
+ * Resolve package-level public entry modules from package metadata and the two
+ * conventional source entry paths. This gives libraries a semantic behavior
+ * surface without treating every exported helper in the repository as product
+ * behavior.
+ */
+function packagePublicEntryPaths(root, relPaths) {
+    const normalizedPaths = new Set(relPaths.map((relPath) => relPath.replace(/\\/g, "/")));
+    const entries = new Set();
+    const extensions = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"];
+    const addCandidate = (packageDir, rawTarget) => {
+        if (!rawTarget || rawTarget.includes("*") || rawTarget.startsWith("#"))
+            return;
+        const cleanTarget = rawTarget.replace(/^\.\//, "").split(/[?#]/, 1)[0];
+        if (!cleanTarget || cleanTarget.startsWith("../") || path.isAbsolute(cleanTarget))
+            return;
+        const relativeTarget = packageDir ? `${packageDir}/${cleanTarget}` : cleanTarget;
+        const candidates = new Set([relativeTarget]);
+        const withoutExt = relativeTarget.replace(RUNTIME_SOURCE_EXT_RE, "");
+        for (const extension of extensions)
+            candidates.add(`${withoutExt}${extension}`);
+        // Published packages often expose dist/index.js while analyzing src/index.ts.
+        const sourceBase = cleanTarget.replace(/^(?:dist|lib|build)\//, "src/").replace(RUNTIME_SOURCE_EXT_RE, "");
+        const sourceTarget = packageDir ? `${packageDir}/${sourceBase}` : sourceBase;
+        for (const extension of extensions)
+            candidates.add(`${sourceTarget}${extension}`);
+        for (const candidate of candidates) {
+            if (normalizedPaths.has(candidate))
+                entries.add(candidate);
+        }
+    };
+    const collectTargets = (value, targets) => {
+        if (typeof value === "string") {
+            targets.push(value);
+        }
+        else if (Array.isArray(value)) {
+            for (const item of value)
+                collectTargets(item, targets);
+        }
+        else if (value && typeof value === "object") {
+            for (const item of Object.values(value))
+                collectTargets(item, targets);
+        }
+    };
+    for (const manifestPath of normalizedPaths) {
+        if (path.posix.basename(manifestPath) !== "package.json")
+            continue;
+        const packageDir = path.posix.dirname(manifestPath) === "." ? "" : path.posix.dirname(manifestPath);
+        try {
+            const manifest = JSON.parse(readFileSync(path.join(root, manifestPath), "utf8"));
+            const targets = [];
+            for (const field of ["exports", "main", "module", "browser"])
+                collectTargets(manifest[field], targets);
+            for (const target of targets)
+                addCandidate(packageDir, target);
+        }
+        catch {
+            // Malformed package metadata is reported elsewhere; it must not stop analysis.
+        }
+        for (const conventional of ["index", "src/index"]) {
+            for (const extension of extensions)
+                addCandidate(packageDir, `${conventional}${extension}`);
+        }
+    }
+    return entries;
+}
 const FLOW_LINK_STOPWORDS = new Set([
     "test",
     "tests",
@@ -282,6 +329,7 @@ export function analyzeRepo(root, opts = {}) {
     const maxSymbols = Math.max(1, opts.maxSymbols ?? MAX_TOTAL_SYMBOLS);
     const ignore = loadIgnore(root);
     const { files, truncated: filesCapHit, max_files: maxFiles } = walkFilesWithMeta(root, ignore, { maxFiles: opts.maxFiles });
+    const publicEntryFiles = packagePublicEntryPaths(root, files.map((file) => file.relPath));
     const warnings = [];
     // Wall-clock budget for the per-file scan (DISCLOSED partial when hit; never silent).
     const now = opts.now ?? (() => Date.now());
@@ -741,7 +789,8 @@ export function analyzeRepo(root, opts = {}) {
                         : callableBehaviorCandidate && !surfaceExclusionReason
                             ? behaviorSurfaceReason(file.relPath, sym.name, sym.member_of)
                             : null;
-                    const eligible = callableBehaviorCandidate && surfaceReason !== null;
+                    const publicApiEntry = callableBehaviorCandidate && !surfaceExclusionReason && publicEntryFiles.has(file.relPath);
+                    const eligible = callableBehaviorCandidate && (surfaceReason !== null || publicApiEntry);
                     const behaviorSurfaceExcluded = callableBehaviorCandidate && surfaceExclusionReason !== null;
                     const notEntryPointAdjacent = callableBehaviorCandidate && !eligible && !behaviorSurfaceExcluded;
                     if (isBoilerplate)
@@ -757,7 +806,7 @@ export function analyzeRepo(root, opts = {}) {
                             ...(sym.end_line ? { end_line: sym.end_line } : {}),
                             ...(sym.member_of ? { member_of: sym.member_of } : {}),
                             ...(sym.callable !== undefined ? { callable_const: sym.callable } : {}),
-                            ...(surfaceReason ? { behavior_surface: "entrypoint_adjacent" } : {}),
+                            ...(surfaceReason ? { behavior_surface: "entrypoint_adjacent" } : publicApiEntry ? { behavior_surface: "public_api_entry" } : {}),
                             ...(behaviorSurfaceExcluded ? { denominator_reason_code: "infra_behavior_surface" } : {}),
                             ...(notEntryPointAdjacent ? { denominator_reason_code: "not_entry_point_adjacent" } : {})
                         },
@@ -777,13 +826,15 @@ export function analyzeRepo(root, opts = {}) {
                                         ? BOILERPLATE_REASON
                                         : eligible && surfaceReason
                                             ? surfaceReason
-                                            : behaviorSurfaceExcluded && surfaceExclusionReason
-                                                ? surfaceExclusionReason
-                                                : callableBehaviorCandidate
-                                                    ? "Callable export is not API/service/route/job-adjacent — kept for grounding, excluded from the behavior denominator."
-                                                    : sym.symbol_kind === "class"
-                                                        ? "Exported class container — kept for grounding; methods/functions carry behavior in v1."
-                                                        : "Exported const (not provably callable) — excluded from the denominator in v1."
+                                            : publicApiEntry
+                                                ? "Callable export from a package public entry module — countable library behavior surface."
+                                                : behaviorSurfaceExcluded && surfaceExclusionReason
+                                                    ? surfaceExclusionReason
+                                                    : callableBehaviorCandidate
+                                                        ? "Callable export is not API/service/route/job-adjacent — kept for grounding, excluded from the behavior denominator."
+                                                        : sym.symbol_kind === "class"
+                                                            ? "Exported class container — kept for grounding; methods/functions carry behavior in v1."
+                                                            : "Exported const (not provably callable) — excluded from the denominator in v1."
                     }));
                     edges.push(makeEdge({
                         from_external_id: symId,

package/dist/local/analyze/behaviorContracts.js

@@ -15,6 +15,10 @@ const NEST_GQL_METHOD_DECORATOR = /@(Query|Mutation|Subscription|ResolveField)\s
 const NEST_PROCESSOR_DECORATOR = /@Processor\s*\(\s*(?:(["'`])([^"'`]*)\1|[A-Za-z_$][A-Za-z0-9_$.]*)?\s*\)(?:\s|@[A-Za-z_$][A-Za-z0-9_$]*(?:\s*\((?:[^()]|\([^()]*\))*\))?|\/\*[\s\S]*?\*\/|\/\/[^\n]*\n)*?(?:export\s+)?class\s+([A-Za-z_$][A-Za-z0-9_$]*)/g;
 const NEST_PROCESS_METHOD_DECORATOR = /@Process\s*\((?:[^()]|\([^()]*\))*\)(?:\s|@[A-Za-z_$][A-Za-z0-9_$]*(?:\s*\((?:[^()]|\([^()]*\))*\))?|\/\*[\s\S]*?\*\/|\/\/[^\n]*\n)*?(?:public\s+|private\s+|protected\s+|async\s+)*([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/g;
 const NEST_CONTROLLER_DECORATOR = /@Controller\s*\(\s*(?:(["'`])([^"'`]*)\1)?\s*\)(?:\s|@[A-Za-z_$][A-Za-z0-9_$]*(?:\s*\((?:[^()]|\([^()]*\))*\))?|\/\*[\s\S]*?\*\/|\/\/[^\n]*\n)*?(?:export\s+)?class\s+([A-Za-z_$][A-Za-z0-9_$]*)/g;
+const NEST_RESOLVER_DECORATOR = /@Resolver(?:\s*\((?:[^()]|\([^()]*\))*\))?(?:\s|@[A-Za-z_$][A-Za-z0-9_$]*(?:\s*\((?:[^()]|\([^()]*\))*\))?|\/\*[\s\S]*?\*\/|\/\/[^\n]*\n)*?(?:export\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][A-Za-z0-9_$]*)/g;
+const NEST_WORKER_PROCESS_METHOD = /(?:^|[\n;}])\s*(?:public\s+|protected\s+|override\s+|async\s+)*\b(process)\s*\(/g;
+const NEST_CRON_METHOD_DECORATOR = /@Cron\s*\((?:[^()]|\([^()]*\))*\)(?:\s|@[A-Za-z_$][A-Za-z0-9_$]*(?:\s*\((?:[^()]|\([^()]*\))*\))?|\/\*[\s\S]*?\*\/|\/\/[^\n]*\n)*?(?:public\s+|private\s+|protected\s+|async\s+)*([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/g;
+const NEST_EVENT_METHOD_DECORATOR = /@(OnEvent|EventPattern|MessagePattern)\s*\(\s*(?:(["'`])([^"'`]*)\2|(?:[^()]|\([^()]*\))*)\s*\)(?:\s|@[A-Za-z_$][A-Za-z0-9_$]*(?:\s*\((?:[^()]|\([^()]*\))*\))?|\/\*[\s\S]*?\*\/|\/\/[^\n]*\n)*?(?:public\s+|private\s+|protected\s+|async\s+)*([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/g;
 const EXPRESS_ROUTER_CALL = /\b(?:router|app)\s*\.\s*(get|post|put|delete|patch|options|head|all)\s*\(\s*(["'`])([^"'`]*)\2\s*,\s*([A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)?|\([^)]*\)\s*=>|async\s+\([^)]*\)\s*=>|function\s+[A-Za-z_$][A-Za-z0-9_$]*)/gi;
 const EXPRESS_ROUTE_CHAIN = /\b(?:router|app)\s*\.\s*route\s*\(\s*(["'`])([^"'`]*)\1\s*\)((?:\s*\.\s*(?:get|post|put|delete|patch|options|head|all)\s*\([^)]*\))+)/gi;
 const CHAINED_METHOD_CALL = /\.\s*(get|post|put|delete|patch|options|head|all)\s*\(\s*([A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)?|\([^)]*\)\s*=>|async\s+\([^)]*\)\s*=>|function\s+[A-Za-z_$][A-Za-z0-9_$]*)/gi;
@@ -26,6 +30,8 @@ export function extractBehaviorContracts(content, file) {
         ...extractNestContracts(content, file),
         ...extractNestGraphqlContracts(content, file),
         ...extractNestProcessorContracts(content, file),
+        ...extractNestScheduledContracts(content, file),
+        ...extractNestEventContracts(content, file),
         ...extractRouterContracts(content, file, EXPRESS_ROUTER_CALL, "express"),
         ...extractExpressRouteChains(content, file),
         ...extractRouterContracts(content, file, FASTIFY_CALL, "fastify")
@@ -49,104 +55,148 @@ function extractFileRouteContracts(content, file) {
     return contracts;
 }
 function extractNestContracts(content, file) {
-    const controllers = [...content.matchAll(NEST_CONTROLLER_DECORATOR)].map((match) => ({
-        index: match.index ?? 0,
-        path: normalizeRoutePath(match[2] ?? ""),
-        name: match[3]
-    }));
+    const controllers = classRanges(content, NEST_CONTROLLER_DECORATOR, 3, 2);
     if (controllers.length === 0)
         return [];
     const contracts = [];
-    for (const match of content.matchAll(NEST_METHOD_DECORATOR)) {
-        const index = match.index ?? 0;
-        const controller = nearestController(controllers, index);
-        const method = httpMethod(match[1]);
-        const routePath = joinRoutePaths(controller?.path ?? "", match[3] ?? match[5] ?? "");
-        const handler = match[6];
-        contracts.push(makeContract({
-            file,
-            framework: "nestjs",
-            method,
-            path: routePath,
-            handler,
-            controller: controller?.name
-        }));
+    for (const controller of controllers) {
+        for (const match of controller.body.matchAll(NEST_METHOD_DECORATOR)) {
+            const method = httpMethod(match[1]);
+            const routePath = joinRoutePaths(normalizeRoutePath(controller.path ?? ""), match[3] ?? match[5] ?? "");
+            const handler = match[6];
+            contracts.push(makeContract({ file, framework: "nestjs", method, path: routePath, handler, controller: controller.name }));
+        }
     }
     return contracts;
 }
 function extractNestGraphqlContracts(content, file) {
-    // GraphQL resolvers are first-class user-triggerable entry points. In
-    // NestJS-heavy monorepos (Twenty: 415 @Query/@Mutation methods vs 139 HTTP
-    // routes) skipping them left almost every user behavior without an Endpoint
-    // anchor, so static flows rooted at internal orphan methods instead.
     if (!/@(Query|Mutation|Subscription)\s*\(/.test(content))
         return [];
-    const resolvers = [...content.matchAll(CLASS_DECLARATION)].map((match) => ({
-        index: match.index ?? 0,
-        path: "",
-        name: match[1]
-    }));
+    // Only methods lexically inside an actual @Resolver class qualify. Looking
+    // for @Query anywhere in a file misclassified query builders and ORM metadata.
+    const resolvers = classRanges(content, NEST_RESOLVER_DECORATOR, 1);
     if (resolvers.length === 0)
         return [];
     const contracts = [];
-    for (const match of content.matchAll(NEST_GQL_METHOD_DECORATOR)) {
-        const resolver = nearestController(resolvers, match.index ?? 0);
-        if (!resolver)
-            continue;
-        const opKind = match[1].toUpperCase();
-        if (opKind === "RESOLVEFIELD")
-            continue; // field resolvers are not user-triggerable operations
-        const handler = match[2];
-        contracts.push(makeContract({
-            file,
-            framework: "nestjs",
-            kind: "graphql_operation",
-            method: opKind,
-            path: `graphql:${handler}`,
-            handler,
-            controller: resolver.name
-        }));
+    for (const resolver of resolvers) {
+        for (const match of resolver.body.matchAll(NEST_GQL_METHOD_DECORATOR)) {
+            const opKind = match[1].toUpperCase();
+            if (opKind === "RESOLVEFIELD")
+                continue;
+            const handler = match[2];
+            contracts.push(makeContract({ file, framework: "nestjs", kind: "graphql_operation", method: opKind, path: `graphql:${handler}`, handler, controller: resolver.name }));
+        }
     }
     return contracts;
 }
 function extractNestProcessorContracts(content, file) {
-    // Background jobs and crons are behaviors (June 27 definition: user- or
-    // system-triggerable, cross-layer, observable outcome). Anchoring them lets
-    // the flow walker show queue-driven chains instead of orphan roots.
-    const processors = [...content.matchAll(NEST_PROCESSOR_DECORATOR)].map((match) => ({
-        index: match.index ?? 0,
-        path: normalizeRoutePath(match[2] ?? ""),
-        name: match[3]
-    }));
+    const processors = classRanges(content, NEST_PROCESSOR_DECORATOR, 3, 2);
     if (processors.length === 0)
         return [];
     const contracts = [];
-    for (const match of content.matchAll(NEST_PROCESS_METHOD_DECORATOR)) {
-        const processor = nearestController(processors, match.index ?? 0);
-        if (!processor)
-            continue;
-        const handler = match[1];
-        contracts.push(makeContract({
-            file,
-            framework: "nestjs",
-            kind: "queue_processor",
-            method: "JOB",
-            path: `queue:${processor.path || processor.name}`,
-            handler,
-            controller: processor.name
-        }));
+    for (const processor of processors) {
+        const handlers = new Set();
+        for (const match of processor.body.matchAll(NEST_PROCESS_METHOD_DECORATOR))
+            handlers.add(match[1]);
+        if (/\bextends\s+WorkerHost\b/.test(processor.header)) {
+            for (const match of processor.body.matchAll(NEST_WORKER_PROCESS_METHOD))
+                handlers.add(match[1]);
+        }
+        for (const handler of handlers) {
+            contracts.push(makeContract({ file, framework: "nestjs", kind: "queue_processor", method: "JOB", path: `queue:${processor.path || processor.name}`, handler, controller: processor.name }));
+        }
     }
     return contracts;
 }
-function nearestController(controllers, index) {
-    let current;
-    for (const controller of controllers) {
-        if (controller.index <= index)
-            current = controller;
-        else
-            break;
+function extractNestScheduledContracts(content, file) {
+    const contracts = [];
+    for (const owner of classRanges(content, CLASS_DECLARATION, 1)) {
+        for (const match of owner.body.matchAll(NEST_CRON_METHOD_DECORATOR)) {
+            const handler = match[1];
+            contracts.push(makeContract({ file, framework: "nestjs", kind: "scheduled_task", method: "SCHEDULE", path: `schedule:${handler}`, handler, controller: owner.name }));
+        }
+    }
+    return contracts;
+}
+function extractNestEventContracts(content, file) {
+    const contracts = [];
+    for (const owner of classRanges(content, CLASS_DECLARATION, 1)) {
+        for (const match of owner.body.matchAll(NEST_EVENT_METHOD_DECORATOR)) {
+            const handler = match[4];
+            const event = match[3] ?? handler;
+            contracts.push(makeContract({ file, framework: "nestjs", kind: "event_consumer", method: "EVENT", path: `event:${event}`, handler, controller: owner.name }));
+        }
+    }
+    return contracts;
+}
+function classRanges(content, pattern, nameGroup, pathGroup) {
+    const ranges = [];
+    for (const match of content.matchAll(pattern)) {
+        const start = match.index ?? 0;
+        const open = content.indexOf("{", start + match[0].length);
+        if (open === -1)
+            continue;
+        const close = matchingBrace(content, open);
+        if (close === -1)
+            continue;
+        ranges.push({
+            name: match[nameGroup],
+            ...(pathGroup ? { path: match[pathGroup] ?? "" } : {}),
+            header: content.slice(start, open),
+            body: content.slice(open + 1, close)
+        });
+    }
+    return ranges;
+}
+function matchingBrace(content, open) {
+    let depth = 0;
+    let quote = "";
+    let lineComment = false;
+    let blockComment = false;
+    for (let i = open; i < content.length; i++) {
+        const c = content[i];
+        const next = content[i + 1] ?? "";
+        if (lineComment) {
+            if (c === "\n")
+                lineComment = false;
+            continue;
+        }
+        if (blockComment) {
+            if (c === "*" && next === "/") {
+                blockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (quote) {
+            if (c === "\\") {
+                i++;
+                continue;
+            }
+            if (c === quote)
+                quote = "";
+            continue;
+        }
+        if (c === "/" && next === "/") {
+            lineComment = true;
+            i++;
+            continue;
+        }
+        if (c === "/" && next === "*") {
+            blockComment = true;
+            i++;
+            continue;
+        }
+        if (c === '"' || c === "'" || c === "`") {
+            quote = c;
+            continue;
+        }
+        if (c === "{")
+            depth++;
+        else if (c === "}" && --depth === 0)
+            return i;
     }
-    return current;
+    return -1;
 }
 function extractRouterContracts(content, file, pattern, framework) {
     const contracts = [];

package/dist/local/analyze/confirm.js

@@ -2376,6 +2376,119 @@ export function confirmPair(ctx, testAbsPath, implAbsPath, behaviorName) {
         reason: "behavior not evaluated"
     });
 }
+// Workspace/alias resolution is useful for candidate linkage in TS monorepos,
+// but resolution and a call reference are not assertion evidence. Keep this
+// resolver separate from the hard-proof confirmer below.
+import { readFileSync as _rf, existsSync as _ex, readdirSync as _rd } from "node:fs";
+import { dirname as _dn, join as _jn, resolve as _rs } from "node:path";
+const EXT_TRIES = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
+const BUILT_DIRS = /\/(lib|dist|build|out)(\/|$)/;
+function tryFile(base) {
+    for (const e of EXT_TRIES)
+        if (_ex(base + e))
+            return base + e;
+    return null;
+}
+function readJsonSafe(p) {
+    try {
+        return JSON.parse(_rf(p, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Nearest tsconfig paths/baseUrl for a file, walking extends chains (depth-capped). */
+function tsconfigPathsFor(fileAbs, stopDir) {
+    let dir = _dn(fileAbs);
+    for (let i = 0; i < 12 && dir.startsWith(stopDir); i++) {
+        const tc = _jn(dir, "tsconfig.json");
+        if (_ex(tc)) {
+            let merged = {};
+            let cur = tc;
+            for (let d = 0; d < 6 && cur; d++) {
+                const j = readJsonSafe(cur);
+                if (!j)
+                    break;
+                const co = (j.compilerOptions ?? {});
+                merged = { baseUrl: merged.baseUrl ?? (co.baseUrl ? _rs(_dn(cur), co.baseUrl) : undefined), paths: { ...co.paths, ...merged.paths } };
+                cur = typeof j.extends === "string" ? (tryFile(_rs(_dn(cur), j.extends)) ?? (_ex(_rs(_dn(cur), j.extends + ".json")) ? _rs(_dn(cur), j.extends + ".json") : null)) : null;
+            }
+            return { baseUrl: merged.baseUrl ?? _dn(tc), paths: merged.paths ?? {} };
+        }
+        const parent = _dn(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/** Workspace member name → package dir, from the root package.json workspaces globs. */
+function workspacePackages(repoRoot) {
+    const out = new Map();
+    const rootPkg = readJsonSafe(_jn(repoRoot, "package.json"));
+    const ws = rootPkg?.workspaces;
+    const globs = Array.isArray(ws) ? ws : Array.isArray(ws?.packages) ? ws.packages : [];
+    const dirs = [];
+    for (const g of globs) {
+        if (g.endsWith("/*")) {
+            const base = _jn(repoRoot, g.slice(0, -2));
+            try {
+                for (const d of _rd(base))
+                    dirs.push(_jn(base, d));
+            }
+            catch { /* absent */ }
+        }
+        else
+            dirs.push(_jn(repoRoot, g));
+    }
+    for (const d of dirs) {
+        const pj = readJsonSafe(_jn(d, "package.json"));
+        const name = pj?.name;
+        if (typeof name === "string")
+            out.set(name, d);
+    }
+    return out;
+}
+/** Resolve one import specifier from a test file to an in-repo file, or null. */
+export function resolveSpecifier(spec, fromFile, repoRoot, wsPkgs) {
+    if (spec.startsWith("."))
+        return tryFile(_rs(_dn(fromFile), spec));
+    const tc = tsconfigPathsFor(fromFile, repoRoot);
+    if (tc) {
+        for (const [pat, targets] of Object.entries(tc.paths)) {
+            const star = pat.indexOf("*");
+            const matches = star >= 0 ? spec.startsWith(pat.slice(0, star)) && spec.endsWith(pat.slice(star + 1)) : spec === pat;
+            if (!matches)
+                continue;
+            const wild = star >= 0 ? spec.slice(pat.slice(0, star).length, spec.length - pat.slice(star + 1).length) : "";
+            for (const t of targets) {
+                const hit = tryFile(_rs(tc.baseUrl, t.replace("*", wild)));
+                if (hit)
+                    return hit;
+            }
+        }
+        if (!spec.startsWith("@") && !spec.includes(":")) {
+            const viaBase = tryFile(_rs(tc.baseUrl, spec));
+            if (viaBase)
+                return viaBase;
+        }
+    }
+    // workspace package name (longest-prefix match), with built→src subpath mapping
+    for (const [name, dir] of wsPkgs) {
+        if (spec !== name && !spec.startsWith(name + "/"))
+            continue;
+        const sub = spec === name ? "" : spec.slice(name.length + 1);
+        const candidates = sub
+            ? [sub, sub.replace(BUILT_DIRS, "/src/"), "src/" + sub.replace(/^(lib|dist|build|out)\//, "")]
+            : ["src/index", "index"];
+        for (const c of candidates) {
+            const hit = tryFile(_jn(dir, c));
+            if (hit)
+                return hit;
+        }
+    }
+    return null;
+}
 /**
  * Run the confirmer over every candidate (test -> impl) pair (the resolver-derived
  * MAY_RELATE_TO links). For each denominator-eligible exported symbol of the impl

package/dist/local/autoProve.js

@@ -794,7 +794,8 @@ export async function autoProve(root, opts, deps) {
         dynamicProofRunner: deps.dynamicProofRunner,
         coverageRunner: deps.coverageRunner,
         analyze: deps.analyze,
-        aiProvider: deps.aiProvider
+        aiProvider: deps.aiProvider,
+        suppressBehaviorReportRefresh: deps.suppressBehaviorReportRefresh
     };
     const graph = loadGraph(workspacePaths(root).graphPath);
     const sourceRoot = resolve(graph.workspace.root);

package/dist/local/cli.js

@@ -22,6 +22,7 @@ import { WORKSPACE_DIR } from "./workspace.js";
 import { summarizeCorpusScope } from "./corpusScope.js";
 import { jobJsonPath, jobLogPath, listJobs, newJobId, readJobRecord, updateJobRecord, writeJobRecord } from "./jobs/jobStore.js";
 import { runGenerateJob } from "./jobs/runner.js";
+import { ORANGEPRO_VERSION } from "./version.js";
 function out(line = "") {
     process.stdout.write(line + "\n");
 }
@@ -157,13 +158,21 @@ function bar(value) {
 }
 async function main() {
     const argv = process.argv.slice(2);
+    if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v" || argv[0] === "version")) {
+        out(ORANGEPRO_VERSION);
+        return 0;
+    }
     const [rawCommand, ...rawRest] = argv;
     const command = !rawCommand || rawCommand.startsWith("--") ? "start" : rawCommand;
     const rest = !rawCommand || rawCommand.startsWith("--") ? argv : rawRest;
     const { positionals, flags } = parseArgs(rest);
     const json = asBool(flags.json, false);
     const cwd = process.cwd();
-    if (command === "help" || flags.help) {
+    if (command === "help" || flags.help || flags.version) {
+        if (flags.version) {
+            out(ORANGEPRO_VERSION);
+            return 0;
+        }
         out(HELP);
         return 0;
     }

package/dist/local/enrich/markdown.js

@@ -11,7 +11,7 @@ const MAX_REQUIREMENTS = 60;
  * REQ-md-the-author-should-do-the-following-if-applicable and surfaced as the
  * report's top suggested next action. Product docs (README, docs/) still count.
  */
-const GOVERNANCE_MD_RE = /(^|\/)\.github\/|(^|\/)(CONTRIBUTING|CODE_OF_CONDUCT|PULL_REQUEST_TEMPLATE|ISSUE_TEMPLATE|SECURITY|SUPPORT|CHANGELOG|LICENSE|GOVERNANCE|MAINTAINERS|CODEOWNERS|AUTHORS)[^\/]*$|(^|\/)\.changeset\/|\/templates?\/|(^|\/)(AGENTS|CLAUDE|GEMINI|COPILOT)\.md$|(^|\/)\.cursor(rules)?\//i;
+const GOVERNANCE_MD_RE = /(^|\/)\.github\/|(^|\/)(CONTRIBUTING|CODE_OF_CONDUCT|PULL_REQUEST_TEMPLATE|ISSUE_TEMPLATE|SECURITY|SUPPORT|CHANGELOG|LICENSE|GOVERNANCE|MAINTAINERS|CODEOWNERS|AUTHORS)[^\/]*$|(^|\/)\.changeset\/|(^|\/)(AGENTS|CLAUDE|GEMINI|COPILOT)\.md$|(^|\/)\.cursor(rules)?\//i;
 /** Words that suggest a heading describes a requirement/feature behavior. */
 const REQUIREMENT_HINTS = [
     "requirement",

package/dist/local/flows/flowWalker.js

@@ -3,7 +3,7 @@ import { LOCAL_GRAPH_SCHEMA_VERSION } from "../graph/ontology.js";
 import { rankRiskGaps } from "../score/risk.js";
 import { stableId } from "../util/ids.js";
 const DEFAULT_MAX_DEPTH = 8;
-const DEFAULT_MAX_FLOWS_PER_ENTRY = 5;
+const DEFAULT_MAX_FLOWS_PER_ENTRY = 20;
 const DEFAULT_GLOBAL_CAP = 500;
 const HIGH_ROUTE_RE = /payment|refund|checkout|cart|order|auth|login|token|customer|user|tax|fulfillment|ship/i;
 const MUTATION_METHOD_RE = /^(POST|PUT|PATCH|DELETE)\b/i;
@@ -103,16 +103,13 @@ export function rankEntries(graph, entries, adjacency) {
         gap.id,
         gap.risk_score
     ]));
-    // Endpoint-anchored flows first. An Endpoint entry IS the definition of a
-    // user-triggerable behavior (June 27 agreement); orphan call-graph roots are
-    // useful but must never crowd endpoints out of the global cap — on Twenty,
-    // saturated risk ties let ~25 internal orphan methods consume all 500 flow
-    // slots while every HTTP/GraphQL entry point went unrendered.
+    // One score space across every topology. Endpoint fallback weight keeps real
+    // external triggers prominent, while a materially riskier internal/library
+    // behavior can still outrank them. A hard Endpoint/Behavior partition made
+    // server-shaped repos look good but hid critical roots in mixed/library repos.
     const score = (e) => Math.max(riskScores.get(e.start) ?? 0, fallbackScore(e, adjacency));
-    const byScore = (a, b) => score(b) - score(a) || a.external_id.localeCompare(b.external_id) || a.start.localeCompare(b.start);
-    const endpoints = entries.filter((e) => e.kind === "Endpoint").sort(byScore);
-    const behaviors = entries.filter((e) => e.kind !== "Endpoint").sort(byScore);
-    return [...endpoints, ...behaviors];
+    const byScore = (a, b) => score(b) - score(a) || (a.kind === b.kind ? 0 : a.kind === "Endpoint" ? -1 : 1) || a.external_id.localeCompare(b.external_id) || a.start.localeCompare(b.start);
+    return [...entries].sort(byScore);
 }
 function prunePrefixSubsumed(flows) {
     const sorted = [...flows].sort((a, b) => b.path.length - a.path.length || a.id.localeCompare(b.id));

package/dist/local/generate/generator.js

@@ -552,7 +552,7 @@ export function gatherContext(graph, behavior, framework, fileReader) {
         acceptance_criteria: acceptance,
         workflow_steps: workflow,
         framework,
-        test_layer: inferLayer(behavior, framework, graph),
+        test_layer: inferTestLayer(behavior, framework, graph),
         code_context: dedupe(codeContext),
         source_excerpts: excerpts,
         weak_context: dedupe(weakContext),
@@ -602,7 +602,7 @@ function flowChainFor(graph, behavior) {
         };
     });
 }
-function inferLayer(behavior, framework, graph) {
+export function inferTestLayer(behavior, framework, graph) {
     const fw = framework.toLowerCase();
     if (fw.includes("playwright") || fw.includes("cypress"))
         return "e2e";
@@ -613,22 +613,40 @@ function inferLayer(behavior, framework, graph) {
     const hint = String(behavior.properties.test_layer ?? "");
     if (hint)
         return hint;
-    // Graph-aware default (hop-count methodology): a behavior that an endpoint
-    // implements, or that participates in a multi-step call chain, is an
-    // INTEGRATION target — the code→flows→behaviors journey is the product;
-    // "unit" is only for genuinely 0-hop leaf functions. The old blanket
-    // "unit" default stamped every vitest/jest repo unit-first.
+    // Infer a layer only from evidence that actually distinguishes it. A CALLS
+    // edge alone says nothing about the intended test boundary: libraries and
+    // ordinary unit subjects call helpers too. External handlers are API targets;
+    // they become integration targets only when their reachable path crosses a
+    // source-file boundary. Ambiguous cases stay unknown instead of being tuned
+    // to a server application's topology.
     if (graph) {
         const id = behavior.external_id;
         const isEntryHandler = graph.edges.some((e) => e.relationship_type === "IMPLEMENTED_IN" && e.to_external_id === id);
+        const fileById = new Map(graph.nodes
+            .filter((node) => node.kind === "CodeSymbol")
+            .map((node) => [node.external_id, String(node.properties.file ?? "")]));
+        const behaviorFile = fileById.get(id) ?? "";
+        const crossesFile = (from, to) => {
+            const fromFile = fileById.get(from) ?? "";
+            const toFile = fileById.get(to) ?? "";
+            return fromFile !== "" && toFile !== "" && fromFile !== toFile;
+        };
+        const directCrossBoundary = graph.edges.some((e) => e.relationship_type === "CALLS" && e.from_external_id === id && crossesFile(e.from_external_id, e.to_external_id));
+        const triggeredCrossBoundary = (graph.analysis?.flows?.flows ?? []).some((flow) => {
+            if (flow.entry_point.kind !== "Endpoint")
+                return false;
+            const chain = flow.hops.length > 0 ? [flow.hops[0].from, ...flow.hops.map((hop) => hop.to)] : [];
+            if (!chain.includes(id))
+                return false;
+            const files = new Set(chain.map((symbolId) => fileById.get(symbolId) ?? "").filter(Boolean));
+            return files.size > 1;
+        });
         if (isEntryHandler)
-            return "integration";
-        const inChain = graph.edges.some((e) => e.relationship_type === "CALLS" && (e.from_external_id === id || e.to_external_id === id)) ||
-            (graph.analysis?.flows?.flows ?? []).some((f) => f.entry_point.external_id === id || f.hops.some((h) => h.from === id || h.to === id));
-        if (inChain)
+            return directCrossBoundary || triggeredCrossBoundary ? "integration" : "api";
+        if (behaviorFile && triggeredCrossBoundary)
             return "integration";
     }
-    return "unit";
+    return "unknown";
 }
 function tooThin(ctx) {
     const needed = [];

package/dist/local/operations.js

@@ -1327,11 +1327,13 @@ export function opProveLoop(root, opts, deps = defaultDeps()) {
     // Best-effort report refresh (exactly like ai-flows --apply): a render failure
     // must never fail a completed proof — the ledger/cert is already written.
     let behaviorCoveragePath;
-    try {
-        behaviorCoveragePath = opBehaviorCoverageHtml(root, `${WORKSPACE_DIR}/behavior-coverage.html`).behavior_coverage_path;
-    }
-    catch {
-        // ponytail: swallow — refresh is advisory; DynamicProofResult carries no warnings channel.
+    if (!deps.suppressBehaviorReportRefresh) {
+        try {
+            behaviorCoveragePath = opBehaviorCoverageHtml(root, `${WORKSPACE_DIR}/behavior-coverage.html`).behavior_coverage_path;
+        }
+        catch {
+            // ponytail: swallow — refresh is advisory; DynamicProofResult carries no warnings channel.
+        }
     }
     return { ...proof, ...(behaviorCoveragePath ? { behavior_coverage_path: behaviorCoveragePath } : {}) };
 }
@@ -1405,11 +1407,13 @@ export async function opAiFlows(root, opts = {}, deps = defaultDeps()) {
         // Best-effort: a render failure must never fail apply (graph is saved).
         const warnings = [...result.warnings];
         let behaviorCoveragePath;
-        try {
-            behaviorCoveragePath = opBehaviorCoverageHtml(root, `${WORKSPACE_DIR}/behavior-coverage.html`).behavior_coverage_path;
-        }
-        catch (error) {
-            warnings.push(`behavior coverage view not written: ${error instanceof Error ? error.message : String(error)}`);
+        if (!deps.suppressBehaviorReportRefresh) {
+            try {
+                behaviorCoveragePath = opBehaviorCoverageHtml(root, `${WORKSPACE_DIR}/behavior-coverage.html`).behavior_coverage_path;
+            }
+            catch (error) {
+                warnings.push(`behavior coverage view not written: ${error instanceof Error ? error.message : String(error)}`);
+            }
         }
         return { ...result, warnings, ...(behaviorCoveragePath ? { behavior_coverage_path: behaviorCoveragePath } : {}) };
     }
@@ -1471,11 +1475,7 @@ function writeStartStaticSnapshot(root, baseRef, warnings) {
     let behaviorCoveragePath;
     try {
         reportProgress("artifacts: writing static behavior view (proof still running)", { current: 4, total: 8 });
-        behaviorCoveragePath = opBehaviorCoverageHtml(root, `${WORKSPACE_DIR}/behavior-coverage.html`, {
-            attempted: 0,
-            proven: 0,
-            needsSetup: []
-        }).behavior_coverage_path;
+        behaviorCoveragePath = opBehaviorCoverageHtml(root, `${WORKSPACE_DIR}/behavior-coverage.html`, { attempted: 0, proven: 0, needsSetup: [] }, { persistBaseline: false }).behavior_coverage_path;
     }
     catch (error) {
         warnings.push(`static behavior view not written: ${error instanceof Error ? error.message : String(error)}`);
@@ -1493,7 +1493,9 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
     const providerOpts = startProviderOverride(root, opts);
     const scanRoot = opts.source ? resolve(opts.source) : resolve(root);
     const providerEnv = loadProviderEnv([root, scanRoot], deps.env);
-    const providerDeps = { ...deps, env: providerEnv };
+    // `start` writes advisory/intermediate views before the final report. Keep
+    // those helpers from advancing report-baseline.json mid-run.
+    const providerDeps = { ...deps, env: providerEnv, suppressBehaviorReportRefresh: true };
     const scope = summarizeCorpusScope(scanRoot);
     reportProgress(`start: preflight found ${scope.files.toLocaleString()} source/doc file(s)`, { current: 1, total: 8 });
     reportProgress("start: running deterministic analysis", { current: 2, total: 8 });
@@ -1995,7 +1997,7 @@ export function opGraphHtml(root, outputPath = "orangepro-graph.html") {
     return { graph_html_path: htmlPath };
 }
 /** Write the self-contained offline behavior-coverage view (deterministic, metadata only). */
-export function opBehaviorCoverageHtml(root, outputPath = "orangepro-behavior-coverage.html", dynamicProof) {
+export function opBehaviorCoverageHtml(root, outputPath = "orangepro-behavior-coverage.html", dynamicProof, options = {}) {
     const graph = loadGraph(workspacePaths(root).graphPath);
     // Standalone regens have no this-run outcome: fall back to the persisted
     // proof-attempts sidecar ONLY when it anchors to the current graph+commit
@@ -2017,11 +2019,13 @@ export function opBehaviorCoverageHtml(root, outputPath = "orangepro-behavior-co
     const html = renderBehaviorReport(data);
     const htmlPath = resolve(root, outputPath);
     writeFileSync(htmlPath, html, "utf8");
-    try {
-        writeFileSync(baselinePath, JSON.stringify(reportBaselineOf(data, new Date().toISOString())), "utf8");
-    }
-    catch {
-        // baseline write is advisory
+    if (options.persistBaseline !== false) {
+        try {
+            writeFileSync(baselinePath, JSON.stringify(reportBaselineOf(data, new Date().toISOString())), "utf8");
+        }
+        catch {
+            // baseline write is advisory
+        }
     }
     return { behavior_coverage_path: htmlPath };
 }

package/dist/local/score/risk.js

@@ -93,7 +93,7 @@ function gitFirstCommitBatch(root, files) {
     }
     return out;
 }
-function isEntryPoint(node) {
+export function isEntryPoint(node) {
     const file = symbolFile(node);
     const title = symbolTitle(node);
     if (API_HANDLER_NAME_RE.test(title) && /(^|\/)api(s)?\//i.test(file))
@@ -424,9 +424,12 @@ export function rankRiskGaps(graph, opts = {}) {
         };
     })
         .sort((a, b) => b.risk_score - a.risk_score || b.incoming_refs - a.incoming_refs || b.git_churn - a.git_churn || a.id.localeCompare(b.id));
-    // Portfolio diversity: cap how many gaps a single file contributes to the
-    // surfaced list, then backfill with the remaining highest scores if short.
-    const maxPerFile = Math.max(1, opts.maxPerFile ?? 3);
+    // The default API is the true global ranking because reports call this list
+    // "top risks". Callers may explicitly request a diversified portfolio, but
+    // that presentation policy must never silently redefine rank.
+    if (opts.maxPerFile === undefined)
+        return ranked.slice(0, limit);
+    const maxPerFile = Math.max(1, opts.maxPerFile);
     const perFile = new Map();
     const surfaced = [];
     const overflow = [];

package/dist/local/viz/behaviorReportData.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { buildRtm } from "../rtm.js";
-import { rankRiskGaps } from "../score/risk.js";
+import { isEntryPoint, rankRiskGaps } from "../score/risk.js";
 import { PROOF_BLOCKER_GUIDE } from "../proofDoctor.js";
 /** Short human phrase per R-1 needs_setup category, for the "blocked because: …" panel copy. */
 const BLOCK_CATEGORY_LABEL = {
@@ -285,7 +285,9 @@ function flows(graph, rows, risks) {
     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 rootNode = nodesById.get(flow.entry_point.external_id);
+        const trigger = endpointTrigger(rootNode);
+        const root_entry = rootNode ? isEntryPoint(rootNode) : false;
         const proof = proven.has(flow.entry_point.external_id) || proven.has(flow.hops[0]?.from ?? "") ? "proven" : "none";
         const steps = [
             {
@@ -306,6 +308,7 @@ function flows(graph, rows, risks) {
         return {
             title: flow.entry_point.title || flow.entry_point.external_id,
             trigger,
+            root_entry,
             risk: risk ? riskBucket(risk.risk_score, maxRiskScore) : null,
             proof,
             services,
@@ -455,17 +458,37 @@ export function computeReportDelta(prev, cur) {
 export function reportBaselineOf(cur, ts) {
     return { ts, summary: cur.summary, riskPaths: cur.risks.map((r) => r.path), generatedTotal: cur.generatedTotal };
 }
-const LANE_OF = {
-    MUTATION: { id: "graphql", label: "GraphQL" },
-    QUERY: { id: "graphql", label: "GraphQL" },
-    SUBSCRIPTION: { id: "graphql", label: "GraphQL" },
-    GET: { id: "http", label: "HTTP" },
-    POST: { id: "http", label: "HTTP" },
-    PUT: { id: "http", label: "HTTP" },
-    PATCH: { id: "http", label: "HTTP" },
-    DELETE: { id: "http", label: "HTTP" },
-    JOB: { id: "job", label: "Jobs" }
-};
+const HTTP_TRIGGER_VERBS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD", "ALL"]);
+const GRAPHQL_TRIGGER_VERBS = new Set(["MUTATION", "QUERY", "SUBSCRIPTION"]);
+/** Map every trigger into a stable lane. Known protocol families get friendly
+ * labels; unknown framework adapters still receive a deterministic lane rather
+ * than being silently deleted from the system map. */
+export function laneForTrigger(trigger) {
+    const verb = (trigger.verb || "OTHER").trim().toUpperCase();
+    const triggerPath = (trigger.path || "").toLowerCase();
+    if (HTTP_TRIGGER_VERBS.has(verb) || triggerPath.startsWith("http:"))
+        return { id: "http", label: "HTTP", priority: 20 };
+    if (GRAPHQL_TRIGGER_VERBS.has(verb) || triggerPath.startsWith("graphql:"))
+        return { id: "graphql", label: "GraphQL", priority: 10 };
+    if (["JOB", "QUEUE", "PROCESS", "WORKER"].includes(verb) || triggerPath.startsWith("queue:"))
+        return { id: "job", label: "Jobs", priority: 30 };
+    if (["SCHEDULE", "CRON", "TIMER"].includes(verb) || triggerPath.startsWith("schedule:") || triggerPath.startsWith("cron:"))
+        return { id: "schedule", label: "Scheduled", priority: 40 };
+    if (["EVENT", "MESSAGE", "CONSUME", "CONSUMER", "SUBSCRIBE"].includes(verb) || triggerPath.startsWith("event:"))
+        return { id: "event", label: "Events", priority: 50 };
+    if (["COMMAND", "CLI"].includes(verb) || triggerPath.startsWith("cli:"))
+        return { id: "cli", label: "CLI", priority: 60 };
+    if (["RPC", "GRPC"].includes(verb) || triggerPath.startsWith("rpc:") || triggerPath.startsWith("grpc:"))
+        return { id: "rpc", label: "RPC", priority: 70 };
+    const id = verb.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "other";
+    const label = verb
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean)
+        .map((part) => part[0].toUpperCase() + part.slice(1))
+        .join(" ") || "Other";
+    return { id, label, priority: 100 };
+}
 function ownerOfSig(sig) {
     const base = sig.includes("#") ? sig.slice(sig.indexOf("#") + 1) : sig;
     return base.includes(".") ? base.slice(0, base.indexOf(".")) : base;
@@ -477,7 +500,22 @@ export function buildSystemMapModel(data, maxServices = 12) {
     // on a full-scale repo. A flow's representative service is its most
     // DISTINCTIVE owner: lowest global frequency, deepest step on ties, with
     // near-ubiquitous owners eligible only when a flow touches nothing else.
-    const triggerFlows = data.flows.filter((f) => f.trigger && LANE_OF[(f.trigger.verb || "").toUpperCase()]);
+    const laneForFlow = (flow) => {
+        if (flow.trigger)
+            return laneForTrigger(flow.trigger);
+        // A program root without a framework trigger is still a real product entry
+        // point (CLI/main). Internal call-graph roots remain excluded.
+        return flow.root_entry ? { id: "entry", label: "Entry points", priority: 80 } : null;
+    };
+    const triggerFlows = data.flows.filter((flow) => laneForFlow(flow) !== null);
+    const laneMeta = new Map();
+    for (const flow of triggerFlows) {
+        const lane = laneForFlow(flow);
+        laneMeta.set(lane.id, lane);
+    }
+    const laneOrder = [...laneMeta.values()]
+        .sort((a, b) => a.priority - b.priority || a.label.localeCompare(b.label) || a.id.localeCompare(b.id))
+        .map((lane) => lane.id);
     const ownerFreq = new Map();
     for (const f of triggerFlows) {
         const seen = new Set();
@@ -496,7 +534,7 @@ export function buildSystemMapModel(data, maxServices = 12) {
     const edgeFlows = new Map();
     const svcLaneFlows = new Map();
     for (const f of triggerFlows) {
-        const lane = LANE_OF[(f.trigger.verb || "").toUpperCase()];
+        const lane = laneForFlow(f);
         const steps = f.steps ?? [];
         let svc = "";
         let bestFreq = Infinity;
@@ -538,18 +576,18 @@ export function buildSystemMapModel(data, maxServices = 12) {
                 best = l;
                 bestN = n;
             }
-        return ["graphql", "http", "job"].indexOf(best);
+        return laneOrder.indexOf(best);
     };
     const byTraffic = [...svcFlows.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
     const chosen = new Set();
     // 1) Every lane is guaranteed its top 2 services — a lane with 56 flows must
     //    never render edge-less just because its traffic is spread thin.
-    for (const laneId of ["graphql", "http", "job"]) {
+    for (const laneId of laneOrder) {
         let taken = 0;
         for (const [svc] of byTraffic) {
             if (taken >= 2)
                 break;
-            if (laneRank(svc) === ["graphql", "http", "job"].indexOf(laneId) && !chosen.has(svc)) {
+            if (laneRank(svc) === laneOrder.indexOf(laneId) && !chosen.has(svc)) {
                 chosen.add(svc);
                 taken++;
             }
@@ -606,7 +644,6 @@ export function buildSystemMapModel(data, maxServices = 12) {
             e.critical = true;
         riskBySvc.set(svc, e);
     }
-    const laneOrder = ["graphql", "http", "job"];
     // Conservation: edges drawn per lane must sum to the lane's stated count.
     // Everything below the cut aggregates into one dashed "+N more services"
     // node per lane — 51 job flows must never silently vanish.
@@ -644,7 +681,7 @@ export function buildSystemMapModel(data, maxServices = 12) {
     return {
         lanes: laneOrder
             .filter((id) => laneFlows.has(id))
-            .map((id) => ({ id, label: id === "graphql" ? "GraphQL" : id === "http" ? "HTTP" : "Jobs", flows: laneFlows.get(id) ?? 0 })),
+            .map((id) => ({ id, label: laneMeta.get(id)?.label ?? id, flows: laneFlows.get(id) ?? 0 })),
         services: [
             ...top.map(([label, flows]) => ({
                 id: label,
@@ -722,6 +759,23 @@ function riskRows(risks, graph) {
     for (const r of risks)
         if (!firstRowForFile.has(r.file))
             firstRowForFile.set(r.file, r.id);
+    // Ambiguity-qualified display: identical titles from DIFFERENT files
+    // (multi-program repos: 76 x main) get their top-level dir as a prefix.
+    // Purely display; single-file titles render unchanged everywhere else.
+    const titleFiles = new Map();
+    for (const r of risks) {
+        const t = (r.title || "").split("(")[0].trim();
+        if (!titleFiles.has(t))
+            titleFiles.set(t, new Set());
+        titleFiles.get(t).add(r.file);
+    }
+    const qualify = (risk, path) => {
+        const t = (risk.title || "").split("(")[0].trim();
+        if ((titleFiles.get(t)?.size ?? 0) <= 1)
+            return path;
+        const top = (risk.file || "").split("/").filter(Boolean)[0] ?? "";
+        return top ? `${top}: ${path}` : path;
+    };
     return risks.map((risk, idx) => {
         const methodMatch = risk.title.match(/^(GET|POST|PUT|PATCH|DELETE)\s+(.+)$/i);
         const tags = [];
@@ -736,17 +790,17 @@ function riskRows(risks, graph) {
             ...(() => {
                 const generatedTests = riskGeneratedTests(graph, risk, riskIds, firstRowForFile.get(risk.file) === risk.id);
                 const verb = methodMatch?.[1]?.toUpperCase() ?? "BEHAVIOR";
-                const path = methodMatch?.[2] ?? risk.title;
-                const coveredCategories = [...new Set([
+                const path = qualify(risk, methodMatch?.[2] ?? risk.title);
+                const generatedCategories = [...new Set([
                         ...generatedTests.map((t) => (t.bucket ? BUCKET_TO_CONCERN[t.bucket] : undefined)),
-                        // An integration/api/e2e-layer test covers the integration_flow
-                        // category by construction — the chip and the pill must agree.
+                        // An integration/api/e2e-layer draft targets integration_flow. This
+                        // remains generation metadata until dynamic proof closes.
                         ...generatedTests.map((t) => (t.concern === "integration" || t.concern === "api" || t.concern === "e2e" ? "integration_flow" : undefined))
                     ].filter((c) => Boolean(c)))];
                 return {
                     generatedTests,
                     applicableCategories: riskApplicableConcerns(risk, verb),
-                    coveredCategories,
+                    generatedCategories,
                     verb,
                     path,
                     todo: riskTodo(risk, verb, path, generatedTests)

package/dist/local/viz/behaviorReportHtml.js

@@ -230,9 +230,8 @@ nav.tabs{display:flex;gap:2px;margin:18px 0 0;border-bottom:1px solid var(--bd)}
 .cat-strip-lbl{font-size:9.5px;color:var(--muted);font-weight:600;letter-spacing:.04em;text-transform:uppercase;margin-bottom:6px}
 .cat-pills{display:flex;flex-wrap:wrap;gap:5px}
 .cat-pill{font-size:10px;padding:3px 8px;border-radius:4px;font-weight:600;letter-spacing:.01em;display:inline-flex;align-items:center;gap:4px}
-.cat-pill.cp-shown{background:var(--gbg);border:1px solid var(--gbd);color:var(--green)}
-.cat-pill.cp-locked{background:transparent;border:1px dashed var(--bd2);color:var(--faint)}
-.cat-pill.cp-locked::after{content:"\\1F512";font-size:8px}
+.cat-pill.cp-drafted{background:var(--obg);border:1px solid var(--obd);color:var(--orange)}
+.cat-pill.cp-open{background:transparent;border:1px dashed var(--bd2);color:var(--faint)}
 /* PAYWALL CTA */
 .paywall{background:linear-gradient(135deg,rgba(240,136,62,.08),rgba(240,136,62,.02));border:1px dashed var(--obd);border-radius:9px;padding:14px 16px;margin-top:14px;text-align:center}
 .paywall-num{font-size:18px;font-weight:750;color:var(--orange);font-variant-numeric:tabular-nums}
@@ -382,7 +381,8 @@ const D=window.DATA,$=(s)=>document.querySelector(s);
   var laneY={},svcY={};
   M.lanes.forEach(function(l,i){laneY[l.id]=padT+i*rowH+(H-2*padT-M.lanes.length*rowH)/2+rowH/2;});
   M.services.forEach(function(sv,i){svcY[sv.id]=padT+i*rowH+rowH/2;});
-  var laneColor={graphql:"var(--purple,#a78bfa)",http:"var(--blue)",job:"var(--orange)"};
+  var lanePalette=["var(--purple,#a78bfa)","var(--blue)","var(--orange)","var(--green)","var(--red)","#22d3ee","#f472b6","var(--muted)"];
+  var laneColor={};M.lanes.forEach(function(l,i){laneColor[l.id]=lanePalette[i%lanePalette.length];});
   var tierColor=function(t){var tot=t.proven+t.assoc+t.candidate+t.none||1;
     if(t.proven/tot>=0.5)return "var(--green)";
     if((t.proven+t.assoc)/tot>=0.5)return "var(--blue)";
@@ -443,7 +443,7 @@ const D=window.DATA,$=(s)=>document.querySelector(s);
     bc.innerHTML='';
     var backBtn=document.createElement("button");
     backBtn.className="sm-crumb-btn";
-    backBtn.textContent="\u2190 Back to system map";
+    backBtn.textContent="← Back to system map";
     backBtn.addEventListener("click",function(){
       if(search){search.value="";search.dispatchEvent(new Event("input"));}
       bc.remove();
@@ -453,7 +453,7 @@ const D=window.DATA,$=(s)=>document.querySelector(s);
     });
     var clearBtn=document.createElement("button");
     clearBtn.className="sm-crumb-btn";
-    clearBtn.textContent="\u2715 Clear filter \u201c"+svc+"\u201d";
+    clearBtn.textContent="✕ Clear filter “"+svc+"”";
     clearBtn.addEventListener("click",function(){
       if(search){search.value="";search.dispatchEvent(new Event("input"));}
       bc.remove();
@@ -523,7 +523,7 @@ function describeBehavior(b){
     :b.tier==="assoc"?"A real test imports and calls it, but no mutation proof exists yet."
     :b.tier==="candidate"?"Only a lexically similar test file was found — an unconfirmed lead, not evidence."
     :"No test signal of any kind was found for it.";
-  const s1="\u201c"+h.words+"\u201d"+(h.owner?" on "+h.owner:"")+" — a behavior in "+(mod||"this repo")+".";
+  const s1="“"+h.words+"”"+(h.owner?" on "+h.owner:"")+" — a behavior in "+(mod||"this repo")+".";
   const s2=reach.length?"A user or system reaches it via "+reach.join(" and ")+(reach.length>=2?" (and possibly more)":"")+".":(b.reachable?"It appears inside at least one statically traced call chain.":"No entry-anchored call chain reaches it in the static flow set.");
   return s1+" "+s2+" "+tierTxt;
 }
@@ -549,14 +549,14 @@ function renderBeh(){
   const rows=D.behaviors.filter(b=>(!activeGrp||b.group===activeGrp)&&(!activeTier||tierOf(b).cls===activeTier)&&(!searchQ||(b.sig+" "+b.file).toLowerCase().includes(searchQ)));
   if(rows.length===0){
     const parts=[];
-    if(searchQ)parts.push('search \u201c'+searchQ+'\u201d');
+    if(searchQ)parts.push('search “'+searchQ+'”');
     if(activeTier)parts.push('the selected evidence tier');
-    if(activeGrp)parts.push('package \u201c'+activeGrp+'\u201d');
+    if(activeGrp)parts.push('package “'+activeGrp+'”');
     const why=parts.length?parts.join(' + '):'the current filters';
     const box=el("div","beh-empty",
-      '<p>No behaviors match '+esc(why)+'. Filters combine \u2014 clearing one usually brings results back.</p>');
+      '<p>No behaviors match '+esc(why)+'. Filters combine — clearing one usually brings results back.</p>');
     if(searchQ){
-      const b1=el("button","sm-crumb-btn","\u2715 Clear search");
+      const b1=el("button","sm-crumb-btn","✕ Clear search");
       b1.onclick=function(){searchEl.value="";searchQ="";renderBeh();};
       box.append(b1);
     }
@@ -697,15 +697,16 @@ function riskCardHtml(r){
   // category strip: show which concern categories apply to this flow
   let catHtml='';
   if(r.applicableCategories&&r.applicableCategories.length){
-    const shownConcerns=new Set(r.coveredCategories||[]);
+    const draftedConcerns=new Set(r.generatedCategories||[]);
     const pills=r.applicableCategories.map(c=>{
-      const shown=shownConcerns.has(c);
+      const drafted=draftedConcerns.has(c);
       const label=c.replace(/_/g,' ');
-      return \`<span class="cat-pill \${shown?'cp-shown':'cp-locked'}">\${esc(label)}</span>\`;
+      const hint=drafted?'Generated draft attached; not coverage or proof':'Applicable category without a generated draft';
+      return \`<span class="cat-pill \${drafted?'cp-drafted':'cp-open'}" title="\${hint}">\${esc(label)}</span>\`;
     }).join('');
-    const shownN=r.applicableCategories.filter(c=>shownConcerns.has(c)).length;
+    const shownN=r.applicableCategories.filter(c=>draftedConcerns.has(c)).length;
     const totalN=r.applicableCategories.length;
-    catHtml=\`<div class="cat-strip"><div class="cat-strip-lbl">Applicable testing categories for this flow (\${shownN} of \${totalN} covered)</div><div class="cat-pills">\${pills}</div></div>\`;
+    catHtml=\`<div class="cat-strip"><div class="cat-strip-lbl">Generated drafts: \${shownN} of \${totalN} applicable testing categories</div><div class="cat-pills">\${pills}</div></div>\`;
   }
   let testsHtml='';
   if(r.generatedTests&&r.generatedTests.length){

package/dist/local/viz/payload.js

@@ -61,20 +61,14 @@ function codeAreaOf(sourceRefOrPath) {
         return parentDir(parts);
     }
     if (language === "python") {
-        if (["src", "app", "mealie"].includes(parts[0]) && parts.length > 2)
+        if (["src", "app"].includes(parts[0]) && parts.length > 2)
             return parts.slice(1, 3).join("/");
         return parts.length > 2 ? parts.slice(0, 2).join("/") : parentDir(parts);
     }
     if (language === "go") {
-        if (parts[0] === "server" && parts[1] === "channels" && parts[2])
-            return `server/${parts[2]}`;
         return parts.length > 2 ? parts.slice(0, 2).join("/") : parentDir(parts);
     }
     if (language === "typescript" || language === "javascript") {
-        if (parts[0] === "webapp" && parts[1] === "channels" && parts[2] === "src" && parts[3])
-            return `webapp/${parts[3]}`;
-        if (parts[0] === "frontend" && parts[1] === "app" && parts[2])
-            return `frontend/${parts[2]}`;
         return parts.length > 2 ? parts.slice(0, 2).join("/") : parentDir(parts);
     }
     return parts.length > 2 ? parts.slice(0, 2).join("/") : parentDir(parts);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orangepro/orangepro-mcp",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "private": false,
   "description": "OrangePro (`opro`) — a local-first, BYOK CLI + MCP server that builds an evidence graph from a local checkout, ingests runtime coverage, and generates grounded tests. Metadata-only exports; no source upload; generated tests stay local.",
   "license": "MIT",