@4da/mcp-server 6.0.2 → 6.2.0

package/dist/tools/agent-memory.js

@@ -5,6 +5,7 @@
  * Cross-agent persistent memory. What Claude Code learns, Cursor can access.
  * Enables AI agents to store and recall memories across sessions and tools.
  */
+import { writeMeta, writerOf } from "../memory-store.js";
 import { rankRowsByRecall } from "./recall.js";
 import { getEmbeddingConfig, semanticScores, } from "../embeddings.js";
 // ============================================================================
@@ -149,8 +150,14 @@ export function executeAgentMemory(db, params) {
             }
             // --- Storage quota: max 1000 entries per agent ---
             const agentType = params.agent_type || "unknown";
+            // The app's own agent_memory table (separate write connection), or the
+            // server's store when the app's schema cannot hold the row.
+            const to = writerOf(db, "agent_memory", [
+                "session_id", "agent_type", "memory_type", "subject", "content", "context_tags", "expires_at",
+            ]);
             try {
-                const countRow = rawDb
+                // Counted where the row will go.
+                const countRow = (to.target === "server_store" ? to.raw : rawDb)
                     .prepare(`SELECT COUNT(*) as cnt FROM agent_memory WHERE agent_type = ?`)
                     .get(agentType);
                 const currentCount = countRow?.cnt ?? 0;
@@ -166,7 +173,7 @@ export function executeAgentMemory(db, params) {
                 };
             }
             try {
-                const stmt = rawDb.prepare(`INSERT INTO agent_memory
+                const stmt = to.raw.prepare(`INSERT INTO agent_memory
              (session_id, agent_type, memory_type, subject, content, context_tags, expires_at)
            VALUES (?, ?, ?, ?, ?, ?, ?)`);
                 const result = stmt.run(params.session_id || "unknown", params.agent_type || "unknown", params.memory_type || "context", params.subject, params.content, JSON.stringify(params.context_tags || []), params.expires_at || null);
@@ -174,6 +181,7 @@ export function executeAgentMemory(db, params) {
                     success: true,
                     id: result.lastInsertRowid,
                     message: `Memory stored: ${params.subject}`,
+                    ...writeMeta(to),
                 };
             }
             catch (error) {

package/dist/tools/app-plan.d.ts

@@ -76,12 +76,22 @@ export interface AppPlanResult {
     totalSteps: number;
     steps: AppPlanStepView[];
     summary: string;
+    /** The project the steps were narrowed to, or null for every project in the plan. */
+    projectScope: string | null;
+    /** Steps of the full plan that only touch other projects (left out by projectScope). */
+    otherProjectSteps?: number;
     snapshot: Omit<AppPlanSnapshot, "steps" | "generatedAt" | "expiresAt">;
     provenance: {
         mode: "app_plan";
         note: string;
     };
 }
+/**
+ * The steps that touch `scope` (a project directory): each step keeps only the
+ * installed lines with a site in that project, and those lines keep only
+ * those sites. Null keeps everything.
+ */
+export declare function scopeAppPlanSteps(steps: AppPlanStepView[], scope: string | null): AppPlanStepView[];
 /** Shape the app's plan as the tool result; `risk_threshold` / `max_recommendations` narrow it. */
 export declare function formatAppPlan(read: Extract<AppPlanRead, {
     kind: "plan";
@@ -89,4 +99,4 @@ export declare function formatAppPlan(read: Extract<AppPlanRead, {
     risk_threshold?: string;
     max_recommendations?: number;
     package?: string;
-}): AppPlanResult;
+}, scope?: string | null): AppPlanResult;

package/dist/tools/app-plan.js

@@ -14,6 +14,7 @@
  * APP_PLAN_SCHEMA_VERSION is treated as absent and the caller falls back to
  * its standalone heuristic.
  */
+import { isWithin } from "./project-scope.js";
 /** The snapshot schema this reader understands (Rust `PLAN_SCHEMA_VERSION`). */
 export const APP_PLAN_SCHEMA_VERSION = 4;
 const PLAN_KV_KEY = "upgrade_plan_snapshot";
@@ -93,13 +94,32 @@ export function readAppPlan(db, now = new Date()) {
 }
 const URGENCY_RISK = { critical: 3, high: 2, medium: 1, watch: 0 };
 const RISK_LEVELS = { low: 0, medium: 1, high: 2, critical: 3 };
+/**
+ * The steps that touch `scope` (a project directory): each step keeps only the
+ * installed lines with a site in that project, and those lines keep only
+ * those sites. Null keeps everything.
+ */
+export function scopeAppPlanSteps(steps, scope) {
+    if (!scope)
+        return steps;
+    const out = [];
+    for (const step of steps) {
+        const lines = step.lines
+            .map((line) => ({ ...line, sites: line.sites.filter((s) => isWithin(s.project, scope)) }))
+            .filter((line) => line.sites.length > 0);
+        if (lines.length > 0)
+            out.push({ ...step, lines });
+    }
+    return out;
+}
 const APP_PROVENANCE_NOTE = "The 4DA desktop app's own cross-project, version-confirmed Upgrade Plan, read from its database " +
     "(the same plan the app shows and `4da plan --json` prints). Each step is keyed by the app's item id.";
 /** Shape the app's plan as the tool result; `risk_threshold` / `max_recommendations` narrow it. */
-export function formatAppPlan(read, params) {
+export function formatAppPlan(read, params, scope = null) {
     const { snapshot, stale } = read;
     const threshold = params.risk_threshold ?? "all";
-    let steps = snapshot.steps;
+    const scoped = scopeAppPlanSteps(snapshot.steps, scope);
+    let steps = scoped;
     // `package` narrows the app's plan the same way it narrows the standalone one.
     const wanted = params.package?.trim().toLowerCase();
     if (wanted)
@@ -113,8 +133,9 @@ export function formatAppPlan(read, params) {
     const count = (m) => selected.filter((s) => s.mechanism === m).length;
     const majors = selected.filter((s) => s.lines.some((l) => l.upgrade_type === "major")).length;
     const parts = [
-        `${selected.length} step${selected.length !== 1 ? "s" : ""} from the 4DA app's plan (generated ${snapshot.generatedAt})`,
+        `${selected.length} step${selected.length !== 1 ? "s" : ""} from the 4DA app's plan (generated ${snapshot.generatedAt})${scope ? ` for ${scope}` : " across every project it tracks"}`,
     ];
+    const otherProjectSteps = snapshot.steps.length - scoped.length;
     if (count("manifest_bump") > 0)
         parts.push(`${count("manifest_bump")} manifest bump(s)`);
     if (count("lockfile_or_parent_update") > 0) {
@@ -126,8 +147,11 @@ export function formatAppPlan(read, params) {
         parts.push(`${count("no_fix")} with no fix published`);
     if (majors > 0)
         parts.push(`${majors} cross a major version`);
-    if (selected.length < snapshot.steps.length) {
-        parts.push(`${snapshot.steps.length} in the full plan (raise max_recommendations for the rest)`);
+    if (selected.length < scoped.length) {
+        parts.push(`${scoped.length} in ${scope ? "the plan for this project" : "the full plan"} (raise max_recommendations for the rest)`);
+    }
+    if (scope && otherProjectSteps > 0) {
+        parts.push(`${otherProjectSteps} step${otherProjectSteps !== 1 ? "s" : ""} only touch other projects (project_path "*" lists every project)`);
     }
     const staleness = stale
         ? `STALE: past its freshness horizon (${snapshot.expiresAt}). The advisories or installs may have changed since; open the 4DA app to recompute.`
@@ -139,9 +163,11 @@ export function formatAppPlan(read, params) {
         expiresAt: snapshot.expiresAt,
         stale,
         staleness,
-        totalSteps: snapshot.steps.length,
+        totalSteps: scoped.length,
         steps: selected,
         summary: parts.join(". ") + ".",
+        projectScope: scope,
+        ...(scope ? { otherProjectSteps } : {}),
         snapshot: {
             schemaVersion: snapshot.schemaVersion,
             generatorVersion: snapshot.generatorVersion,

package/dist/tools/briefing-task-scope.d.ts

@@ -23,6 +23,8 @@ export interface TaskPackage {
     /** Versions the task text names after the package ("5.x to 7.x" -> from 5.x, to 7.x). */
     requested_from: string | null;
     requested_to: string | null;
+    /** Set when the package was found through a family the task names ("all tauri plugins" -> "tauri"). */
+    family?: string;
 }
 /**
  * Package names that are also everyday words. One of these counts as named
@@ -36,8 +38,25 @@ export declare const COMMON_WORDS: Set<string>;
  * Direct dependencies first; at most `limit` packages.
  */
 export declare function detectTaskPackages(task: string, files: string[], deps: ResolvedDependency[], limit?: number): TaskPackage[];
-/** Major version of a version or a `7.x` / `v7` request; null when unreadable. */
-export declare function majorOf(version: string | null): number | null;
+/**
+ * The package families a task names, as base names: "all tauri plugins",
+ * "tauri and its plugins", "@tauri-apps packages", "tauri-plugin-*",
+ * "@tauri-apps/*". A name alone ("bump tauri") is not a family.
+ */
+export declare function detectFamilyBases(task: string, files?: string[]): string[];
+/** True when `name` belongs to the family of `base`: base-*, base_*, @base/*, @base-apps/*. */
+export declare function inFamily(name: string, base: string): boolean;
+/**
+ * The direct dependencies in the families the task names, other than the
+ * packages it names exactly. Only packages this project actually declares:
+ * a family is expanded against the lockfiles, never guessed. Measured
+ * 2026-10-07: "bump tauri and all tauri plugins" matched only `tauri`.
+ */
+export declare function detectFamilyPackages(task: string, files: string[], deps: ResolvedDependency[], exact: TaskPackage[], limit?: number): TaskPackage[];
+/** True when the task asks for the newest release ("to latest", "newest major"). */
+export declare function wantsLatest(task: string): boolean;
+/** The caret line a version sits on: "2" for 2.12.1, "0.13" for 0.13.5. */
+export declare function caretLine(version: string | null): string | null;
 /** Actionable advisories on the installed copies of one package, highest presented severity first. */
 export declare function advisoriesFor(pkg: TaskPackage, vulns: VulnerabilityEntry[]): {
     id: string;

package/dist/tools/briefing-task-scope.js

@@ -95,10 +95,103 @@ export function detectTaskPackages(task, files, deps, limit = 5) {
     packages.sort((a, b) => Number(b.direct) - Number(a.direct));
     return packages.slice(0, limit);
 }
-/** Major version of a version or a `7.x` / `v7` request; null when unreadable. */
-export function majorOf(version) {
-    const m = version ? /^v?(\d+)/.exec(version) : null;
-    return m ? Number(m[1]) : null;
+/** Words after a name that make it a family: "tauri plugins", "@tauri-apps packages". */
+const FAMILY_NOUNS = /^(?:plugins?|packages?|crates?|family|families|ecosystem|deps|dependencies|libraries|libs|modules|siblings)$/i;
+/**
+ * The package families a task names, as base names: "all tauri plugins",
+ * "tauri and its plugins", "@tauri-apps packages", "tauri-plugin-*",
+ * "@tauri-apps/*". A name alone ("bump tauri") is not a family.
+ */
+export function detectFamilyBases(task, files = []) {
+    const tokens = tokenize(`${task} ${files.join(" ")}`);
+    const bases = new Set();
+    let lastName = null;
+    tokens.forEach((token, i) => {
+        // Globs: "tauri-plugin-*" -> tauri, "@tauri-apps/*" -> @tauri-apps.
+        const glob = /^(@?[a-z0-9][\w.-]*?)(?:-plugin)?(?:[-_/]\*)$/.exec(token);
+        if (glob) {
+            bases.add(glob[1]);
+            return;
+        }
+        const next = tokens[i + 1];
+        if (next && FAMILY_NOUNS.test(next) && /^@?[a-z][\w.@/-]*$/.test(token) && !FAMILY_NOUNS.test(token)) {
+            if (!/^(?:all|every|its|their|the|other|any|some|these|those|related|official|first-party|in|of|for|with|from|our|my|your|and|or|to|dev|npm|cargo|pip|go|rust|js|node|python|workspace|root|outdated|vulnerable|new|old|unused|direct|transitive)$/.test(token)) {
+                bases.add(token);
+            }
+            else if (token === "its" || token === "their") {
+                // "tauri and its plugins": the name the possessive refers to.
+                if (lastName)
+                    bases.add(lastName);
+            }
+        }
+        if (/^@?[a-z][\w.@/-]*$/.test(token) && !FAMILY_NOUNS.test(token) && !/^(?:and|or|its|their|all|every|to|the|bump|upgrade|update)$/.test(token)) {
+            lastName = token;
+        }
+    });
+    return [...bases];
+}
+/** True when `name` belongs to the family of `base`: base-*, base_*, @base/*, @base-apps/*. */
+export function inFamily(name, base) {
+    const n = name.toLowerCase();
+    const b = base.toLowerCase();
+    if (n === b)
+        return false;
+    if (b.startsWith("@"))
+        return n.startsWith(`${b}/`);
+    return (n.startsWith(`${b}-`) ||
+        n.startsWith(`${b}_`) ||
+        n.startsWith(`@${b}/`) ||
+        n.startsWith(`@${b}-`) // @tauri-apps/api, @tauri-apps/plugin-shell
+    );
+}
+/**
+ * The direct dependencies in the families the task names, other than the
+ * packages it names exactly. Only packages this project actually declares:
+ * a family is expanded against the lockfiles, never guessed. Measured
+ * 2026-10-07: "bump tauri and all tauri plugins" matched only `tauri`.
+ */
+export function detectFamilyPackages(task, files, deps, exact, limit = 25) {
+    const bases = detectFamilyBases(task, files);
+    if (bases.length === 0)
+        return [];
+    const taken = new Set(exact.map((p) => `${p.ecosystem}\0${p.name}`));
+    const groups = new Map();
+    for (const dep of deps) {
+        if (!dep.name || !dep.isDirect)
+            continue;
+        const key = `${dep.ecosystem}\0${dep.name}`;
+        if (taken.has(key))
+            continue;
+        const base = bases.find((b) => inFamily(dep.name, b));
+        if (!base)
+            continue;
+        const group = groups.get(key) ?? { base, copies: [] };
+        group.copies.push(dep);
+        groups.set(key, group);
+    }
+    const out = [...groups.values()].map(({ base, copies }) => ({
+        name: copies[0].name,
+        ecosystem: copies[0].ecosystem,
+        installed: [...new Set(copies.map((d) => d.version).filter((v) => Boolean(v)))],
+        direct: true,
+        dev: copies.every((d) => d.isDev),
+        requested_from: null,
+        requested_to: null,
+        family: base,
+    }));
+    out.sort((a, b) => a.ecosystem.localeCompare(b.ecosystem) || a.name.localeCompare(b.name));
+    return out.slice(0, limit);
+}
+/** True when the task asks for the newest release ("to latest", "newest major"). */
+export function wantsLatest(task) {
+    return /\b(?:latest|newest|most recent)\b/i.test(task);
+}
+/** The caret line a version sits on: "2" for 2.12.1, "0.13" for 0.13.5. */
+export function caretLine(version) {
+    const m = version ? /^v?(\d+)\.(\d+)/.exec(version) : null;
+    if (!m)
+        return null;
+    return m[1] === "0" ? `0.${m[2]}` : m[1];
 }
 /** Actionable advisories on the installed copies of one package, highest presented severity first. */
 export function advisoriesFor(pkg, vulns) {

package/dist/tools/decision-memory.js

@@ -5,6 +5,7 @@
  * Manage developer decisions - record, list, check alignment, update, and supersede.
  * Decisions persist and inform signal classification, tech radar, and agent context.
  */
+import { writeMeta, writerOf } from "../memory-store.js";
 import { executeCheckDecisionAlignment } from "./decision-enforcement.js";
 // ============================================================================
 // Tool Definition
@@ -132,7 +133,10 @@ export function executeDecisionMemory(db, params) {
                     error: "subject and decision are required for record action",
                 };
             }
-            const stmt = rawDb.prepare(`INSERT INTO developer_decisions
+            // The app's own developer_decisions table (separate write connection), or
+            // the server's store when the app's schema cannot hold the row.
+            const to = writerOf(db, "developer_decisions", ["decision_type", "subject", "decision", "rationale", "alternatives_rejected", "context_tags", "confidence", "status"]);
+            const stmt = to.raw.prepare(`INSERT INTO developer_decisions
            (decision_type, subject, decision, rationale,
             alternatives_rejected, context_tags, confidence, status)
          VALUES (?, ?, ?, ?, ?, ?, ?, 'active')`);
@@ -141,6 +145,7 @@ export function executeDecisionMemory(db, params) {
                 success: true,
                 id: result.lastInsertRowid,
                 message: `Decision recorded: ${params.subject}`,
+                ...writeMeta(to),
             };
         }
         case "list": {
@@ -207,7 +212,8 @@ export function executeDecisionMemory(db, params) {
             }
             sets.push("updated_at = datetime('now')");
             values.push(params.id);
-            const updated = rawDb
+            const updater = writerOf(db, "developer_decisions", ["id", "updated_at", ...sets.map((s) => s.split(" ")[0])]);
+            const updated = updater.raw
                 .prepare(`UPDATE developer_decisions SET ${sets.join(", ")} WHERE id = ?`)
                 .run(...values);
             if (updated.changes === 0) {
@@ -229,7 +235,7 @@ export function executeDecisionMemory(db, params) {
             if (missing.length > 0) {
                 return { error: `No decision with id ${missing.join(" or ")}. Use action "list" to find ids.` };
             }
-            rawDb
+            writerOf(db, "developer_decisions", ["id", "status", "superseded_by", "updated_at"]).raw
                 .prepare(`UPDATE developer_decisions
            SET status = 'superseded',
                superseded_by = ?,

package/dist/tools/dependency-check-signals.d.ts

@@ -8,11 +8,11 @@
  * another source was unreachable, but a missing source never lets the
  * verdict fall through to `proceed`.
  */
-import type { PackageReleaseIndex, ReleaseRecord } from "../live/release-metadata.js";
+import type { CheckEcosystem, PackageReleaseIndex, ReleaseRecord } from "../live/release-metadata.js";
 export type Verdict = "proceed" | "wait" | "review" | "avoid" | "unknown";
 export type SignalEffect = Verdict | "info";
 export interface CheckItem {
-    ecosystem: "npm" | "crates.io";
+    ecosystem: CheckEcosystem;
     package: string;
     to: string;
     from?: string;
@@ -60,13 +60,31 @@ export declare function selectBaseline(index: PackageReleaseIndex, item: CheckIt
 /** Runtime dependency names in `to` that the baseline did not have; null when either list is unknown. */
 export declare function introducedDependencies(to: ReleaseRecord, base: ReleaseRecord | null): string[] | null;
 export declare function advisoriesSignal(item: CheckItem, facts: AdvisoryFacts): Signal;
-export declare function releaseAgeSignal(item: CheckItem, to: ReleaseRecord, advisories: Signal, now: Date): Signal;
+/**
+ * Why the hold does not apply to a clean `to`: every safe release on its line
+ * is inside the hold too, and every older release on it has an advisory, so
+ * holding back would leave only vulnerable releases to write.
+ */
+export interface HoldWaiver {
+    /** The release line judged ("7.x", "v0", "==3.1.*"). */
+    line: string;
+    /** Releases on the line past the hold, all with a known advisory. */
+    olderVulnerable: number;
+}
+export declare function releaseAgeSignal(item: CheckItem, to: ReleaseRecord, advisories: Signal, now: Date, waiver?: HoldWaiver): Signal;
 export declare function publishTrustSignal(item: CheckItem, to: ReleaseRecord, base: ReturnType<typeof selectBaseline>): Signal;
 export declare function installScriptSignal(item: CheckItem, to: ReleaseRecord, from: ReleaseRecord | null): Signal;
-export declare function newDependenciesSignal(to: ReleaseRecord, base: ReturnType<typeof selectBaseline>, introduced: string[] | null, created: Map<string, CreatedAtFact>): Signal;
+export declare function newDependenciesSignal(item: CheckItem, to: ReleaseRecord, base: ReturnType<typeof selectBaseline>, introduced: string[] | null, created: Map<string, CreatedAtFact>): Signal;
 export declare function withdrawnSignal(item: CheckItem, to: ReleaseRecord): Signal;
+/**
+ * The bump's semver class. A breaking range (a major, or below 1.0 a minor or
+ * 0.0.x patch) is `review`: the supply-chain signals say nothing about whether
+ * the project's code survives it. Until 6.0.2 this was information only, so
+ * vitest 3 -> 5, reqwest 0.12 -> 0.13 and stripe 22 -> 23 all came back
+ * "proceed" and the summary told the agent to apply them (2026-10-07 eval).
+ */
 export declare function upgradeTypeSignal(item: CheckItem): Signal;
-export declare function upgradeType(from: string | undefined, to: string): "patch" | "minor" | "major" | "downgrade" | "none" | "new_dependency" | "unknown";
+export declare function upgradeType(from: string | undefined, to: string, ecosystem?: CheckEcosystem): "patch" | "minor" | "major" | "downgrade" | "none" | "new_dependency" | "unknown";
 /** The item verdict and its one-line reason, from the strongest signal effect. */
 export declare function decide(signals: Signal[]): {
     verdict: Verdict;

package/dist/tools/dependency-check-signals.js

@@ -9,7 +9,7 @@
  * another source was unreachable, but a missing source never lets the
  * verdict fall through to `proceed`.
  */
-import { comparePrecedence, parseSemverPrecedence } from "../live/semver-precedence.js";
+import { compareIn, isPrereleaseIn, versionParts } from "./dependency-check-versions.js";
 /** Verdict precedence, strongest first. */
 const PRECEDENCE = ["avoid", "review", "unknown", "wait", "proceed"];
 export const WAIT_DAYS = 3;
@@ -25,23 +25,25 @@ export function selectBaseline(index, item) {
             note: rec ? `installed ${item.from}` : `installed version ${item.from} is not listed on the registry`,
         };
     }
-    const target = parseSemverPrecedence(item.to);
+    const eco = item.ecosystem;
+    const target = versionParts(eco, item.to);
     if (!target)
-        return { record: null, kind: "previous_on_line", note: "target version is not readable semver" };
+        return { record: null, kind: "previous_on_line", note: "target version is not readable" };
+    const targetPre = isPrereleaseIn(eco, item.to);
     let best = null;
     for (const rec of Object.values(index.releases)) {
         if (rec.withdrawn)
             continue;
-        const p = parseSemverPrecedence(rec.version);
-        if (!p || !sameLine(p, target) || comparePrecedence(p, target) >= 0)
+        const p = versionParts(eco, rec.version);
+        if (!p || !sameLine(p, target) || compareIn(eco, rec.version, item.to) >= 0)
             continue;
-        if (p.prerelease.length > 0 && target.prerelease.length === 0)
+        if (isPrereleaseIn(eco, rec.version) && !targetPre)
             continue;
-        if (!best || comparePrecedence(p, best.p) > 0)
-            best = { rec, p };
+        if (!best || compareIn(eco, rec.version, best.version) > 0)
+            best = rec;
     }
     return best
-        ? { record: best.rec, kind: "previous_on_line", note: `previous release on the same line, ${best.rec.version}` }
+        ? { record: best, kind: "previous_on_line", note: `previous release on the same line, ${best.version}` }
         : { record: null, kind: "previous_on_line", note: "first release on its line; nothing earlier to compare" };
 }
 /** Same compatibility line: same major, or same 0.minor below 1.0. */
@@ -95,7 +97,7 @@ function list(advisories) {
     const shown = advisories.slice(0, 3).map(fmt).join(", ");
     return advisories.length > 3 ? `${shown} and ${advisories.length - 3} more` : shown;
 }
-export function releaseAgeSignal(item, to, advisories, now) {
+export function releaseAgeSignal(item, to, advisories, now, waiver) {
     if (!to.publishedAt) {
         return { id: "release_age", value: null, evidence: `The registry gives no publish time for ${item.to}.`, effect: "unknown" };
     }
@@ -114,6 +116,16 @@ export function releaseAgeSignal(item, to, advisories, now) {
             evidence: `${ageText}, under the ${WAIT_DAYS}-day hold, but it fixes ${fixed.join(", ")} affecting ${item.from}; a security fix is not held back.`,
         };
     }
+    if (waiver) {
+        return {
+            id: "release_age",
+            value: { ...value, hold_waived: "no_settled_safe_release" },
+            effect: "proceed",
+            evidence: `${ageText}, under the ${WAIT_DAYS}-day hold, but every release of ${waiver.line} older than that has a known advisory ` +
+                `(${waiver.olderVulnerable} of them) and no safe one is past the hold; a vulnerable release is the worse risk, so the hold is not applied. ` +
+                `Tell the user this version is ${value.days} day${value.days === 1 ? "" : "s"} old.`,
+        };
+    }
     return {
         id: "release_age",
         value,
@@ -122,6 +134,9 @@ export function releaseAgeSignal(item, to, advisories, now) {
     };
 }
 export function publishTrustSignal(item, to, base) {
+    if (item.ecosystem === "PyPI" || item.ecosystem === "Go") {
+        return { id: "publish_trust", value: "not_applicable", evidence: to.trustEvidence, effect: "info" };
+    }
     if (to.withdrawn === "unpublished") {
         // Its publisher record is gone with it; comparing would report a "drop" we cannot see.
         return { id: "publish_trust", value: null, evidence: `${item.to} was unpublished; its publish metadata is gone.`, effect: "info" };
@@ -144,7 +159,7 @@ export function publishTrustSignal(item, to, base) {
 }
 export function installScriptSignal(item, to, from) {
     if (item.ecosystem !== "npm") {
-        return { id: "install_script_added", value: "not_applicable", evidence: "npm only (crates run build.rs at build time, which the registry does not expose).", effect: "info" };
+        return { id: "install_script_added", value: "not_applicable", evidence: NO_INSTALL_SCRIPTS[item.ecosystem], effect: "info" };
     }
     const scripts = to.installScripts ?? [];
     if (!item.from) {
@@ -174,7 +189,20 @@ export function installScriptSignal(item, to, from) {
         evidence: scripts.length > 0 ? `Install scripts unchanged (${scripts.join(", ")}).` : "Neither version declares install-time scripts.",
     };
 }
-export function newDependenciesSignal(to, base, introduced, created) {
+const NO_INSTALL_SCRIPTS = {
+    "crates.io": "not applicable: npm only (crates run build.rs at build time, which the registry does not expose).",
+    PyPI: "not applicable: PyPI's index exposes no install hooks (an sdist-only release runs its build backend at install).",
+    Go: "not applicable: Go runs no package code when a module is downloaded.",
+};
+export function newDependenciesSignal(item, to, base, introduced, created) {
+    if (item.ecosystem === "PyPI" || item.ecosystem === "Go") {
+        return {
+            id: "new_dependencies",
+            value: "not_applicable",
+            evidence: `not applicable: per-release dependency lists are not read for ${item.ecosystem}.`,
+            effect: "info",
+        };
+    }
     if (!base.record) {
         return { id: "new_dependencies", value: null, evidence: `No baseline to diff against: ${base.note}.`, effect: "info" };
     }
@@ -222,20 +250,35 @@ export function withdrawnSignal(item, to) {
     }
     return { id: "yanked_or_deprecated", value: null, effect: "proceed", evidence: `${item.to} is neither yanked nor deprecated.` };
 }
+/**
+ * The bump's semver class. A breaking range (a major, or below 1.0 a minor or
+ * 0.0.x patch) is `review`: the supply-chain signals say nothing about whether
+ * the project's code survives it. Until 6.0.2 this was information only, so
+ * vitest 3 -> 5, reqwest 0.12 -> 0.13 and stripe 22 -> 23 all came back
+ * "proceed" and the summary told the agent to apply them (2026-10-07 eval).
+ */
 export function upgradeTypeSignal(item) {
-    const kind = upgradeType(item.from, item.to);
+    const kind = upgradeType(item.from, item.to, item.ecosystem);
     const text = item.from ? `${item.from} -> ${item.to}: ${kind}` : `new dependency at ${item.to}`;
-    const zeroX = kind === "major" && /^0\./.test(item.from ?? "") ? " (0.x: a minor bump is breaking)" : "";
-    return { id: "upgrade_type", value: kind, evidence: `${text}${zeroX}.`, effect: "info" };
+    if (kind === "major") {
+        const zeroX = /^v?0\./.test(item.from ?? "") ? " (below 1.0 a minor bump is a major one)" : "";
+        return {
+            id: "upgrade_type",
+            value: kind,
+            evidence: `${text}${zeroX}: breaking version range, run upgrade_impact to see what changes for this project.`,
+            effect: "review",
+        };
+    }
+    return { id: "upgrade_type", value: kind, evidence: `${text}.`, effect: "info" };
 }
-export function upgradeType(from, to) {
+export function upgradeType(from, to, ecosystem = "npm") {
     if (!from)
         return "new_dependency";
-    const a = parseSemverPrecedence(from);
-    const b = parseSemverPrecedence(to);
+    const a = versionParts(ecosystem, from);
+    const b = versionParts(ecosystem, to);
     if (!a || !b)
         return "unknown";
-    const cmp = comparePrecedence(b, a);
+    const cmp = compareIn(ecosystem, to, from);
     if (cmp === 0)
         return "none";
     if (cmp < 0)

package/dist/tools/dependency-check-versions.d.ts

@@ -0,0 +1,94 @@
+/**
+ * dependency_check version handling across npm, crates.io, PyPI and Go:
+ * reading `to` as an exact version, "latest", or a constraint, and finding
+ * the safe releases a constraint admits.
+ *
+ * Why a constraint: an agent told "pin ws 7.x" writes the 7.x release it
+ * remembers. In the G7 agent evaluation (2026-10-11) that was ws 7.5.10 and
+ * body-parser 1.20.3, both affected by an advisory their next patch fixes.
+ * Asked with `to: "7.x"`, the check answers with the smallest and newest
+ * release in the constraint that no known advisory affects.
+ *
+ * Constraint syntax is the ecosystem's own (npm ranges, Cargo requirements,
+ * PEP 440 specifiers), plus the shorthand every agent writes: "7.x", "3.1.*",
+ * "v1" for a Go major. Pure functions, no I/O.
+ */
+import { type AdvisoryRanges } from "../live/osv-ranges.js";
+import type { CheckEcosystem, PackageReleaseIndex } from "../live/release-metadata.js";
+export type Target = {
+    kind: "exact";
+    version: string;
+} | {
+    kind: "latest";
+} | {
+    kind: "range";
+    range: string;
+}
+/** PyPI "3.1": the release 3.1 when it is published, else the 3.1.* series. */
+ | {
+    kind: "exact_or_series";
+    version: string;
+    range: string;
+};
+/** Read a `to` value; null when it is neither a version nor a constraint this ecosystem understands. */
+export declare function parseTarget(ecosystem: CheckEcosystem, raw: string): Target | null;
+/** Whether a constraint admits a version, in the ecosystem's own syntax. Null = unreadable constraint or version. */
+export declare function rangeAdmits(ecosystem: CheckEcosystem, range: string, version: string): boolean | null;
+/**
+ * PEP 440 version specifiers: comma-separated clauses of `==`, `!=` (both
+ * with optional `.*` prefix matching), `>=`, `<=`, `>`, `<`, `~=` and `===`.
+ * Null when a clause or the version is unreadable.
+ */
+export declare function pep440SpecAdmits(spec: string, version: string): boolean | null;
+/** Order two versions of one ecosystem. */
+export declare function compareIn(ecosystem: CheckEcosystem, a: string, b: string): number;
+export declare function isPrereleaseIn(ecosystem: CheckEcosystem, version: string): boolean;
+/** MAJOR.MINOR.PATCH of a version in any of the four ecosystems (PEP 440 release parts; missing ones 0). */
+export declare function versionParts(ecosystem: CheckEcosystem, version: string): {
+    major: number;
+    minor: number;
+    patch: number;
+} | null;
+/**
+ * The release line a version belongs to, as a constraint: the same major (the
+ * same 0.minor below 1.0) on npm and crates.io; the same module major on Go,
+ * where v0 is one line (`go get -u` moves freely within a module path); the
+ * same X.Y series on PyPI, where many projects do not follow semver (Django
+ * 4.2 LTS, Jinja2 3.1).
+ */
+export declare function lineOf(ecosystem: CheckEcosystem, version: string): string | null;
+export interface RangeCheck {
+    /** The constraint evaluated. */
+    range: string;
+    /** "requested" (the caller's `to`) or "same_line" (the line of an affected exact `to`). */
+    basis: "requested" | "same_line";
+    /** Installable, non-prerelease releases the constraint admits. */
+    releases_in_range: number;
+    /** How many of them a known advisory affects. */
+    vulnerable_in_range: number;
+    smallest_safe_in_range: string | null;
+    newest_safe_in_range: string | null;
+    /** Up to 8 of the newest safe releases, ascending. */
+    safe_versions: string[];
+    /** Advisories that affect every release in range (no safe choice inside it); at most 10 named. */
+    affecting_all?: string[];
+    /** When nothing in range is safe: the newest release of the package that is, outside the range. */
+    newest_safe_outside_range?: string | null;
+    /** When `from` is given: the smallest safe release above it (the minimal fixing upgrade). */
+    smallest_safe_upgrade?: string | null;
+}
+/**
+ * The releases a constraint admits, judged against every advisory OSV.dev
+ * lists for the package. Withdrawn (yanked / unpublished / retracted) and
+ * deprecated releases are not candidates; neither are prereleases, unless
+ * the constraint admits nothing else. Maintenance notices do not make a
+ * release unsafe.
+ */
+export declare function checkRange(input: {
+    ecosystem: CheckEcosystem;
+    index: PackageReleaseIndex;
+    range: string;
+    basis: RangeCheck["basis"];
+    advisories: AdvisoryRanges[];
+    from?: string;
+}): RangeCheck;