instar 1.3.239 → 1.3.240

package/upgrades/apprenticeship-channel-enforcement.eli16.md

@@ -0,0 +1,16 @@
+# Enforcing the dogfooded channel — explained simply
+
+The apprenticeship rule (just documented) is: a mentor must drive its mentee through
+the REAL Telegram UX (via Playwright), because experiencing the user experience IS the
+test. A shortcut — calling the mentee's CLI directly — gets an answer but skips the
+thing we're actually testing.
+
+A doc alone is a wish. This makes it a guarantee: every recorded apprenticeship cycle
+now writes down WHICH channel it actually ran through. And the keystone check — the one
+that tells us the real mentor↔mentee work is happening — only counts a cycle if it ran
+through the real channel (Telegram-Playwright, or the backup). A shortcut cycle is still
+saved (so we're honest it happened), but it does NOT light up the keystone. So a shortcut
+can never make the program look healthier than it is.
+
+Older cycles (recorded before this field existed) are grandfathered in — they still
+count, so this never retroactively "un-fires" a keystone we already earned.

package/upgrades/side-effects/apprenticeship-channel-enforcement.md

@@ -0,0 +1,39 @@
+# Side-Effects Review — Apprenticeship dogfooded-channel enforcement
+
+**Slug:** `apprenticeship-channel-enforcement` · **Date:** `2026-06-04` · **Author:** `echo`
+**Second-pass reviewer:** `not required` (additive field + a counting gate; grandfathered)
+
+## Summary
+
+Adds a `channel` field to ApprenticeshipCycleStore records (`telegram-playwright` |
+`threadline-backup` | `direct-shortcut` | `unknown`), an idempotent ALTER-TABLE migration
+for existing DBs (default `unknown`), and a `roleCoverage` gate: a
+`mentor-mentee-differential` cycle on `direct-shortcut` is recorded but does NOT count
+toward the keystone axis (surfaced via a new `shortcutDifferentialCount`). Enforces the
+§4a dogfooded-channel standard in code.
+
+## Decision-point inventory
+
+One new branch in `roleCoverage`: a mentor-mentee-differential cycle is skipped from axis
+tallying iff `channel === 'direct-shortcut'`. Covered both-sides (dogfooded fires; shortcut
+doesn't + increments the counter; grandfathered/backup fire).
+
+## 1. Over-block
+
+Rejects nothing. Garbage/unset channels normalize to `unknown`, which COUNTS (grandfathered)
+— so it never retroactively un-fires an earned keystone (cycle #4, recorded pre-field, holds).
+Only an EXPLICIT `direct-shortcut` is gated, and even then the cycle is still stored + listed.
+
+## 2. Under-block
+
+The mentor tick (#743) records cycles without setting `channel` → they default to `unknown`
+→ count. That is intentionally grandfathered for now; aligning the automated tick to set
+`direct-shortcut` (or to drive via Playwright, the real fix) is the follow-on once Codey's
+Playwright driving capability exists. The gate is per-axis-tally; it does not retro-rewrite
+stored rows.
+
+## 3. Level-of-abstraction fit
+
+Right layer: the enforcement lives in the cycle store's `roleCoverage` (the single place the
+keystone is computed), reusing the existing axis-tally loop. No route/server change — the
+existing `GET /apprenticeship/instances/:id/role-coverage` surfaces the new field for free.

package/upgrades/side-effects/threadline-a2a-resume-session-id.md

@@ -0,0 +1,59 @@
+# Side-Effects Review — Threadline A2A resume via deterministic session-id
+
+**Version / slug:** `threadline-a2a-resume-session-id`
+**Date:** `2026-06-04`
+**Author:** `Echo (instar dev agent)`
+**Second-pass reviewer:** `not required (Tier 1)`
+
+## Summary of the change
+
+Path 1 of the A2A continuity fix. Headless `claude -p` reply sessions never reported their session id, so `onSessionComplete` left the resume entry's uuid as a placeholder and resume-after-exit cold-spawned. Fix: when `ThreadlineRouter.spawnNewThread` spawns the first reply session it mints a uuid and passes it as `claude --session-id <uuid>` (so the transcript is created at exactly `<uuid>.jsonl`), and persists that uuid as the resume entry. `resumeThread` spawns the follow-up with `claude --resume <uuid>` (reloading the full transcript) and a minimal prompt (new message + grounding only — the transcript already holds history). Threaded through: `SessionManager.spawnSession` (new `sessionId?`/`resumeSessionId?` options → `--session-id`/`--resume` spliced into the claude-code headless argv before `-p`, mutually exclusive, gated on framework), `SpawnRequestManager` (forwards both from `SpawnRequest` → callback), the relay `spawnSession` callback in `server.ts`. Files: `src/core/SessionManager.ts`, `src/messaging/SpawnRequestManager.ts`, `src/commands/server.ts`, `src/threadline/ThreadlineRouter.ts` + tests.
+
+## Decision-point inventory
+
+- `SessionManager.spawnSession` headless argv (`src/core/SessionManager.ts`) — **modify (additive)** — splice `--session-id`/`--resume` when the new options are set; no change when absent.
+- `ThreadlineRouter.spawnNewThread` resume-entry uuid (`src/threadline/ThreadlineRouter.ts`) — **modify** — save the real minted uuid instead of the placeholder.
+- `ThreadlineRouter.resumeThread` prompt + spawn (`src/threadline/ThreadlineRouter.ts`) — **modify** — pass `resumeSessionId` + minimal prompt (drop re-injected history).
+- `SpawnRequest`/`SpawnRequestManager.evaluate` forwarding — **modify (additive)** — carry `sessionId`/`resumeSessionId`.
+
+## 1. Over-block
+
+**What legitimate inputs does this change reject that it shouldn't?**
+
+None — no allow/block surface. The flags only set/resume the conversation id. No message is rejected. When the new options are absent (every non-A2A spawn), behavior is unchanged. "No block/allow surface — over-block not applicable."
+
+## 2. Under-block
+
+**What failure modes does this still miss?**
+
+Rapid-fire (multiple messages while the reply session is still running): `--resume` on a still-busy session, or a fresh spawn hitting the 30s cooldown, is unchanged by this slice — that is the warm-session follow-up. Also: a `--resume` against a transcript that was deleted/rotated falls back to a fresh spawn (handled by the existing stale-uuid guard), losing that thread's history — acceptable + lossless beyond history.
+
+## 3. Level-of-abstraction fit
+
+The uuid is minted + owned by `ThreadlineRouter` (which owns the resume entry) and threaded down to the spawn primitive — the right layering. `SessionManager` only learns "set/resume this id," mirroring its existing `--resume` (triage) and `extraClaudeFlags` patterns.
+
+## 4. Signal vs authority compliance
+
+Not a gate/authority change. No approval surface added or relaxed. Trust gates on the inbound path are untouched.
+
+## 5. Interactions
+
+- Builds on shipped slices 1+2 (router finds the live session + real tmux name). With this, `get()`'s `jsonlExists(uuid)` now passes legitimately (the transcript exists at the minted id) → resume path fires for spaced follow-ups.
+- The relay `spawnSession` callback keeps `codexAllowMcpTools: true` + all MCP/permission flags → the A2A worker still replies via `threadline_send`.
+- 1548 threadline/fixes/continuity unit tests pass; tsc clean. One obsolete test (`includes thread history in resume prompt`) replaced — it asserted the now-removed history-re-injection behavior.
+
+## 6. External surfaces
+
+No new HTTP routes, no config defaults, no template/CLAUDE.md change. Pure internal session-lifecycle behavior. Migration-parity: nothing to migrate (no config/hook/template surface).
+
+## 7. Rollback cost
+
+Low — revert the four source files. No persisted-format change (the resume entry already had a `uuid` field; it now holds a real id instead of a placeholder — old placeholder entries simply fail `jsonlExists` and cold-spawn as before). No external dependency.
+
+## Conclusion
+
+Low-risk, additive, deterministic fix that completes the realistic turn-based A2A continuity case on top of the shipped foundation. The mechanism (`--session-id` set + `--resume` reload) was empirically verified before coding. Rapid-fire smoothness is explicitly out of scope.
+
+## Second-pass review (if required)
+
+Not required — Tier 1 (additive, gated, ~single-concern).

package/upgrades/threadline-a2a-resume-session-id.eli16.md

@@ -0,0 +1,28 @@
+# Why agent-to-agent conversations can now actually remember
+
+## The one-sentence version
+When another agent sends me several messages over a conversation, each of my replies used to run as a throwaway that finished and forgot everything — so the next message met a stranger. Now I give each reply session a **known name tag** when it starts, write that tag down, and on the next message I **re-open the exact same conversation by its tag** — so I pick up right where we left off, with the full history.
+
+## What was broken (proven live)
+A real round-trip with Dawn showed every follow-up still cold-spawned a memoryless session. The deep reason: each reply ran as a headless one-shot Claude that **never reports its own session id back to me**, so when it finished I had no handle to reconnect to. My earlier fix made the router *try* to reconnect, but there was nothing to reconnect to.
+
+## The fix (deterministic, no guessing)
+Claude lets you (a) **set** a session's id when you launch it (`--session-id <uuid>`) and (b) **re-open** a session by that id later (`--resume <uuid>`). I verified both directly: setting an id creates the transcript under that exact id, and resuming it reloads the whole prior conversation (I planted a secret word in turn 1 and the resumed session recalled it).
+
+So now:
+- When a peer's first message spawns a reply session, I **mint a fresh id and pass it as `--session-id`**, then store that id as the thread's resume handle.
+- When the next message arrives, I spawn with **`--resume <that id>`** so the session reloads the full prior transcript and continues — and I send it only the new message (the transcript already holds the history, so re-pasting it would just duplicate it).
+
+## The safety rails
+1. **Additive + off by default.** The new options do nothing unless set. Every other kind of session (jobs, your topic sessions, Codex) is byte-for-byte unchanged.
+2. **Claude-code only, and the two flags are mutually exclusive** — a launch either sets a new id or resumes one, never both.
+3. **A stale id can't wedge me.** If a transcript no longer exists, the existing resume-crash guard falls back to a fresh spawn instead of hanging.
+4. **The reply path is untouched.** Setting/resuming the conversation id doesn't change tools or permissions, so the agent still replies normally over the secure channel.
+5. **Built on the shipped foundation** (the router already finds the live session + carries the real session name); this adds the missing piece — the real, resumable id.
+
+## What it does NOT yet fix
+The *rapid-fire* case (three messages in ten seconds, while the reply is still being written) still isn't smooth — that needs the bigger persistent-session work. This fixes the realistic **turn-based** conversation (you reply, I reply, you reply a minute later), which is exactly what the agent-to-agent feedback migration needs.
+
+---
+
+**Rendered (verified) view:** _set below after creating the tunnel view._