@junghanacs/entwurf 0.17.2 → 0.18.1

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/raw-claude-session-switch/README.md

@@ -0,0 +1,170 @@
+# Raw measurement — what Claude Code's SessionStart actually says on a session switch (#101)
+
+**Status: RUN on oracle, 2026-09-04, Claude Code 2.1.260, `--model haiku`.** GLG approved the
+LIVE cells (S1–S5 first, S6 added after). Six cells, one host, one vendor version — that is the
+whole claim. Everything below is verbatim from `~/.pi/agent/meta-bridge-hook.log`, produced by
+the repaired hook, which now logs the envelope's `source` on every line it writes.
+
+The #101 repair does **not** depend on any of it: the retirement rule reads the sender marker on
+disk and branches on no vendor field. What this lab adds is the envelope order the diagnosis had
+to inherit from vendor documentation — and it **refuted one inherited sentence** (see S2/S3).
+
+## What the lab changed in the story
+
+The diagnosis said the two SessionStarts come from the TUI resume picker firing once for a
+placeholder id and again for the picked id. **Measured, that is not what happens.**
+`claude --resume`, with or without the picker, fires exactly ONE SessionStart carrying the real
+id (S2, S3). The two-SessionStart shape comes from a bare `claude` — which mints a real, empty
+new session — followed by an in-session `/resume` or `/clear` (S4, S5). The field case fits: `ps`
+showed pid 143742 started bare `claude` at 09:31:32, and the second SessionStart landed 4s later.
+
+The consequence for the repair is nil (either way one pid stops serving one garden and starts
+serving another, and the sender marker is what says so), but the prose was wrong and is now
+corrected in `meta-bridge-hook.ts`, `entwurf-deliverability.ts`, `meta-session.ts` and
+`check-meta-hook-session-switch.ts`.
+
+## The three falsification conditions, judged
+
+The pre-run README named three findings that would have changed the repair. All three are
+answered:
+
+1. **"A switch leaves the sender marker pointing at the OLD garden when the receiver marker has
+   already moved"** — the repair's one real assumption. **Not observed.** In S4 and S5 the
+   retirement line is written BEFORE the sender marker is rewritten, and both precede the new
+   garden's arm (log order below, same millisecond). The hook reads the pre-switch value it needs.
+2. **"Compaction re-fires SessionStart under a NEW native id, so a compacted session is a garden
+   switch"** — **refuted.** Compaction (manual S6a and automatic S6b) re-fires SessionStart for
+   the SAME native id, attaches the SAME garden, and retires nothing. The same-garden rule covers
+   it; nothing had to change.
+3. **"Three SessionStarts in one process"** — **not observed** in any cell. Every switch was
+   exactly one additional SessionStart, and the two-drive gate fixture stays adequate.
+
+## The cells
+
+| cell | how it was reached | SessionStarts | `source` | native id | retirement |
+|---|---|---|---|---|---|
+| S1 | bare `claude` | 1 | `startup` | new | — (nothing prior) |
+| S2 | `claude --resume` → picker → Enter | **1** | `resume` | the picked one | — (no prior garden in this pid) |
+| S3 | `claude --resume <id>` (argv) | **1** | `resume` | the given one | — |
+| S4 | bare `claude`, then in-session `/resume` | **2** | `startup` → `resume` | new → picked | **yes** — the startup garden retired |
+| S5 | in-session `/clear` | 1 more | `clear` | new | **yes** — the previous garden retired |
+| S6a | in-session `/compact` | 1 more | `compact` | **same** | no (same garden) |
+| S6b | automatic compaction at ~98% context | 1 more | `compact` | **same** | no (same garden) |
+
+`UserPromptSubmit` carries **no** `source` at all (`source=(unset)`) — worth knowing, since it is
+the event that rewrites the sender marker on every keystroke and must retire nothing.
+
+It also always names the session it belongs to. Across the four lab pids, **8 of 8**
+`UserPromptSubmit` events carried the native id their own pid's preceding `SessionStart` had
+established, and none carried any other. The hook runs synchronously inside the session's own
+process, so a keystroke envelope is that session speaking — which is why the pointer it moves is
+treated as authoritative rather than as something to defend against.
+
+## Verbatim receipts
+
+**S1 — bare `claude`.** One SessionStart, a fresh garden, `source=startup`. Then one turn, whose
+`UserPromptSubmit` carries no source and retires nothing (same garden):
+
+```
+2026-09-04T04:10:22.678Z INFO create record 20260904T131022-ac38b6.meta.json (event=SessionStart, source=startup, native=bbba9cbe-f11c-4b67-a0bd-991c3f678238)
+2026-09-04T04:10:22.681Z INFO sender marker 564537 -> 20260904T131022-ac38b6 (event=SessionStart, source=startup)
+2026-09-04T04:10:22.681Z INFO armed watch /home/junghan/.pi/agent/meta-mailbox/20260904T131022-ac38b6/inbox.signal
+2026-09-04T04:10:22.682Z INFO receiver marker 20260904T131022-ac38b6 owner=564537 arm=SessionStart source=startup
+2026-09-04T04:11:00.196Z INFO attach record 20260904T131022-ac38b6.meta.json (event=UserPromptSubmit, source=(unset), native=bbba9cbe-f11c-4b67-a0bd-991c3f678238)
+2026-09-04T04:11:00.198Z INFO sender marker 564537 -> 20260904T131022-ac38b6 (event=UserPromptSubmit, source=(unset))
+```
+
+**S2 — `claude --resume`, picker, Enter.** Nothing at all is logged while the picker is open; the
+single SessionStart lands on selection, already carrying the real native id. **No placeholder.**
+
+```
+2026-09-04T04:12:24.853Z INFO attach record 20260904T131022-ac38b6.meta.json (event=SessionStart, source=resume, native=bbba9cbe-f11c-4b67-a0bd-991c3f678238)
+2026-09-04T04:12:24.855Z INFO sender marker 565726 -> 20260904T131022-ac38b6 (event=SessionStart, source=resume)
+2026-09-04T04:12:24.855Z INFO armed watch /home/junghan/.pi/agent/meta-mailbox/20260904T131022-ac38b6/inbox.signal
+2026-09-04T04:12:24.855Z INFO receiver marker 20260904T131022-ac38b6 owner=565726 arm=SessionStart source=resume
+```
+
+**S3 — `claude --resume <id>` (argv).** Same shape as S2:
+
+```
+2026-09-04T04:14:53.710Z INFO attach record 20260904T131022-ac38b6.meta.json (event=SessionStart, source=resume, native=bbba9cbe-f11c-4b67-a0bd-991c3f678238)
+2026-09-04T04:14:53.711Z INFO sender marker 568726 -> 20260904T131022-ac38b6 (event=SessionStart, source=resume)
+2026-09-04T04:14:53.711Z INFO armed watch /home/junghan/.pi/agent/meta-mailbox/20260904T131022-ac38b6/inbox.signal
+2026-09-04T04:14:53.712Z INFO receiver marker 20260904T131022-ac38b6 owner=568726 arm=SessionStart source=resume
+```
+
+**S4 — THE cell: bare `claude`, then `/resume`.** This is #101 reproduced deliberately, and the
+repair firing on it. One pid (566479), two gardens, 33 seconds apart:
+
+```
+2026-09-04T04:13:04.371Z INFO create record 20260904T131304-f85f0e.meta.json (event=SessionStart, source=startup, native=aa49d155-8416-41a5-9d59-52d747b428d7)
+2026-09-04T04:13:04.372Z INFO sender marker 566479 -> 20260904T131304-f85f0e (event=SessionStart, source=startup)
+2026-09-04T04:13:04.373Z INFO armed watch /home/junghan/.pi/agent/meta-mailbox/20260904T131304-f85f0e/inbox.signal
+2026-09-04T04:13:04.373Z INFO receiver marker 20260904T131304-f85f0e owner=566479 arm=SessionStart source=startup
+2026-09-04T04:13:37.966Z INFO attach record 20260904T131022-ac38b6.meta.json (event=SessionStart, source=resume, native=bbba9cbe-f11c-4b67-a0bd-991c3f678238)
+2026-09-04T04:13:37.967Z INFO retired receiver marker 20260904T131304-f85f0e — owner pid 566479 switched to 20260904T131022-ac38b6 (event=SessionStart, source=resume)
+2026-09-04T04:13:37.968Z INFO sender marker 566479 -> 20260904T131022-ac38b6 (event=SessionStart, source=resume)
+2026-09-04T04:13:37.969Z INFO armed watch /home/junghan/.pi/agent/meta-mailbox/20260904T131022-ac38b6/inbox.signal
+2026-09-04T04:13:37.970Z INFO receiver marker 20260904T131022-ac38b6 owner=566479 arm=SessionStart source=resume
+```
+
+State immediately after, read from the real store (read-only):
+
+```
+- 20260904T131022-ac38b6  backend=claude-code  liveness=unsupported  receiver=active  transcript=exists  cwd=…/scratchpad/lab
+- 20260904T131304-f85f0e  backend=claude-code  liveness=unsupported  receiver=none    transcript=absent  cwd=…/scratchpad/lab
+```
+
+Both records survive. `meta-receivers/` holds only `20260904T131022-ac38b6.json`, and
+`meta-senders/claude-code/566479.json` names `20260904T131022-ac38b6`. Before the repair the
+abandoned garden would have read `receiver=active` and accepted mail — that is the #101 defect,
+and this is the same shape as the field case (`ac7a1a`, still on this host as evidence).
+
+**S5 — `/clear`.** Same switch shape, `source=clear`, and the retirement fires again:
+
+```
+2026-09-04T04:14:18.703Z INFO create record 20260904T131418-31129e.meta.json (event=SessionStart, source=clear, native=eac3c9ae-2873-454b-90ca-11b7ee24b508)
+2026-09-04T04:14:18.705Z INFO retired receiver marker 20260904T131022-ac38b6 — owner pid 566479 switched to 20260904T131418-31129e (event=SessionStart, source=clear)
+2026-09-04T04:14:18.706Z INFO sender marker 566479 -> 20260904T131418-31129e (event=SessionStart, source=clear)
+2026-09-04T04:14:18.706Z INFO armed watch /home/junghan/.pi/agent/meta-mailbox/20260904T131418-31129e/inbox.signal
+2026-09-04T04:14:18.706Z INFO receiver marker 20260904T131418-31129e owner=566479 arm=SessionStart source=clear
+```
+
+**S6a — manual `/compact`.** SAME native id, SAME garden, no retirement:
+
+```
+2026-09-04T04:15:29.240Z INFO attach record 20260904T131022-ac38b6.meta.json (event=SessionStart, source=compact, native=bbba9cbe-f11c-4b67-a0bd-991c3f678238)
+2026-09-04T04:15:29.242Z INFO sender marker 568726 -> 20260904T131022-ac38b6 (event=SessionStart, source=compact)
+2026-09-04T04:15:29.242Z INFO armed watch /home/junghan/.pi/agent/meta-mailbox/20260904T131022-ac38b6/inbox.signal
+2026-09-04T04:15:29.243Z INFO receiver marker 20260904T131022-ac38b6 owner=568726 arm=SessionStart source=compact
+```
+
+**S6b — automatic compaction.** Reached by having the session read large repo files until the
+context filled: 60% → 80% → 91% → 98% (196.5K/200K of a 200K window), then one more large read
+tipped it. Byte-identical shape to S6a; context fell to 72.1K afterwards:
+
+```
+2026-09-04T04:29:06.583Z INFO attach record 20260904T131022-ac38b6.meta.json (event=SessionStart, source=compact, native=bbba9cbe-f11c-4b67-a0bd-991c3f678238)
+2026-09-04T04:29:06.585Z INFO sender marker 568726 -> 20260904T131022-ac38b6 (event=SessionStart, source=compact)
+2026-09-04T04:29:06.586Z INFO armed watch /home/junghan/.pi/agent/meta-mailbox/20260904T131022-ac38b6/inbox.signal
+2026-09-04T04:29:06.587Z INFO receiver marker 20260904T131022-ac38b6 owner=568726 arm=SessionStart source=compact
+```
+
+Manual and automatic compaction are the same event to this hook. Note it needs ~98% of the window
+before it fires, and that a session under a smaller model or a shorter window will reach it sooner
+— the threshold is the vendor's, not ours.
+
+## How to re-run
+
+`tmux new-session -d -s lab -c <scratch> 'claude --model haiku'`, drive it with `send-keys` (send
+the text and the `Enter` as SEPARATE calls — a combined one leaves the prompt typed but
+unsubmitted), and read the delta of `~/.pi/agent/meta-bridge-hook.log` between cells. Nothing else
+is needed: the hook log is the instrument. A cell costs a few seconds of a cheap model, except
+S6b, which costs one full context window.
+
+## Boundary
+
+One host (oracle), one vendor version (2.1.260), one model (Haiku 4.5), one operator's config.
+The cells say what this Claude does here; they do not certify another host, an older Claude, or
+a different terminal. The repair does not rest on them — it rests on the sender marker — which is
+why a refutation here (S2/S3) corrected the prose and left the code alone.

