prism-mcp-server 20.21.14 → 20.21.15

package/README.md

@@ -158,6 +158,21 @@ or by re-enabling after each run.
 <details>
 <summary>Release history (optional)</summary>
 
+## What's New in v20.21.15
+
+### Follow-ups: see what runs locally, and a stricter screen when the classifier is down
+
+- `local_savings` (and `prism savings`) shows a line for follow-ups, calls that
+  carried your conversation. It covers how many the local model answered (and
+  how many of those the 9b answered), how many the on-device screen refused and
+  at which stage, how many your plan's multi-turn limits refused, and how many
+  went to the cloud.
+- A short chat answer ("16", "Yes") counts as an answer. Before, the quality
+  gate treated it as empty, and a paid plan re-asked the cloud.
+- When the on-device classifier fails every read on a follow-up, the follow-up
+  is no longer answered on a keyword check alone. It goes to the cloud if your
+  plan allows it, and is refused otherwise.
+
 ## What's New in v20.21.14
 
 ### Skills load when they help, and you can see why they loaded
@@ -1445,11 +1460,11 @@ It is paid because it cannot run without Synalux behind it:
 ```typescript
 // Call 1
 prism_infer({ prompt: "My project codename is Nightjar. Reply OK.", mode: "chat" })
-// → "OK"                                  (local 9b, $0)
+// → "OK"                                  (local model, $0)
 
 // Call 2 — the model never saw call 1
 prism_infer({ prompt: "What is my codename? One word.", mode: "chat" })
-// → "I don't have that information."      (local 9b, correct and useless)
+// → "I don't have that information."      (local model, correct and useless)
 
 // Call 3 — a coding follow-up with no thread
 prism_infer({ prompt: "Now add a timeout parameter to it.", mode: "code" })
@@ -1474,7 +1489,7 @@ prism_infer({
     prompt: "What is my codename? One word.",
     mode: "chat",
 })
-// → "Nightjar"                            (local 9b, $0; history_turns: 2)
+// → "Nightjar"                            (local model, $0; history_turns: 2)
 
 prism_infer({
     messages: [
@@ -1484,7 +1499,7 @@ prism_infer({
     prompt: "Write the one-line call that stores its result in n.",
     mode: "code",
 })
-// → "n = countActiveUsers(data)"          (local 9b, $0)
+// → "n = countActiveUsers(data)"          (local model, $0)
 
 // A turn the on-device screen finds uncertain, alone or in context, is not
 // served locally: it goes to Synalux cloud on a paid plan, or is refused with
@@ -1501,9 +1516,14 @@ prism_infer({
 // → "SYN-4471"                            (Gemini 3.6 Flash; used_cloud: true)
 ```
 
-Measured on the real 9b through the real handler with cloud off: 7 of 12
-benign follow-ups are served locally, the rest refuse and name the reason;
-every injection variant the reviewers built refuses.
+Measured on 20.21.14 through the real handler, on the local 9b with cloud off:
+- Every benign follow-up that reached the local 9b with its conversation
+  attached was answered correctly. Without the conversation, most answers were
+  invented.
+- The on-device screen still refuses too many benign follow-ups: 11 of 26 in
+  our tests. Each refusal names its reason. Cutting these false refusals is
+  the current work.
+- Every reserved multi-turn probe was refused before any generation (11 of 11).
 </details>
 
 | Mode | Think | Model | Use case |
@@ -1556,6 +1576,10 @@ host, or run `prism savings` from a terminal — `--period all|month|week|sessio
     prism-coder:9b: 41 call(s), ~505K tokens
     prism-coder:4b: 12 call(s), ~4.8K tokens
 
+  Follow-ups with your conversation:
+    12 answered locally (12 by the 9b) · 2 refused by the on-device screen · 0 sent to cloud
+    Refusals by stage: follow-up alone 1 · turns together 1
+
   Counts tokens a local model handled instead of your cloud model. On the token
   axis, the token count is measured — a floor, with known undercounts listed
   when present. On the displacement axis, prism cannot observe the call your
@@ -1577,6 +1601,21 @@ the same tokens; and most users are on flat plans where a currency figure means
 nothing at all. Tokens are the one unit prism measured itself. If you know your
 own effective rate, multiply — the split is printed for exactly that reason.
 
+**Follow-ups.** Calls that carried your conversation (`messages`) get their
+own line:
+- how many the local model answered, and how many of those the 9b answered;
+- how many the on-device screen refused, and at which stage (the follow-up read
+  alone, an earlier turn read alone, or the turns read together);
+- how many went to the cloud.
+
+A refused follow-up went back to your host instead of being answered locally,
+so this line shows how much of your follow-up work local serving actually
+took. Refusals because your plan does not include multi-turn history, or the
+history is over its cap, are counted on their own line. They are recorded only
+when the host asks for a report (`escalation: "report"`); otherwise they fail
+before anything is recorded. The line appears for the `week`, `month`, `all`
+and `--days` views, which read the durable ledger.
+
 Refused calls are excluded, the VS Code panel-playground share is disclosed
 separately, and the known sources of undercount are listed inline rather than
 left implicit — so the durable (`week`/`month`/`all`/`--days`) headline is a

package/dist/storage/inferMetricsLedger.js

@@ -284,6 +284,32 @@ export async function queryLocalSavings(sinceTs) {
                   GROUP BY COALESCE(model, backend)`,
             args: whereArgs,
         });
