@agfpd/iapeer 0.4.129 → 0.4.131

package/docs/12-cli-reference.md

@@ -47,7 +47,7 @@ The full list of `iapeer <command>`. General rules: `--help` / `-h` anywhere in
 | `refresh <peer> [runtime] \| --all` | A lazy "soft restart": an agent peer comes up fresh (re-reads the doctrine/fragments from disk) on its NEXT natural wake. Doesn't kill a live session, doesn't wake the rest, doesn't do an immediate restart — only sets a marker. Routers (notifier/telegram) and absent runtimes are skipped (they have no doctrine). `--all` — all peers. |
 | `remove <peer> [--force]` | Delete the registry entry (doesn't touch the peer's folder). Refuses a live peer without `--force`. Idempotent. |
 | `attach <peer> [runtime]` | Bring up (if asleep), resume the conversation, open the session under the supervisor in the terminal (detach — `Ctrl-]`). |
-| `interrupt <peer> [runtime]` | Interrupt the current turn (Escape), context intact. |
+| `interrupt <peer> [runtime]` | Interrupt the current turn (Escape / abort), context intact. **Without a runtime: EVERY live runtime of the peer, in parallel** (operator stop = the peer stops); with a runtime: that endpoint only. |
 | `compact <peer> [runtime]` | Compact the conversation; a sleeper is resumed first after idle sleep. |
 | `add-runtime <runtime> (--peer <p> \| --all)` | Add a runtime to existing peers. Doesn't touch `default_runtime`. An infrastructure runtime attaches an always-on channel and is `--peer`-only (never an `--all` sweep). |
 | `default-runtime <runtime> (--peer <p> \| --all)` | Switch the primary runtime (routing / first bring-up). Refuses if the runtime isn't declared. |

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
 
@@ -203,7 +208,7 @@ What the headline states look like on the stream: a peer **waking** is `ev=wake`
 | `start` | clear the stop flag (warm peers become wakeable; no session is launched) / bootstrap always-on | `200` / `502` mirror of `stop` |
 | `new` | **unconditional** fresh restart (the emergency lever) | `200` + `action:"fresh"` |
 | `refresh` | lazy soft-reload: fresh on next natural wake, no kill | `200` + `outcomes[]` |
-| `interrupt` | interrupt a stuck/raving turn (Escape into the live session) | `200` / `502` |
+| `interrupt` | interrupt the current turn. **No `runtime` in the body → every live runtime of the peer, in parallel** (response `controlledAll`, partial failures in `failed`); with `runtime` → that endpoint only. An operator `/stop` must send NO runtime | `200` / `502` |
 | `compact` | compact the resumable dialogue (honest failure when none) | `200` + `action:"compacted"` / `502` |
 
 `POST /fleet/v1/send` — deliver a message through the same routing path as the `send_to_peer` tool (wake-on-miss, queueing, delivery log — identical semantics):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.129",
+  "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/cli/index.ts

@@ -1716,7 +1716,7 @@ const VERBS: ReadonlyArray<{ sig: string; desc: string }> = [
     desc: 'switch/set the PRIMARY runtime of peer(s) (routing/wake default) — the fleet-switch lever; refuses an undeclared runtime; registry self-healed in the same command',
   },
   { sig: 'attach <peer> [runtime]', desc: 'ensure-live + resume, then attach to the pty session (Ctrl-] detaches)' },
-  { sig: 'interrupt <peer> [runtime]', desc: 'interrupt the current turn (Escape) — context intact' },
+  { sig: 'interrupt <peer> [runtime]', desc: 'interrupt the current turn (Escape) — context intact; no runtime = EVERY live runtime of the peer' },
   { sig: 'compact <peer> [runtime]', desc: 'compact the peer\'s dialogue (/compact); resumes clean-asleep first' },
   { sig: 'self-fresh', desc: '(agent self-call) mark /new eager-fresh + self-kill — the daemon relaunches fresh' },
   { sig: 'self-done', desc: '(agent self-call, ephemeral) silent finish: arm own quiet-reap, wake no one' },
@@ -2998,7 +2998,9 @@ export async function runCli(argv: string[], env: NodeJS.ProcessEnv = process.en
           errOut(`${verb}: ${r.error.message}\n`)
           return 1
         }