package/scripts/smoke-acp-cortex-live.ts

@@ -51,7 +51,11 @@ import * as os from "node:os";
 import * as path from "node:path";
 import * as readline from "node:readline";
 import { fileURLToPath } from "node:url";
-import { upsertMetaSession, writeMetaReceiverMarker } from "../pi-extensions/lib/meta-session.ts";
+import {
+	upsertMetaSession,
+	writeMetaReceiverMarker,
+	writeMetaSenderMarker,
+} from "../pi-extensions/lib/meta-session.ts";
 import { terminateChild } from "./lib/acp-child-cleanup.ts";
 import { skipLive } from "./lib/live-skip.ts";
 import { PI_BOOT_TIMEOUT_MS, waitForPiRecord } from "./lib/pi-record-discovery.ts";
@@ -210,7 +214,8 @@ async function main(): Promise<void> {
 	const sessionsDir = path.join(world, "sessions");
 	const mailboxDir = path.join(world, "mailbox");
 	const receiversDir = path.join(world, "receivers");
-	for (const d of [sessionsDir, mailboxDir, receiversDir]) await fsp.mkdir(d, { recursive: true });
+	const sendersDir = path.join(world, "senders");
+	for (const d of [sessionsDir, mailboxDir, receiversDir, sendersDir]) await fsp.mkdir(d, { recursive: true });
 
 	const nonce = `CORTEXV2-${crypto.randomBytes(5).toString("hex").toUpperCase()}`;
 
@@ -224,6 +229,12 @@ async function main(): Promise<void> {
 		dir: sessionsDir,
 	});
 	const receiverGid = receiver.record.gardenId;