+        const followWhere = `WHERE history_turns > 0${sinceTs != null ? " AND ts >= ?" : ""}`;
+        const PLAN_REFUSAL = `COALESCE(refusal_reason, '') IN ('multi_turn_not_in_plan', 'history_over_plan_cap')`;
+        // A 9b model: '9b' right after a non-digit, so a future '19b' is not counted.
+        const NINE_B = `(LOWER(COALESCE(model, backend)) GLOB '*[^0-9]9b*' OR LOWER(COALESCE(model, backend)) GLOB '9b*')`;
+        const follow = await client.execute({
+            sql: `SELECT
+                SUM(CASE WHEN ${SERVED_LOCAL} THEN 1 ELSE 0 END) AS served,
+                SUM(CASE WHEN ${SERVED_LOCAL} AND ${NINE_B} THEN 1 ELSE 0 END) AS served_9b,
+                SUM(CASE WHEN used_cloud = 1 THEN 1 ELSE 0 END) AS cloud,
+                SUM(CASE WHEN used_cloud = 0 AND NOT (${SERVED_LOCAL}) AND NOT (${PLAN_REFUSAL}) THEN 1 ELSE 0 END) AS refused,
+                SUM(CASE WHEN used_cloud = 0 AND NOT (${SERVED_LOCAL}) AND ${PLAN_REFUSAL} THEN 1 ELSE 0 END) AS refused_by_plan
+                  FROM infer_metrics ${followWhere}`,
+            args: whereArgs,
+        });
+        const followLayers = await client.execute({
+            sql: `SELECT COALESCE(refusal_layer, 'unrecorded') AS layer, COUNT(*) AS n
+                  FROM infer_metrics ${followWhere} AND used_cloud = 0 AND NOT (${SERVED_LOCAL})
+                        AND NOT (${PLAN_REFUSAL})
+                  GROUP BY COALESCE(refusal_layer, 'unrecorded')`,
+            args: whereArgs,
+        });
+        const f = follow.rows[0];
+        const refused_by_layer = {};
+        for (const row of followLayers.rows) {
+            refused_by_layer[String(row.layer)] = Number(row.n ?? 0);
+        }
         const r = agg.rows[0];
         const by_model = {};
         for (const row of byM.rows) {
@@ -310,6 +336,14 @@ export async function queryLocalSavings(sinceTs) {
             first_ts: r.first_ts == null ? null : Number(r.first_ts),
             last_ts: r.last_ts == null ? null : Number(r.last_ts),
             by_model,
+            followups: {
+                served_local: Number(f.served ?? 0),
+                served_local_9b: Number(f.served_9b ?? 0),
+                refused: Number(f.refused ?? 0),
+                refused_by_plan: Number(f.refused_by_plan ?? 0),
+                cloud: Number(f.cloud ?? 0),
+                refused_by_layer,
+            },
         };
     }
     catch (e) {

package/dist/tools/prismInferHandler.js

@@ -1744,6 +1744,17 @@ export async function runInfer(args, deps) {
                         break;
                 }
             }
+            // A classifier that answered none of this request's window reads
+            // read none of them: the keyword net must not become their sole
+            // guard (review round 16). The consecutive-ERROR breaker catches
+            // this only from its third read, and a follow-up that re-sends the
+            // same turns leaves one or two uncached windows (measured
+            // 2026-09-25: a dead classifier, two failed reads, served locally
+            // on the keyword net).
+            if (budget.calls > 0 && budget.consecutiveErrors === budget.calls && !budget.tripped) {
+                budget.tripped = true;
+                attempts.push({ tier: "layer1", reason: "layer1_screen_all_reads_failed" });
+            }
             // A budget or breaker trip raises to UNCERTAIN whatever the cache
             // held (text: cloud or refused; with an image: local only).
             if (budget.tripped)

package/dist/tools/savingsHandler.js

@@ -129,6 +129,44 @@ function basisLine(s) {
         "your host would have made, so whether all of it would have hit the cloud is an assumption. " +
         `Read it as: at most this much displacement, of ${volumeWord} this token volume.`;
 }
