@orangepro/orangepro-mcp 0.2.35 → 0.2.36

package/dist/local/analyze/analyzer.js

@@ -475,6 +475,18 @@ export function analyzeRepo(root, opts = {}) {
     // Emitted CodeSymbol names per file — the call graph resolves callers/callees
     // ONLY to symbols that actually became nodes (the "known symbol" invariant).
     const symbolsByFile = new Map();
+    // Retained callee NAMES (no node, no edge) for calls the resolver cannot anchor —
+    // shared by the TS/JS loop and the tree-sitter loop; persisted as external_callees.
+    const externalCalleesByCaller = new Map();
+    const recordExternalCallee = (callerId, name) => {
+        let set = externalCalleesByCaller.get(callerId);
+        if (!set) {
+            set = new Set();
+            externalCalleesByCaller.set(callerId, set);
+        }
+        if (set.size < 32)
+            set.add(name);
+    };
     // Raw (caller, callee) call pairs per TS/JS code file, resolved after the
     // import graph is built (cross-file calls need its bindings + targets).
     const rawCallsByFile = new Map();
@@ -1312,6 +1324,8 @@ export function analyzeRepo(root, opts = {}) {
                             }
                         }
                         // A non-imported (local/param) qualifier is NOT anchored — no edge.
+                        if (!ns && !qImport)
+                            recordExternalCallee(callerId, `${c.qualifier}.${c.callee}`); // round two: retain by name
                         // Retain the callee NAME as a fact on the caller (Fix B): `t.adminClient.
                         // DeleteWorkflowExecution` is invisible as an edge (external interface) but
                         // is exactly the kind of sink risk scoring must be able to see. Names only —