+	// The receiver marker alone is no longer the whole fixture (#101): a `claude-code-cli` watch
+	// owner is deliverable only while ITS OWN sender marker still names the garden it is armed
+	// for — that join is what refuses a session which switched away in place. A receiver marker
+	// with no sender marker beside it models a state the product now treats as retired, so this
+	// smoke would fail on its own fixture instead of on the rail it exists to prove. Same shape
+	// as smoke-mux-lifecycle-live / smoke-omp-fresh-live, which already seeded both.
 	writeMetaReceiverMarker({
 		gardenId: receiverGid,
 		backend: "claude-code",
@@ -232,6 +243,14 @@ async function main(): Promise<void> {
 		armProvenance: "session-start",
 		receiversDir,
 	});
+	writeMetaSenderMarker({
+		backend: "claude-code",
+		gardenId: receiverGid,
+		nativeSessionId: receiver.record.nativeSessionId,
+		cwd: world,
+		ownerPid: process.pid,
+		sendersDir,
+	});
 	console.error(`[smoke-acp-cortex-live] peer:  ${receiverGid} (armed mailbox receiver)`);
 
 	let senderGid = "";
@@ -252,6 +271,7 @@ async function main(): Promise<void> {
 					ENTWURF_META_SESSIONS_DIR: sessionsDir,
 					ENTWURF_META_MAILBOX_DIR: mailboxDir,
 					ENTWURF_META_RECEIVERS_DIR: receiversDir,
+					ENTWURF_META_SENDERS_DIR: sendersDir,
 				},
 			},
 		);

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+).

