@agfpd/iapeer 0.4.129 → 0.4.130

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

@@ -203,7 +203,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.130",
   "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/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 {