tailii-host 0.4.0 → 0.6.0

package/dist/chat/subagentTailer.js

@@ -7,6 +7,7 @@ import { execFile } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { PROTOCOL_V2 } from "../protocol.js";
+import { injectedReminderBodies } from "../shared/harnessReminder.js";
 import { abortableSleep } from "../shared/sleep.js";
 import { extractToolActivities, TranscriptTailer } from "./transcriptTailer.js";
 /** サブエージェント meta/jsonl と親 transcript の tool_result を監視する。 */
@@ -15,7 +16,11 @@ export class SubagentTailer {
     tailIndefinitely;
     orphanGraceMs;
     orphanProbeIntervalMs;
+    agentOrphanGraceMs;
+    tentativeFinalGraceMs;
     probeOutputOpen;
+    probeSessionAlive;
+    sessionStaleMs;
     jsonlPaths = new Map();
     outputPaths = new Map();
     constructor(options = {}) {
@@ -23,7 +28,12 @@ export class SubagentTailer {
         this.tailIndefinitely = options.tailIndefinitely ?? true;
         this.orphanGraceMs = options.orphanGraceMs ?? 60_000;
         this.orphanProbeIntervalMs = options.orphanProbeIntervalMs ?? 30_000;
+        this.agentOrphanGraceMs = options.agentOrphanGraceMs ?? 120_000;
+        this.tentativeFinalGraceMs = Math.max(this.agentOrphanGraceMs, options.tentativeFinalGraceMs ?? 600_000);
         this.probeOutputOpen = options.probeOutputOpen ?? defaultProbeOutputOpen;
+        this.sessionStaleMs = options.sessionStaleMs ?? 6 * 60 * 60 * 1000;
+        this.probeSessionAlive = options.probeSessionAlive
+            ?? ((sessionId, lastActivityMs) => defaultProbeSessionAlive(sessionId, lastActivityMs, this.sessionStaleMs));
     }
     /** 現在 tail 中の nodeId から transcript 実体を引く。 */
     jsonlPath(nodeId) {
@@ -65,10 +75,25 @@ export class SubagentTailer {
         // 通知が握り潰された背景コマンドの孤児判定（taskId → 終了扱いにした ts）。
         const bgOrphanTsByTaskId = new Map();
         const bgFirstSeenMsByTaskId = new Map();
+        // 通知が配達されえない背景エージェントの孤児判定（nodeId → settle 扱いにした ts/status）。
+        const agentOrphanByNodeId = new Map();
+        // 死亡セッションの一括 sweep マーク。生存へ転じたら全破棄して回復できるよう、
+        // 通常の孤児 settle とは別に持つ。
+        const deadSweepByNodeId = new Map();
+        // セッション transcript 群の最終更新（生存プローブの補助情報）。
+        let lastActivityTsMs = null;
+        // セッション（claude プロセス）の生存。false のみが「死亡確定」。null は生存扱い（安全側）。
+        let sessionAlive = null;
+        let lastSessionProbeMs = 0;
         let lastOrphanProbeMs = 0;
         let aggregateDirty = true;
+        let lastMetaRefreshMs = 0;
         while (!signal?.aborted) {
-            if (discoverMetaFiles(subagentsDir, tracked))
+            // meta の stat/再読込は毎 tick やると重い（ノード数×50ms）。1秒ごとに間引く。
+            const refreshMetas = Date.now() - lastMetaRefreshMs >= 1_000;
+            if (refreshMetas)
+                lastMetaRefreshMs = Date.now();
+            if (discoverMetaFiles(subagentsDir, tracked, refreshMetas))
                 aggregateDirty = true;
             for (const node of tracked.values()) {
                 if (node.jsonlPath !== null)
@@ -83,6 +108,9 @@ export class SubagentTailer {
                     if (node !== null) {
                         node.currentActivity = null;
                         node.lastJsonlTimestampMs = null;
+                        node.finalReportMarker = null;
+                        node.finalDefinite = false;
+                        node.apiErrorMarker = false;
                     }
                 }
                 if (node !== null)
@@ -91,6 +119,9 @@ export class SubagentTailer {
                     aggregateDirty = true;
                 for (const line of read.lines) {
                     const lineTs = timestampMs(line);
+                    if (lineTs !== null && (lastActivityTsMs === null || lineTs > lastActivityTsMs)) {
+                        lastActivityTsMs = lineTs;
+                    }
                     if (read.state.firstTimestampMs === null && lineTs !== null) {
                         read.state.firstTimestampMs = lineTs;
                     }
@@ -129,18 +160,42 @@ export class SubagentTailer {
                                 status: "completed",
                                 exitCode: null,
                                 ts: hit.ts ?? lineTs,
+                                stopAck: true,
                             });
                         }
                     }
-                    const notification = extractTaskNotification(line);
-                    if (notification !== null) {
+                    for (const notification of extractTaskNotifications(line)) {
+                        // 同じ task-id の通知は enqueue ログと配達行（user / attachment / assistant 注入形）の
+                        // 複数行に現れ、再開→再停止で複数回起こる。ファイル横断の集約と同じく最新 ts の
+                        // 記録を採る（= 最後に起きた完了イベント）。TaskStop の ack は明示停止として常に優先。
+                        const existing = read.state.notificationByTaskId.get(notification.taskId);
+                        if (existing?.stopAck === true)
+                            continue;
+                        const ts = notification.ts ?? lineTs;
+                        if (existing !== undefined && (existing.ts ?? 0) > (ts ?? 0))
+                            continue;
+                        // enqueue（完了時点の正確な ts）を、同じ完了イベントの遅い配達 ts で前進させない。
+                        // 配達は停止境界までずれ込むため、その間の再開（自 transcript の追記）を「通知より
+                        // 古い」と誤認して running のエージェントを completed に塗ってしまう。再完了は新しい
+                        // enqueue が先に書かれるので latest-wins のまま拾える。
+                        if (existing !== undefined && existing.enqueue === true && !notification.enqueue
+                            && existing.status === notification.status && existing.exitCode === notification.exitCode) {
+                            continue;
+                        }
                         read.state.notificationByTaskId.set(notification.taskId, {
                             status: notification.status,
                             exitCode: notification.exitCode,
-                            ts: notification.ts ?? lineTs,
+                            ts,
+                            ...(notification.enqueue ? { enqueue: true } : {}),
                         });
                     }
                     if (node !== null) {
+                        const shape = messageShape(line);
+                        if (shape !== null) {
+                            node.finalReportMarker = shape.final;
+                            node.finalDefinite = shape.definite;
+                            node.apiErrorMarker = shape.apiError;
+                        }
                         const activity = latestActivitySummary(line);
                         if (activity !== null)
                             node.currentActivity = activity;
@@ -162,7 +217,17 @@ export class SubagentTailer {
                         resultByToolUseId.set(id, result);
                     for (const [id, notification] of state.notificationByTaskId) {
                         const existing = notificationByTaskId.get(id);
-                        if (existing === undefined || (notification.ts ?? 0) >= (existing.ts ?? 0)) {
+                        if (existing?.stopAck === true && notification.stopAck !== true)
+                            continue;
+                        // per-file と同じ規則: enqueue の正確な ts を、同じ完了イベントの遅い配達 ts で
+                        // 前進させない。
+                        if (existing?.enqueue === true && notification.enqueue !== true
+                            && notification.stopAck !== true
+                            && existing.status === notification.status && existing.exitCode === notification.exitCode) {
+                            continue;
+                        }
+                        if (existing === undefined || notification.stopAck === true
+                            || (notification.ts ?? 0) >= (existing.ts ?? 0)) {
                             notificationByTaskId.set(id, notification);
                         }
                     }
@@ -171,34 +236,218 @@ export class SubagentTailer {
                 }
                 aggregateDirty = false;
             }
-            for (const node of tracked.values()) {
-                const result = resultByToolUseId.get(node.meta.toolUseId) ?? null;
-                let status;
-                let ts;
+            const ownerOf = (node) => {
+                // meta の直接リンクを優先（forked-skill の子は transcript 相関では解決できない）。
+                const pid = node.meta.parentAgentId;
+                if (pid !== null && tracked.has(pid))
+                    return pid;
+                const correlated = node.meta.toolUseId === null
+                    ? undefined
+                    : ownerByToolUseId.get(node.meta.toolUseId);
+                // 深さ1は起動元が main（root）と確定できる（forked-skill 親もここに落ちる）。
+                return correlated ?? (node.meta.spawnDepth <= 1 ? "root" : undefined);
+            };
+            const resolveAgentStatus = (node) => {
+                const result = node.meta.toolUseId === null
+                    ? null
+                    : resultByToolUseId.get(node.meta.toolUseId) ?? null;
                 if (result !== null && !result.asyncLaunch) {
                     // 同期実行: 親 transcript の tool_result が終了信号。
-                    status = result.isError ? "error" : "completed";
-                    ts = result.ts ?? node.firstJsonlTimestampMs ?? mtimeMs(node.metaPath);
+                    return {
+                        status: result.isError ? "error" : "completed",
+                        ts: result.ts ?? node.firstJsonlTimestampMs ?? mtimeMs(node.metaPath),
+                    };
                 }
-                else {
-                    // バックグラウンド実行（または結果未着）: task-notification が終了信号。
-                    // 通知後に自分の transcript が伸びたら resume とみなし running へ戻す。
-                    const notification = notificationByTaskId.get(node.nodeId) ?? null;
-                    const resumedAfter = notification !== null && notification.ts !== null
-                        && (node.lastJsonlTimestampMs ?? 0) > notification.ts;
-                    if (notification !== null && !resumedAfter) {
-                        status = notification.status === "completed" ? "completed" : "error";
-                        ts = notification.ts ?? node.lastJsonlTimestampMs ?? mtimeMs(node.metaPath);
+                // バックグラウンド実行（または結果未着）: task-notification が終了信号。
+                // 通知後に自分の transcript が伸びたら resume とみなし running へ戻す
+                // （再通知か、通知済み継続の settle（下記 notifiedContinuation）で再び終端する）。
+                const notification = notificationByTaskId.get(node.nodeId) ?? null;
+                const resumedAfter = notification !== null && notification.ts !== null
+                    && (node.lastJsonlTimestampMs ?? 0) > notification.ts;
+                if (notification !== null && !resumedAfter) {
+                    return {
+                        status: notification.status === "completed" ? "completed" : "error",
+                        ts: notification.ts ?? node.lastJsonlTimestampMs ?? mtimeMs(node.metaPath),
+                    };
+                }
+                // ユーザー停止済み（TaskStop 等）。通知は残らないため meta の刻印が終了信号。
+                if (node.meta.stoppedByUser) {
+                    return { status: "completed", ts: node.lastJsonlTimestampMs ?? mtimeMs(node.metaPath) };
+                }
+                // 通知が配達されえず孤児 settle 済みなら終端。settle 後に transcript が
+                // 伸びたら resume とみなしマークを破棄して running へ戻す（孤児検知で再評価される）。
+                const orphan = agentOrphanByNodeId.get(node.nodeId);
+                if (orphan !== undefined) {
+                    if ((node.lastJsonlTimestampMs ?? 0) > orphan.ts) {
+                        agentOrphanByNodeId.delete(node.nodeId);
+                    }
+                    else {
+                        return { status: orphan.status, ts: orphan.ts };
+                    }
+                }
+                // 死亡セッションの sweep マーク。transcript が伸びたら破棄（誤判定からの回復）。
+                const sweep = deadSweepByNodeId.get(node.nodeId);
+                if (sweep !== undefined) {
+                    if ((node.lastJsonlTimestampMs ?? 0) > sweep.ts) {
+                        deadSweepByNodeId.delete(node.nodeId);
                     }
                     else {
-                        status = "running";
-                        ts = node.firstJsonlTimestampMs ?? mtimeMs(node.metaPath);
+                        return { status: sweep.status, ts: sweep.ts };
                     }
                 }
-                const parentNodeId = ownerByToolUseId.get(node.meta.toolUseId) ?? fallbackParent(node.meta.spawnDepth);
+                return { status: "running", ts: node.firstJsonlTimestampMs ?? mtimeMs(node.metaPath) };
+            };
+            const nowMs = Date.now();
+            if (nowMs - lastSessionProbeMs >= this.orphanProbeIntervalMs) {
+                lastSessionProbeMs = nowMs;
+                sessionAlive = await this.probeSessionAlive(sessionId, lastActivityTsMs);
+            }
+            // 孤児判定（エージェント）: 背景エージェントの task-notification は「起動元の transcript に、
+            // 起動元が次に動くとき」に投函されるため、起動元が子より先に終端した・セッションが死んだ等で
+            // 配達が途絶えると二度と届かない。判定はセッション生存で二分する:
+            //
+            // [死亡確定 (sessionAlive === false)] このセッションの作業は何も動いていない。
+            //   静止時間が猶予を超えた running ノードを最終レポートの有無を問わず一括 settle する
+            //   （中断で tool_use のまま止まった木・同期起動の孤児もここで解消する）。
+            //
+            // [生存または不明] root（main）起動のノードは settle しない — 生きている main への
+            //   通知配達は途絶えないし、SendMessage 待機中の生存エージェントを「完了」に
+            //   してはならない。settle するのは「実信号（通知/同期結果/停止刻印/過去の settle）で
+            //   終端した起動元」に根ざした木だけ。条件:
+            //   - 背景起動（forked-skill、または async 起動 ack 済み）だが有効な完了信号がない
+            //   - 最後の message 行が「text のみの assistant」（最終レポート済み。再開注入の
+            //     user 行や生成途中の thinking 行でマーカーが倒れるため、再開直後の長考中・
+            //     長い最終レポートのストリーミング中は候補にならない）
+            //   - transcript が agentOrphanGraceMs 以上静止（transcript 時刻起点なので
+            //     tail 張り直し直後でも古い孤児は即 settle できる）
+            //   - 直下に running かつ非候補の子（エージェント/背景コマンド）がいない（fixpoint。
+            //     子の通知で再開されうるため）
+            //   - 起動元が終端済み、または「終端済みに根ざして承認された候補」（承認は終端
+            //     アンカーからの伝播のみ。候補同士の相互承認では settle しないので、壊れた
+            //     meta の循環参照でも誤 settle しない）
+            //   - 例外=「通知済み継続」: 完了通知が一度出た後に自 transcript が伸びたノードは、
+            //     起動元が root でも settle する。ハーネスは 1 回の走行につき最初の停止でしか
+            //     通知しないため、停止境界で自分の背景タスク通知（[SYSTEM NOTIFICATION]）を
+            //     受け取って続行した走行の 2 度目の停止には通知が来ない（実測: 通知後 3 分続行し
+            //     最終レポートで停止 → 20 時間「実行中」残留）。通知済み = 起動元へ完了が届いた
+            //     後なので、SendMessage 待機中の「未通知の生存エージェント」保護とは衝突しない。
+            //     coordinator 再開（SendMessage）なら再通知が数秒で届き、そちらの ts が優先される。
+            const agentStatusById = new Map();
+            for (const node of tracked.values())
+                agentStatusById.set(node.nodeId, resolveAgentStatus(node).status);
+            const lastActivityMs = (node) => node.lastJsonlTimestampMs ?? mtimeMs(node.jsonlPath ?? node.metaPath);
+            // 最終レポートの形で止まっていれば完了、API エラーで途絶えていれば error。
+            const settledStatus = (node) => node.finalReportMarker === true && !node.apiErrorMarker ? "completed" : "error";
+            if (sessionAlive === false) {
+                for (const node of tracked.values()) {
+                    if (agentStatusById.get(node.nodeId) !== "running")
+                        continue;
+                    if (deadSweepByNodeId.has(node.nodeId))
+                        continue;
+                    const lastTs = lastActivityMs(node);
+                    if (lastTs <= 0 || nowMs - lastTs < this.agentOrphanGraceMs)
+                        continue;
+                    // tool_use のまま止まっていれば中断(error)。
+                    deadSweepByNodeId.set(node.nodeId, { ts: lastTs, status: settledStatus(node) });
+                }
+            }
+            else {
+                // 生存（または不明）へ転じたら sweep 由来のマークは全破棄する。
+                // 死亡判定が誤りだった場合の回復経路（通常の孤児 settle は保持する）。
+                if (deadSweepByNodeId.size > 0)
+                    deadSweepByNodeId.clear();
+                const settleCandidates = new Set();
+                const notifiedContinuations = new Set();
+                for (const node of tracked.values()) {
+                    if (agentStatusById.get(node.nodeId) !== "running")
+                        continue;
+                    const result = node.meta.toolUseId === null
+                        ? null
+                        : resultByToolUseId.get(node.meta.toolUseId) ?? null;
+                    const backgroundLaunch = node.meta.toolUseId === null || (result !== null && result.asyncLaunch);
+                    if (!backgroundLaunch)
+                        continue;
+                    if (node.finalReportMarker !== true)
+                        continue;
+                    if (node.lastJsonlTimestampMs === null)
+                        continue;
+                    // stop_reason 無しの暫定的な最終行は「続きの tool_use を生成中」でもあり得るので長い猶予。
+                    const graceMs = node.finalDefinite ? this.agentOrphanGraceMs : this.tentativeFinalGraceMs;
+                    if (nowMs - node.lastJsonlTimestampMs < graceMs)
+                        continue;
+                    settleCandidates.add(node.nodeId);
+                    const notification = notificationByTaskId.get(node.nodeId) ?? null;
+                    if (notification !== null && notification.ts !== null && node.lastJsonlTimestampMs > notification.ts) {
+                        notifiedContinuations.add(node.nodeId);
+                    }
+                }
+                for (;;) {
+                    const blockedOwners = new Set();
+                    for (const node of tracked.values()) {
+                        if (agentStatusById.get(node.nodeId) !== "running")
+                            continue;
+                        if (settleCandidates.has(node.nodeId))
+                            continue;
+                        const owner = ownerOf(node);
+                        if (owner !== undefined)
+                            blockedOwners.add(owner);
+                    }
+                    for (const command of bgCommandByTaskId.values()) {
+                        if (notificationByTaskId.has(command.taskId) || bgOrphanTsByTaskId.has(command.taskId))
+                            continue;
+                        blockedOwners.add(command.owner);
+                    }
+                    let changed = false;
+                    for (const id of settleCandidates) {
+                        if (!blockedOwners.has(id))
+                            continue;
+                        settleCandidates.delete(id);
+                        changed = true;
+                    }
+                    if (!changed)
+                        break;
+                }
+                const approved = new Set();
+                for (;;) {
+                    let changed = false;
+                    for (const id of settleCandidates) {
+                        if (approved.has(id))
+                            continue;
+                        const node = tracked.get(id);
+                        if (node === undefined)
+                            continue;
+                        // 通知済み継続は起動元を問わず承認（起動元へは完了が届いている）。
+                        if (notifiedContinuations.has(id)) {
+                            approved.add(id);
+                            changed = true;
+                            continue;
+                        }
+                        const ownerId = ownerOf(node);
+                        if (ownerId === undefined || ownerId === "root")
+                            continue;
+                        const ownerStatus = agentStatusById.get(ownerId);
+                        if (ownerStatus !== "completed" && ownerStatus !== "error" && !approved.has(ownerId))
+                            continue;
+                        approved.add(id);
+                        changed = true;
+                    }
+                    if (!changed)
+                        break;
+                }
+                for (const id of approved) {
+                    const node = tracked.get(id);
+                    if (node === undefined)
+                        continue;
+                    agentOrphanByNodeId.set(id, { ts: lastActivityMs(node), status: settledStatus(node) });
+                }
+            }
+            for (const node of tracked.values()) {
+                const { status, ts } = resolveAgentStatus(node);
+                const parentNodeId = ownerOf(node) ?? fallbackParent(node.meta.spawnDepth);
                 const messageNode = {
                     nodeId: node.nodeId,
-                    toolUseId: node.meta.toolUseId,
+                    // forked-skill エージェントに tool_use はない。ワイヤ上は必須 string のため空で送る。
+                    toolUseId: node.meta.toolUseId ?? "",
                     parentNodeId,
                     agentType: node.meta.agentType,
                     label: node.meta.description,
@@ -213,11 +462,10 @@ export class SubagentTailer {
                 node.lastKey = key;
                 yield { type: "subagent_node", v: PROTOCOL_V2, node: messageNode };
             }
-            // 孤児判定: task-notification は起動元エージェントが先に終了すると届かないまま
-            // 消えることがある（完了信号の消失）。output ファイルを開いているプロセスが
+            // 孤児判定（背景コマンド）: task-notification は起動元エージェントが先に終了すると
+            // 届かないまま消えることがある（完了信号の消失）。output ファイルを開いているプロセスが
             // いなければ「終了済みなのに通知が来ない孤児」として完了へ落とす。
             // 実行中のコマンドはシェルが output の fd を保持し続けるため誤爆しない。
-            const nowMs = Date.now();
             if (nowMs - lastOrphanProbeMs >= this.orphanProbeIntervalMs) {
                 lastOrphanProbeMs = nowMs;
                 for (const command of bgCommandByTaskId.values()) {
@@ -277,7 +525,7 @@ export class SubagentTailer {
         }
     }
 }
-function discoverMetaFiles(dir, tracked) {
+function discoverMetaFiles(dir, tracked, refreshMetas) {
     let files;
     try {
         files = fs.readdirSync(dir);
@@ -298,6 +546,18 @@ function discoverMetaFiles(dir, tracked) {
                 existing.jsonlPath = jsonlPath;
                 changed = true;
             }
+            // stoppedByUser は停止時に後から書き込まれるため、mtime 変化で meta を読み直す。
+            if (refreshMetas) {
+                const metaMtime = mtimeMs(existing.metaPath);
+                if (metaMtime !== existing.metaMtimeMs) {
+                    existing.metaMtimeMs = metaMtime;
+                    const meta = readMeta(existing.metaPath);
+                    if (meta !== null) {
+                        existing.meta = meta;
+                        changed = true;
+                    }
+                }
+            }
             continue;
         }
         const metaPath = path.join(dir, file);
@@ -308,9 +568,13 @@ function discoverMetaFiles(dir, tracked) {
             nodeId,
             meta,
             metaPath,
+            metaMtimeMs: mtimeMs(metaPath),
             jsonlPath: siblingJsonl(metaPath),
             firstJsonlTimestampMs: null,
             lastJsonlTimestampMs: null,
+            finalReportMarker: null,
+            finalDefinite: false,
+            apiErrorMarker: false,
             currentActivity: null,
             lastKey: null,
         });
@@ -323,15 +587,16 @@ function readMeta(metaPath) {
         const parsed = JSON.parse(fs.readFileSync(metaPath, "utf8"));
         if (typeof parsed["agentType"] !== "string" ||
             typeof parsed["description"] !== "string" ||
-            typeof parsed["toolUseId"] !== "string" ||
             typeof parsed["spawnDepth"] !== "number") {
             return null;
         }
         return {
             agentType: parsed["agentType"],
             description: parsed["description"],
-            toolUseId: parsed["toolUseId"],
+            toolUseId: typeof parsed["toolUseId"] === "string" ? parsed["toolUseId"] : null,
             spawnDepth: parsed["spawnDepth"],
+            parentAgentId: typeof parsed["parentAgentId"] === "string" ? parsed["parentAgentId"] : null,
+            stoppedByUser: parsed["stoppedByUser"] === true,
         };
     }
     catch {
@@ -524,26 +789,163 @@ function extractBackgroundSpawns(line) {
     return out;
 }
 /**
- * 親 transcript の `<task-notification>` 行（user メッセージの文字列 content）を解析する。
- * バックグラウンドのエージェント/コマンド共通の完了信号で、task-id はエージェントの
- * nodeId またはコマンドの taskId に一致する。
+ * `<task-notification>` ブロックを運ぶ行の本文と出所（enqueue = 完了時点の正確な ts を
+ * 持つ）を返す。配達形は 4 つ:
+ *   - user 行（文字列 content）: 起動元がターン境界で受け取った通知（ts ≈ 完了時刻）
+ *   - attachment(queued_command) 行: 起動元がターン中だったとき、次の tool_result 境界で
+ *     配達された通知（prompt に本文。user 行としては残らない。ts は enqueue 時刻）
+ *   - queue-operation 行（content）: ハーネスのキュー操作ログ。`enqueue` は完了時点で
+ *     配達より先に書かれる最速の信号。`remove` は配達後（実測で最大 268s 後）に書かれる
+ *     ログなので読まない — その ts を通知時刻に採ると、配達遅延の間に起きた再開
+ *     （SendMessage）を「通知より古い行」と誤認して completed に塗ってしまう。
+ *   - assistant 行の text ブロック末尾（`<system-reminder>` 包み。Claude Code 2.1.251〜の
+ *     停止境界注入）: 通知が user 行に残らない配達形。行頭形ブロックの中身だけを返す
+ *     （引用・fence 内には反応しない。ts は assistant 行 ≈ 配達時刻）。
  */
-function extractTaskNotification(line) {
-    const content = messageContent(line);
-    if (typeof content !== "string" || !content.includes("<task-notification>"))
+function notificationText(line) {
+    try {
+        const obj = JSON.parse(line);
+        if (obj["type"] === "attachment") {
+            const attachment = typeof obj["attachment"] === "object" && obj["attachment"] !== null
+                ? obj["attachment"]
+                : null;
+            if (attachment?.["type"] !== "queued_command")
+                return null;
+            return typeof attachment["prompt"] === "string" ? { text: attachment["prompt"], enqueue: false } : null;
+        }
+        if (obj["type"] === "queue-operation") {
+            if (obj["operation"] !== "enqueue")
+                return null;
+            return typeof obj["content"] === "string" ? { text: obj["content"], enqueue: true } : null;
+        }
+        const message = obj["message"];
+        if (typeof message === "object" && message !== null) {
+            const content = message["content"];
+            if (typeof content === "string")
+                return { text: content, enqueue: false };
+            // 停止境界の背景通知注入（Claude Code 2.1.251〜）: 通知が user 行に残らず、直前の
+            // assistant text ブロック末尾へ <system-reminder> として追記される。行頭形ブロックの
+            // 中身だけを通知本文として読む（表示側の除去と同じ門番なので、モデルが本文や fence
+            // 内で引用した <task-notification> には反応しない）。
+            if (obj["type"] === "assistant" && Array.isArray(content)) {
+                const joined = content
+                    .flatMap((block) => {
+                    if (typeof block !== "object" || block === null)
+                        return [];
+                    const rec = block;
+                    return rec["type"] === "text" && typeof rec["text"] === "string" ? [rec["text"]] : [];
+                })
+                    .join("\n");
+                if (!joined.includes("<task-notification>"))
+                    return null;
+                const bodies = injectedReminderBodies(joined);
+                return bodies.length > 0 ? { text: bodies.join("\n"), enqueue: false } : null;
+            }
+            return null;
+        }
+        return typeof obj["content"] === "string" ? { text: obj["content"], enqueue: false } : null;
+    }
+    catch {
         return null;
-    const taskId = /<task-id>([^<]+)<\/task-id>/.exec(content)?.[1];
-    if (taskId === undefined)
+    }
+}
+/**
+ * 行に含まれる `<task-notification>` を全て解析する（1 行に複数ブロックが束ねられる:
+ * 同時に終わった背景コマンド 2 件が 1 つの [SYSTEM NOTIFICATION] で届く等）。
+ * バックグラウンドのエージェント/コマンド共通の完了信号で、task-id はエージェントの
+ * nodeId またはコマンドの taskId に一致する。同じ封筒は完了以外にも使われる
+ * （Monitor の進捗 `<event>`、背景コマンドの「対話入力待ちらしい」ヒント）。それらは
+ * `<status>` を持たないので、`<status>` のないブロックは完了信号として扱わない。
+ */
+function extractTaskNotifications(line) {
+    const carried = notificationText(line);
+    if (carried === null || !carried.text.includes("<task-notification>"))
+        return [];
+    const content = carried.text;
+    const ts = timestampMs(line);
+    const out = [];
+    const blockPattern = /<task-notification>([\s\S]*?)(?:<\/task-notification>|$)/g;
+    for (const match of content.matchAll(blockPattern)) {
+        const block = match[1] ?? "";
+        const taskId = /<task-id>([^<]+)<\/task-id>/.exec(block)?.[1];
+        if (taskId === undefined)
+            continue;
+        const status = /<status>([^<]+)<\/status>/.exec(block)?.[1];
+        if (status === undefined)
+            continue;
+        const summary = /<summary>([^<]*)<\/summary>/.exec(block)?.[1] ?? "";
+        const exitCode = /exit code (\d+)/.exec(summary)?.[1];
+        out.push({
+            taskId,
+            status,
+            exitCode: exitCode === undefined ? null : Number(exitCode),
+            ts,
+            enqueue: carried.enqueue,
+        });
+    }
+    return out;
+}
+/** message の生成完了を示す stop_reason（これ以外は「続きがある」か「不明」）。 */
+const TERMINAL_STOP_REASONS = new Set(["end_turn", "stop_sequence", "max_tokens", "refusal"]);
+/** 続きのブロック/ターンが確定している stop_reason（text のみ行でも最終レポートではない）。 */
+const CONTINUING_STOP_REASONS = new Set(["tool_use", "pause_turn"]);
+/**
+ * message 行の「最終レポートらしさ」を返す:
+ *   final=true  = text のみの assistant 行（サブエージェントはこの形で停止する）
+ *   final=false = それ以外の message 行（user 行・tool_use を含む assistant 行・
+ *                 生成途中の thinking のみの assistant 行・stop_reason が「続きあり」の text 行）
+ *   null        = message を持たない行（summary 等。判定を変えない）
+ * final のまま transcript が静止していればエージェントは停止済み。再開注入
+ * （task-notification / SendMessage）は user 行として届き false へ倒れるため、
+ * 再開直後の長考中を「最終レポート済み」と誤認しない。
+ * claude は content ブロックを 1 行ずつ書く（実データ: サブエージェント側 assistant 2.4 万行中
+ * 複数ブロックは 1 行、main 側 4.0 万行中 0）。
+ * thinking ブロックの行は後続の text/tool_use をまだ生成中の印（最終行になるのは中断時だけ）
+ * なので final=false。text 行の stop_reason は:
+ *   - 終端（end_turn 等）→ definite（生成完了確定。確定形の猶予）
+ *   - tool_use / pause_turn → 続きの tool_use/ターンが確定 → final=false（message 途中の text 行を
+ *     main 側 writer はこの形で書く: main transcript で 3,685 行、サブエージェント側は 10 行。
+ *     99.9% が同一 message の tool_use 行に続かれ、最終行になった例は両側とも 0）
+ *   - null / 欠落 / 未知 → 暫定（サブエージェント側 writer は message 途中の text 行を null で
+ *     書く（無音の最長は実測 135s、>120s は 0.4%）。一方で null のまま書かれた最終レポートも
+ *     版を問わず 6〜30%（全体 11.7%）あり判別不能）→ 呼び出し側が長い猶予で扱う
+ */
+function messageShape(line) {
+    try {
+        const obj = JSON.parse(line);
+        const message = obj["message"];
+        if (typeof message !== "object" || message === null)
+            return null;
+        const rec = message;
+        const content = rec["content"];
+        if (content === undefined || content === null)
+            return null;
+        const notFinal = { final: false, definite: false, apiError: false };
+        if (rec["role"] !== "assistant")
+            return notFinal;
+        const apiError = obj["isApiErrorMessage"] === true;
+        const stopReason = typeof rec["stop_reason"] === "string" ? rec["stop_reason"] : null;
+        if (stopReason !== null && CONTINUING_STOP_REASONS.has(stopReason))
+            return notFinal;
+        const definite = stopReason !== null && TERMINAL_STOP_REASONS.has(stopReason);
+        if (typeof content === "string")
+            return { final: true, definite, apiError };
+        if (!Array.isArray(content))
+            return null;
+        const types = content.map((block) => typeof block === "object" && block !== null
+            ? block["type"]
+            : undefined);
+        if (types.includes("tool_use"))
+            return notFinal;
+        const thinkingOnly = types.length > 0
+            && types.every((type) => type === "thinking" || type === "redacted_thinking");
+        if (thinkingOnly)
+            return notFinal;
+        return { final: true, definite, apiError };
+    }
+    catch {
         return null;
-    const status = /<status>([^<]+)<\/status>/.exec(content)?.[1] ?? "completed";
-    const summary = /<summary>([^<]*)<\/summary>/.exec(content)?.[1] ?? "";
-    const exitCode = /exit code (\d+)/.exec(summary)?.[1];
-    return {
-        taskId,
-        status,
-        exitCode: exitCode === undefined ? null : Number(exitCode),
-        ts: timestampMs(line),
-    };
+    }
 }
 function latestActivitySummary(line) {
     const activities = extractToolActivities(messageContent(line));
@@ -649,6 +1051,48 @@ function probeViaLsof(filePath) {
         });
     });
 }
+const defaultProbeExec = (cmd, args, callback) => {
+    execFile(cmd, args, { timeout: 10_000 }, (error, stdout) => {
+        callback(error, stdout ?? "");
+    });
+};
+/**
+ * セッションの claude プロセス生存を判定する。
+ *   1) argv にセッション id を持つプロセスがいれば生存確定（Tailii が張る engine は
+ *      `--session-id`/`--resume` で id を運ぶ）。
+ *   2) argv 不一致でも bare CLI（argv に id なし）の可能性が残るため、transcript が
+ *      staleMs 以内に更新されていれば「不明」（生存扱い）。
+ *   3) argv 不一致 かつ transcript が staleMs 以上静止しているときだけ「死亡確定」。
+ *      生きているのに静かなだけのセッションを誤判定しても、transcript が伸びれば
+ *      sweep マークは破棄され running へ回復する。
+ * プロセス名の照合（`lsof -c claude` 等）は使わない — macOS では CLI の comm が
+ * バージョン文字列（例 "2.1.226"）になるなど環境・バージョンで壊れるため。
+ * プローブ不能（pgrep 不在・タイムアウト等）は常に「不明」= 生存扱いへ倒す。
+ */
+export async function defaultProbeSessionAlive(sessionId, lastActivityMs, staleMs, exec = defaultProbeExec) {
+    const byArgv = await probeArgvAlive(sessionId, exec);
+    if (byArgv === true)
+        return true;
+    if (byArgv === null)
+        return null;
+    if (lastActivityMs === null)
+        return null;
+    return Date.now() - lastActivityMs >= staleMs ? false : null;
+}
+/** argv にセッション id を持つプロセスの有無。true / false / null(判定不能)。 */
+function probeArgvAlive(sessionId, exec) {
+    return new Promise((resolve) => {
+        exec("pgrep", ["-f", sessionId], (error, stdout) => {
+            if (error === null) {
+                resolve(stdout.trim().length > 0);
+                return;
+            }
+            // exit 1 = 一致なし。それ以外（pgrep 不在・タイムアウト等）は判定不能。
+            const code = error.code;
+            resolve(code === 1 ? false : null);
+        });
+    });
+}
 /** lsof が無い Linux 向けフォールバック。/proc/<pid>/fd を走査する。 */
 function probeViaProcFd(filePath) {
     let target;