package/scripts/smoke-acp-v2-send-live.ts

@@ -79,7 +79,11 @@ import * as os from "node:os";
 import * as path from "node:path";
 import * as readline from "node:readline";
 import { fileURLToPath } from "node:url";
-import { upsertMetaSession, writeMetaReceiverMarker } from "../pi-extensions/lib/meta-session.ts";
+import {
+	upsertMetaSession,
+	writeMetaReceiverMarker,
+	writeMetaSenderMarker,
+} from "../pi-extensions/lib/meta-session.ts";
 import { terminateChild } from "./lib/acp-child-cleanup.ts";
 import { skipLive } from "./lib/live-skip.ts";
 import { PI_BOOT_TIMEOUT_MS, waitForPiRecord } from "./lib/pi-record-discovery.ts";
@@ -210,7 +214,8 @@ async function main(): Promise<void> {
 	const sessionsDir = path.join(world, "sessions");
 	const mailboxDir = path.join(world, "mailbox");
 	const receiversDir = path.join(world, "receivers");
-	for (const d of [sessionsDir, mailboxDir, receiversDir]) await fsp.mkdir(d, { recursive: true });
+	const sendersDir = path.join(world, "senders");
+	for (const d of [sessionsDir, mailboxDir, receiversDir, sendersDir]) await fsp.mkdir(d, { recursive: true });
 
 	const nonce = `ACPV2-${crypto.randomBytes(5).toString("hex").toUpperCase()}`;
 
@@ -225,6 +230,13 @@ async function main(): Promise<void> {
 	});
 	const receiverGid = receiver.record.gardenId;
 	// armed = a presence marker owned by THIS (live) process → deliverable.
