@orangepro/orangepro-mcp 0.2.7 → 0.2.9

package/dist/local/analyze/analyzer.js

@@ -47,7 +47,7 @@ function extractionBackend(language) {
         return "tsc"; // TS/JS compiler path (or unextracted)
     return treeSitterReady(language) ? "ts" : "rx"; // tree-sitter AST vs regex fallback
 }
-import { runConfirmer } from "./confirm.js";
+import { repoRootOf, resolveSpecifier, workspacePackages, runConfirmer } from "./confirm.js";
 const DETECTOR = "repo_analyzer";
 // Global ceiling on extracted code symbols. A SINGLE counter shared across the walk,
 // so a low value lets whichever language is walked first (e.g. a Go `server/`) eat the
@@ -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,
@@ -1921,6 +1972,46 @@ export function analyzeRepo(root, opts = {}) {
             seenPair.add(key);
             candidates.push({ testRel, testAbs, implRel, implAbs });
         }
+        // Import-derived pairing: a test file is a candidate for every in-repo
+        // impl file it imports — an import IS the relationship; resolution
+        // (relative, tsconfig paths, npm/pnpm workspace names) decides
+        // membership. Adds PAIRS only; the assertion-aware confirmer remains
+        // the sole judge.
+        {
+            const pairRoot = repoRootOf(root);
+            const wsPkgs = workspacePackages(pairRoot);
+            const relByAbs = new Map(resolveFiles.map((f) => [f.abs, f.rel]));
+            const IMPORT_SPEC_RE = /(?:import|export)[^'"\n]*from\s*['"]([^'"]+)['"]|require\(\s*['"]([^'"]+)['"]\s*\)/g;
+            for (const tf of resolveFiles) {
+                if (tf.role !== "test")
+                    continue;
+                let srcTxt = "";
+                try {
+                    srcTxt = readFileSync(tf.abs, "utf8");
+                }
+                catch {
+                    continue;
+                }
+                let m;
+                IMPORT_SPEC_RE.lastIndex = 0;
+                while ((m = IMPORT_SPEC_RE.exec(srcTxt)) !== null) {
+                    const spec = m[1] ?? m[2];
+                    if (!spec)
+                        continue;
+                    const resolvedAbs = resolveSpecifier(spec, tf.abs, pairRoot, wsPkgs);
+                    if (!resolvedAbs)
+                        continue;
+                    const implRel = relByAbs.get(resolvedAbs);
+                    if (!implRel || !eligibleSymbolsByFile.has(implRel))
+                        continue;
+                    const key = `${tf.rel}|${implRel}`;
+                    if (seenPair.has(key))
+                        continue;
+                    seenPair.add(key);
+                    candidates.push({ testRel: tf.rel, testAbs: tf.abs, implRel, implAbs: resolvedAbs });
+                }
+            }
+        }
         const confirmBudget = Math.max(1, Number(process.env.ORANGEPRO_MAX_CONFIRM_FILES) || 1500);
         const riskSymbolLimit = Math.max(1, Number(process.env.ORANGEPRO_CONFIRM_RISK_SYMBOLS) || DEFAULT_CONFIRM_RISK_SYMBOLS);
         const involved = new Set();

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

@@ -22,6 +22,7 @@
 // is the SOLE producer of hard TESTED_BY/COVERS edges.
 import ts from "typescript";
 import path from "node:path";
+import { readFileSync as fsRead, existsSync as fsExists } from "node:fs";
 import { loadTsConfigFor, resolveImport } from "../resolve/resolver.js";
 import { walkBarrel } from "../resolve/barrelWalker.js";
 import { isSelfAssertingCallee } from "./selfAssert.js";
@@ -33,10 +34,45 @@ const norm = (p) => path.resolve(p);
  * the target repo. JSX is preserved and emit/lib-checks are off — we only read
  * symbols, never compile.
  */