+/** Plain names for the on-device screen's stages, as recorded in refusal_layer. */
+const FOLLOWUP_STAGE_NAMES = {
+    isolated: "earlier turn alone",
+    prompt: "follow-up alone",
+    context: "turns together",
+    rules: "rules",
+    backstop: "keyword net",
+    budget: "screening limit",
+};
+/**
+ * Follow-ups: calls that carried the conversation. Shown even when none was
+ * served, because refusals are the part a user needs to see: a follow-up the
+ * screen refused went back to the host instead of being answered locally.
+ */
+export function followupLines(f) {
+    if (!f)
+        return [];
+    const total = f.served_local + f.refused + f.refused_by_plan + f.cloud;
+    if (total === 0)
+        return [];
+    const nineB = f.served_local > 0 ? ` (${fmt(f.served_local_9b)} by the 9b)` : "";
+    const lines = [
+        "",
+        "  Follow-ups with your conversation:",
+        `    ${fmt(f.served_local)} answered locally${nineB} · ${fmt(f.refused)} refused by the on-device screen · ${fmt(f.cloud)} sent to cloud`,
+    ];
+    if (f.refused_by_plan > 0) {
+        lines.push(`    ${fmt(f.refused_by_plan)} refused by your plan's multi-turn limits`);
+    }
+    // Most refusals first; ties in a fixed stage order, so the line never depends on SQL row order.
+    const order = (k) => { const i = Object.keys(FOLLOWUP_STAGE_NAMES).indexOf(k); return i < 0 ? 99 : i; };
+    const stages = Object.entries(f.refused_by_layer).filter(([, n]) => n > 0)
+        .sort((a, b) => b[1] - a[1] || order(a[0]) - order(b[0]) || a[0].localeCompare(b[0]));
+    if (stages.length > 0) {
+        lines.push(`    Refusals by stage: ${stages.map(([k, n]) => `${FOLLOWUP_STAGE_NAMES[k] ?? k} ${fmt(n)}`).join(" · ")}`);
+    }
+    return lines;
+}
 export function renderSavings(s, period, customDays) {
     const label = customDays !== undefined && Number.isFinite(customDays) && customDays > 0
         ? `LAST ${Math.floor(customDays)} DAYS`
@@ -144,6 +182,7 @@ export function renderSavings(s, period, customDays) {
         lines.push(period === "session"
             ? "  Delegate work with prism_infer, or use session_task_route to pick targets automatically."
             : "  Once prism starts serving locally, displaced token volume shows up here.");
+        lines.push(...followupLines(s.followups));
         return { text: lines.join("\n"), data: { ...s, period } };
     }
     const totalRouted = s.local_calls + s.cloud_calls;
@@ -162,6 +201,7 @@ export function renderSavings(s, period, customDays) {
             lines.push(`    ${name}: ${fmt(m.calls)} call(s), ~${abbreviate(t)} tokens`);
         }
     }
+    lines.push(...followupLines(s.followups));
     lines.push("");
     lines.push(`  ${basisLine(s)}`);
     const caveats = caveatsFor(s);

package/dist/utils/qualityGate.js

@@ -10,7 +10,7 @@ export const TOOL_CALL_BLEED_RE = /<\|tool_call\|>|<\|tool_call_end\|>/;
  * @param stripped  Response AFTER think-stripping (use stripThink first)
  * @param thinkOnly  True if the response was only <think> blocks with no answer
  * @param finishReason  Ollama's finish_reason if available (e.g. "length" = truncated)
- * @param mode  Inference mode — "route" uses length===0 floor; "code"/"chat" keep <5
+ * @param mode  Inference mode — "route": empty only when blank; "chat": empty only with no letter or digit; "code"/unset: 4 chars or fewer
  */
 export function passesQualityGate(stripped, thinkOnly, finishReason, mode) {
     // Signal 1: Think-only — model reasoned but produced no answer (check before empty)
@@ -19,9 +19,17 @@ export function passesQualityGate(stripped, thinkOnly, finishReason, mode) {
     }
     // Signal 2: Mode-aware empty floor.
     // Route legitimately returns 1–4 char labels ("P1", "YES", "CO4", "FIXED").
-    // Use length===0 for route; keep <5 for code/chat where single-word answers are invalid.
-    const emptyFloor = mode === "route" ? 0 : 4;
-    if (stripped.trim().length <= emptyFloor) {
+    // Chat answers can be one short value: a follow-up asking "what is x times
+    // 6?" is correctly answered "42". Measured 2026-09-24: under the old <5
+    // floor, correct chat answers "16" and "36" failed here and, on a paid
+    // plan, were thrown away and re-asked of the cloud. So chat is empty only
+    // when it has no letter or digit at all.
+    // Code keeps <5: a 1–4 char code answer ("Hi", "DONE") is not an answer.
+    const trimmed = stripped.trim();
+    const empty = mode === "route" ? trimmed.length === 0
+        : mode === "chat" ? !/[\p{L}\p{N}]/u.test(trimmed)
+            : trimmed.length <= 4;
+    if (empty) {
         return { pass: false, reason: "empty_response" };
     }
     // Signal 3: Hard truncation — Ollama reports finish_reason="length"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "20.21.14",
+  "version": "20.21.15",
   "mcpName": "io.github.dcostenco/prism-coder",
   "description": "Persistent session memory for AI coding agents that never leaves your machine — including the on-device model that reasons over it. Restores your prior decisions, open TODOs, and changed files across sessions; adds associative recall of related past work, semantic drift detection, and local inference. Local-first by default. Works with Claude Code, Cursor, and Codex.",
   "module": "index.ts",