+	//
+	// The receiver marker alone is no longer the whole fixture (#101): a `claude-code-cli` watch
+	// owner is deliverable only while ITS OWN sender marker still names the garden it is armed
+	// for — that join is what refuses a session which switched away in place. A receiver marker
+	// with no sender marker beside it models a state the product now treats as retired, so this
+	// smoke would fail on its own fixture instead of on the rail it exists to prove. Same shape
+	// as smoke-mux-lifecycle-live / smoke-omp-fresh-live, which already seeded both.
 	writeMetaReceiverMarker({
 		gardenId: receiverGid,
 		backend: "claude-code",
@@ -233,6 +245,14 @@ async function main(): Promise<void> {
 		armProvenance: "session-start",
 		receiversDir,
 	});
+	writeMetaSenderMarker({
+		backend: "claude-code",
+		gardenId: receiverGid,
+		nativeSessionId: receiver.record.nativeSessionId,
+		cwd: world,
+		ownerPid: process.pid,
+		sendersDir,
+	});
 	console.error(`[smoke-acp-v2-send-live] peer:  ${receiverGid} (armed mailbox receiver)`);
 
 	let senderGid = "";
@@ -252,6 +272,7 @@ async function main(): Promise<void> {
 					ENTWURF_META_SESSIONS_DIR: sessionsDir,
 					ENTWURF_META_MAILBOX_DIR: mailboxDir,
 					ENTWURF_META_RECEIVERS_DIR: receiversDir,
+					ENTWURF_META_SENDERS_DIR: sendersDir,
 				},
 			},
 		);