@junghanacs/entwurf 0.18.0 → 0.18.1

package/scripts/check-release-gate-outcomes.ts

@@ -25,7 +25,15 @@
 //      "internal prerequisite" case, Cortex being the one that was measured).
 //   7. every LIVE smoke is either wired into the aggregate or excluded for a
 //      reason the docs actually state — the protocol cannot vouch for a step the
-//      gate never lists.
+//      gate never lists;
+//   8. the moved check-gate-qualification stays reachable on its owners, and the
+//      CI step qualifies the FULL floor;
+//   9. every gate a committed mutant NAMES also runs inside `check:full` (or says
+//      in its own prose why it deliberately does not) — a gate reachable only
+//      through qualification's control-pre puts a whole defect class behind the
+//      28-minute body;
+//  10. the CI push trigger is filtered to BRANCH refs, so pushing a release tag
+//      does not rebuild a SHA its branch run already built.
 //
 // Cells 5-6 SPAWN the real subcommands rather than reasoning about them: the
 // whole defect was an assumption about what a step would do, so an assumption is
@@ -329,7 +337,7 @@ function runSubcommand(sub: string, env: Record<string, string | undefined>): {
 //    check-gate-qualification left the default check chains (operator
 //    inner-loop cost, 2026-08 subtraction). That move is a gate/release
 //    contract: the step must stay REACHABLE on the axes that now own it — the
-//    CI check job on every push and release_gate as its own MUST step — and
+//    CI check job on every branch push and release_gate as its own MUST step — and
 //    must not silently return to the default chain. Without this cell,
 //    deleting the release_gate qualification block or the CI line leaves every
 //    focused gate green while a cut quietly loses its discriminating-power
@@ -374,7 +382,7 @@ function runSubcommand(sub: string, env: Record<string, string | undefined>): {
 		!qualGateBody.includes('results+=("FAIL  check-gate-qualification")')
 	)
 		holes.push("the release_gate qualification step does not wire PASS/FAIL into the MUST counters");
-	if (!verifyDoc.includes("in the CI `check` job on every push, and as a release-gate MUST step"))
+	if (!verifyDoc.includes("in the CI `check` job on every branch push, and as a release-gate MUST step"))
 		holes.push("VERIFY.md no longer names the owners of the moved qualification step");
 	assert.ok(
 		holes.length === 0,
@@ -406,6 +414,153 @@ function runSubcommand(sub: string, env: Record<string, string | undefined>): {
 	);
 }
 
+// ===========================================================================
+// 9. Every gate a mutant manifest NAMES runs inside `pnpm run check:full`
+//
+//    The measurement behind this (#99 B-3/B-4): across 549 CI runs the mutant-
+//    EXECUTION half of qualification never once produced a SURVIVED / WRONG-REASON /
+//    MUTANT-STALE / HANG. What it did catch twice was a gate that was already red on a
+//    clean tree — CONTROL-PRE — and that class is caught 5.4 minutes earlier, and for
+//    free, by any gate the deterministic floor already runs. So a mutant-named gate
+//    that sits OUTSIDE `check:full` is the one place where a baseline break can only
+//    be found by paying the 28-minute body. `check-omp-birth-hook` was exactly that
+//    gate, reachable in the whole repo only through qualification's control-pre.
+//
+//    The exclusion arm is not a loophole: `scripts/check-setup-qualification.sh` is a
+//    mutation-attribution oracle the manifests invoke DIRECTLY and its own header says
+//    it is deliberately outside every tier. Like cell 7, the excuse is checked against
+//    the text an operator can read, never against a list only this gate believes in.
+//
+//    ONE PREMISE, stated because it is invisible from here: the script-path join below
+//    ignores MODE FLAGS in a gate argv. The `--attribution-self-test` gate therefore
+//    counts as covered by the `check-gate-manifests` arm only because
+//    `checkVitestAttribution()` runs UNCONDITIONALLY, before that flag is read
+//    (`scripts/check-gate-qualification.ts`). Move that call behind a flag and this
+//    cell stays green while saying something false.
+// ===========================================================================
+{
+	const pkg = JSON.parse(readFileSync(join(REPO_DIR, "package.json"), "utf8")) as { scripts: Record<string, string> };
+	// The floor is composed (#70): `check:full` names group scripts, and a group script
+	// may name further ones. Expand transitively rather than hard-coding the tier list.
+	const expand = (name: string, seen: Set<string>): string => {
+		if (seen.has(name)) return "";
+		seen.add(name);
+		const body = pkg.scripts[name] ?? "";
+		let out = body;
+		for (const ref of body.matchAll(/pnpm run ([\w:.-]+)/g)) out += ` ${expand(ref[1], seen)}`;
+		const elapsed = /check-elapsed\.sh\s+[\w:.-]+\s+(.+)$/.exec(body);
+		if (elapsed) for (const g of elapsed[1].trim().split(/\s+/)) out += ` ${expand(g, seen)}`;
+		return out;
+	};
+	const floorText = expand("check:full", new Set());
+	const floorSubcommands = new Set([...floorText.matchAll(/\.\/run\.sh ([\w:.-]+)/g)].map((m) => m[1]));
+
+	// run.sh case arms, so a gate invoked by SCRIPT PATH can be joined to the floor
+	// subcommand that runs that same script.
+	const arms = new Map<string, string>();
+	{
+		let names: string[] = [];
+		let body: string[] = [];
+		for (const line of readFileSync(join(REPO_DIR, "run.sh"), "utf8").split("\n")) {
+			const head = /^ {2}([\w|:.-]+)\)$/.exec(line);
+			if (head) {
+				names = head[1].split("|");
+				body = [];
+				continue;
+			}
+			if (line === "    ;;") {
+				for (const n of names) arms.set(n, body.join("\n"));
+				names = [];
+				continue;
+			}
+			if (names.length > 0) body.push(line);
+		}
+	}
+
+	const gates = new Map<string, string[]>();
+	for (const rel of globSync("scripts/mutants/*.json", { cwd: REPO_DIR }).sort()) {
+		const doc = JSON.parse(readFileSync(join(REPO_DIR, rel), "utf8")) as { mutants: Array<{ gate: string[] }> };
+		for (const m of doc.mutants) gates.set(m.gate.join(" "), m.gate);
+	}
+	assert.ok(gates.size >= 40, `expected the committed mutant gate set, found ${gates.size} distinct gate argvs`);
+
+	// argv → the file that states, in prose an operator reads, why it is outside the floor.
+	const DOCUMENTED_OUTSIDE: Record<string, [file: string, sentence: string]> = {
+		"bash scripts/check-setup-qualification.sh": [
+			"scripts/check-setup-qualification.sh",
+			"run.sh subcommand and NOT in any check tier",
+		],
+	};
+
+	const unreached: string[] = [];
+	for (const [key, argv] of gates) {
+		if (argv[0] === "bash" && argv[1] === "run.sh") {
+			if (!floorSubcommands.has(argv[2])) unreached.push(`${key} — run.sh ${argv[2]} is in no check:full group`);
+			continue;
+		}
+		const scriptPath = argv.find((t) => /^scripts\/.+\.(sh|ts|py)$/.test(t));
+		if (scriptPath !== undefined && [...floorSubcommands].some((sub) => (arms.get(sub) ?? "").includes(scriptPath))) {
+			continue;
+		}
+		const excused = DOCUMENTED_OUTSIDE[key];
+		if (excused === undefined) {
+			unreached.push(`${key} — no check:full subcommand invokes ${scriptPath ?? "(no script path in its argv)"}`);
+			continue;
+		}
+		const [file, sentence] = excused;
+		if (!readFileSync(join(REPO_DIR, file), "utf8").includes(sentence)) {
+			unreached.push(`${key} claims a documented exclusion, but ${file} no longer says "${sentence}"`);
+		}
+	}
+	assert.ok(
+		unreached.length === 0,
+		"[QK:MUTANT-GATES-INSIDE-FULL-FLOOR] every gate a committed mutant names must also run inside `pnpm run " +
+			"check:full`, or state its exclusion where an operator reads it. A gate reachable ONLY through " +
+			"qualification's control-pre makes the 28-minute mutant body the only thing that can notice it going red on " +
+			"a clean tree — the one CI class that body has actually caught, and the one the 5.4-minute floor catches for " +
+			`free everywhere else. Unreached: ${unreached.join("; ")}`,
+	);
+}
+
+// ===========================================================================
+// 10. A TAG push rebuilds nothing
+//
+//     Measured over this repo's whole history (#99 B-1): 66 of 66 semver tag-push runs
+//     rebuilt a SHA some other run had already built, and no tag run ever reported a
+//     fact its branch run did not — the single non-green one failed at the same step as
+//     its main run, two seconds later. That is 28% of a release window's runner minutes
+//     buying a badge on a ref. The exact-SHA evidence a release quotes is the BRANCH
+//     run, which is also the run `entwurf-release` land mode reports.
+//
+//     So `on.push` must carry a REF FILTER that selects branches. `branches:` alone is
+//     what makes a tag push create no run at all; a `tags:` key would put them back.
+// ===========================================================================
+{
+	const ciYml = readFileSync(join(REPO_DIR, ".github/workflows/ci.yml"), "utf8");
+	const onAt = ciYml.indexOf("\non:\n");
+	const envAt = ciYml.indexOf("\nenv:\n");
+	assert.ok(onAt !== -1 && envAt > onAt, "located the workflow `on:` block");
+	const onLines = ciYml.slice(onAt, envAt).split("\n");
+	const pushAt = onLines.findIndex((l) => /^ {2}push:\s*$/.test(l));
+	const nextKeyAt = onLines.findIndex((l, i) => i > pushAt && /^ {2}\S/.test(l));
+	const pushBody = onLines
+		.slice(pushAt + 1, nextKeyAt === -1 ? undefined : nextKeyAt)
+		.filter((l) => l.trim() !== "" && !/^\s*#/.test(l));
+	const gaps: string[] = [];
+	if (pushAt === -1) gaps.push("the `on:` block has no `push:` trigger");
+	if (!pushBody.some((l) => /^ {4}branches(-ignore)?:/.test(l)))
+		gaps.push(`the push trigger carries no branch ref filter (body: ${JSON.stringify(pushBody)})`);
+	if (pushBody.some((l) => /^ {4}tags(-ignore)?:/.test(l)))
+		gaps.push("the push trigger names tags — a tag push would create a second run for a SHA already built");
+	assert.ok(
+		gaps.length === 0,
+		"[QK:CI-TAG-PUSH-NOT-REBUILT] the CI `push` trigger must be filtered to BRANCH refs, so pushing a release tag " +
+			"creates no run: 66/66 semver tag runs in this repo's history rebuilt an already-built SHA and none ever " +
+			"reported a fact its branch run had not, while costing 28% of a release window's runner minutes. Dropping " +
+			`the filter does not add evidence, it duplicates it. Broken: ${gaps.join("; ")}`,
+	);
+}
+
 // ===========================================================================
 // The integrated mux lifecycle is a MUST, and the focused fresh-call LIVE is not
 //
@@ -501,5 +656,7 @@ console.log(
 		"LIVE smoke is either wired into release_gate or excluded by a sentence the docs still carry; and the moved " +
 		"check-gate-qualification stays reachable on its owners (absent from the default chain, exactly once in CI, " +
 		"exactly once as a release-gate MUST step) and the CI step qualifies the FULL floor, which runs before it; and " +
+		"every gate a committed mutant names is itself inside check:full or states its exclusion in prose an operator " +
+		"reads; and the CI push trigger is filtered to branch refs, so a release tag creates no duplicate run; and " +
 		"the operator's CONFIGURED bridge invocation is booted exactly once through run_step, before the ACP LIVE tier",
 );

package/scripts/mutants/bridge-command-boot.json

@@ -19,7 +19,7 @@
 			"subject": "scripts/agy-bridge.sh",
 			"find": ["      if command_boots \"$invocation\"; then"],
 			"replace": ["      if true; then"],
-			"gate": ["bash", "scripts/smoke-agy-install-state.sh"],
+			"gate": ["bash", "run.sh", "smoke-agy-install-state"],
 			"timeoutSeconds": 300,
 			"signature": "[QK:AGY-DOCTOR-BOOT-NEGATIVE]",
 			"signatureSource": "scripts/smoke-agy-install-state.sh"
@@ -43,7 +43,7 @@
 			"subject": "scripts/agy-bridge-config.py",
 			"find": ["    args = server.get(\"args\", [])"],
 			"replace": ["    args = []"],
-			"gate": ["bash", "scripts/smoke-agy-install-state.sh"],
+			"gate": ["bash", "run.sh", "smoke-agy-install-state"],
 			"timeoutSeconds": 300,
 			"signature": "[QK:AGY-DOCTOR-PROBES-ARGS]",
 			"signatureSource": "scripts/smoke-agy-install-state.sh"
@@ -54,7 +54,7 @@
 			"subject": "scripts/agy-bridge-config.py",
 			"find": ["    env = server.get(\"env\", {})"],
 			"replace": ["    env = {}"],
-			"gate": ["bash", "scripts/smoke-agy-install-state.sh"],
+			"gate": ["bash", "run.sh", "smoke-agy-install-state"],
 			"timeoutSeconds": 300,
 			"signature": "[QK:AGY-DOCTOR-PROBES-ENV]",
 			"signatureSource": "scripts/smoke-agy-install-state.sh"

package/scripts/mutants/gate-qualification.json

@@ -0,0 +1,28 @@
+{
+	"schemaVersion": 1,
+	"lane": "gate-qualification",
+	"mutants": [
+		{
+			"claim": "MANIFEST-SET-INTEGRITY-REFUSED",
+			"title": "a committed manifest points a claim at a gate source that does not carry its token — the cross-manifest contract that makes a KILLED verdict mean anything is broken, and the run must refuse rather than certify kills whose signature nothing can attribute (the 08-20 CI catch, run 32421631735, which died in validateManifestSet in 5s)",
+			"subject": "scripts/mutants/probe-ordering.json",
+			"find": ["\"signatureSource\": \"scripts/check-probe-ordering.ts\""],
+			"replace": ["\"signatureSource\": \"run.sh\""],
+			"gate": ["bash", "run.sh", "check-gate-manifests"],
+			"timeoutSeconds": 120,
+			"signature": "[QK:MANIFEST-SET-INTEGRITY-REFUSED]",
+			"signatureSource": "scripts/check-gate-qualification.ts"
+		},
+		{
+			"claim": "LANE-INVENTORY-DECLARED",
+			"title": "a lane is renamed in its manifest and the declared inventory is not moved with it — the vacuous-green shape where the run reports n/n killed over whatever set happened to be on disk (the 08-21 and 08-28 CI catches, runs 32450955048 and 33154263432, both dead at the inventory assertion in under 5s)",
+			"subject": "scripts/mutants/capability-cache.json",
+			"find": ["\"lane\": \"capability-cache\","],
+			"replace": ["\"lane\": \"capability-cache-renamed\","],
+			"gate": ["bash", "run.sh", "check-gate-manifests"],
+			"timeoutSeconds": 120,
+			"signature": "[QK:LANE-INVENTORY-DECLARED]",
+			"signatureSource": "scripts/check-gate-qualification.ts"
+		}
+	]
+}

package/scripts/mutants/pack-install.json

@@ -4,14 +4,25 @@
 	"mutants": [
 		{
 			"claim": "PACK-INSTALL-PIN-MATCHER-BOUNDED",
-			"title": "the pin-leak matcher loses its version boundary and blesses substring lookalikes — @0.84.30 reads as the pinned 0.84.3 and the gate announces a verified tree it never verified (independent review, 2026-08-25)",
+			"title": "the pin-leak matcher loses its version boundary and blesses substring lookalikes — @0.85.10 reads as the pinned 0.85.1 and the gate announces a verified tree it never verified (independent review, 2026-08-25)",
 			"subject": "run.sh",
-			"find": ["  grep '^@earendil-works+pi-' | grep -Ev '@0\\.84\\.4(_|$)' || true"],
-			"replace": ["  grep '^@earendil-works+pi-' | grep -v '@0\\.84\\.4' || true"],
+			"find": ["  grep '^@earendil-works+' | grep -Ev '@0\\.85\\.1(_|$)' || true"],
+			"replace": ["  grep '^@earendil-works+' | grep -v '@0\\.85\\.1' || true"],
 			"gate": ["bash", "run.sh", "check-pack-pin-matcher"],
 			"timeoutSeconds": 120,
 			"signature": "[QK:PACK-INSTALL-PIN-MATCHER-BOUNDED]",
 			"signatureSource": "run.sh"
+		},
+		{
+			"claim": "PACK-INSTALL-PIN-MATCHER-COVERS-CLOSURE",
+			"title": "the pin-leak matcher narrows back to the pi-* families and goes blind to a non-pi member of the same runtime closure — @earendil-works/chord (new in pi 0.85.0, a runtime dependency of pi-coding-agent/pi-agent-core/pi-client/pi-protocol) floats unpinned while the gate prints a verified pin (measured 2026-09-06 on a real 0.85.1 install tree)",
+			"subject": "run.sh",
+			"find": ["  grep '^@earendil-works+' | grep -Ev '@0\\.85\\.1(_|$)' || true"],
+			"replace": ["  grep '^@earendil-works+pi-' | grep -Ev '@0\\.85\\.1(_|$)' || true"],
+			"gate": ["bash", "run.sh", "check-pack-pin-matcher"],
+			"timeoutSeconds": 120,
+			"signature": "[QK:PACK-INSTALL-PIN-MATCHER-COVERS-CLOSURE]",
+			"signatureSource": "run.sh"
 		}
 	]
 }

