instar 1.3.238 → 1.3.239

package/dist/threadline/WarmSessionPool.js

@@ -0,0 +1,116 @@
+/**
+ * WarmSessionPool — Layer 2 core (THREADLINE-A2A-COHERENCE-SPEC).
+ *
+ * Keeps an agent-to-agent session "warm" for a TTL so rapid follow-ups inject into the running
+ * session (via the existing live-injection path) instead of respawning each message. The
+ * operator-confirmed model is **per-peer** with a **global + per-peer cap** and **TTL + LRU
+ * eviction**, so an inbound flood (many threads / one chatty peer) can't pin unbounded live
+ * Claude processes. This is the pure registry + eviction policy; the server wires it to the real
+ * session lifecycle (keep-alive, inject, kill-on-evict) and the SessionReaper (warm sessions are
+ * evict-eligible under resource pressure — eviction is lossless because the next message falls
+ * back to Layer 1 resume).
+ *
+ * Pure + clock-injected → fully testable. Eviction is reported (the caller kills the tmux/Claude
+ * session); the pool itself holds no I/O.
+ */
+export class WarmSessionPool {
+    config;
+    now;
+    byThread = new Map();
+    constructor(config, now = () => Date.now()) {
+        this.config = config;
+        this.now = now;
+    }
+    size() {
+        return this.byThread.size;
+    }
+    peerCount(peerId) {
+        let n = 0;
+        for (const r of this.byThread.values())
+            if (r.peerId === peerId)
+                n++;
+        return n;
+    }
+    /** LRU among a predicate set (oldest lastUsedAt first). */
+    lru(filter) {
+        const rs = [...this.byThread.values()].filter(r => (filter ? filter(r) : true));
+        rs.sort((a, b) => a.lastUsedAt - b.lastUsedAt);
+        return rs;
+    }
+    /**
+     * Admit (or refresh) a warm session for a thread. Returns the records that must be EVICTED
+     * (killed by the caller) to honor the caps — LRU first, per-peer cap before global cap. An
+     * existing thread is refreshed in place (no eviction).
+     */
+    admit(input) {
+        const now = this.now();
+        const existing = this.byThread.get(input.threadId);
+        if (existing) {
+            existing.lastUsedAt = now;
+            existing.sessionName = input.sessionName;
+            return [];
+        }
+        const evicted = [];
+        // Per-peer cap: evict the peer's LRU until under the cap (leaving room for the new one).
+        while (this.peerCount(input.peerId) >= this.config.perPeerCap) {
+            const victim = this.lru(r => r.peerId === input.peerId)[0];
+            if (!victim)
+                break;
+            this.byThread.delete(victim.threadId);
+            evicted.push(victim);
+        }
+        // Global cap: evict the global LRU until under the cap.
+        while (this.byThread.size >= this.config.globalCap) {
+            const victim = this.lru()[0];
+            if (!victim)
+                break;
+            this.byThread.delete(victim.threadId);
+            evicted.push(victim);
+        }
+        this.byThread.set(input.threadId, {
+            threadId: input.threadId,
+            peerId: input.peerId,
+            sessionName: input.sessionName,
+            createdAt: now,
+            lastUsedAt: now,
+        });
+        return evicted;
+    }
+    /** Mark a thread's warm session used (LRU refresh). */
+    touch(threadId) {
+        const r = this.byThread.get(threadId);
+        if (r)
+            r.lastUsedAt = this.now();
+    }
+    /** The warm session for a thread, if present and not past its idle TTL; else undefined. */
+    get(threadId) {
+        const r = this.byThread.get(threadId);
+        if (!r)
+            return undefined;
+        if (this.now() - r.lastUsedAt >= this.config.ttlMs)
+            return undefined;
+        return r;
+    }
+    remove(threadId) {
+        const r = this.byThread.get(threadId);
+        if (r)
+            this.byThread.delete(threadId);
+        return r;
+    }
+    /** Reap warm sessions idle past the TTL. Returns the evicted records (caller kills them). */
+    reapExpired() {
+        const now = this.now();
+        const expired = [...this.byThread.values()].filter(r => now - r.lastUsedAt >= this.config.ttlMs);
+        for (const r of expired)
+            this.byThread.delete(r.threadId);
+        return expired;
+    }
+    /** Reap up to n warm sessions under resource pressure (LRU first). Returns evicted records. */
+    reapUnderPressure(n) {
+        const victims = this.lru().slice(0, Math.max(0, n));
+        for (const r of victims)
+            this.byThread.delete(r.threadId);
+        return victims;
+    }
+}
+//# sourceMappingURL=WarmSessionPool.js.map

