specpi 0.29.0 → 0.30.0

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 0.30.0 - 2026-09-21
+
+- Replace the evaluations page with Terminal-Bench 2.0. The suite that filled it was written in this repository, and it was retired for the reason it kept reporting: nearly every harness passed nearly every task, so the thing it was built to measure was the thing it could not see, and three rounds of harder tasks did not move it. A suite cannot mark its own homework. The page now carries somebody else's benchmark on tasks nobody here chose -- Pi with no harness, SpecPi + Jev, Oh My Pi and Claude Code, 334 scored attempts on one model through one endpoint.
+- Report the result the outside benchmark actually gives, which is that it does not separate the harnesses either. Solve rate spans 0.767 to 0.838 across the four arms; Pi against SpecPi + Jev is Fisher p = 0.83, and exactly 30/39 each on the slice the comparison rests on. That is the second suite to find no difference in capability, and this one's tasks were not chosen here and are failed about a fifth of the time, so the usual explanation -- that the tasks are too easy -- does not cover it.
+- Make spend the column the page is about, because it is the one that separates. SpecPi + Jev reaches the same solve rate as bare Pi on 26% fewer prompt tokens and 23% less cost per attempt, and cost per attempt spans 1.7x across the three rows whose cached share could be measured. Score is the control here rather than the finding.
+- Publish the run unfinished, and say so in the first paragraph. Terminal-Bench 2.0's hard split and a SWE-Gym slice have not run, plain SpecPi is not an arm so nothing separates the harness from the advisory layer, and Oh My Pi's widened slice holds six attempts per task rather than three because two launches of the same script raced into one output directory. Section 07 of the page lists each of these rather than leaving the reader to infer them from a table that looks complete.
+- Publish Claude Code's cached share as absent rather than as zero. Its traffic crosses the Messages/chat-completions translation, which recorded no cached tokens at all on these runs, and a zero would have read as "Claude Code destroys cache efficiency" -- which the run does not show, since Pi and SpecPi see 94% on the same endpoint in the same sitting. Its cost is published as an upper bound for the same reason, because the cached share is what would discount it.
+- Map Anthropic's cache tokens onto the pair Anthropic reports them as. `scripts/eval-anthropic.mjs` was passing the provider's prompt total through as `input_tokens` and emitting no `cache_read_input_tokens`, but Anthropic counts cache reads outside the input total rather than inside it, so the two have to split the prompt. This is the fault above, fixed; the rows it spoiled predate it and are labelled rather than silently re-priced, because the tokens are not recoverable from an archived aggregate.
+- Count auxiliary calls as spend. `modelRequests()` answers how many turns an attempt took, and the token totals were reading the same filtered list, so the session-title call Claude Code makes on every attempt cost nothing in any report. Billing and conversation counting are separate questions now: totals and pricing cover the auxiliary calls, while the turn series and the per-turn figures stay conversation-only, because an auxiliary is not a turn.
+- Fail a Responses reply the provider reported as failed. `scripts/eval-responses.mjs` inspected only `incomplete_details`, so an HTTP 200 stream carrying `response.failed` was assembled into an ordinary reply and returned with a `stop` finish reason -- a provider failure arriving at the harness as a short answer, which is the one shape that cannot be told from the harness giving up. The proxy returns 502 with the provider's own code and message instead. `max_output_tokens` stays a finish reason rather than a failure, because that turn happened and its text is real.
+- Admit a row to the controlled-window comparison only when the window was enforced. `scripts/tier6-metrics.mjs` accepted any attempt that had compacted at all, which is evidence that the harness compacts and not that it compacted at the declared window: an 80,000-token attempt with one compaction was being compared against attempts held to 24,000. The bound is measured rather than picked -- at that window, enforced attempts peak at 1.58x it and provider-default attempts start at 1.89x -- and it excludes rather than admits when it is unsure.
+- Let an eval run drop one part of the SpecPi layer. `SPECPI_EVAL_ABLATE` takes `agents`, `tools` and `goal`, combinable, so a run can strip the harness to Pi's exact tool surface and measure what that alone accounts for. It was built to test a specific claim of mine -- that SpecPi's four extra tools explained a collapse on one model -- and it refuted it, which is the use an ablation is for.
+- Delete the retired suite's publishers rather than leaving them aimed at sections that no longer exist. `scripts/tb-metrics.mjs`, `scripts/tb-site.mjs` and `scripts/tier6-site.mjs` go with the three data files they wrote. `scripts/eval-site.mjs` keeps the part with other callers -- reading run reports, and the chart and table renderers the new page draws with -- and loses the page-specific rendering it no longer has a page for. `scripts/tier6-metrics.mjs` still runs, writing beside the runs it describes instead of into a published directory.
+
+- Add Claude Code to the eval suite as `--harness=claude-code`. It is the first harness that speaks the Anthropic Messages API, and the provider the whole suite runs against is chat-completions only, so measuring it at all meant translating both directions. `scripts/eval-anthropic.mjs` does that and nothing else.
+- Translate at the edge rather than throughout. The request becomes a chat-completions request before the proxy records anything, and the reply is converted back only on the way out, so `summarizeRequest`, `toolOutcomeOf`, `extractUsage`, `extractToolCalls` and the cost pipeline all keep reading the one shape they have always read. The alternative -- teaching each of them a second shape -- is six places to drift instead of one place to read.
+- Rebuild the stream rather than piping it. `startProxy` already buffers the whole upstream reply before answering, so there is no streaming fidelity to lose: the OpenAI deltas are collected into one finished message and re-emitted as a well-formed Anthropic event sequence. `tests/eval-anthropic.test.mjs` covers the cases where a wrong conversion would be scored as the harness failing the task rather than as the suite losing its work -- several tool results in one turn, a failed tool result, fragmented tool arguments, and arguments that never parse.
+- Read no Anthropic credential and spend none. Claude Code normally authenticates against a stored subscription login, so a run against a real configuration could fall back to it and bill a subscription for an eval. The row uses a disposable `CLAUDE_CONFIG_DIR` with no login to fall back on, points `ANTHROPIC_BASE_URL` at the logging proxy, and the proxy discards the client's token and sends `EVAL_FORWARD_KEY` upstream. Runs bill the same OpenCode Go subscription as every other harness; the probe confirms it, reporting `apiKeySource: none`.
+- Answer the reachability probe instead of recording it. Claude Code sends `HEAD /api/hello` before it starts. It carries no body and names no model, so recording it added a turn with no tokens, and forwarding it posted an empty payload to the provider's completions endpoint and billed for the reply.
+- Keep the session-title call out of the turn count. A Messages request carrying no tool schema is the harness titling its own session, which is the rule `conversationSummary` has always used to find the real first call; it is now tagged so its spend stays in the cost column while it stops inflating turns. Claude Code is the first proxy harness to make one -- OpenCode makes one too but reports its own per-step usage rather than going through this log. Uncorrected, a single-prompt attempt read as three turns instead of one.
+- Stop losing a finished attempt to a directory that will not delete. On Windows a directory stays locked while any process holds it as a working directory, and a harness that leaves a helper alive for a moment after its own exit keeps the attempt's workspace locked with it. The attempt's result is already computed by then, so throwing discarded a real measurement to report a temporary file the operating system cleans up anyway. It now retries for longer, then says so and moves on.
+- Note what this row cannot do. Claude Code exposes no context-window setting -- its compaction triggers off the model's own window -- so it cannot be held to a tier's declared window, and tier 6 reads its attempts as unwindowed the way it did for Codex and OpenCode before those learned to read one.
+- Withdraw compaction guidance from the Jev layer. It was the layer's only system that had ever applied a verdict at scale, and the only measurement of it says it cost solve rate. Tier 6 ran the pair comparison twice, months apart on two versions: SpecPi 0.28.0 gave 5/8 against plain SpecPi's 8/8 on the long-session task, and 0.29.0 gave 3/8 against 6/8. Pooled that is 8/16 against 14/16, Fisher exact p = 0.054. The shorter task showed nothing either time. `extensions/jev-advisor/questions/compaction.mjs`, both hooks that used it, its gate thresholds and its budget are gone, and the managed set drops with them.
+- Attribute the loss before removing the thing. Over those attempts `compaction` accounted for 139 of the 142 verdicts the layer applied; `retention` applied nothing across 287 calls and `progress` applied three. Whatever separated the two arms was almost entirely this one system's doing, which is what made a removal defensible on a comparison that never reached significance.
+- Say plainly what this does not establish. p = 0.054 is not significance. A within-arm check of whether heavier compaction predicts failure reaches only p = 0.251. The mechanism was never isolated: the system could not delete anything -- it appended one sentence to the summariser's prompt, leaving Pi's own cut point and token budget alone -- so any harm ran through a summary that kept the wrong material, most likely because the sentence told the summariser to *prioritise* one kind of content on a task built so that a fact from the first turn must survive. What carried the decision was three weak signals agreeing and the asymmetry of the bet, not a result.
+- Take the `/tree` branch labels with it. They rode the compaction switch by design, on the reasoning that someone who has decided the advisor may steer a summary has decided that once, and the same `decide()` that built the harmful sentence also fed the branch-summary path. Nothing measured the labels either way; they are removed because the machinery they shared is.
+- Bump the settings schema to 5 and drop both `systems.compaction` and `budgets.compaction` on the way through, the way schema 4 dropped the guard keys. Nothing anyone had switched on is being switched off in any meaningful sense: the hooks those keys gated no longer exist, so a retained preference could only describe a system that cannot run. The panel in SpecPi Chat drops the row with it, and a test pins the panel's shape to the advisor's so the two cannot drift.
+- Keep the runs that led here in the record rather than deleting them. The tier-6 tables carried the compaction row and both pair comparisons until this release retired that page; they remain in this repository's history, and the Jev page points at this changelog for the comparison and the p-values. A measurement that led to a removal is the reason the removal can be defended, so it outlives the page it was published on.
+- Grade tier 1 and 2 answers by content rather than by the line endings they were written with. A file written through a Windows shell redirection ends its lines CRLF and one written through a file tool ends them LF; six checkers compared bytes, so they failed correct work for the route it took. Five of the six tier 1-2 failures in the published DeepSeek run were this, all on Codex, which published Codex at 30/37 and a 0.742 score against the 35/37 and 0.862 the regrade measures. Files a task says not to touch stay byte-exact, because rewriting one with different endings is still rewriting it.
+- Supersede eval cells rather than pooling them. Each attempt's workspace is discarded, so a cell cannot be re-graded, only re-run; the site now keeps one cell per harness, task and tier and takes the last report that measured it. Without that rule the regrade above would have been averaged with the readings it corrects.
+- Reach a provider on the wire it actually speaks. Muse Spark serves only the Responses API and returns 503 "Endpoint is unavailable" to a chat-completions request, as gpt-5.6-luna and grok-4.6 do; Codex already spoke Responses and reached it unaided, so the model was measurable on one row out of eight. `scripts/eval-responses.mjs` translates at the edge, the seam `eval-anthropic.mjs` already uses, and `EVAL_FORWARD_WIRE` declares the wire rather than probing for it, so latency is not doubled and the wire stays a property of the run. The report records which wire was used and the method says so, because seven rows having been translated is a material fact about how they were measured.
+- Mint an OpenCode session only for the endpoint that routes on one. The gate was on forwarding rather than on the endpoint, so a run against any other provider spent an OpenCode call per attempt, billed its tokens to the run, and needed a login the run was not otherwise using, to produce an id the provider ignores. The published method claimed every forwarded run minted one, which was never true of a direct provider.
 ## 0.29.0 - 2026-09-20
 
 - Return the command guard to `specpi-jev-guard`, and leave it there. 0.28.0 built the guard into the layer as its eighth system, for three stated reasons that were properties of the package as it stood: a global configuration file with no session scope, a key read from the environment only, and a fail-closed posture. Two of the three are fixed upstream. Guard 0.3.0 ships `/jev-guard setup | on | off [--global] | check | model | backend`, so it has a session scope and a switch of its own, and it resolves Pi's saved login before the environment, so `/login openrouter` serves it exactly as it serves the advisor. What remains is fail-closed, which is a disclosed trade rather than a defect. `extensions/jev-advisor/risk.mjs` and `questions/guard.mjs` are gone, the package is pinned again, and the base is eight.

