@agfpd/iapeer 0.4.128 → 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/docs/19-notices.md

@@ -336,7 +336,9 @@ nothing to spare). A sweep only opens files whose mtime moved since the last pas
 
 Attribution does not derive the path from `cwd`. It reads the cwd each file states **about
 itself** (claude: the `cwd` field on every line; codex: `session_meta.payload.cwd`) and matches
-it against the registry, case-insensitively. A file whose cwd belongs to no peer is ignored —
+it against the registry, case-insensitively — the peer whose cwd is that path or its NEAREST
+ancestor (a peer that `cd`-ed into a subdirectory stays itself, 18.10.2026; ancestors shallower
+than `/<a>/<b>/<c>` match only exactly). A file whose cwd belongs to no peer is ignored —
 a human's own session never notifies.
 
 The reason is that one rule must serve both runtimes: the claude slug is a naming convention we

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.128",
+  "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/daemon/mutewatch.ts

@@ -557,6 +557,28 @@ export function muteWatchTick(deps: MuteWatchDeps, sinceMs: number): { raised: n
   return { raised, sinceMs: startedMs }
 }
 
+/**
+ * personality ← a session's self-stated cwd: the peer whose registered cwd is that path OR its
+ * NEAREST ancestor. A session records the cwd it is IN at each line, and a peer that `cd`s into a
+ * subdirectory of its project (observed 18.10.2026: `…/oc-test-nemo/.iapeer`) would otherwise fall
+ * out of attribution — no notice, no limit-park. Longest prefix wins, so a peer nested inside
+ * another peer's tree is attributed to itself. Keys are normalized (trailing slash off, lowercase).
+ */
+export function peerByCwdPrefix(byCwd: Map<string, string>, cwd: string): string | undefined {
+  const exact = cwd.replace(/\/+$/, '').toLowerCase()
+  let p = exact
+  while (p) {
+    const hit = byCwd.get(p)
+    // An ANCESTOR hit counts only below /<a>/<b>/<c> depth: a peer whose cwd is $HOME (or shallower)
+    // must not swallow every session on the host — such a peer attributes by exact match only.
+    if (hit && (p === exact || p.split('/').length > 4)) return hit
+    const i = p.lastIndexOf('/')
+    if (i <= 0) return undefined
+    p = p.slice(0, i)
+  }
+  return undefined
+}
+
 export interface StartMuteWatchOptions {
   env?: NodeJS.ProcessEnv
   intervalMs?: number
@@ -604,7 +626,7 @@ export function startMuteWatch(cfg: LifecycleConfig, board: NoticeBoard, opts: S
         now,
         onError: opts.onError,
         onLimit: opts.onLimit,
-        peerByCwd: (cwd: string) => byCwd.get(cwd.replace(/\/+$/, '').toLowerCase()),
+        peerByCwd: (cwd: string) => peerByCwdPrefix(byCwd, cwd),
         opencodeJournals: () =>
           rows
             .filter(r => (r.runtimes ?? []).includes('opencode'))

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 {