-        out(`${verb} → ${r.value.controlled.personality} (${r.value.controlled.runtime})\n`)
+        const rts = (r.value.controlledAll ?? [r.value.controlled]).map(c => c.runtime).join(', ')
+        out(`${verb} → ${r.value.controlled.personality} (${rts})\n`)
+        for (const f of r.value.failed ?? []) errOut(`${verb}: ${r.value.controlled.personality} (${f.runtime}) failed: ${f.error}\n`)
         return 0
       }
       case 'compact': {

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

package/src/transport/index.ts

@@ -1182,6 +1182,10 @@ export async function executeControlOnTarget(
 export interface ControlResult {
   ok: true
   controlled: { personality: string; runtime: string }
+  /** interrupt WITHOUT a runtime: every live endpoint it acted on (>= 1; `controlled` is the first). */
+  controlledAll?: Array<{ personality: string; runtime: string }>
+  /** interrupt WITHOUT a runtime: live endpoints whose interrupt FAILED (others still interrupted). */
+  failed?: Array<{ runtime: string; error: string }>
   command: string
   ts: string
 }
@@ -1217,6 +1221,7 @@ export async function routeControl(personality: string, runtime: string | undefi
     return err(`invalid personality "${personality}" — must match /^[a-z][a-z0-9-]{0,31}$/`)
   }
   if (runtime && !isRuntime(runtime)) return err(`invalid runtime "${runtime}"`)
+  if (command.name === 'interrupt' && !runtime) return interruptAllLive(personality, command)
   const target = resolveControlTarget(personality, runtime)
   if (!target.ok) return err(`cannot control "${personality}": ${target.error.message}`)
   const done = await executeControlOnTarget(target.value, command)
@@ -1229,6 +1234,48 @@ export async function routeControl(personality: string, runtime: string | undefi
   })
 }
 
+/**
+ * Operator STOP = the PEER stops, not one of its sessions (Artur 18.10: «Стоп должен работать на все
+ * рантаймы. Один пир может одновременно в нескольких рантаймах»). A runtime-less interrupt acts on
+ * EVERY live endpoint of the peer, in parallel (the whole stop lands within one control round-trip, not
+ * N of them). An explicit runtime stays exact (routeControl above). /compact and /new are NOT widened:
+ * they act on a dialogue's context, and a peer's dialogues are per-runtime by design.
+ * Zero live → the usual `peer offline: <p>`; all failed → error; partial → ok with `failed` listed.
+ */
+export async function interruptAllLive(
+  personality: string,
+  command: ControlCommand,
+  seam: { env?: NodeJS.ProcessEnv; live?: () => Array<{ personality: string; runtime: string }>; exec?: typeof executeControlOnTarget } = {},
+): Promise<Result<ControlResult>> {
+  const env = seam.env ?? process.env
+  const exec = seam.exec ?? executeControlOnTarget
+  const live = (seam.live?.() ?? listOnlinePeers(resolveSockDir(env), env)).filter(p => p.personality === personality)
+  if (live.length === 0) return err(`cannot control "${personality}": peer offline: ${personality}`)
+  const sockDir = resolveSockDir(env)
+  const results = await Promise.all(
+    live.map(async p => {
+      const target: DeliveryTarget = {
+        runtime: p.runtime,
+        personality: p.personality,
+        address: buildProcessAddress(p.runtime, p.personality),
+        socketPath: buildSocketPath(p.runtime, p.personality, sockDir),
+      }
+      return { runtime: p.runtime, r: await exec(target, command) }
+    }),
+  )
+  const done = results.filter(x => x.r.ok).map(x => ({ personality, runtime: x.runtime }))
+  const failed = results.flatMap(x => (x.r.ok ? [] : [{ runtime: x.runtime, error: x.r.error.message }]))
+  if (done.length === 0) return err(`interrupt failed on every live runtime of "${personality}": ${failed.map(f => `${f.runtime}: ${f.error}`).join('; ')}`)
+  return ok({
+    ok: true,
+    controlled: done[0]!,
+    controlledAll: done,
+    ...(failed.length ? { failed } : {}),
+    command: command.name,
+    ts: new Date().toISOString(),
+  })
+}
+
 // ─── Route + deliver orchestration (Ф1: no wake; miss → explicit offline) ────
 
 export interface SendToPeerInput {