tailii-host 0.1.1 → 0.3.0

package/dist/chat/subagentTailer.js

@@ -0,0 +1,704 @@
+// subagentTailer.ts
+// tailii (TS host) — サブエージェント進捗ツリー tail
+// Swift 版 SubagentTailer.swift の移植。
+// claude の `<sessionId>/subagents/agent-*.meta.json` と main/subagent transcript を監視し、
+// subagent_node（spawn/running → completed/error）を engine チャネルへ流す。
+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 { abortableSleep } from "../shared/sleep.js";
+import { extractToolActivities, TranscriptTailer } from "./transcriptTailer.js";
+/** サブエージェント meta/jsonl と親 transcript の tool_result を監視する。 */
+export class SubagentTailer {
+    pollIntervalMs;
+    tailIndefinitely;
+    orphanGraceMs;
+    orphanProbeIntervalMs;
+    probeOutputOpen;
+    jsonlPaths = new Map();
+    outputPaths = new Map();
+    constructor(options = {}) {
+        this.pollIntervalMs = options.pollIntervalMs ?? 50;
+        this.tailIndefinitely = options.tailIndefinitely ?? true;
+        this.orphanGraceMs = options.orphanGraceMs ?? 60_000;
+        this.orphanProbeIntervalMs = options.orphanProbeIntervalMs ?? 30_000;
+        this.probeOutputOpen = options.probeOutputOpen ?? defaultProbeOutputOpen;
+    }
+    /** 現在 tail 中の nodeId から transcript 実体を引く。 */
+    jsonlPath(nodeId) {
+        return this.jsonlPaths.get(nodeId) ?? null;
+    }
+    /** バックグラウンドコマンドの nodeId(taskId) から出力ファイルを引く。 */
+    outputPath(nodeId) {
+        return this.outputPaths.get(nodeId) ?? null;
+    }
+    async *streamProjectDir(projectDir, preferredSessionId, newerThanMs = null, signal) {
+        this.jsonlPaths.clear();
+        this.outputPaths.clear();
+        const start = Date.now();
+        let mainTranscript = null;
+        while (!signal?.aborted) {
+            mainTranscript = TranscriptTailer.resolveJsonl(projectDir, preferredSessionId, newerThanMs);
+            if (mainTranscript !== null)
+                break;
+            if (!this.tailIndefinitely)
+                return;
+            await abortableSleep(this.pollIntervalMs, signal);
+            if (!this.tailIndefinitely && Date.now() - start > this.pollIntervalMs)
+                return;
+        }
+        if (mainTranscript === null || signal?.aborted)
+            return;
+        yield* this.streamSession(mainTranscript, signal);
+    }
+    async *streamSession(mainTranscript, signal) {
+        const sessionId = path.basename(mainTranscript, ".jsonl");
+        const subagentsDir = path.join(path.dirname(mainTranscript), sessionId, "subagents");
+        const tracked = new Map();
+        const fileStates = new Map();
+        const ownerByToolUseId = new Map();
+        const resultByToolUseId = new Map();
+        const notificationByTaskId = new Map();
+        const bgCommandByTaskId = new Map();
+        const bgLastKeyByTaskId = new Map();
+        // 通知が握り潰された背景コマンドの孤児判定（taskId → 終了扱いにした ts）。
+        const bgOrphanTsByTaskId = new Map();
+        const bgFirstSeenMsByTaskId = new Map();
+        let lastOrphanProbeMs = 0;
+        let aggregateDirty = true;
+        while (!signal?.aborted) {
+            if (discoverMetaFiles(subagentsDir, tracked))
+                aggregateDirty = true;
+            for (const node of tracked.values()) {
+                if (node.jsonlPath !== null)
+                    this.jsonlPaths.set(node.nodeId, node.jsonlPath);
+            }
+            const transcriptOwners = transcriptFiles(mainTranscript, tracked);
+            for (const transcript of transcriptOwners) {
+                const read = readNewLines(transcript.path, fileStates);
+                const node = transcript.nodeId === null ? null : (tracked.get(transcript.nodeId) ?? null);
+                if (read.reset) {
+                    aggregateDirty = true;
+                    if (node !== null) {
+                        node.currentActivity = null;
+                        node.lastJsonlTimestampMs = null;
+                    }
+                }
+                if (node !== null)
+                    node.firstJsonlTimestampMs = read.state.firstTimestampMs;
+                if (read.lines.length > 0)
+                    aggregateDirty = true;
+                for (const line of read.lines) {
+                    const lineTs = timestampMs(line);
+                    if (read.state.firstTimestampMs === null && lineTs !== null) {
+                        read.state.firstTimestampMs = lineTs;
+                    }
+                    if (node !== null) {
+                        node.firstJsonlTimestampMs = read.state.firstTimestampMs;
+                        if (lineTs !== null)
+                            node.lastJsonlTimestampMs = lineTs;
+                    }
+                    for (const id of extractSpawnToolUseIds(line))
+                        read.state.ownerByToolUseId.set(id, transcript.owner);
+                    for (const spawn of extractBackgroundSpawns(line)) {
+                        read.state.bgSpawnByToolUseId.set(spawn.id, { label: spawn.label, ts: lineTs });
+                    }
+                    for (const hit of extractToolResults(line)) {
+                        read.state.resultByToolUseId.set(hit.id, {
+                            isError: hit.isError,
+                            ts: hit.ts,
+                            asyncLaunch: hit.asyncLaunch,
+                        });
+                        const launch = hit.backgroundLaunch;
+                        const spawn = read.state.bgSpawnByToolUseId.get(hit.id);
+                        if (launch !== null && spawn !== undefined) {
+                            read.state.bgCommandByTaskId.set(launch.taskId, {
+                                taskId: launch.taskId,
+                                toolUseId: hit.id,
+                                owner: transcript.owner,
+                                label: spawn.label,
+                                startTs: spawn.ts ?? hit.ts,
+                                outputPath: launch.outputPath,
+                            });
+                        }
+                        // TaskStop で停止されたタスクは task-notification を残さない。
+                        // 停止 ack を「静かな完了」として通知と同列に扱う。
+                        if (hit.stoppedTaskId !== null) {
+                            read.state.notificationByTaskId.set(hit.stoppedTaskId, {
+                                status: "completed",
+                                exitCode: null,
+                                ts: hit.ts ?? lineTs,
+                            });
+                        }
+                    }
+                    const notification = extractTaskNotification(line);
+                    if (notification !== null) {
+                        read.state.notificationByTaskId.set(notification.taskId, {
+                            status: notification.status,
+                            exitCode: notification.exitCode,
+                            ts: notification.ts ?? lineTs,
+                        });
+                    }
+                    if (node !== null) {
+                        const activity = latestActivitySummary(line);
+                        if (activity !== null)
+                            node.currentActivity = activity;
+                    }
+                }
+            }
+            if (aggregateDirty) {
+                ownerByToolUseId.clear();
+                resultByToolUseId.clear();
+                notificationByTaskId.clear();
+                bgCommandByTaskId.clear();
+                for (const transcript of transcriptOwners) {
+                    const state = fileStates.get(transcript.path);
+                    if (state === undefined)
+                        continue;
+                    for (const [id, owner] of state.ownerByToolUseId)
+                        ownerByToolUseId.set(id, owner);
+                    for (const [id, result] of state.resultByToolUseId)
+                        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)) {
+                            notificationByTaskId.set(id, notification);
+                        }
+                    }
+                    for (const [id, command] of state.bgCommandByTaskId)
+                        bgCommandByTaskId.set(id, command);
+                }
+                aggregateDirty = false;
+            }
+            for (const node of tracked.values()) {
+                const result = resultByToolUseId.get(node.meta.toolUseId) ?? null;
+                let status;
+                let ts;
+                if (result !== null && !result.asyncLaunch) {
+                    // 同期実行: 親 transcript の tool_result が終了信号。
+                    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);
+                    }
+                    else {
+                        status = "running";
+                        ts = node.firstJsonlTimestampMs ?? mtimeMs(node.metaPath);
+                    }
+                }
+                const parentNodeId = ownerByToolUseId.get(node.meta.toolUseId) ?? fallbackParent(node.meta.spawnDepth);
+                const messageNode = {
+                    nodeId: node.nodeId,
+                    toolUseId: node.meta.toolUseId,
+                    parentNodeId,
+                    agentType: node.meta.agentType,
+                    label: node.meta.description,
+                    depth: node.meta.spawnDepth,
+                    status,
+                    currentActivity: status === "running" ? node.currentActivity : null,
+                    ts,
+                };
+                const key = stableNodeKey(messageNode);
+                if (key === node.lastKey)
+                    continue;
+                node.lastKey = key;
+                yield { type: "subagent_node", v: PROTOCOL_V2, node: messageNode };
+            }
+            // 孤児判定: task-notification は起動元エージェントが先に終了すると届かないまま
+            // 消えることがある（完了信号の消失）。output ファイルを開いているプロセスが
+            // いなければ「終了済みなのに通知が来ない孤児」として完了へ落とす。
+            // 実行中のコマンドはシェルが output の fd を保持し続けるため誤爆しない。
+            const nowMs = Date.now();
+            if (nowMs - lastOrphanProbeMs >= this.orphanProbeIntervalMs) {
+                lastOrphanProbeMs = nowMs;
+                for (const command of bgCommandByTaskId.values()) {
+                    if (notificationByTaskId.has(command.taskId))
+                        continue;
+                    if (bgOrphanTsByTaskId.has(command.taskId))
+                        continue;
+                    if (command.outputPath === null)
+                        continue;
+                    let bornMs = bgFirstSeenMsByTaskId.get(command.taskId);
+                    if (bornMs === undefined) {
+                        bornMs = command.startTs ?? nowMs;
+                        bgFirstSeenMsByTaskId.set(command.taskId, bornMs);
+                    }
+                    if (nowMs - bornMs < this.orphanGraceMs)
+                        continue;
+                    const open = await this.probeOutputOpen(command.outputPath);
+                    if (open === false) {
+                        const endTs = mtimeMs(command.outputPath);
+                        bgOrphanTsByTaskId.set(command.taskId, endTs > 0 ? endTs : nowMs);
+                    }
+                }
+            }
+            for (const command of bgCommandByTaskId.values()) {
+                if (command.outputPath !== null)
+                    this.outputPaths.set(command.taskId, command.outputPath);
+                const notification = notificationByTaskId.get(command.taskId) ?? null;
+                // 遅配された本物の通知が届いたら exit code 込みでそちらを優先する。
+                const orphanTs = notification === null ? (bgOrphanTsByTaskId.get(command.taskId) ?? null) : null;
+                const failed = notification !== null
+                    && (notification.status !== "completed" || (notification.exitCode ?? 0) !== 0);
+                const status = notification !== null
+                    ? (failed ? "error" : "completed")
+                    : (orphanTs !== null ? "completed" : "running");
+                const ownerNode = tracked.get(command.owner) ?? null;
+                const messageNode = {
+                    nodeId: command.taskId,
+                    toolUseId: command.toolUseId,
+                    parentNodeId: command.owner,
+                    agentType: "Bash",
+                    label: command.label,
+                    depth: ownerNode === null ? 1 : ownerNode.meta.spawnDepth + 1,
+                    status,
+                    currentActivity: null,
+                    ts: notification?.ts ?? orphanTs ?? command.startTs ?? 0,
+                    kind: "command",
+                };
+                const key = stableNodeKey(messageNode);
+                if (key === bgLastKeyByTaskId.get(command.taskId))
+                    continue;
+                bgLastKeyByTaskId.set(command.taskId, key);
+                yield { type: "subagent_node", v: PROTOCOL_V2, node: messageNode };
+            }
+            if (!this.tailIndefinitely)
+                return;
+            await abortableSleep(this.pollIntervalMs, signal);
+        }
+    }
+}
+function discoverMetaFiles(dir, tracked) {
+    let files;
+    try {
+        files = fs.readdirSync(dir);
+    }
+    catch {
+        return false;
+    }
+    let changed = false;
+    for (const file of files.sort()) {
+        const match = /^agent-(.+)\.meta\.json$/.exec(file);
+        if (match === null)
+            continue;
+        const nodeId = match[1];
+        const existing = tracked.get(nodeId);
+        if (existing !== undefined) {
+            const jsonlPath = siblingJsonl(existing.metaPath);
+            if (existing.jsonlPath !== jsonlPath) {
+                existing.jsonlPath = jsonlPath;
+                changed = true;
+            }
+            continue;
+        }
+        const metaPath = path.join(dir, file);
+        const meta = readMeta(metaPath);
+        if (meta === null)
+            continue;
+        tracked.set(nodeId, {
+            nodeId,
+            meta,
+            metaPath,
+            jsonlPath: siblingJsonl(metaPath),
+            firstJsonlTimestampMs: null,
+            lastJsonlTimestampMs: null,
+            currentActivity: null,
+            lastKey: null,
+        });
+        changed = true;
+    }
+    return changed;
+}
+function readMeta(metaPath) {
+    try {
+        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"],
+            spawnDepth: parsed["spawnDepth"],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function siblingJsonl(metaPath) {
+    const jsonl = metaPath.replace(/\.meta\.json$/, ".jsonl");
+    return fs.existsSync(jsonl) ? jsonl : null;
+}
+function transcriptFiles(mainTranscript, tracked) {
+    const out = [
+        { path: mainTranscript, owner: "root", nodeId: null },
+    ];
+    for (const node of tracked.values()) {
+        if (node.jsonlPath !== null)
+            out.push({ path: node.jsonlPath, owner: node.nodeId, nodeId: node.nodeId });
+    }
+    return out;
+}
+function readNewLines(file, states) {
+    let stat;
+    try {
+        stat = fs.statSync(file);
+    }
+    catch {
+        const state = ensureFileState(file, states);
+        return { lines: [], reset: false, state };
+    }
+    const state = ensureFileState(file, states);
+    let reset = false;
+    if (stat.size < state.position) {
+        state.position = 0;
+        state.lineBuf = Buffer.alloc(0);
+        state.ownerByToolUseId.clear();
+        state.resultByToolUseId.clear();
+        state.notificationByTaskId.clear();
+        state.bgSpawnByToolUseId.clear();
+        state.bgCommandByTaskId.clear();
+        state.firstTimestampMs = null;
+        reset = true;
+    }
+    let fd;
+    try {
+        fd = fs.openSync(file, "r");
+    }
+    catch {
+        return { lines: [], reset, state };
+    }
+    const out = [];
+    const chunk = Buffer.alloc(4096);
+    try {
+        for (;;) {
+            const bytesRead = fs.readSync(fd, chunk, 0, chunk.length, state.position);
+            if (bytesRead === 0)
+                break;
+            state.position += bytesRead;
+            state.lineBuf = Buffer.concat([state.lineBuf, chunk.subarray(0, bytesRead)]);
+            let nl = state.lineBuf.indexOf(0x0a);
+            while (nl >= 0) {
+                const line = state.lineBuf.subarray(0, nl).toString("utf8").replaceAll("\r", "");
+                state.lineBuf = state.lineBuf.subarray(nl + 1);
+                if (line.length > 0)
+                    out.push(line);
+                nl = state.lineBuf.indexOf(0x0a);
+            }
+        }
+    }
+    catch {
+        return { lines: out, reset, state };
+    }
+    finally {
+        // Subagent tailing watches a changing set of files, so each tick opens only for
+        // the incremental read and closes immediately. Offsets and partial lines stay cached.
+        try {
+            fs.closeSync(fd);
+        }
+        catch {
+            // 二重 close 等は無視。
+        }
+    }
+    return { lines: out, reset, state };
+}
+function ensureFileState(file, states) {
+    let state = states.get(file);
+    if (state === undefined) {
+        state = {
+            position: 0,
+            lineBuf: Buffer.alloc(0),
+            ownerByToolUseId: new Map(),
+            resultByToolUseId: new Map(),
+            notificationByTaskId: new Map(),
+            bgSpawnByToolUseId: new Map(),
+            bgCommandByTaskId: new Map(),
+            firstTimestampMs: null,
+        };
+        states.set(file, state);
+    }
+    return state;
+}
+function extractSpawnToolUseIds(line) {
+    const content = messageContent(line);
+    if (!Array.isArray(content))
+        return [];
+    const ids = [];
+    for (const block of content) {
+        if (typeof block !== "object" || block === null)
+            continue;
+        const rec = block;
+        if (rec["type"] !== "tool_use")
+            continue;
+        // 実データでは Agent、brief のサンプル/旧名では Task。どちらも同じ spawn path として扱う。
+        if (rec["name"] !== "Task" && rec["name"] !== "Agent")
+            continue;
+        if (typeof rec["id"] === "string")
+            ids.push(rec["id"]);
+    }
+    return ids;
+}
+function extractToolResults(line) {
+    const content = messageContent(line);
+    const ts = timestampMs(line);
+    if (!Array.isArray(content))
+        return [];
+    const out = [];
+    for (const block of content) {
+        if (typeof block !== "object" || block === null)
+            continue;
+        const rec = block;
+        if (rec["type"] !== "tool_result")
+            continue;
+        if (typeof rec["tool_use_id"] !== "string")
+            continue;
+        const text = toolResultPlainText(rec["content"]);
+        const bgMatch = /Command running in background with ID: (\S+?)\.?(?:\s|$)/.exec(text);
+        const outputMatch = /Output is being written to: (\S+?)\.?(?:\s|$)/.exec(text);
+        const stopMatch = /Successfully stopped task: ([A-Za-z0-9_-]+)/.exec(text);
+        out.push({
+            id: rec["tool_use_id"],
+            isError: rec["is_error"] === true,
+            ts,
+            asyncLaunch: text.startsWith("Async agent launched successfully"),
+            backgroundLaunch: bgMatch === null
+                ? null
+                : { taskId: bgMatch[1], outputPath: outputMatch?.[1] ?? null },
+            stoppedTaskId: stopMatch?.[1] ?? null,
+        });
+    }
+    return out;
+}
+function toolResultPlainText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const block of content) {
+        if (typeof block !== "object" || block === null)
+            continue;
+        const rec = block;
+        if (rec["type"] === "text" && typeof rec["text"] === "string")
+            parts.push(rec["text"]);
+    }
+    return parts.join("\n");
+}
+/** Bash の run_in_background 起動（バックグラウンドコマンド）の tool_use を抽出する。 */
+function extractBackgroundSpawns(line) {
+    const content = messageContent(line);
+    if (!Array.isArray(content))
+        return [];
+    const out = [];
+    for (const block of content) {
+        if (typeof block !== "object" || block === null)
+            continue;
+        const rec = block;
+        if (rec["type"] !== "tool_use" || rec["name"] !== "Bash")
+            continue;
+        if (typeof rec["id"] !== "string")
+            continue;
+        const input = typeof rec["input"] === "object" && rec["input"] !== null
+            ? rec["input"]
+            : null;
+        if (input?.["run_in_background"] !== true)
+            continue;
+        const description = typeof input["description"] === "string" ? input["description"] : "";
+        const command = typeof input["command"] === "string" ? input["command"] : "";
+        const label = description.length > 0 ? description : truncateActivityLabel(command);
+        out.push({ id: rec["id"], label: label.length > 0 ? label : "background command" });
+    }
+    return out;
+}
+/**
+ * 親 transcript の `<task-notification>` 行（user メッセージの文字列 content）を解析する。
+ * バックグラウンドのエージェント/コマンド共通の完了信号で、task-id はエージェントの
+ * nodeId またはコマンドの taskId に一致する。
+ */
+function extractTaskNotification(line) {
+    const content = messageContent(line);
+    if (typeof content !== "string" || !content.includes("<task-notification>"))
+        return null;
+    const taskId = /<task-id>([^<]+)<\/task-id>/.exec(content)?.[1];
+    if (taskId === undefined)
+        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));
+    const latest = activities.at(-1);
+    return latest === undefined ? null : truncateActivityLabel(formatActivityLabel(latest));
+}
+function formatActivityLabel(activity) {
+    switch (activity.name) {
+        case "Bash":
+            return `Bash: ${activity.command ?? activity.description ?? stripActivityPrefix(activity.label, activity.name)}`;
+        case "Edit":
+        case "MultiEdit":
+            return `${activity.name} ${displayActivityTarget(activity)}`;
+        case "Write":
+        case "NotebookEdit":
+            return `${activity.name} ${displayActivityTarget(activity)}`;
+        case "Read":
+            return `Read ${displayActivityTarget(activity)}`;
+        case "TodoWrite":
+            return "Todo更新";
+        default: {
+            const detail = displayActivityTarget(activity);
+            return detail === activity.name ? activity.name : `${activity.name}: ${detail}`;
+        }
+    }
+}
+function displayActivityTarget(activity) {
+    if (activity.file !== undefined && activity.file.length > 0) {
+        const base = path.basename(activity.file);
+        return base.length > 0 ? base : activity.file;
+    }
+    return stripActivityPrefix(activity.label, activity.name);
+}
+function stripActivityPrefix(label, fallback) {
+    const stripped = label
+        .replace(/^(実行済み|編集済み|作成済み|既読|検索済み)\s*/, "")
+        .replace(/^Todoを更新しました$/, "Todo更新")
+        .trim();
+    return stripped.length > 0 ? stripped : fallback;
+}
+function truncateActivityLabel(label) {
+    const limit = 60;
+    return label.length <= limit ? label : `${label.slice(0, limit - 1)}…`;
+}
+function messageContent(line) {
+    try {
+        const obj = JSON.parse(line);
+        const message = obj["message"];
+        if (typeof message === "object" && message !== null) {
+            return message["content"];
+        }
+        return obj["content"];
+    }
+    catch {
+        return null;
+    }
+}
+function timestampMs(line) {
+    try {
+        const obj = JSON.parse(line);
+        if (typeof obj["timestamp"] !== "string")
+            return null;
+        const ms = Date.parse(obj["timestamp"]);
+        return Number.isFinite(ms) ? ms : null;
+    }
+    catch {
+        return null;
+    }
+}
+function mtimeMs(file) {
+    try {
+        return Math.floor(fs.statSync(file).mtimeMs);
+    }
+    catch {
+        return 0;
+    }
+}
+function fallbackParent(depth) {
+    return depth <= 1 ? "root" : null;
+}
+/**
+ * 背景コマンドの output ファイルを開いているプロセスの有無を調べる。
+ * ハーネスは背景シェルの stdout/stderr を output へ向けるため、コマンド（と子孫）が
+ * 生きている限り fd 保持者が存在する。true=生存 / false=誰も開いていない / null=判定不能。
+ */
+async function defaultProbeOutputOpen(filePath) {
+    const viaLsof = await probeViaLsof(filePath);
+    if (viaLsof !== null)
+        return viaLsof;
+    return probeViaProcFd(filePath);
+}
+function probeViaLsof(filePath) {
+    return new Promise((resolve) => {
+        execFile("lsof", ["-t", "--", filePath], { timeout: 10_000 }, (error, stdout) => {
+            if (error === null) {
+                resolve(stdout.trim().length > 0);
+                return;
+            }
+            // exit 1 = 開いているプロセスなし（ファイル消失も同じ扱いで孤児側に倒す）。
+            // lsof 不在・タイムアウト等は判定不能として running 維持（安全側）。
+            const code = error.code;
+            resolve(code === 1 ? false : null);
+        });
+    });
+}
+/** lsof が無い Linux 向けフォールバック。/proc/<pid>/fd を走査する。 */
+function probeViaProcFd(filePath) {
+    let target;
+    try {
+        target = fs.realpathSync(filePath);
+    }
+    catch {
+        return false;
+    }
+    let pids;
+    try {
+        pids = fs.readdirSync("/proc");
+    }
+    catch {
+        return null;
+    }
+    for (const pid of pids) {
+        if (!/^\d+$/.test(pid))
+            continue;
+        let fds;
+        try {
+            fds = fs.readdirSync(`/proc/${pid}/fd`);
+        }
+        catch {
+            continue;
+        }
+        for (const fd of fds) {
+            try {
+                if (fs.readlinkSync(`/proc/${pid}/fd/${fd}`) === target)
+                    return true;
+            }
+            catch {
+                // 走査中に消えた fd は無視。
+            }
+        }
+    }
+    return false;
+}
+function stableNodeKey(node) {
+    return JSON.stringify([
+        node.nodeId,
+        node.toolUseId,
+        node.parentNodeId ?? null,
+        node.agentType,
+        node.label,
+        node.depth,
+        node.status,
+        node.currentActivity ?? null,
+        node.ts,
+        node.kind ?? null,
+    ]);
+}
+//# sourceMappingURL=subagentTailer.js.map