@@ -1319,6 +1333,10 @@ export function analyzeRepo(root, opts = {}) {
                     }
                 }
                 else if (c.via === "injected" && c.injectedType) {
+                    // Retain `this.<field>.<callee>` by name regardless of resolution: names are
+                    // facts, not evidence, and consequence signals need the callee even when the
+                    // injected type never resolves (round two — TS parity with Go).
+                    recordExternalCallee(callerId, `this.${c.qualifier ?? c.injectedType}.${c.callee}`);
                     const typeBinding = typeImports?.get(c.injectedType) ?? imports?.get(c.injectedType);
                     if (typeBinding) {
                         const targetMember = resolveInjectedMember(typeBinding, c.callee);
@@ -1859,16 +1877,6 @@ export function analyzeRepo(root, opts = {}) {
             const dir = rel.includes("/") ? rel.slice(0, rel.lastIndexOf("/")) : "";
             return goPkgMethods.get(dir)?.get(member);
         };
-        const externalCalleesByCaller = new Map();
-        const recordExternalCallee = (callerId, name) => {
-            let set = externalCalleesByCaller.get(callerId);
-            if (!set) {
-                set = new Set();
-                externalCalleesByCaller.set(callerId, set);
-            }
-            if (set.size < 32)
-                set.add(name);
-        };
         for (const [rel, { language, structure }] of nonTsStructureByFile) {
             const localSyms = symbolsByFile.get(rel);
             if (!localSyms)

package/dist/local/score/risk.js

@@ -315,8 +315,15 @@ const NEW_CODE_SECONDS = NEW_CODE_DAYS * 24 * 60 * 60;
 /** Calls that make a defect irreversible: deletes, drops, purges. Matched on the
  *  LAST segment of a call name, so `t.adminClient.DeleteWorkflowExecution` and a
  *  local `purgeAll` both count; `deleteButtonLabel` (no call) does not. */
-const DESTRUCTIVE_CALL_RE = /^(delete|drop|purge|truncate|remove|forcedelete|destroy)[A-Za-z0-9_]*$/i;
-const SCHEDULED_ENTRY_NAME_RE = /(^|\.)(Run|Execute|Handle|Process|Tick|Scan)$/;
+// `truncate` dropped (time.Truncate is common; DB truncation is rare in app code);
+// `remove` kept but not for listener/handler/attribute/child tails — those detach,
+// they don't destroy data.
+const DESTRUCTIVE_CALL_RE = /^(?:delete(?!d)|purge|drop|forcedelete|destroy)[A-Za-z0-9_]*$/i;
+// `remove*` is only a data sink through a persistence-shaped field; in-memory
+// removals (`pollers.Remove`, `RemoveSpeculativeWorkflowTaskTimeout`) are not.
+const REMOVE_CALL_RE = /^remove(?![A-Za-z0-9_]*(?:listener|handler|observer|callback|attribute|attr|class|child|style|hook|timeout|timer)$)[A-Za-z0-9_]*$/i;
+const PERSISTENCE_FIELD_RE = /(store|client|db|repo|repository|persistence|manager|queue|bucket|index|table|storage|dao)/i;
+const SCHEDULED_ENTRY_NAME_RE = /(^|\.)(run|execute|handle|process|tick|scan)$/i;
 const SCHEDULED_ENTRY_PATH_RE = /(^|\/)(jobs?|workers?|scanners?|scavengers?|cron|schedulers?|processors?|consumers?|reconcil\w*)(\/|$)/i;
 /** A time- or queue-triggered entry: nothing calls it synchronously, nobody waits
  *  for a response, so a failure is far less likely to be NOTICED. Graph facts only. */
@@ -378,7 +385,9 @@ export function rankRiskGaps(graph, opts = {}) {
     // Fix D: ranking hygiene. Test-support code, bare constants/variables, and trivial
     // accessors stay in the behavior DENOMINATOR but never compete for a risk slot.
     const TEST_SUPPORT_PATH_RE = /(^|\/)(testing|testutils?|testhelpers?|fixtures?|mocks?|fakes?)(\/|$)/i;
-    const extraTestSupportRef = loadRiskConfig(opts.repoRoot ?? graph.workspace.root).config.classification.test_support_paths.map(globToRegExp);
+    const cfgEarly = loadRiskConfig(opts.repoRoot ?? graph.workspace.root).config.classification;
+    const extraTestSupportRef = cfgEarly.test_support_paths.map(globToRegExp);
+    const rankExcludeRef = cfgEarly.rank_exclude_paths.map(globToRegExp);
     const ACCESSOR_RE = /(^|\.)(Get|Set|Is|Has)[A-Z][A-Za-z0-9]*$/;
     const rankEligible = (n) => {
         const props = (n.properties ?? {});
@@ -395,6 +404,8 @@ export function rankRiskGaps(graph, opts = {}) {
         const span = (props.end_line ?? 0) - (props.start_line ?? 0);
         if (ACCESSOR_RE.test(n.title || "") && span <= 3)
             return false;
+        if (rankExcludeRef.some((re) => re.test(symbolFile(n))))
+            return false;
         return true;
     };
     const suppressedRef = loadRiskConfig(opts.repoRoot ?? graph.workspace.root).config.overrides.filter((o) => o.action === "suppress");
@@ -483,29 +494,42 @@ export function rankRiskGaps(graph, opts = {}) {
     // A sink is a destructive call on an EXTERNAL surface — a persistence store, an
     // admin/service client, a database handle. In-repo methods named `delete` are
     // not sinks by name alone (CHASM's `Node.delete` is a tree op, not a data loss).
-    const SINK_QUALIFIER_RE = /(client|store|manager|persistence|db|admin|repo|repository|dao|storage|bucket|index)/i;
-    const isSink = (id) => {
+    // A retained callee is by construction a call through a receiver FIELD to code
+    // the graph could not resolve — i.e. an external surface. That structural fact is
+    // the test; the qualifier's NAME is not (round one's store/client/db vocabulary was
+    // Temporal-shaped and hid inngest's `w.q.DeleteOldQueueSnapshots`).
+    const sinkCallee = (id) => {
         const n = nodeById.get(id);
         if (!n)
-            return false;
+            return undefined;
         const ext = n.properties?.external_callees ?? [];
-        return ext.some((c) => (DESTRUCTIVE_CALL_RE.test(lastSeg(c)) && SINK_QUALIFIER_RE.test(c.slice(0, c.lastIndexOf(".")))) || extraSinks.some((re) => re.test(lastSeg(c))));
+        // A receiver FIELD path is `x.field.Method` — no call parentheses before the last
+        // segment. `q.Clock().Now().Truncate` is a chain of return values, not a surface.
+        const viaField = (c) => !c.slice(0, c.lastIndexOf(".")).includes("(");
+        const fieldOf = (c) => c.slice(0, c.lastIndexOf("."));
+        return ext.find((c) => viaField(c) && (DESTRUCTIVE_CALL_RE.test(lastSeg(c)) ||
+            (REMOVE_CALL_RE.test(lastSeg(c)) && PERSISTENCE_FIELD_RE.test(fieldOf(c))) ||
+            extraSinks.some((re) => re.test(lastSeg(c)))));
     };
-    const reachesSinkFrom = (id, depth, seen) => {
-        if (isSink(id))
-            return true;
+    const isSink = (id) => sinkCallee(id) !== undefined;
+    const reachedSinkFrom = (id, depth, seen) => {
+        const own = sinkCallee(id);
+        if (own)
+            return own;
         if (depth === 0)
-            return false;
+            return undefined;
         for (const t of fanOutTargets.get(id) ?? []) {
             if (seen.has(t))
                 continue;
             seen.add(t);
-            if (reachesSinkFrom(t, depth - 1, seen))
-                return true;
+            const hit = reachedSinkFrom(t, depth - 1, seen);
+            if (hit)
+                return hit;
         }
-        return false;
+        return undefined;
     };
-    const reachesSink = new Map(symbols.map((s) => [s.external_id, reachesSinkFrom(s.external_id, 2, new Set([s.external_id]))]));
+    const sinkReached = new Map(symbols.map((s) => [s.external_id, reachedSinkFrom(s.external_id, 2, new Set([s.external_id]))]));
+    const reachesSink = new Map([...sinkReached].map(([k, v]) => [k, v !== undefined]));
     const depthCtx = buildFlowDepthContext(graph);
     const staticLinked = staticTestLinkedIds(graph, symbolIds);
     const candidateLinked = candidateSignalIds(graph, symbolIds);
@@ -605,6 +629,9 @@ export function rankRiskGaps(graph, opts = {}) {
             reasons.push(`config override (${override.action}): ${override.reason}`);
         return {
             ...(override && override.action !== "suppress" ? { override: { action: override.action, reason: override.reason } } : {}),
+            ...(sinkReached.get(s.external_id) ? { sink_callee: sinkReached.get(s.external_id) } : {}),
+            ...(rawScores[idx].scheduledEntry ? { scheduled_entry: true } : {}),
+            detection_tier: detectionTier,
             id: s.external_id,
             title: s.title || s.external_id,
             file,

package/dist/local/score/riskConfig.js

@@ -9,7 +9,7 @@ import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 export const DEFAULT_RISK_CONFIG = {
-    classification: { test_support_paths: [], scheduled_entry_paths: [], destructive_sinks: [], sensitivity_ignore: [] },
+    classification: { test_support_paths: [], scheduled_entry_paths: [], destructive_sinks: [], sensitivity_ignore: [], rank_exclude_paths: [] },
     tuning: { irreversibility_floor: true, silence_multiplier: true },
     overrides: []
 };
@@ -33,6 +33,7 @@ export function loadRiskConfig(repoRoot) {
             cfg.classification.scheduled_entry_paths = asStringArray(cls.scheduled_entry_paths);
             cfg.classification.destructive_sinks = asStringArray(cls.destructive_sinks);
             cfg.classification.sensitivity_ignore = asStringArray(cls.sensitivity_ignore);
+            cfg.classification.rank_exclude_paths = asStringArray(cls.rank_exclude_paths);
             const tun = (raw.tuning ?? {});
             if (typeof tun.irreversibility_floor === "boolean")
                 cfg.tuning.irreversibility_floor = tun.irreversibility_floor;

package/dist/local/viz/behaviorReportData.js

@@ -2,7 +2,7 @@ import { loadRiskConfig } from "../score/riskConfig.js";
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { buildRtm } from "../rtm.js";
-import { inspectRiskInputHealth, isEntryPoint, rankPriorityGaps } from "../score/risk.js";
+import { inspectRiskInputHealth, isEntryPoint, rankPriorityGaps, rankRiskGaps } from "../score/risk.js";
 import { ORANGEPRO_VERSION } from "../version.js";
 import { PROOF_BLOCKER_GUIDE } from "../proofDoctor.js";
 import { classifyGeneratedDraftBlocker } from "../generate/draftGuidance.js";
@@ -451,21 +451,49 @@ function riskContext(risk) {
                     : (risk.data_sensitivity ?? 1) >= 3 ? "notification/webhook"
                         : "";
     const pos = (risk.flow_position ?? 0) >= 5
-        ? "an entry point"
+        ? "entry point"
         : (risk.flow_position ?? 0) >= 3
-            ? `${5 - (risk.flow_position ?? 0)} call${5 - (risk.flow_position ?? 0) === 1 ? "" : "s"} from the nearest entry point`
+            ? `${5 - (risk.flow_position ?? 0)} call${5 - (risk.flow_position ?? 0) === 1 ? "" : "s"} from an entry point`
             : "deep in the call graph";
-    const churn = risk.churn_available !== false
-        ? `${risk.git_churn} line${risk.git_churn === 1 ? "" : "s"} changed in 180 days`
-        : "Git churn unavailable (provisional static-only ranking)";
-    // Consequence signals and config overrides are stated on the row, so a reader can
-    // disagree with a weight without doubting the fact — and a tuned report is visible.
-    const flagged = (risk.reasons ?? []).filter((r) => r.startsWith("reaches a destructive") || r.startsWith("scheduled/queue-triggered") || r.startsWith("config override"));
-    const parts = [
-        `Sits at ${pos}${sens ? ` on ${sens} paths` : ""}.`,
-        ...flagged.map((r) => `${r[0].toUpperCase()}${r.slice(1)}.`),
-        `ORS ${risk.risk_score} (P${risk.probability ?? "?"} × I${risk.impact ?? "?"} × D${risk.detection_difficulty ?? "?"}) reflects flow position, change activity, complexity, impact, and test evidence; ${risk.fan_out ?? 0} downstream call${(risk.fan_out ?? 0) === 1 ? "" : "s"}, ${churn} — and no test proves this flow.`
+    const sink = risk.sink_callee;
+    const scheduled = risk.scheduled_entry === true;
+    const churnKnown = risk.churn_available !== false;
+    const churn = churnKnown
+        ? (risk.git_churn > 0 ? `${risk.git_churn} line${risk.git_churn === 1 ? "" : "s"} changed in 180 days` : "unchanged in 180 days")
+        : "change history unavailable";
+    const tier = risk.detection_tier ?? "";
+    const evidence = tier === "candidate"
+        ? "no test links here (a similarly-named test exists but never calls it)"
+        : tier === "associated" ? "a test calls it but nothing proves it fails when broken" : "no test links here";
+    const sinkShort = sink ? sink.split(".").pop() ?? sink : "";
+    // Line 1 — the consequence, in plain English, from the signals only.
+    const lead = sink && scheduled
+        ? `Runs on a schedule and can ${sinkShort.toLowerCase().startsWith("purge") ? "purge" : "delete"} data — nothing proves it does the right thing.`
+        : sink
+            ? `Can ${sinkShort.toLowerCase().startsWith("purge") ? "purge" : "delete"} data and nothing proves it works.`
+            : scheduled
+                ? "Runs on a schedule with no proof — a failure here surfaces nowhere."
+                : sens
+                    ? `Sits on ${sens} paths, changes, and nothing proves it.`
+                    : "Reachable and changing, with nothing proving it.";
+    // Line 2 — what the graph saw. Facts only: names, counts, tiers.
+    const seen = [
+        pos + (sens ? ` on ${sens} paths` : ""),
+        ...(sink ? [`reaches \`${sink}\` within two calls`] : []),
+        ...(scheduled ? ["scheduled / queue-triggered"] : []),
+        `${risk.fan_out ?? 0} downstream call${(risk.fan_out ?? 0) === 1 ? "" : "s"}`,
+        churn,
+        evidence
     ];
+    // Line 3 — what would close it: a test SHAPE, never a claim that one exists.
+    const close = sink
+        ? `one test that drives the path to \`${sinkShort}\` and fails when the guard before it is broken.`
+        : scheduled
+            ? "one test that runs this entry against a mutated dependency and fails."
+            : "one test that exercises this behavior and fails when it is mutated.";
+    const scoreWords = `ORS ${risk.risk_score} — ${(risk.probability ?? 0) >= 6 ? "changes often" : (risk.probability ?? 0) >= 3 ? "changes some" : "stable"} (${risk.probability ?? "?"}) × ${sink ? "irreversible" : (risk.impact ?? 0) >= 6 ? "high blast radius" : "moderate impact"} (${risk.impact ?? "?"}) × ${(risk.detection_difficulty ?? 0) >= 9 ? "unproven and silent" : "unproven"} (${risk.detection_difficulty ?? "?"})`;
+    const overrides = (risk.reasons ?? []).filter((r) => r.startsWith("config override"));
+    const parts = [lead, `Seen: ${seen.join(" · ")}.`, `Would close it: ${close}`, ...overrides.map((o) => `${o[0].toUpperCase()}${o.slice(1)}.`), scoreWords + "."];
     return parts.join(" ");
 }
 /** Pure delta between a persisted baseline and the current report data.
@@ -898,6 +926,18 @@ export function buildBehaviorReportData(graph, ledger, opts = {}) {
         .filter((row) => row.evidence_tier === "proven" && Boolean(row.code_symbol))
         .map((row) => row.code_symbol));
     const riskGaps = rankPriorityGaps(graph, { repoRoot, limit: opts.riskLimit ?? 20, provenIds });
+    // Two worklists from ONE ranking, no new weights. A multiplicative P×I×D top-N
+    // cannot hold "changing fast, unproven" and "irreversible, stable, unproven" on
+    // the same page: with P=1 for stable code, one family always erases the other
+    // (verified three ways on Temporal). Same rows, two questions.
+    const wide = rankRiskGaps(graph, { repoRoot, limit: 200, provenIds });
+    const changeFrontier = [...wide]
+        .filter((r) => !r.sink_callee)
+        .sort((a, b) => (b.probability ?? 0) - (a.probability ?? 0) || b.risk_score - a.risk_score || a.id.localeCompare(b.id))
+        .slice(0, 20)
+        .map((r) => ({ path: r.title, file: r.file, score: r.risk_score, probability: r.probability ?? 0 }));
+    const irreversible = wide.filter((r) => r.sink_callee).slice(0, 20)
+        .map((r) => ({ path: r.title, file: r.file, score: r.risk_score, sink: r.sink_callee ?? "" }));
     const riskHealth = inspectRiskInputHealth(repoRoot);
     const churnAvailable = riskHealth.churnAvailable && riskGaps.every((risk) => risk.churn_available !== false);
     const provenance = {
@@ -935,6 +975,7 @@ export function buildBehaviorReportData(graph, ledger, opts = {}) {
         flows: flowRows,
         candidateFlows: candidateFlows(graph),
         risks,
+        worklists: { changeFrontier, irreversible },
         zeroProofExplainer: summary.proven === 0 ? { title: ZERO_PROOF_EXPLAINER.title, body: [...ZERO_PROOF_EXPLAINER.body] } : null,
         mapModel: buildSystemMapModel({ flows: flowRows, risks, behaviors: sortedBehaviors }),
         viewMeta: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orangepro/orangepro-mcp",
-  "version": "0.2.35",
+  "version": "0.2.36",
   "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",