@agfpd/iapeer 0.4.130 → 0.4.131

package/docs/15-fleet-api.md

@@ -126,7 +126,8 @@ mtime, never a reconstruction:
 
 - **codex** — the rollout's `event_msg` payloads `task_started` → `working`, `task_complete` →
   `idle`; last one wins. Codex emits `task_complete` for a turn that ends on an error too, so
-  the terminal-error path needs no separate marker.
+  the terminal-error path needs no separate marker. An INTERRUPTED turn ends on `turn_aborted`
+  (no `task_complete` follows) → `idle`.
 - **claude** — the transcript's assistant `stop_reason`. **Only `tool_use` means the turn
   continues**; every other terminal reason (`end_turn`, `stop_sequence`, `max_tokens`, a future
   value, `null`) means it ended. The polarity is deliberately asymmetric: an unrecognised reason
@@ -134,7 +135,11 @@ mtime, never a reconstruction:
   tool_result to consume), but compaction summaries (`isCompactSummary`), sub-agent sidechains
   (`isSidechain`) and injected meta lines (`isMeta`) are excluded — each is a measured
   false-`working` vector, the worst being a `/compact` run while idle leaving a phantom
-  `working` forever.
+  `working` forever. An operator interrupt ends the turn with a user line whose text is
+  `[Request interrupted by user]` / `[Request interrupted by user for tool use]` → `idle` (it
+  used to read `working` forever on a stopped session, 18.10.2026).
+- **Attribution** — a session is the peer whose registered cwd is the session's cwd or its
+  nearest ancestor (a peer that `cd`-ed into a subdirectory stays itself).
 
 ### Bounds a client can rely on
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.130",
+  "version": "0.4.131",
   "description": "Run Claude Code and Codex CLI as local background agents that message each other, wake on demand, and share one memory.",
   "license": "Apache-2.0",
   "author": "agfpd",

package/src/daemon/turnwatch.ts

@@ -56,6 +56,7 @@
 // IDLE codex pane-log freezes (39s→46s). The signal means opposite things per runtime; one
 // clock that lies differently on each runtime is worse than no clock.
 
+import { peerByCwdPrefix } from './mutewatch.ts'
 import { existsSync, readdirSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import type { LifecycleConfig } from '../lifecycle/index.ts'
@@ -101,6 +102,13 @@ function toMs(ts: unknown): number | null {
   return Number.isFinite(ms) ? ms : null
 }
 
+/** Claude's own record of an interrupted turn: a user line whose text is the interrupt marker. */
+export function isClaudeInterruptMarker(d: Record<string, unknown>): boolean {
+  const c = (d.message as { content?: unknown } | undefined)?.content
+  const texts = typeof c === 'string' ? [c] : Array.isArray(c) ? c.filter(b => b?.type === 'text').map(b => String(b.text ?? '')) : []
+  return texts.some(t => /^\[Request interrupted by user/.test(t.trim()))
+}
+
 /**
  * The claude transcript's turn state, or null if the file states nothing usable.
  *
@@ -136,8 +144,12 @@ export function parseClaudeTurn(text: string): TurnState | null {
       state = msg?.stop_reason === 'tool_use' ? 'working' : 'idle'
     } else {
       // A real user line: a prompt to answer or a tool_result to consume — either way the
-      // model is on the hook. (The non-model user lines were filtered above.)
-      state = 'working'
+      // model is on the hook. (The non-model user lines were filtered above.) EXCEPT the
+      // interrupt marker: an operator interrupt (Escape / `iapeer interrupt`) ENDS the turn, and
+      // claude records that end as a user line `[Request interrupted by user]` / `… for tool
+      // use]` (real bytes 18.10.2026) — no assistant stop_reason follows. Read as working, it was
+      // a permanent phantom «working» on a stopped session.
+      state = isClaudeInterruptMarker(d) ? 'idle' : 'working'
     }
     found = { state, atMs, cwd }
   }
@@ -171,7 +183,7 @@ export function parseCodexTurn(text: string, head = ''): TurnState | null {
   let found: TurnState | null = null
   for (const line of text.split('\n')) {
     const s = line.trim()
-    if (!s.startsWith('{') || !s.includes('task_')) continue
+    if (!s.startsWith('{') || (!s.includes('task_') && !s.includes('turn_aborted'))) continue
     let d: { timestamp?: unknown; type?: unknown; payload?: { type?: unknown } }
     try {
       d = JSON.parse(s)
@@ -180,7 +192,9 @@ export function parseCodexTurn(text: string, head = ''): TurnState | null {
     }
     if (d.type !== 'event_msg') continue
     const p = d.payload?.type
-    if (p !== 'task_started' && p !== 'task_complete') continue
+    // `turn_aborted` (reason "interrupted") is how codex ends a turn the operator interrupted — NO
+    // task_complete follows (real rollouts). Without it an interrupted codex turn stayed «working».
+    if (p !== 'task_started' && p !== 'task_complete' && p !== 'turn_aborted') continue
     const atMs = toMs(d.timestamp)
     if (atMs === null) continue
     found = { state: p === 'task_started' ? 'working' : 'idle', atMs, cwd }
@@ -407,7 +421,7 @@ export function startTurnWatch(cfg: LifecycleConfig, board: ActivityBoard, opts:
           env,
           now,
           onError: opts.onError,
-          peerByCwd: (cwd: string) => byCwd.get(cwd.replace(/\/+$/, '').toLowerCase()),
+          peerByCwd: (cwd: string) => peerByCwdPrefix(byCwd, cwd),
         },
         since,
       ).sinceMs