+export function repoRootOf(anchor) {
+    let dir = anchor;
+    for (let i = 0; i < 15; i++) {
+        try {
+            const pj = JSON.parse(fsRead(path.join(dir, "package.json"), "utf8"));
+            if (pj && pj.workspaces)
+                return dir;
+        }
+        catch { /* not here; walk up */ }
+        if (fsExists(path.join(dir, "pnpm-workspace.yaml")))
+            return dir;
+        if (fsExists(path.join(dir, ".git")) || fsExists(path.join(dir, "go.mod")))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return dir;
+        dir = parent;
+    }
+    return dir;
+}
 export function buildConfirmProgram(absFiles, anchorFile) {
     const base = loadTsConfigFor(anchorFile).options;
+    // Workspace-aware resolution: synthesize compilerOptions.paths from the
+    // repo's workspaces manifest so the STANDARD compiler resolves
+    // "@scope/pkg" and "@scope/pkg/lib/x" to source. Adds no confirmation
+    // path — only lets the existing assertion-aware bar evaluate tests it
+    // previously could not resolve at all.
+    const wsRoot = repoRootOf(anchorFile);
+    const wsPaths = {};
+    for (const [name, dir] of workspacePackages(wsRoot)) {
+        wsPaths[name] = [dir + "/src/index", dir + "/index", dir + "/src"];
+        wsPaths[name + "/lib/*"] = [dir + "/src/*"];
+        wsPaths[name + "/dist/*"] = [dir + "/src/*"];
+        wsPaths[name + "/*"] = [dir + "/src/*", dir + "/*"];
+    }
     const options = {
         ...base,
+        baseUrl: base.baseUrl ?? wsRoot,
+        paths: { ...wsPaths, ...base.paths },
         noEmit: true,
         allowJs: true,
         checkJs: false,
@@ -2376,6 +2412,130 @@ 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. */
+export function workspacePackages(repoRoot) {
+    const pnpmGlobs = [];
+    try {
+        const y = fsRead(path.join(repoRoot, "pnpm-workspace.yaml"), "utf8");
+        for (const line of y.split("\n")) {
+            const m = /^\s*-\s*['"]?([^'"#\n]+?)['"]?\s*$/.exec(line);
+            if (m)
+                pnpmGlobs.push(m[1].trim());
+        }
+    }
+    catch { /* not a pnpm workspace */ }
+    const out = new Map();
+    const rootPkg = readJsonSafe(_jn(repoRoot, "package.json"));
+    const ws = rootPkg?.workspaces;
+    const npmGlobs = Array.isArray(ws) ? ws : Array.isArray(ws?.packages) ? ws.packages : [];
+    const globs = [...npmGlobs, ...pnpmGlobs];
+    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/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

@@ -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/generate/promptV5.js

@@ -159,6 +159,8 @@ export function buildBatchGenerationSystemPromptV5() {
         "- Never mock, stub, or spy on the behavior-under-test itself. The subject must execute for real. Mock only true external I/O boundaries — network calls, the system clock, third-party SDKs, outbound HTTP. If the behavior calls internal services in the same codebase, let them run (or use real test doubles at the I/O edge, never at the subject). A test that mocks the subject proves nothing and will be rejected.",
         "- Each test is complete and runnable (all imports, setup, assertions, cleanup).",
         "- Start each test with: // Concern: <concern> | Technique: <technique>",
+        "- When asserting an exact return value (string, number, constant), copy the expected value VERBATIM from the provided source code. Never invent an expected value.",
+        "- If the exact value is not visible in the provided source, assert structure instead (non-nil, error vs no-error, type, boolean outcome) — never a guessed literal.",
         "- Assert all targets listed in each scenario.",
         "- Do not copy source excerpts verbatim. Use them to understand, then write original code.",
         "- Reuse SUBJECT IMPORTS. Do not invent module paths.",

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))
@@ -139,8 +139,8 @@ function deriveRouteWeight(node) {
 function deriveDataSensitivity(node) {
     const text = `${node.external_id} ${symbolFile(node)} ${symbolTitle(node)}`.toLowerCase();
     const tiers = [
-        [/payment|stripe|capture|refund|charge|billing/, 10],
-        [/auth|token|session|password|credential|jwt|oauth/, 9],
+        [/payment|stripe|refund|charge(?!r)|billing|payout|chargeback/, 10],
+        [/auth(?!or\b)|token(?!iz)|session|password|credential|jwt|oauth/, 9],
         [/order|cart|checkout|invoice|transaction/, 7],
         [/customer|user|account|profile|pii|gdpr/, 6],
         [/notification|email|sms|webhook|push/, 3]
@@ -389,7 +389,10 @@ export function rankRiskGaps(graph, opts = {}) {
         const i = Math.round(iExact);
         const d = rawScores[idx].d;
         const detectionTier = detectionFor(s.external_id);
-        const score = Math.round(pExact * iExact * d * 10) / 10;
+        let score = Math.round(pExact * iExact * d * 10) / 10;
+        const disconnected = (incoming.get(s.external_id) ?? 0) === 0 && fan_out === 0;
+        if (disconnected)
+            score = Math.round(score * 0.25 * 10) / 10;
         const reasons = [
             `ORS ${score} ≈ P${p} × I${i} × D${d}`,
             `${incoming_refs} incoming structural reference${incoming_refs === 1 ? "" : "s"} (method-attributed)`,
@@ -400,6 +403,8 @@ export function rankRiskGaps(graph, opts = {}) {
             reasons.push("near an API/route/handler entry point");
         if (is_new_code)
             reasons.push("new code (< 30 days)");
+        if (disconnected)
+            reasons.push("no callers and no callees — structurally disconnected, score dampened");
         if (detectionTier === "candidate")
             reasons.push("lexical candidate test match only — unconfirmed");
         return {
@@ -424,15 +429,25 @@ 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();
+    // Multi-program repos flood identical titles (76 x main) across files; the
+    // per-FILE cap cannot see it. Same diversity principle, second axis.
+    const maxPerTitle = 2;
+    const perTitle = new Map();
     const surfaced = [];
     const overflow = [];
     for (const gap of ranked) {
         const used = perFile.get(gap.file) ?? 0;
-        if (used < maxPerFile) {
+        const tKey = (gap.title || "").split("(")[0].trim();
+        const tUsed = perTitle.get(tKey) ?? 0;
+        if (used < maxPerFile && tUsed < maxPerTitle) {
+            perTitle.set(tKey, tUsed + 1);
             perFile.set(gap.file, used + 1);
             surfaced.push(gap);
         }

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,
@@ -406,6 +409,12 @@ function fmtRefs(n) {
         return "<1";
     return String(Math.round(n));
 }
+function displayTitle(title, file) {
+    if (title.includes("."))
+        return title;
+    const pkg = file && file.includes("/") ? file.split("/").slice(-2, -1)[0] : "";
+    return pkg ? `${pkg}.${title}` : title;
+}
 /** Deterministic 1–2 line behavior context from graph facts only — no LLM.
  *  Sensitivity label mirrors deriveDataSensitivity's tiers. */
 function riskContext(risk) {
@@ -455,17 +464,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 +506,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 +540,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 +582,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 +650,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 +687,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,
@@ -703,13 +746,16 @@ function riskTodo(risk, verb, path, generatedTests) {
     const call = verb !== "BEHAVIOR"
         ? `issues ${verb} ${path}`
         : risk.entry_point
-            ? `invokes ${risk.title} through its entry point`
-            : `calls ${risk.title} directly`;
-    const sens = (risk.data_sensitivity ?? 1) >= 9
-        ? " Include a negative case: invalid or expired credentials must fail closed."
-        : (risk.data_sensitivity ?? 1) >= 7
-            ? " Include a failure case: a rejected transaction must leave no partial state."
-            : "";
+            ? `invokes ${displayTitle(risk.title, risk.file)} through its entry point`
+            : `calls ${displayTitle(risk.title, risk.file)} directly`;
+    const s = risk.data_sensitivity ?? 1;
+    const sens = s >= 10
+        ? " Include a failure case: a rejected transaction must leave no partial state."
+        : s >= 9
+            ? " Include a negative case: invalid or expired credentials must fail closed."
+            : s >= 7
+                ? " Include a failure case: a rejected transaction must leave no partial state."
+                : "";
     if (risk.integration_signal === "candidate") {
         return `A similarly named test exists but nothing links it. Write a test that imports and ${call}, asserting the observable outcome — that upgrades this from unconfirmed candidate to a hard link.${sens}`;
     }
@@ -722,6 +768,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,7 +799,7 @@ 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 path = qualify(risk, methodMatch?.[2] ?? displayTitle(risk.title, risk.file));
                 const generatedCategories = [...new Set([
                         ...generatedTests.map((t) => (t.bucket ? BUCKET_TO_CONCERN[t.bucket] : undefined)),
                         // An integration/api/e2e-layer draft targets integration_flow. This
@@ -770,7 +833,7 @@ export function buildBehaviorReportData(graph, ledger, opts = {}) {
     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 riskGaps = rankRiskGaps(graph, { repoRoot, limit: opts.riskLimit ?? 20, maxPerFile: 3 });
     const lists = behaviorLists(rows, flowIds);
     const risks = riskRows(riskGaps, graph);
     const sortedBehaviors = [...lists.behaviors].sort((a, b) => tierRank(a) - tierRank(b));

package/dist/local/viz/behaviorReportHtml.js

@@ -381,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)";

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.7",
+  "version": "0.2.9",
   "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",