package/scripts/mutants/release-gate.json

@@ -136,6 +136,28 @@
 			"signature": "[QK:MUX-LIFECYCLE-IS-RELEASE-MUST]",
 			"signatureSource": "scripts/check-release-gate-outcomes.ts"
 		},
+		{
+			"claim": "MUTANT-GATES-INSIDE-FULL-FLOOR",
+			"title": "a gate a committed mutant names drops out of check:full — the #99 B-4 shape, where check-omp-birth-hook was reachable in the whole repo only through qualification's control-pre, so the one CI class that half has ever caught (a gate already red on a clean tree) could be found only by paying the 28-minute mutant body",
+			"subject": "package.json",
+			"find": [" && ./run.sh check-omp-birth-hook"],
+			"replace": [""],
+			"gate": ["bash", "run.sh", "check-release-gate-outcomes"],
+			"timeoutSeconds": 180,
+			"signature": "[QK:MUTANT-GATES-INSIDE-FULL-FLOOR]",
+			"signatureSource": "scripts/check-release-gate-outcomes.ts"
+		},
+		{
+			"claim": "CI-TAG-PUSH-NOT-REBUILT",
+			"title": "the CI push trigger loses its branch ref filter, so every release tag rebuilds a SHA its branch run already built — 66/66 historically, 28% of a release window's runner minutes, and not once a fact the branch run had not already reported",
+			"subject": ".github/workflows/ci.yml",
+			"find": ["    branches: ['**']"],
+			"replace": ["    # the branch ref filter was dropped, so a tag push rebuilds the SHA again"],
+			"gate": ["bash", "run.sh", "check-release-gate-outcomes"],
+			"timeoutSeconds": 180,
+			"signature": "[QK:CI-TAG-PUSH-NOT-REBUILT]",
+			"signatureSource": "scripts/check-release-gate-outcomes.ts"
+		},
 		{
 			"claim": "PI-DOCTOR-IS-RELEASE-MUST",
 			"title": "the pi-provider boot doctor is quietly dropped from the gate — the operator's CONFIGURED bridge invocation is never booted, so a 127 launcher (the #81 relocated cmd-shim class) stays invisible until smoke-acp-bundled-mcp-live sixteen LIVE steps and real model spend later",

package/scripts/raw-acp-compaction-measure/README.md

@@ -0,0 +1,77 @@
+# raw-acp-compaction-measure — what a compacting turn looks like after claude-agent-acp 0.75.0
+
+Measurement receipts for the ONE change in the `claude-agent-acp 0.73.0 → 0.75.1` bump that
+reaches entwurf. Not a gate; nothing here runs in any check tier.
+
+```
+LIVE=1 node --experimental-strip-types scripts/raw-acp-compaction-measure/probe.ts
+```
+
+## The change
+
+`0.75.0` (#991, `f74a517`, "surface context compaction as an ACP tool lifecycle") stopped
+sending compaction as assistant text and started sending it as a **synthetic tool call**.
+
+`[읽음, ~/repos/3rd/claude-agent-acp]` at `v0.73.0 src/acp-agent.ts:3437-3457` a compaction
+result produced two `agent_message_chunk` texts — `"\n\nCompacting completed."` and
+`"Compacting failed<reason>"`. At `v0.75.1` those are gone; `ContextCompactionLifecycle`
+(`git grep -c` in `src/`: **0** at v0.73.0 and v0.74.0, **2** at v0.75.0 and v0.75.1) drives
+`tool_call` / `tool_call_update` notifications instead
+(`dist/acp-agent.js:31`, `:1877`, `:2711-2742`).
+
+**What did NOT change:** the post-compaction occupancy refresh. `v0.73.0
+src/acp-agent.ts:3460+` already emitted a `usage_update` at `compact_boundary`, and 0.75.1
+still does (`dist/acp-agent.js:2740-2752`) — only its source moved, from a
+`getContextUsage` control request to `compact_metadata.post_tokens`. So the
+`used_end`-shrinks-mid-turn case that `backend.ts:1286-1288` already names as #96's weak
+floor is **not newly triggered by this bump**.
+
+## M1 — one live `/compact` turn, and the same notifications replayed through our mapper
+
+`[측정 2026-09-06, oracle, claude-agent-acp 0.75.1, model claude-sonnet-5]`
+`compact stopReason=end_turn`, 2 tool-lifecycle notifications. Verbatim from the probe:
+
+```
+tool_call        kind=think status=in_progress title="Compact conversation"
+                 meta={"contextCompaction":{"version":1},"claudeCode":{"toolName":"compact"}}
+tool_call_update kind=-     status=failed      title=null
+                 meta={"contextCompaction":{"version":1,"error":"Not enough messages to compact."},
+                       "claudeCode":{"toolName":"compact"}}
+```
+
+Those exact objects, replayed through the PRODUCTION `applyAcpSessionUpdate`
+(`pi-extensions/lib/acp/event-mapper.ts`) — the same function `backend.ts` calls — produce:
+
+```json
+[{"type":"text","text":"\n[tool:start] Compact conversation\n"},
+ {"type":"text","text":"\n[tool:failed] Compact conversation — Compaction failed: Not enough messages to compact.\n"}]
+```
+
+### What this establishes
+
+1. **No type or contract break.** `renderToolUpdate` (`event-mapper.ts:236-270`) routes every
+   `tool_call`/`tool_call_update` regardless of `kind`, so a `kind: "think"` synthetic call
+   needs no new branch. The turn ends `end_turn`, not an error.
+2. **`_meta.contextCompaction` reaches nothing.** It is carried on the notification and
+   dropped by the mapper, which reads only `toolCallId` / `title` / `status` / `content` /
+   `rawOutput`. No accounting path sees it — `usage.acp`, `_meta.quota` and the four pi
+   fields are untouched by this lifecycle.
+3. **What an operator now SEES changed.** Where 0.73.0 put `Compacting completed.` in the
+   assistant's own text, 0.75.1 puts a `[tool:start]` / `[tool:failed]` notice pair in the
+   transcript — that pair is what was OBSERVED. On a compaction that succeeds the second
+   notice is `[tool:done]`, which is inferred from the mapper's own status branch
+   (`event-mapper.ts:262-266`) and not observed here; see the limits below. Either way,
+   that notice pair is the whole reachable delta of this bump.
+
+### What this does NOT establish (measured limits, stated rather than rounded off)
+
+- **The `completed` branch was not observed.** The seeded session was too short, so the
+  vendor answered `"Not enough messages to compact."` and the lifecycle terminated at
+  `status: "failed"`. The success path — `status: "completed"` plus
+  `_meta.contextCompaction` carrying `trigger` / `preTokens` / `postTokens` / `durationMs`
+  (`f74a517` commit message; `contextCompactionMetadataFromBoundary`) — is **inferred from
+  source, not measured here.** In the mapper it is the same `status`-transition branch that
+  produced `[tool:failed]` above, one literal apart (`[tool:done]`,
+  `event-mapper.ts:262-266`).
+- **No organic (auto-trigger) compaction was driven.** Only the explicit `/compact` command.
+- One host, one model, one run.

package/scripts/raw-acp-compaction-measure/probe.ts

@@ -0,0 +1,196 @@
+// RAW MEASUREMENT PROBE — not a gate, not in any check tier.
+//
+//   LIVE=1 node --experimental-strip-types scripts/raw-acp-compaction-measure/probe.ts
+//
+// WHY THIS EXISTS. claude-agent-acp 0.75.0 (#991, `f74a517`) stopped surfacing Claude's
+// context compaction as assistant text and started surfacing it as a SYNTHETIC ACP tool
+// lifecycle: a `tool_call` with `kind: "think"`, title `Compact conversation`, and
+// `_meta.contextCompaction` schema v1. Reading the dist says that much
+// (`dist/acp-agent.js:31`, `:1877`, `:2711-2742`); it does not say what an entwurf
+// operator actually SEES, because that depends on our own `applyAcpSessionUpdate`.
+//
+// So this probe drives one real `/compact` turn on the pinned adapter, captures the
+// tool-lifecycle notifications verbatim, and then replays those exact notifications
+// through the PRODUCTION event mapper — the same function backend.ts calls — and prints
+// the pi-side transcript fragment they produce. The point is the join: vendor wire on one
+// side, our rendered notice on the other, in one receipt.
+//
+// It asserts nothing and blocks nothing. The receipt goes in README.md next to it.
+
+import { type ChildProcessByStdio, spawn } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Readable, Writable } from "node:stream";
+import { ndJsonStream, PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
+import { connectAcpClient } from "../../pi-extensions/lib/acp/acp-client.ts";
+import { applyAcpSessionUpdate, createAcpStreamState } from "../../pi-extensions/lib/acp/event-mapper.ts";
+import { terminateChild } from "../lib/acp-child-cleanup.ts";
+
+const MODEL_ID = process.env.ENTWURF_ACP_RAW_TURN_MODEL ?? "claude-sonnet-5";
+const OUT = process.env.RAW_COMPACTION_OUT ?? join(tmpdir(), "raw-acp-compaction.json");
+
+if (process.env.LIVE !== "1") {
+	console.error("[raw-acp-compaction] set LIVE=1 to spend a real turn.");
+	process.exit(0);
+}
+
+function withTimeout<T>(label: string, p: Promise<T>, ms: number): Promise<T> {
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	const timeout = new Promise<never>((_, reject) => {
+		timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+	});
+	return Promise.race([p, timeout]).finally(() => {
+		if (timer) clearTimeout(timer);
+	});
+}
+
+const require = createRequire(import.meta.url);
+const bin = require.resolve("@agentclientprotocol/claude-agent-acp/dist/index.js");
+
+const scratch = await mkdtemp(join(tmpdir(), "raw-acp-compaction-"));
+const child: ChildProcessByStdio<Writable, Readable, Readable> = spawn(process.execPath, [bin], {
+	cwd: scratch,
+	env: { ...process.env },
+	stdio: ["pipe", "pipe", "pipe"],
+}) as ChildProcessByStdio<Writable, Readable, Readable>;
+
+const stderrTail: string[] = [];
+child.stderr.on("data", (c) => {
+	stderrTail.push(c.toString());
+	if (stderrTail.length > 200) stderrTail.shift();
+});
+
+const stream = ndJsonStream(
+	Writable.toWeb(child.stdin) as unknown as WritableStream<Uint8Array>,
+	Readable.toWeb(child.stdout) as unknown as ReadableStream<Uint8Array>,
+);
+
+// Every tool-lifecycle notification, verbatim, in arrival order.
+const toolUpdates: Record<string, unknown>[] = [];
+let agentText = "";
+
+const connection = connectAcpClient(
+	stream as never,
+	{
+		sessionUpdate: async (notification: { update?: Record<string, unknown> }) => {
+			const u = notification?.update;
+			if (!u) return;
+			if (u.sessionUpdate === "tool_call" || u.sessionUpdate === "tool_call_update") {
+				toolUpdates.push(structuredClone(u));
+			}
+			if (u.sessionUpdate === "agent_message_chunk") {
+				const t = (u.content as { text?: unknown } | undefined)?.text;
+				if (typeof t === "string") agentText += t;
+			}
+		},
+		requestPermission: async () => ({ outcome: { outcome: "cancelled" } }),
+		readTextFile: async () => {
+			throw new Error("unexpected readTextFile");
+		},
+		writeTextFile: async () => {
+			throw new Error("unexpected writeTextFile");
+		},
+	} as never,
+);
+
+let failure: Error | null = null;
+try {
+	await withTimeout(
+		"initialize",
+		connection.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} } as never),
+		30_000,
+	);
+	const session = (await withTimeout(
+		"newSession",
+		connection.newSession({ cwd: scratch, mcpServers: [] } as never),
+		60_000,
+	)) as { sessionId?: string };
+	const sessionId = session?.sessionId;
+	if (!sessionId) throw new Error("newSession returned no sessionId");
+
+	const setConfig = (connection as unknown as { setSessionConfigOption?: unknown }).setSessionConfigOption;
+	if (typeof setConfig === "function") {
+		await withTimeout(
+			"setSessionConfigOption",
+			(setConfig as (a: unknown) => Promise<unknown>).call(connection, {
+				sessionId,
+				configId: "model",
+				value: MODEL_ID,
+			}),
+			30_000,
+		);
+	}
+
+	// One tiny turn so the transcript has something to compact.
+	await withTimeout(
+		"seed prompt",
+		connection.prompt({
+			sessionId,
+			prompt: [{ type: "text", text: "Reply with exactly SEED and nothing else." }],
+		} as never),
+		180_000,
+	);
+	const seedText = agentText;
+	agentText = "";
+	const beforeCompact = toolUpdates.length;
+
+	// The compaction turn. `/compact` is the vendor's own trigger for the lifecycle
+	// under measurement (`dist/acp-agent.js:2054`, `:2103`).
+	const compactResult = (await withTimeout(
+		"compact prompt",
+		connection.prompt({ sessionId, prompt: [{ type: "text", text: "/compact" }] } as never),
+		300_000,
+	)) as { stopReason?: string };
+
+	const compactionUpdates = toolUpdates.slice(beforeCompact);
+
+	// Replay the captured notifications through the PRODUCTION mapper.
+	const notices: string[] = [];
+	const state = createAcpStreamState(
+		{ push: (ev: unknown) => notices.push(JSON.stringify(ev)) } as never,
+		{ api: "entwurf", provider: "entwurf", model: MODEL_ID } as never,
+		{ timestamp: 0 },
+	);
+	for (const u of compactionUpdates) applyAcpSessionUpdate(state, u);
+
+	const receipt = {
+		measuredAt: new Date().toISOString(),
+		adapter: JSON.parse(
+			(await import("node:fs")).readFileSync(
+				require.resolve("@agentclientprotocol/claude-agent-acp/package.json"),
+				"utf8",
+			),
+		).version,
+		model: MODEL_ID,
+		seedText: seedText.trim().slice(0, 80),
+		compactStopReason: compactResult?.stopReason,
+		compactionToolUpdates: compactionUpdates,
+		mappedContent: state.output.content,
+		mappedStreamEvents: notices,
+	};
+	await writeFile(OUT, `${JSON.stringify(receipt, null, "\t")}\n`, "utf8");
+	console.log(`[raw-acp-compaction] receipt -> ${OUT}`);
+	console.log(`  adapter:            ${receipt.adapter}`);
+	console.log(`  compact stopReason: ${receipt.compactStopReason}`);
+	console.log(`  tool updates:       ${compactionUpdates.length}`);
+	for (const u of compactionUpdates) {
+		console.log(
+			`    ${String(u.sessionUpdate)} kind=${String(u.kind ?? "-")} status=${String(u.status ?? "-")} title=${JSON.stringify(u.title ?? null)} meta=${JSON.stringify(u._meta ?? null)}`,
+		);
+	}
+	console.log(`  pi-side content blocks: ${JSON.stringify(state.output.content)}`);
+} catch (err) {
+	failure = err instanceof Error ? err : new Error(String(err));
+	console.error(`[raw-acp-compaction] stderr tail:\n${stderrTail.slice(-20).join("")}`);
+} finally {
+	connection.close?.();
+	await terminateChild(child);
+	await rm(scratch, { recursive: true, force: true }).catch(() => {});
+}
+
+if (failure) {
+	console.error(`[raw-acp-compaction] FAILED: ${failure.message}`);
+	process.exit(1);
+}

package/scripts/smoke-acp-raw-turn-live.ts

@@ -3,7 +3,7 @@
 //   LIVE=1 ./run.sh smoke-acp-raw-turn-live
 //
 // What this proves (and ONLY this): the pinned Claude ACP adapter
-// (@agentclientprotocol/claude-agent-acp@0.73.0) spawns, speaks the ACP wire
+// (@agentclientprotocol/claude-agent-acp@0.75.1) spawns, speaks the ACP wire
 // protocol over stdio NDJSON, and returns one real model turn. It is the
 // bytes-flow proof that the S2a dep surface is not just installable but
 // actually drivable — before any provider/overlay/streamSimple code (S2b+).