package/NPM_RELEASE.md

@@ -6,7 +6,7 @@ Publishing, tags, deprecation, ownership changes and GitHub Releases require exp
 
 ## Prepare
 
-1. This candidate is SpecPi **0.29.0**, paired with the Chat **0.14.0** VSIX. Browser QA **0.3.0** is already independently published; do not republish or edit its source as part of this release. Choose an unused version; update `package.json`, the dated `CHANGELOG.md` entry, README, and the website. Check Chat's version and VSIX download links. Preserve historical changelog entries.
+1. This candidate is SpecPi **0.30.0**, paired with the Chat **0.14.0** VSIX. Browser QA **0.3.0** is already independently published; do not republish or edit its source as part of this release. Choose an unused version; update `package.json`, the dated `CHANGELOG.md` entry, README, and the website. Check Chat's version and VSIX download links. Preserve historical changelog entries.
 2. Validate:
 
     ```sh

package/README.md

@@ -73,36 +73,35 @@ The gap between the two SpecPi bars comes from a few separate switches, so the e
 ## Harness evaluations
 
 The chart above counts characters. It says nothing about what a harness costs to
-actually use, or whether it finishes the job. That is what the eval suite is for:
-the same tasks, the same model and the same frozen price list, with only the
-harness changing.
+actually use, or whether it finishes the job. That is what the evals are for:
+[Terminal-Bench 2.0](https://www.tbench.ai/), the same model and the same frozen
+price list, with only the harness changing.
 
 <!-- eval-summary -->
 
-**259 attempts across 7 harnesses and 24 tasks**, all on `deepseek-v4.1-flash`.
+**334 scored attempts across 20 tasks and 4 harnesses**,
+all on `deepseek-v4.1-flash`.
 
-| Harness | Solved | Cost/attempt | Prompt tokens | Sent before any work |
-| --- | --- | --- | --- | --- |
-| Pi | 34/37 | $0.0038 | 112,681 | 5,522 |
-| SpecPi | 35/37 | $0.0042 | 134,859 | 13,799 |
-| OpenCode | 31/37 | $0.0043 | 143,830 | 38,097 |
-| SpecPi + Jev | 35/37 | $0.0046 | 153,077 | 13,799 |
-| Codex CLI | 30/37 | $0.0067 | 242,031 | 38,148 |
-| Oh My Pi | 35/37 | $0.0070 | 257,783 | 62,612 |
-| DeepSeek Harness | 35/37 | $0.0078 | 281,676 | 31,750 |
+| Harness | Solved | Rate | Cost/attempt | Prompt tokens | Cache hit |
+| --- | --- | --- | --- | --- | --- |
+| SpecPi + Jev | 62/74 | 0.838 | $0.0125 | 381,153 | 94.5% |
+| Pi (base) | 60/74 | 0.811 | $0.0161 | 512,903 | 93.7% |
+| Oh My Pi | 90/113 | 0.796 | $0.0216 | 1,103,136 | 97.4% |
+| Claude Code | 56/73 | 0.767 | $0.1128 or less | 630,410 | not measured |
 
-Cost is the harness's own model spend, priced from recorded usage against a
-dated price file. The last column is the tool schema plus system instructions
-riding every single request, which is the fixed toll a harness charges before
-the model does anything.
+Solve rate does not separate these harnesses -- Pi against SpecPi + Jev is Fisher
+p = 0.83 -- so the column worth reading is what each one spent reaching the same
+answers. Cost is recomputed from recorded tokens against a dated price file, never
+taken from a harness's self-report. Claude Code's cached share was not recorded on
+this run, so its cost is an upper bound.
 
 <!-- /eval-summary -->
 
-Read the method, the charts and the caveats on the
-[evaluations page](https://tannermidd.github.io/SpecPi/evaluations/). The runner,
-the tasks and the recorded results are in [evals/](evals/), and this table is
-regenerated from those reports by `node scripts/eval-site.mjs`, so it cannot
-drift from the published figures.
+This run is still in progress. Read the method, the charts and the caveats on the
+[evaluations page](https://tannermidd.github.io/SpecPi/evaluations/), which lists
+what is missing and what is known to be wrong. The table above is regenerated
+from the run data by `node scripts/tb2-site.mjs`, so it cannot drift from the
+published figures.
 
 ## Install
 

package/extensions/jev-advisor/broker.mjs

@@ -6,8 +6,8 @@
 // inside sanitize.
 //
 // AWAIT ONLY THE SYSTEMS THAT MUTATE WHAT THEY INSPECT. Retention must be awaited, because its
-// answer replaces the tool result it was asked about; so must compaction, the branch hook and the
-// two tool_call systems, which return a patch or edit `event.input` in place. A system that acts on
+// answer replaces the tool result it was asked about; so must the two tool_call systems, which
+// return a patch or edit `event.input` in place. A system that acts on
 // a later turn must not be awaited: at roughly 300ms a call, a turn-level system firing thirty
 // times would add nine seconds to an attempt that takes a hundred and thirty, to deliver advice
 // that was never going to change the turn it was asked during.
@@ -22,7 +22,6 @@ import { writeUsage } from "./usage.mjs";
 
 export const SYSTEM_LABELS = Object.freeze({
     retention: "Tool-result retention",
-    compaction: "Compaction guidance",
     gap: "Capability-gap triage",
     sources: "Delegation source ranking",
     progress: "Progress and thrash detection",

package/extensions/jev-advisor/config.mjs

@@ -18,15 +18,7 @@ import path from "node:path";
 import { randomUUID } from "node:crypto";
 
 /** Systems that may run inside a session. Offline scripts are not gated here. */
-export const SYSTEM_NAMES = Object.freeze([
-    "retention",
-    "compaction",
-    "gap",
-    "sources",
-    "progress",
-    "untrusted",
-    "capability",
-]);
+export const SYSTEM_NAMES = Object.freeze(["retention", "gap", "sources", "progress", "untrusted", "capability"]);
 
 /**
  * What a confident stuck verdict is allowed to do. `notify` tells the person and cannot be wrong in
@@ -57,14 +49,14 @@ const MAX_TOTAL_BUDGET = 2048;
  * session, and which one won would be decided by event ordering rather than by anyone's policy.
  *
  * So the ceiling is two-level: each system gets its own, and the total is a real constraint because
- * it is deliberately less than their sum -- 2048 against 2322. That relationship is the invariant,
+ * it is deliberately less than their sum -- 2048 against 2274. That relationship is the invariant,
  * not either number: raising the total without raising the per-system ceilings would leave a total
  * no combination of systems could ever reach, which is a limit that reads as a limit and is not
  * one. `tests/jev-advisor.test.mjs` pins the inequality so a future change to one has to consider
  * the other. Running out of one system's budget stops that system and nothing else.
  *
  * The per-system numbers follow how often each one can fire: retention on every large read-only
- * result, compaction once or twice in a long session, gap per report, sources per delegation batch.
+ * result, gap per report, sources per delegation batch.
  */
 export const DEFAULT_BUDGETS = Object.freeze({
     // A backstop, not a working limit, and the number says which. Measured, a full tier-3 task -- a
@@ -92,7 +84,6 @@ export const DEFAULT_BUDGETS = Object.freeze({
     // add up to is not a constraint at all -- see below. They are scaled rather than re-derived:
     // each one's rationale is a firing frequency, and none of those frequencies changed.
     retention: 832,
-    compaction: 48,
     gap: 192,
     sources: 128,
     // Turn-level, but gated behind local signals and a four-turn cooldown, so it only spends on
@@ -144,7 +135,7 @@ export function regularFile(file, label) {
 /** Every unknown shape collapses to the same all-off default rather than a partial enable. */
 export function defaultSettings() {
     return {
-        schema: 4,
+        schema: 5,
         master: false,
         startup: false,
         systems: Object.fromEntries(SYSTEM_NAMES.map((name) => [name, false])),
@@ -206,6 +197,29 @@ function migrateToFour(raw) {
     return { ...rest, schema: 4, systems };
 }
 
+/**
+ * Schema 5 removes compaction guidance, which was withdrawn rather than fixed.
+ *
+ * Two tier-6 runs, on SpecPi 0.28.0 and 0.29.0, both measured the arm carrying it solving fewer
+ * long-session tasks than plain SpecPi: 14/16 against 8/16 pooled, Fisher exact p = 0.054. Over the
+ * same attempts compaction was 55 of 56 applied verdicts, so the arm's behaviour was almost entirely
+ * this system's, and no other system in the layer applied enough to be a candidate.
+ *
+ * The evidence never reached significance and the mechanism was never isolated. The system was
+ * removed anyway, because a system that steers a summary has to earn the risk it takes, and one
+ * whose only measurement says it costs solve rate has not.
+ *
+ * Both the `systems.compaction` switch and the per-system `budgets.compaction` ceiling go. Dropping
+ * them turns nothing off that a user had on in any meaningful sense: the hooks they gated no longer
+ * exist, so a retained preference could only describe a system that cannot run.
+ */
+function migrateToFive(raw) {
+    const { compaction: _system, ...systems } = raw?.systems ?? {};
+    const { compaction: _budget, ...budgets } = raw?.budgets ?? {};
+
+    return { ...raw, schema: 5, systems, budgets };
+}
+
 /**
  * What the advisor will read, given a settings object, without writing it anywhere.
  *
@@ -222,15 +236,16 @@ export function normalizeSettings(raw) {
 
 function normalize(raw) {
     const one = raw?.schema === 1 ? migrate(raw) : raw;
-    const source = one?.schema === 2 || one?.schema === 3 ? migrateToFour(one) : one;
-    if (source?.schema !== 4) {
+    const four = one?.schema === 2 || one?.schema === 3 ? migrateToFour(one) : one;
+    const source = four?.schema === 4 ? migrateToFive(four) : four;
+    if (source?.schema !== 5) {
         return defaultSettings();
     }
 
     const systems = Object.fromEntries(SYSTEM_NAMES.map((name) => [name, source.systems?.[name] === true]));
 
     return {
-        schema: 4,
+        schema: 5,
         master: source.master === true,
         startup: source.startup === true,
         systems,
@@ -268,7 +283,7 @@ export function writeFileAtomic(file, contents) {
 export function saveSettings(settings) {
     // A caller handing back an older shape is migrated rather than reset, so a round trip through
     // an old reader cannot quietly disable the layer.
-    const next = normalize([1, 2, 3].includes(settings?.schema) ? settings : { ...settings, schema: 4 });
+    const next = normalize([1, 2, 3, 4].includes(settings?.schema) ? settings : { ...settings, schema: 5 });
     const file = settingsFile();
     if (fs.existsSync(file)) {
         regularFile(file, "Jev settings");

package/extensions/jev-advisor/gate.mjs

@@ -50,12 +50,11 @@
 //    was unreachable, and running the layer could never have revealed it, because a system that
 //    never fires looks exactly like a system whose advice was always to do nothing.
 //
-//    compaction's `unresolved_thread` had the same problem at high 0.85: the clearest open
-//    investigation the fixture can express scores 0.63-0.65. It is lowered to 0.60, which is
-//    defensible only because of what that branch does -- add one sentence to a summariser prompt
-//    that is being rebuilt from scratch anyway. It is the cheapest action in the layer, so it can
-//    afford the loosest gate. gap keeps 0.85 because its Noul reaches 0.96 on the case that matters
-//    and because a firing there blocks a write.
+//    Compaction guidance had the same problem and was lowered to 0.60 to clear it. That system has
+//    since been withdrawn -- two tier-6 runs measured the arm carrying it solving fewer long-session
+//    tasks than plain SpecPi -- so the loosest gate in the layer is gone with it. gap keeps 0.85
+//    because its Noul reaches 0.96 on the case that matters and because a firing there blocks a
+//    write.
 
 /**
  * The figures the comment above cites, in a form a test can check against the artifact. A citation
@@ -91,16 +90,6 @@ export const THRESHOLDS = Object.freeze({
         // Measured 0.06-0.07 on the spent case, so this clears with room.
         low: 0.1,
     }),
-    compaction: Object.freeze({
-        scoreConfidence: 0.6,
-        boundary: 0.3,
-        choiceConfidence: 0.75,
-        margin: 0.25,
-        // Lowered from 0.85: the clearest open investigation scores 0.63-0.65, and the action is
-        // one sentence added to a prompt that is being rebuilt regardless.
-        high: 0.6,
-        low: 0.15,
-    }),
     gap: Object.freeze({
         scoreConfidence: 0.6,
         boundary: 0.3,

package/extensions/jev-advisor/index.ts

@@ -8,7 +8,6 @@ import { createBroker } from "./broker.mjs";
 import { ledgerPath, read as readLedger } from "./ledger.mjs";
 import { usagePath } from "./usage.mjs";
 import * as retention from "./questions/retention.mjs";
-import * as compaction from "./questions/compaction.mjs";
 import * as gap from "./questions/gap.mjs";
 import * as sources from "./questions/sources.mjs";
 import * as progress from "./questions/progress.mjs";
@@ -334,115 +333,6 @@ export default function jevAdvisor(pi: ExtensionAPI) {
         }
     });
 
-    // System 1b: steer the summary at the one boundary where the prompt cache is discarded anyway.
-    // Only customInstructions is supplied; the preparation's own cut and budget are left alone.
-    pi.on("session_before_compact", async (event: any, ctx: ExtensionContext) => {
-        if (!enabled("compaction")) {
-            return;
-        }
-
-        try {
-            const result = await broker.request({
-                system: "compaction",
-                state: compaction.buildInput({ preparation: event.preparation, objective }),
-                questions: compaction.questions(),
-                ctx,
-                root: ctx.cwd,
-                signal: event.signal,
-                decide: (answers: any) => {
-                    const built = compaction.decide(answers);
-
-                    // Nothing is shortened here, so savedBytes stays 0 and `applied` is the whole
-                    // record: either a sentence reached the summariser or Pi's own prompt ran.
-                    return { applied: Boolean(built.customInstructions), decision: built };
-                },
-            });
-            if (!result.ok) {
-                return;
-            }
-
-            const advice = result.decision;
-            if (!advice.customInstructions) {
-                return;
-            }
-
-            const existing = typeof event.customInstructions === "string" ? event.customInstructions.trim() : "";
-
-            return {
-                customInstructions: existing
-                    ? `${existing}\n\n${advice.customInstructions}`
-                    : advice.customInstructions,
-            };
-        } catch {
-            return;
-        }
-    });
-
-    // System 1b, second hook. Branch summarisation is the same problem at the same boundary --
-    // something is about to be reduced to a summary and the prefix is being rebuilt regardless --
-    // and it was simply unserved. It shares the compaction switch rather than adding a fifth
-    // system, because a user who has decided the advisor may steer a summary has decided that once.
-    //
-    // `label` is the part worth having. Pi's `/tree` can filter to labelled entries, so a branch
-    // that says what it was is the difference between a navigable tree and a list of timestamps,
-    // and the enum is fixed so no model-written text reaches the session file.
-    pi.on("session_before_tree", async (event: any, ctx: ExtensionContext) => {
-        if (!enabled("compaction")) {
-            return;
-        }
-
-        try {
-            const entries = event?.preparation?.entriesToSummarize ?? [];
-            if (entries.length === 0) {
-                return;
-            }
-
-            const result = await broker.request({
-                system: "compaction",
-                state: compaction.buildBranchInput({ preparation: event.preparation, objective }),
-                questions: compaction.questions({ branch: true }),
-                ctx,
-                root: ctx.cwd,
-                signal: event.signal,
-                decide: (answers: any) => {
-                    const built = compaction.decide(answers);
-                    const branchLabel = compaction.label(answers);
-
-                    return {
-                        applied: Boolean(branchLabel || built.customInstructions),
-                        decision: { ...built, label: branchLabel },
-                    };
-                },
-            });
-            if (!result.ok) {
-                return;
-            }
-
-            const advice = result.decision;
-            const patch: Record<string, unknown> = {};
-            if (advice.label) {
-                patch.label = advice.label;
-            }
-
-            // Only when a summary is actually going to be generated. Instructions for a summariser
-            // that will not run are bytes nobody reads, and `replaceInstructions` is left alone so
-            // Pi's own branch prompt still frames the result.
-            if (advice.customInstructions && event.preparation?.userWantsSummary === true) {
-                const existing =
-                    typeof event.preparation?.customInstructions === "string"
-                        ? event.preparation.customInstructions.trim()
-                        : "";
-                patch.customInstructions = existing
-                    ? `${existing}\n\n${advice.customInstructions}`
-                    : advice.customInstructions;
-            }
-
-            return Object.keys(patch).length > 0 ? patch : undefined;
-        } catch {
-            return;
-        }
-    });
-
     pi.on("tool_call", async (event: any, ctx: ExtensionContext) => {
         history.signatures.push(progress.signature(event.toolName, event.input));
         history.tools.push(event.toolName);
@@ -568,7 +458,7 @@ export default function jevAdvisor(pi: ExtensionAPI) {
     // System 5: notice a session that has stopped making progress, while it can still be helped.
     //
     // THE ONE HANDLER THAT IS NOT AWAITED. Everything else in this file mutates what it inspects --
-    // a tool result, a compaction patch, a tool's input -- so the session has to wait for the
+    // a tool result, a tool's input -- so the session has to wait for the
     // answer. This one acts on the next turn, and at roughly 300ms a call, awaiting it on a
     // thrashing session would add seconds to an attempt to deliver advice that could not have
     // changed the turn it was asked during.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specpi",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "Scope control and a human-selected harness improvement loop for Pi",
   "author": "Tanner Middleton",
   "repository": {

package/scripts/specpi.mjs

@@ -60,7 +60,6 @@ const resourcePaths = [
     "extensions/jev-advisor/broker.mjs",
     "extensions/jev-advisor/gate.mjs",
     "extensions/jev-advisor/questions/retention.mjs",
-    "extensions/jev-advisor/questions/compaction.mjs",
     "extensions/jev-advisor/questions/gap.mjs",
     "extensions/jev-advisor/questions/sources.mjs",
     "extensions/jev-advisor/questions/progress.mjs",

package/extensions/jev-advisor/questions/compaction.mjs

@@ -1,153 +0,0 @@
-// System 1b: guide compaction, which is the one moment the prompt cache is discarded anyway.
-//
-// Pi's `findCutPoint` is documented as "walk backwards from newest, accumulating estimated message
-// sizes, stop when we've accumulated >= keepRecentTokens". It is a token ruler: it cannot tell the
-// load-bearing finding from six dead-end greps, and it discards whichever falls on the wrong side
-// of the line. Since the prefix is being rebuilt regardless, improving that choice costs nothing.
-//
-// This system never sets the cut itself. It supplies `customInstructions` — an existing documented
-// parameter on the compaction path — so the summariser is told what this session was actually
-// about. The token budget still bounds the result, so bad advice can shape a summary, never blow
-// the budget or drop an entry the preparation meant to keep.
-
-import { choice, noul } from "../client.mjs";
-import { choiceValue, nounTrue } from "../gate.mjs";
-import { compact } from "../sanitize.mjs";
-
-export const WORK_KINDS = Object.freeze({
-    debugging: "Tracking down why something fails",
-    building: "Adding or changing a feature",
-    refactoring: "Restructuring code without changing behaviour",
-    research: "Reading and answering questions about a codebase",
-    testing: "Writing or repairing tests",
-    ops: "Builds, releases, configuration or tooling",
-    review: "Reading a diff and judging it",
-});
-
-/**
- * A digest of what compaction is about to discard: entry kinds and scale, never their text. The
- * summariser still sees the real conversation; this only steers what it keeps.
- */
-export function buildInput({ preparation, objective }) {
-    const messages = preparation?.messagesToSummarize ?? [];
-    const kinds = {};
-    for (const message of messages) {
-        const role = typeof message?.role === "string" ? message.role : "unknown";
-        kinds[role] = (kinds[role] ?? 0) + 1;
-    }
-
-    const files = preparation?.fileOps ?? {};
-
-    return {
-        objective: compact(objective ?? "", 180),
-        discarding: messages.length,
-        roles: kinds,
-        tokensBefore: preparation?.tokensBefore ?? 0,
-        splitTurn: preparation?.isSplitTurn === true,
-        filesRead: [...(files.read ?? [])].slice(0, 12).map((item) => compact(item, 60)),
-        filesWritten: [...(files.written ?? []), ...(files.edited ?? [])].slice(0, 12).map((item) => compact(item, 60)),
-        hadPreviousSummary: typeof preparation?.previousSummary === "string",
-    };
-}
-
-/**
- * The same digest for a branch being left behind. `/tree` hands a different preparation shape --
- * session entries rather than messages, and no token count, because nothing is being cut to fit a
- * budget -- so it gets its own builder rather than a compaction input with three fields quietly
- * reading undefined.
- */
-export function buildBranchInput({ preparation, objective }) {
-    const entries = preparation?.entriesToSummarize ?? [];
-    const kinds = {};
-    for (const entry of entries) {
-        const kind = typeof entry?.type === "string" ? entry.type : "unknown";
-        kinds[kind] = (kinds[kind] ?? 0) + 1;
-    }
-
-    return {
-        objective: compact(objective ?? "", 180),
-        abandoning: entries.length,
-        kinds,
-        wantsSummary: preparation?.userWantsSummary === true,
-        // Navigating to an ancestor is backing out of a line of work; navigating elsewhere is
-        // moving between siblings. The distinction is most of what a label has to capture.
-        toAncestor: preparation?.targetId === preparation?.commonAncestorId,
-    };
-}
-
-/**
- * Short, navigational, and a fixed enum so no model-written text reaches the session file. `/tree`
- * can filter to labelled entries, so a branch that says what it was is the difference between a
- * navigable tree and a list of timestamps.
- */
-export const BRANCH_LABELS = Object.freeze({
-    "dead end": "The branch was abandoned because the approach did not work",
-    "alternative tried": "A different approach to the same goal, set aside for another",
-    "work completed": "The branch finished what it set out to do",
-    research: "The branch was reading and answering questions, not changing anything",
-    reverted: "The branch's changes were undone",
-    interrupted: "The branch stopped part-way for an unrelated reason",
-});
-
-export function questions({ branch = false } = {}) {
-    return {
-        ...(branch ? { branch_label: choice("What was this abandoned branch?", BRANCH_LABELS) } : {}),
-        work_kind: choice("What kind of work has this session mostly been doing?", WORK_KINDS),
-        unresolved_thread: noul("There is an unfinished investigation whose findings must survive compaction"),
-        discarded_span_was_dead_ends: noul(
-            "The work being discarded was mostly abandoned attempts that led nowhere useful",
-        ),
-    };
-}
-
-const FOCUS = Object.freeze({
-    debugging: "the symptom, what has been ruled out, and the current hypothesis",
-    building: "what has been implemented so far and what remains",
-    refactoring: "the invariants being preserved and which call sites have been updated",
-    research: "the questions answered so far, with the files each answer came from",
-    testing: "which tests exist, which fail, and why",
-    ops: "the commands run, their outcomes, and the current configuration state",
-    review: "the findings raised so far and their severity",
-});
-
-/**
- * Build `customInstructions` from gated answers only. With nothing gated this returns undefined and
- * Pi's own default prompt is used unchanged.
- */
-/**
- * The label for a branch summary entry, or undefined when the answer is ungated. Separate from
- * `decide` because the compaction hook has no label to set and would carry a dead field.
- */
-export function label(answers) {
-    const value = choiceValue(answers?.branch_label, "compaction");
-
-    return value && Object.hasOwn(BRANCH_LABELS, value) ? value : undefined;
-}
-
-export function decide(answers) {
-    const kind = choiceValue(answers?.work_kind, "compaction");
-    const unresolved = nounTrue(answers?.unresolved_thread, "compaction");
-    const deadEnds = nounTrue(answers?.discarded_span_was_dead_ends, "compaction");
-    const parts = [];
-    if (kind && FOCUS[kind]) {
-        parts.push(`This session has mainly been ${kind}. Prioritise ${FOCUS[kind]}.`);
-    }
-
-    if (unresolved) {
-        parts.push(
-            "An investigation is still open. Preserve its findings and the current hypothesis in full, even at the cost of earlier detail.",
-        );
-    }
-
-    if (deadEnds) {
-        parts.push(
-            "Most of the discarded work was abandoned attempts. Record what was ruled out in one line each rather than recounting them, so the same paths are not retried.",
-        );
-    }
-
-    if (parts.length === 0) {
-        return { customInstructions: undefined, deadEnds, unresolved };
-    }
-
-    return { customInstructions: parts.join(" "), deadEnds, unresolved };
-}