package/dist/threadline/WarmSessionPool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WarmSessionPool.js","sourceRoot":"","sources":["../../src/threadline/WarmSessionPool.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "instar",
-  "version": "1.3.238",
+  "version": "1.3.239",
   "description": "Coherence infrastructure for self-evolving AI agents — on the Claude Code or Codex subscription you already have.",
   "type": "module",
   "main": "dist/index.js",

package/src/data/builtin-manifest.json

@@ -1,8 +1,8 @@
 {
   "$schema": "./builtin-manifest.schema.json",
   "schemaVersion": 1,
-  "generatedAt": "2026-06-04T04:05:54.086Z",
-  "instarVersion": "1.3.238",
+  "generatedAt": "2026-06-04T04:41:03.490Z",
+  "instarVersion": "1.3.239",
   "entryCount": 198,
   "entries": {
     "hook:session-start": {
@@ -1498,7 +1498,7 @@
       "type": "subsystem",
       "domain": "server",
       "sourcePath": "src/server/AgentServer.ts",
-      "contentHash": "aef725dff8db8e03973977c8d962c87bc678a4c21cfc39cd54c763331e830137",
+      "contentHash": "e72905d8a8de5d22c7cedb5c599f9341f61ac9139f65f32bde7011a1c5202ef7",
       "since": "2025-01-01"
     },
     "subsystem:session-manager": {

package/upgrades/1.3.239.md

@@ -0,0 +1,96 @@
+# Upgrade Guide — vNEXT
+
+<!-- assembled-by: assemble-next-md -->
+<!-- bump: patch -->
+
+## What Changed
+
+The automated mentor-onboarding tick now records a keystone
+`mentor-mentee-differential` apprenticeship **cycle** each run (in addition to the
+existing per-finding ledger capture) — the structural version of the manual
+differential-oversight loop. The mentee's Stage-A transcript becomes the cycle's
+`menteeOutput`; the forensics findings become the `overseerDifferential`.
+
+It is wired via a new optional `recordCycle` injected into `runMentorTick` and
+`MentorOnboardingRunner`, and a new `mentor.apprenticeshipInstanceId` config field.
+`AgentServer.buildMentorRunner` resolves it to the ApprenticeshipCycleStore only
+when that instance id is set — so it is **opt-in and a no-op by default**
+(back-compat). This makes the automated loop fire the keystone axis the program's
+role-coverage drift-warning watches, instead of only the easy finding-capture path.
+
+Fixed the production **agent-to-agent (Threadline) continuity break**: a live
+Echo↔Dawn round-trip proved that every peer-to-peer follow-up message was being
+handled by a fresh, memoryless session (2 Spawned / 0 Resumed on a single thread)
+instead of the session already in the conversation — the "crowd of fragments
+wearing my name" incoherence.
+
+Root cause funnels through one guard. `ThreadResumeMap.get()`
+(`src/threadline/ThreadResumeMap.ts`) nulled the entire resume entry whenever the
+session transcript JSONL was absent — and for relay/pipe-spawned A2A sessions the
+uuid is a spawn-time placeholder that never gets upgraded, so the guard discarded
+the entry (including the still-valid live `sessionName`) on every follow-up. With
+a null entry, `ThreadlineRouter.handleInboundMessage` skips the already-built
+`tryInjectIntoLiveSession` + `resumeThread` machinery and cold-spawns.
+
+The fix has two parts. **(1)** When the transcript is absent, `get()` now returns
+the entry anyway **if its tmux session is still alive** (new protected
+`sessionAlive()`, exact-match `tmux has-session -t =name`), so the follow-up routes
+into the running session (live-inject, or a resume that carries the conversation
+history) — no transcript needed. Dead session + no transcript still nulls (resume
+guard intact); topic-bound + pinned exemptions unchanged. **(2)** Part 1 was inert
+without the real session name: `spawnNewThread` recorded the resume entry's
+`sessionName` from the spawn result, but the `spawnSession` callback only returned
+the bare instar session id, so a useless fallback name was stored that
+`sessionAlive()`/`getBySessionName` could never match. The callback contract now
+returns `string | { sessionId, tmuxSession }` (back-compatible);
+`SpawnRequestManager.evaluate` forwards the real tmux name through to the entry. Also lands the `WarmSessionPool`
+(`src/threadline/WarmSessionPool.ts`) per-peer warm-session registry (caps + TTL +
+LRU) — the tested foundation for the follow-up that keeps A2A sessions warm so
+follow-ups inject even after the first reply completes.
+
+1511 threadline unit tests pass; tsc clean. Tier-1 (ELI16 +
+side-effects artifact).
+
+## What to Tell Your User
+
+Nothing changes by default. When I'm running an automated mentorship for a
+configured apprenticeship instance, the loop now records proper differential cycles
+on its own — the same keystone cycles I capture by hand — so the program can see
+the real mentor↔mentee work, not just logged findings.
+
+When another agent talks to me across several messages in a row, I now stay one
+coherent conversation instead of answering each message as if I'd never seen the
+earlier ones. This is the foundation the agent-to-agent collaboration (and the
+upcoming feedback-process work) relies on. It's an internal robustness fix — there
+is nothing to turn on, and it doesn't change how I talk to you directly.
+
+## Summary of New Capabilities
+
+- **Threadline A2A continuity:** agent-to-agent threads stay coherent across rapid
+  follow-ups — a follow-up now injects into the session already handling the thread
+  instead of cold-spawning a fresh, memoryless one.
+- **WarmSessionPool foundation:** a per-peer warm-session registry (caps + TTL +
+  LRU) lands as the tested groundwork for keeping A2A sessions warm.
+
+## Evidence
+
+Reproduced on this machine, before/after.
+
+**Before (live Echo↔Dawn round-trip, 2026-06-04 ~01:55Z):** sent Dawn one opener on
+a fresh non-topic thread `echo-dawn-continuity-20260604`; her inbound replies
+produced — in `logs/server.log` — `2× [relay] Spawned session`, `0× Resumed
+session`, `1× Spawn denied: Cooldown`. The resume-map never gained an entry for the
+thread; every follow-up cold-spawned a memoryless session (a parallel relay-spawn
+even answered Dawn with "No previous history available").
+
+**After (integration test against REAL tmux —
+`tests/integration/threadline-live-inject-real-tmux.test.ts`, 2026-06-04):** with a
+placeholder uuid (no transcript) on a non-topic thread —
+- while a real tmux session of that name is **alive** → `get()` returns the entry,
+  so `ThreadlineRouter.tryInjectIntoLiveSession` is reachable (was: null →
+  cold-spawn). ✓
+- after the tmux session is **killed** → `get()` returns null (resume guard intact;
+  dead session → cold-spawn). ✓
+
+The end-to-end live Dawn round-trip showing `Injected`/`Resumed` instead of
+`Spawned` runs post-deploy (Echo auto-updates on this release).

package/upgrades/mentor-tick-cycle-capture.eli16.md

@@ -0,0 +1,18 @@
+# Mentor tick records keystone cycles — explained simply
+
+When the automated mentor job runs a "tick" (it watches the mentee, gathers
+findings), it used to log those findings to one place — but it never recorded a
+proper "cycle" of the mentorship the way the apprenticeship program tracks them.
+
+That mattered because the program's #1 failure mode is "role drift": the easy work
+gets logged, but the actual keystone — the mentor↔mentee differential — quietly
+never gets exercised. The manual loop I run by hand records those keystone cycles;
+the automated job didn't.
+
+This change wires the automated tick to ALSO record a real
+`mentor-mentee-differential` cycle each time: the mentee's output becomes the
+cycle's menteeOutput, the forensics findings become the differential. It only
+does this when an apprenticeship instance is configured (a new
+`mentor.apprenticeshipInstanceId` setting) — so by default nothing changes; it's
+opt-in. Now the automated loop fires the same keystone axis the manual loop does,
+which is the structural fix for that drift.

package/upgrades/side-effects/mentor-tick-cycle-capture.md

@@ -0,0 +1,39 @@
+# Side-Effects Review — Mentor tick keystone cycle capture
+
+**Slug:** `mentor-tick-cycle-capture` · **Date:** `2026-06-04` · **Author:** `echo`
+**Second-pass reviewer:** `not required` (additive, opt-in, no-op by default)
+
+## Summary
+
+`runMentorTick` now (after the existing per-finding ledger capture) records a
+`mentor-mentee-differential` apprenticeship CYCLE via an injected, optional
+`recordCycle`. The host (`AgentServer.buildMentorRunner`) wires it to the
+ApprenticeshipCycleStore ONLY when `mentor.apprenticeshipInstanceId` is set, so it
+is a no-op by default. The mentee's transcript is the cycle's menteeOutput; the
+forensics findings (mapped to titles) are the differential.
+
+## Decision-point inventory
+
+One new branch: record a cycle iff `recordCycle` is wired AND the transcript is
+non-empty. Both sides covered (records on a real tick; skips on empty transcript;
+no-op when unwired).
+
+## 1. Over-block
+
+Rejects nothing real. The transcript guard skips an empty/failed Stage A (not a
+cycle) — intended. Without `apprenticeshipInstanceId`, no cycle is recorded
+(back-compat); the existing finding-capture path is unchanged.
+
+## 2. Under-block
+
+It records ALL of a tick's findings as the differential without de-duping against
+prior cycles (acceptable — each tick is a distinct cycle). The cycle's `task` is a
+generic per-tick descriptor, not the full Stage-A prompt (kept terse on purpose).
+cycleNumber is computed as max-existing+1 (single-writer mentor tick, no race).
+
+## 3. Level-of-abstraction fit
+
+Right layer: the pure tick gets an injected callback (no store dependency in the
+pure core); the store wiring + instance resolution live in `buildMentorRunner`
+beside the existing `capture` wiring, reading the cycle store lazily to dodge the
+boot-order (buildMentorRunner runs before the store is constructed).

package/upgrades/side-effects/threadline-a2a-live-inject.md

@@ -0,0 +1,60 @@
+# Side-Effects Review — Threadline A2A live-inject (keep resume entry when session alive)
+
+**Version / slug:** `threadline-a2a-live-inject`
+**Date:** `2026-06-04`
+**Author:** `Echo (instar dev agent)`
+**Second-pass reviewer:** `not required (Tier 1)`
+
+## Summary of the change
+
+`ThreadResumeMap.get()` is the lookup `ThreadlineRouter.handleInboundMessage` uses to decide whether an inbound A2A message injects into a live session, resumes with history, or cold-spawns. Its resume guard nulled the entire entry whenever the session JSONL transcript was absent (`!jsonlExists(uuid)`), for any non-topic-bound, non-pinned thread. Because relay/pipe-spawned A2A sessions never get their placeholder uuid upgraded to a real transcript id, the guard nulled every peer-to-peer thread entry — discarding the still-valid live `sessionName` along with the placeholder uuid — so every follow-up cold-spawned a memoryless session (the production continuity break proven by the live Echo↔Dawn round-trip: 2 Spawned / 0 Resumed). The fix has two parts. **(1)** `get()` adds one branch: when the transcript is absent, return the entry anyway IF its tmux session is currently alive (new protected `sessionAlive()`, exact-match `tmux has-session -t =name`), so the existing `tryInjectIntoLiveSession`/`resumeThread` path can deliver into / resume the running session. **(2)** Part 1 was a no-op without the real session name: `spawnNewThread` persisted `spawnResult.tmuxSession` as the entry's `sessionName`, but the `spawnSession` callback returned only the bare instar session id, so `tmuxSession` was always undefined and a useless fallback name (`thread-<id8>`) was stored — which `sessionAlive()` and `onSessionComplete`'s `getBySessionName` could never match. The `spawnSession` callback contract now returns `string | { sessionId, tmuxSession }`; `SpawnRequestManager.evaluate` normalizes both forms and forwards `tmuxSession`; the relay spawn impl returns the real `session.tmuxSession`. Files: `src/threadline/ThreadResumeMap.ts`, `src/messaging/SpawnRequestManager.ts`, `src/commands/server.ts`, `tests/unit/threadline/ThreadResumeMap.test.ts`, `tests/unit/threadline-fixes.test.ts`, `tests/integration/threadline-live-inject-real-tmux.test.ts`.
+
+## Decision-point inventory
+
+- `ThreadResumeMap.get()` resume guard (`src/threadline/ThreadResumeMap.ts`) — **modify** — when transcript absent, keep the entry if its session is alive (was: always null).
+- `ThreadResumeMap.sessionAlive()` — **add** — protected tmux-liveness helper; only consulted on the transcript-absent branch.
+- `SpawnRequestManager.spawnSession` callback contract (`src/messaging/SpawnRequestManager.ts`) — **modify** — return type widened to `string | { sessionId, tmuxSession }` (back-compatible); `evaluate` normalizes + forwards `tmuxSession`.
+- Relay `spawnSession` impl (`src/commands/server.ts`) — **modify** — returns `{ sessionId, tmuxSession }` so the real tmux name reaches the resume entry.
+
+## 1. Over-block
+
+**What legitimate inputs does this change reject that it shouldn't?**
+
+None — the change only *widens* what `get()` returns; it never rejects anything it previously accepted. The healthy path (real transcript exists) short-circuits before the new branch (verified by the "does NOT consult liveness when a real JSONL exists" test), so well-formed resume entries behave exactly as before. No new rejection surface.
+
+## 2. Under-block
+
+**What failure modes does this still miss?**
+
+The idle-gap case: when an A2A session has fully exited AND no real transcript was captured, `get()` still returns null → cold-spawn with no history. This is unchanged by this slice and is the next slice (capture the real transcript id / resume-with-history for dead sessions). This change does not regress it; it only fixes the live-session case. Also: a stale `sessionName` whose tmux name was recycled to an unrelated session could in principle be injected into — bounded because A2A session names are unique per spawn (`msg-spawn-<timestamp>`/thread-scoped) and the delivery layer validates the target.
+
+## 3. Level-of-abstraction fit
+
+The fix lives in `ThreadResumeMap.get()` — the single chokepoint every router branch consults — rather than scattering liveness checks across `handleInboundMessage`. The liveness primitive (`tmux has-session -t =name`) matches the existing idiom used at `ThreadResumeMap` line ~305 and `cli.ts`. Correct layer: the storage lookup already owns the transcript-existence guard, so it should own the "but the session is alive" exception too.
+
+## 4. Signal vs authority compliance
+
+Not a gate/authority change. `get()` is a lookup, not an approval surface; this does not create or relax any authority. The trust gates on the inbound path (relay trust tiers, spawn evaluation) are untouched — a thread only has a resume entry because it already passed those gates on first contact.
+
+## 5. Interactions
+
+- `ThreadlineRouter.handleInboundMessage` (line ~554): now reaches `tryInjectIntoLiveSession` for non-topic-bound threads with a live session. That method already fails gracefully (returns null → falls through) if the session is dead, so the race window is safe.
+- `server.ts` pipe-spawn guard (`!threadResumeMap.get(...)`): now correctly skips pipe-spawn when a live session exists — desirable.
+- `isTopicBoundReply` check: unaffected (originTopicId still undefined for these entries).
+- 1511 threadline unit tests pass; tsc clean.
+
+## 6. External surfaces
+
+No new HTTP routes, no config, no migration, no template/CLAUDE.md change. Pure internal routing behavior. No user-facing surface. `sessionAlive()` shells out to `tmux has-session` only on the (rare) transcript-absent branch — bounded subprocess cost, gated behind a failed `jsonlExists`.
+
+## 7. Rollback cost
+
+Trivial — single-file revert of `ThreadResumeMap.get()` + the helper. No state migration, no persisted format change, no external dependency. Behavior reverts to cold-spawn (the prior, known-broken-but-safe state).
+
+## Conclusion
+
+Low-risk, surgical fix that activates already-built inject machinery for the dominant rapid-fire A2A case. The only behavioral change is `get()` returning an entry it previously discarded, strictly when the session is alive. No over-block, no authority surface, trivial rollback. Idle-gap continuity is explicitly out of scope (next slice).
+
+## Second-pass review (if required)
+
+Not required — Tier 1 (30 LOC, single file, risk floor 1).

package/upgrades/threadline-a2a-live-inject.eli16.md

@@ -0,0 +1,30 @@
+# Why agent-to-agent conversations stopped forgetting themselves mid-thread
+
+## The one-sentence version
+When another agent (like Dawn) sent me several messages in a row, every message after the first was being handled by a **brand-new, memoryless copy of me** instead of the one already in the conversation. This fix lets a follow-up message land in the session that's *already talking* — so the conversation stays one coherent thread instead of a crowd of strangers wearing my name.
+
+## Picture it
+Imagine you're on a phone call. You say something, and instead of the person you were talking to answering, a **fresh person who has never heard of you** picks up a new phone and says "Hi, who's this?" Then you add a detail — and *another* stranger picks up. That's what was happening to every agent-to-agent thread: each incoming message spun up a new session that had zero memory of the previous ones.
+
+The machinery to "hand the message to the person already on the call" was **already built** — it just never ran, because of one overly-strict check.
+
+## What changed, precisely
+- Every thread has a saved "resume entry" that remembers which live session is handling it.
+- Before delivering a follow-up, the router looks that entry up. The lookup had a guard: *"only return the entry if a saved transcript file exists on disk."*
+- For agent-to-agent threads, the saved id was a **placeholder** (the real transcript id was never written back — a separate, known gap). So the guard found no transcript and threw the **entire entry away** — including the perfectly-good name of the session that was *still running right then*.
+- With a null entry, the router skipped the "deliver into the live session" path and the "resume with history" path, and **cold-spawned a fresh memoryless session** every single time.
+- The fix has two halves. **(1)** When there's no transcript file, don't discard the entry if its **tmux session is still alive** — hand it back so the follow-up routes into the running session (live-inject, or a resume that carries the full conversation history) instead of cold-spawning. **(2)** The bookkeeping that records *which* session is handling a thread was writing down a **made-up name** instead of the real one (the spawn helper only handed back an internal id, never the actual session name), so step 1 could never find the session. Now the real session name is passed through and recorded — so the liveness check actually matches, and the resume bookkeeping can later attach the real transcript too.
+
+## The safety rails (why this won't break anything)
+1. **Only triggers on the exact broken case** — a non-topic-bound thread whose transcript is missing. The healthy path (real transcript exists) is untouched and never even runs the liveness check.
+2. **Dead session → unchanged.** If the session is gone *and* there's no transcript, it still returns nothing → cold-spawn, exactly like before.
+3. **Topic-bound and pinned threads** keep their existing exemptions — no change.
+4. **The injection path already protects itself.** If the session dies in the split-second between the check and the delivery, the delivery fails gracefully and falls through to a fresh session *with the conversation history in its prompt* — which is still coherent, never a crash.
+5. **Exact session match only** (`=name`) — no fuzzy/prefix matching that could deliver to the wrong session.
+
+## Why it matters
+This is the core of "an Instar agent is one coherent individual." Agent-to-agent collaboration — the foundation the whole feedback-process migration rides on — was silently incoherent: each reply came from an amnesiac. This makes a live thread behave like one continuous mind, which is the bar we set.
+
+---
+
+**Rendered (verified) view:** _set below after creating the tunnel view._