@nocville/npc 0.0.0-stage → 0.2.0

package/dist/cjs/npcs/agent-common/hook-runner.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hookEventName = hookEventName;
+exports.readStdin = readStdin;
+exports.runAgentHook = runAgentHook;
+exports.runFlushCommand = runFlushCommand;
+exports.collectSessionGitStats = collectSessionGitStats;
+const node_fs_1 = require("node:fs");
+const activity_js_1 = require("./activity.js");
+const git_stats_js_1 = require("./git-stats.js");
+const liveness_js_1 = require("./liveness.js");
+const lock_js_1 = require("./lock.js");
+const session_js_1 = require("./session.js");
+const watchdog_js_1 = require("./watchdog.js");
+function hookEventName(event) {
+    return event.hook_event_name ?? event.event ?? '';
+}
+/** Read all of stdin synchronously; '' on error. */
+function readStdin() {
+    try {
+        return (0, node_fs_1.readFileSync)(0, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Process one hook invocation. Never throws. Only a configured neutral JSON response
+ * reaches stdout; other hosts receive no output.
+ */
+async function runAgentHook(spec, config, rawInput, opts = {}) {
+    try {
+        await runAgentHookUnsafe(spec, config, rawInput, opts);
+    }
+    catch (err) {
+        if (config.debug) {
+            console.error(`[nocville ${spec.adapter.command} hook] ${err?.message ?? err}`);
+        }
+    }
+    finally {
+        if (spec.stdoutOnSuccess !== undefined)
+            process.stdout.write(spec.stdoutOnSuccess + '\n');
+    }
+}
+async function runAgentHookUnsafe(spec, config, rawInput, opts) {
+    if (typeof rawInput === 'string' && !rawInput.trim())
+        return;
+    let event;
+    try {
+        event = typeof rawInput === 'string' ? JSON.parse(rawInput) : rawInput;
+    }
+    catch {
+        return;
+    }
+    if (!event || typeof event !== 'object')
+        return;
+    const sessionId = typeof event.session_id === 'string' ? event.session_id : '';
+    if (!sessionId)
+        return;
+    const { adapter } = spec;
+    const eventName = hookEventName(event);
+    // Leave headroom for launcher startup and the 1.5s HTTP attempt within Codex's 3s cap.
+    const shutdown = eventName === 'SessionEnd' || eventName === 'Interrupt';
+    const lockWaitMs = shutdown ? 150 : adapter.family === 'gemini' ? 500 : undefined;
+    const canResolvePid = adapter.processNames?.length !== 0 &&
+        !shutdown &&
+        opts.mode === 'detach' &&
+        process.env['NOCVILLE_NO_WATCHDOG'] !== '1';
+    const now = (opts.now ?? Date.now)();
+    if (eventName === 'SessionStart')
+        await (0, session_js_1.maybeCleanupSessionStates)(adapter.stateDir, now);
+    const { decision, offline, resolvePid, collectStats } = await (0, lock_js_1.withStateLock)((0, session_js_1.stateFilePath)(adapter.stateDir, sessionId), () => {
+        const prev = (0, session_js_1.readSessionState)(adapter.stateDir, sessionId);
+        if (prev && adapter.processNames?.length === 0 && (prev.agentPid || prev.watchdogPid)) {
+            // Retire observers installed before an adapter opted out of process liveness.
+            prev.agentPid = undefined;
+            prev.agentStartedAt = undefined;
+            prev.watchdogPid = undefined;
+            (0, session_js_1.writeSessionState)(adapter.stateDir, prev);
+        }
+        const identity = spec.deliveryIdentity?.(event);
+        const deliveries = (prev?.hookDeliveries ?? []).filter((d) => now - d.at < 5000);
+        if (identity) {
+            const duplicate = deliveries.findIndex((d) => d.key === identity.key && d.source !== identity.source);
+            if (duplicate >= 0 && prev) {
+                deliveries.splice(duplicate, 1);
+                prev.hookDeliveries = deliveries;
+                (0, session_js_1.writeSessionState)(adapter.stateDir, prev);
+                return {
+                    decision: { kind: 'none' },
+                    offline: !!prev.offline,
+                    resolvePid: false,
+                    collectStats: false,
+                };
+            }
+            deliveries.push({ ...identity, at: now });
+        }
+        const cwd = (typeof event.cwd === 'string' && event.cwd) || prev?.projectDir || process.cwd();
+        // An offline sentinel awaiting retry cannot be revived by late async tool hooks.
+        if (prev?.offline && eventName !== 'SessionStart')
+            return {
+                decision: { kind: 'now' },
+                offline: true,
+                resolvePid: false,
+                collectStats: false,
+            };
+        const agentId = typeof event['agent_id'] === 'string' ? event['agent_id'] : '';
+        if (adapter.family === 'claude' &&
+            agentId &&
+            prev &&
+            eventName !== 'PermissionRequest' &&
+            eventName !== 'SubagentStart') {
+            const next = (0, session_js_1.applySubagentEvent)(prev, agentId, typeof event['agent_type'] === 'string' ? event['agent_type'] : 'subagent', eventName, (0, activity_js_1.describeToolUse)(event.tool_name, event.tool_input, cwd), now);
+            let decision = { kind: 'none' };
+            if (next.rev !== prev.rev) {
+                const gap = opts.minPushGapMs ?? session_js_1.DEFAULT_MIN_PUSH_GAP_MS;
+                const elapsed = now - (prev.lastPushAt ?? 0);
+                if (!prev.lastPushAt || elapsed >= gap) {
+                    next.lastPushAt = now;
+                    decision = { kind: 'now' };
+                }
+                else if (!next.flushAt || next.flushAt <= now - 2000) {
+                    const delayMs = Math.max(50, gap - elapsed);
+                    next.flushAt = now + delayMs;
+                    decision = { kind: 'defer', delayMs };
+                }
+            }
+            const resolvePid = canResolvePid && (0, liveness_js_1.reserveAgentPidAttempt)(next, now);
+            (0, session_js_1.writeSessionState)(adapter.stateDir, next);
+            return { decision, offline: false, resolvePid, collectStats: false };
+        }
+        // Codex has no documented agent_id in hook payloads: keep its parent transitions.
+        // https://developers.openai.com/codex/hooks
+        const { next, decision } = (0, session_js_1.applyTransition)(prev, {
+            sessionId,
+            serviceId: spec.serviceIdFor(sessionId, cwd),
+            projectDir: cwd,
+            eventName,
+            name: spec.resolveName?.(event, prev),
+            transition: spec.transition(event, prev),
+            now,
+        }, opts.minPushGapMs ?? session_js_1.DEFAULT_MIN_PUSH_GAP_MS);
+        if (!prev || prev.offline) {
+            next.agentPid = undefined;
+            next.agentStartedAt = undefined;
+            next.agentPidResolveAttempts = 0;
+            next.agentPidLastResolveAt = undefined;
+            next.watchdogPid = undefined;
+            next.offlineRetryStartedAt = undefined;
+            next.offlineDeliveryStopped = undefined;
+            next.subagents = {};
+            next.agentStats = undefined;
+            next.statsPendingRev = undefined;
+        }
+        if (identity)
+            next.hookDeliveries = deliveries.slice(-64);
+        const resolvePid = canResolvePid && (0, liveness_js_1.reserveAgentPidAttempt)(next, now);
+        const collectStats = (spec.statsEvents ?? ['Stop']).includes(eventName) && !next.offline;
+        if (collectStats)
+            next.statsPendingRev = next.rev ?? 0;
+        else if (next.state === 'WORKING' || next.offline)
+            next.statsPendingRev = undefined;
+        (0, session_js_1.writeSessionState)(adapter.stateDir, next);
+        return { decision, offline: !!next.offline, resolvePid, collectStats };
+    }, lockWaitMs);
+    if (resolvePid && !offline) {
+        const proc = (0, liveness_js_1.resolveAgentPid)(adapter, sessionId);
+        await (0, lock_js_1.withStateLock)((0, session_js_1.stateFilePath)(adapter.stateDir, sessionId), () => {
+            const fresh = (0, session_js_1.readSessionState)(adapter.stateDir, sessionId);
+            if (!fresh || fresh.offline)
+                return;
+            fresh.agentPid = proc?.pid;
+            fresh.agentStartedAt = proc?.startedAt;
+            (0, session_js_1.writeSessionState)(adapter.stateDir, fresh);
+        }, lockWaitMs);
+    }
+    if (opts.mode === 'detach' && !offline)
+        await (0, watchdog_js_1.ensureWatchdog)(adapter, config, sessionId, opts.cliPath, lockWaitMs);
+    // SessionEnd is synchronous and bounded by the agent's short shutdown timeout.
+    if (offline) {
+        await (0, session_js_1.flushSession)(adapter, config, sessionId, {
+            push: opts.push,
+            timeoutMs: 1500,
+            lockWaitMs: 150,
+        });
+        // If delivery failed, the watchdog retries; unsupported hosts get one detached retry.
+        const pending = (0, session_js_1.readSessionState)(adapter.stateDir, sessionId);
+        if (opts.mode === 'detach' && pending && (pending.rev ?? 0) > (pending.pushedRev ?? 0))
+            (0, session_js_1.spawnDetachedFlush)(adapter, config, sessionId, 0, opts.cliPath);
+        return;
+    }
+    if (decision.kind === 'none' && !collectStats)
+        return;
+    const mode = opts.mode ?? 'inline';
+    const delayMs = decision.kind === 'defer' ? decision.delayMs : 0;
+    if (opts.scheduleFlush && decision.kind === 'defer') {
+        opts.scheduleFlush(sessionId, delayMs);
+        return;
+    }
+    if (mode === 'detach') {
+        (0, session_js_1.spawnDetachedFlush)(adapter, config, sessionId, delayMs, opts.cliPath, collectStats);
+        return;
+    }
+    if (delayMs > 0) {
+        const timer = setTimeout(() => {
+            void (0, session_js_1.flushSession)(adapter, config, sessionId, { push: opts.push });
+        }, delayMs);
+        timer.unref?.();
+        return;
+    }
+    await (0, session_js_1.flushSession)(adapter, config, sessionId, { push: opts.push });
+}
+/** `<agent> flush <session> --delay=ms`: the detached half of a hook push. */
+async function runFlushCommand(adapter, config, sessionId, delayMs, stats = false) {
+    if (!sessionId)
+        return;
+    try {
+        if (delayMs && delayMs > 0)
+            await (0, session_js_1.sleep)(Math.min(delayMs, 10_000));
+        if (stats || (0, session_js_1.readSessionState)(adapter.stateDir, sessionId)?.statsPendingRev !== undefined)
+            await collectSessionGitStats(adapter, sessionId);
+        await (0, session_js_1.flushSession)(adapter, config, sessionId);
+    }
+    catch {
+        // never surface errors from a background flush
+    }
+}
+/** Git runs outside the state lock, and a newer turn can invalidate its result. */
+async function collectSessionGitStats(adapter, sessionId, compute = git_stats_js_1.computeGitStats) {
+    const snapshot = (0, session_js_1.readSessionState)(adapter.stateDir, sessionId);
+    if (!snapshot || snapshot.offline || snapshot.state === 'WORKING')
+        return;
+    // Another scheduled flush may already have consumed an explicit --stats request.
+    if (snapshot.statsPendingRev === undefined)
+        return;
+    const revision = snapshot.statsPendingRev;
+    const stats = compute(snapshot.projectDir);
+    await (0, lock_js_1.withStateLock)((0, session_js_1.stateFilePath)(adapter.stateDir, sessionId), () => {
+        const fresh = (0, session_js_1.readSessionState)(adapter.stateDir, sessionId);
+        if (!fresh || fresh.offline || fresh.state === 'WORKING' || fresh.statsPendingRev !== revision)
+            return;
+        fresh.statsPendingRev = undefined;
+        fresh.agentStats = stats ?? undefined;
+        if (stats && stats.filesChanged > 0) {
+            const line = `Uncommitted changes — ${stats.filesChanged} file${stats.filesChanged === 1 ? '' : 's'}, +${stats.insertions}/−${stats.deletions}`;
+            fresh.activity = (0, session_js_1.pushHistory)(fresh.activity, line);
+        }
+        fresh.rev = (fresh.rev ?? 0) + 1;
+        (0, session_js_1.writeSessionState)(adapter.stateDir, fresh);
+    });
+}
+//# sourceMappingURL=hook-runner.js.map

package/dist/cjs/npcs/agent-common/hook-settings.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOOK_MARKER_COMMENT = exports.HOOK_MARKER = void 0;
+exports.installHookGroups = installHookGroups;
+exports.removeHookGroups = removeHookGroups;
+exports.findNocvilleCommand = findNocvilleCommand;
+exports.extractFlag = extractFlag;
+exports.shellQuote = shellQuote;
+exports.buildAgentHookCommand = buildAgentHookCommand;
+exports.stableNodePath = stableNodePath;
+exports.resolveCliPath = resolveCliPath;
+exports.readJsonFile = readJsonFile;
+exports.writeJsonFile = writeJsonFile;
+exports.buildShimHookCommand = buildShimHookCommand;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const shim_js_1 = require("./shim.js");
+/**
+ * Matcher-group hook config shared by Claude Code (`~/.claude/settings.json`)
+ * and Codex (`~/.codex/hooks.json`) — both use:
+ *
+ *   { "hooks": { "<Event>": [ { "matcher": "", "hooks": [ { "type": "command", "command": "…" } ] } ] } }
+ *
+ * Install/uninstall only ever touch entries whose command carries the
+ * `nocville-npc` marker; the user's own hooks are preserved verbatim.
+ */
+/** Marker used to identify nocville-npc hook commands (flat or nested). */
+exports.HOOK_MARKER = 'nocville-npc';
+/**
+ * Trailing shell comment appended to hook commands. `/bin/sh` ignores it, but it
+ * guarantees the marker is present for idempotency regardless of install path.
+ */
+exports.HOOK_MARKER_COMMENT = '# nocville-npc-hook';
+function isCommandHookWithMarker(hook) {
+    if (!hook ||
+        typeof hook !== 'object' ||
+        typeof hook.command !== 'string')
+        return false;
+    const command = hook.command;
+    if (command.includes(exports.HOOK_MARKER) ||
+        /nocville-hook\.cmd"?\s+(?:claude-code|codex|gemini|cursor)\s+hook\b/.test(command))
+        return true;
+    // Recognize the legacy encoded Windows form so setup replaces it and uninstall removes it.
+    const encoded = /^powershell\.exe -NoProfile -NonInteractive -EncodedCommand ([A-Za-z0-9+/=]+)$/.exec(command);
+    if (!encoded)
+        return false;
+    const decoded = Buffer.from(encoded[1], 'base64').toString('utf16le');
+    return (decoded.startsWith(`& cmd.exe /d /s /c '`) &&
+        decoded.endsWith(` # ${exports.HOOK_MARKER}`) &&
+        /nocville-hook\.cmd" (?:claude-code|codex|gemini|cursor) hook/.test(decoded));
+}
+function isGroup(entry) {
+    return (typeof entry === 'object' &&
+        entry !== null &&
+        Array.isArray(entry.hooks));
+}
+/** Old flat format: a bare command hook (no nested `hooks` array). */
+function isFlatNocvilleEntry(entry) {
+    return !isGroup(entry) && isCommandHookWithMarker(entry);
+}
+/** Strip nocville hooks from one event's entry list. Returns kept entries + removed count. */
+function stripNocville(entries) {
+    const kept = [];
+    let removed = 0;
+    let flat = 0;
+    for (const entry of entries) {
+        if (isFlatNocvilleEntry(entry)) {
+            removed++;
+            flat++;
+            continue;
+        }
+        if (isGroup(entry)) {
+            const keptHooks = entry.hooks.filter((h) => !isCommandHookWithMarker(h));
+            const diff = entry.hooks.length - keptHooks.length;
+            if (diff === 0)
+                kept.push(entry);
+            else {
+                removed += diff;
+                if (keptHooks.length > 0)
+                    kept.push({ ...entry, hooks: keptHooks });
+            }
+            continue;
+        }
+        kept.push(entry);
+    }
+    return { kept, removed, flat };
+}
+/**
+ * Install one nocville hook group into each of `events`. Idempotent: existing
+ * nocville entries (flat legacy or nested) are removed first, preserving the
+ * user's own hooks, then a single group per event is appended. Mutates `file`.
+ */
+function installHookGroups(file, command, events, extra = {}) {
+    if (!file.hooks || typeof file.hooks !== 'object' || Array.isArray(file.hooks))
+        file.hooks = {};
+    const root = file.hooks;
+    let migrated = 0;
+    let installed = 0;
+    // Drop nocville entries from events we no longer install, too.
+    for (const ev of Object.keys(root)) {
+        if (events.includes(ev) || !Array.isArray(root[ev]))
+            continue;
+        const { kept } = stripNocville(root[ev]);
+        if (kept.length === 0)
+            delete root[ev];
+        else
+            root[ev] = kept;
+    }
+    for (const ev of events) {
+        const existing = Array.isArray(root[ev]) ? root[ev] : [];
+        const { kept, flat } = stripNocville(existing);
+        migrated += flat;
+        const hook = { type: 'command', command };
+        if (extra.timeout !== undefined)
+            hook.timeout = extra.timeout;
+        Object.assign(hook, extra.perEvent?.[ev]);
+        kept.push({ matcher: '', hooks: [hook] });
+        installed++;
+        root[ev] = kept;
+    }
+    return { migrated, installed };
+}
+/** Remove every nocville hook entry. Mutates `file`; returns the count removed. */
+function removeHookGroups(file) {
+    if (!file.hooks || typeof file.hooks !== 'object')
+        return 0;
+    const root = file.hooks;
+    let removed = 0;
+    for (const ev of Object.keys(root)) {
+        const arr = root[ev];
+        if (!Array.isArray(arr))
+            continue;
+        const res = stripNocville(arr);
+        removed += res.removed;
+        if (res.kept.length === 0)
+            delete root[ev];
+        else
+            root[ev] = res.kept;
+    }
+    if (Object.keys(root).length === 0)
+        delete file.hooks;
+    return removed;
+}
+/** First nocville hook command found in any event (any format). */
+function findNocvilleCommand(file) {
+    const root = file.hooks;
+    if (!root || typeof root !== 'object')
+        return undefined;
+    for (const ev of Object.keys(root)) {
+        const arr = root[ev];
+        if (!Array.isArray(arr))
+            continue;
+        for (const entry of arr) {
+            if (isFlatNocvilleEntry(entry))
+                return entry.command;
+            if (isGroup(entry)) {
+                const hook = entry.hooks.find(isCommandHookWithMarker);
+                if (hook)
+                    return hook.command;
+            }
+        }
+    }
+    return undefined;
+}
+/** Extract a `--flag` value from a command string; supports `=`, quotes, or the space form. */
+function extractFlag(command, flag) {
+    const re = new RegExp(`--${flag}(?:=|\\s+)('([^']*)'|"([^"]*)"|([^\\s]+))`);
+    const m = command.match(re);
+    if (!m)
+        return undefined;
+    return m[2] ?? m[3] ?? m[4];
+}
+/** POSIX single-quote a string so /bin/sh treats it as one literal token. */
+function shellQuote(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * Absolute hook command: `'<node>' '<cli.js>' <agent> hook # nocville-npc-hook`.
+ *
+ * Agents run hooks via `/bin/sh` without the user's interactive PATH (nvm /
+ * homebrew shims are absent), so a bare `nocville-npc` would fail; absolute
+ * paths fix that. No API key on the command line — the hook reads the saved
+ * user config (~/.config/nocville/config.json).
+ */
+function buildAgentHookCommand(cliPath, agent, extraArgs = [], nodePath = stableNodePath()) {
+    const args = extraArgs.length ? ' ' + extraArgs.join(' ') : '';
+    return `${shellQuote(nodePath)} ${shellQuote(cliPath)} ${agent} hook${args} ${exports.HOOK_MARKER_COMMENT}`;
+}
+/**
+ * The node binary to bake into hook commands. `process.execPath` is often a
+ * versioned path (e.g. Homebrew's /opt/homebrew/Cellar/node/24.4.1/bin/node)
+ * that disappears on upgrade, so prefer an unversioned PATH entry (e.g.
+ * /opt/homebrew/bin/node) that resolves to the same binary.
+ */
+function stableNodePath(execPath = process.execPath, pathEnv = process.env['PATH'] ?? '') {
+    let target;
+    try {
+        target = (0, node_fs_1.realpathSync)(execPath);
+    }
+    catch {
+        return execPath;
+    }
+    const exe = process.platform === 'win32' ? 'node.exe' : 'node';
+    for (const dir of pathEnv.split(node_path_1.delimiter)) {
+        if (!dir || /[\\/]Cellar[\\/]/.test(dir))
+            continue;
+        const candidate = (0, node_path_1.join)(dir, exe);
+        try {
+            if (candidate !== execPath && (0, node_fs_1.realpathSync)(candidate) === target)
+                return candidate;
+        }
+        catch {
+            // not here
+        }
+    }
+    return execPath;
+}
+/** Realpath the running CLI (follows npm bin symlinks). */
+function resolveCliPath(explicit) {
+    const candidate = explicit ?? process.argv[1];
+    if (candidate) {
+        try {
+            return (0, node_fs_1.realpathSync)(candidate);
+        }
+        catch {
+            return candidate;
+        }
+    }
+    return 'nocville-npc';
+}
+/** Read a JSON hooks/settings file; missing → {}; unparsable → null (refuse to overwrite). */
+function readJsonFile(path) {
+    if (!(0, node_fs_1.existsSync)(path))
+        return {};
+    try {
+        const raw = (0, node_fs_1.readFileSync)(path, 'utf-8');
+        if (!raw.trim())
+            return {};
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/** Write JSON, keeping a one-time `.nocville-backup` of the original file. */
+function writeJsonFile(path, data) {
+    const backup = `${path}.nocville-backup`;
+    if ((0, node_fs_1.existsSync)(path) && !(0, node_fs_1.existsSync)(backup)) {
+        try {
+            (0, node_fs_1.copyFileSync)(path, backup);
+        }
+        catch {
+            // best effort
+        }
+    }
+    (0, node_fs_1.writeFileSync)(path, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+}
+function buildShimHookCommand(agent, platform = process.platform) {
+    if (platform === 'win32') {
+        const shim = `${(0, shim_js_1.SHIM_PATH)()}.cmd`;
+        if (agent === 'claude-code') {
+            // installHooksInto sets shell: powershell, bypassing Git Bash detection.
+            return `& '${shim.replace(/['‘’‚‛]/g, '$&$&')}' ${agent} hook ${exports.HOOK_MARKER_COMMENT}`;
+        }
+        const payload = `""${shim}" ${agent} hook"`;
+        if (agent === 'gemini') {
+            // Gemini uses PowerShell (7 or 5.1). Stop native-argument parsing so cmd
+            // receives its quotes intact. The newline ends --% before Gemini appends
+            // its own PowerShell exit-code check. No encoded command or policy bypass.
+            return `cmd.exe /d /s /c --% ${payload}\n`;
+        }
+        return `cmd.exe /d /s /c ${payload}`;
+    }
+    return `${shellQuote((0, shim_js_1.SHIM_PATH)())} ${agent} hook ${exports.HOOK_MARKER_COMMENT}`;
+}
+//# sourceMappingURL=hook-settings.js.map

package/dist/cjs/npcs/agent-common/liveness.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAgentAlive = isAgentAlive;
+exports.claudePidFromStore = claudePidFromStore;
+exports.ancestorPid = ancestorPid;
+exports.resolveAgentPid = resolveAgentPid;
+exports.reserveAgentPidAttempt = reserveAgentPidAttempt;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+function startTime(pid, timeout = 1000) {
+    if (process.platform === 'win32')
+        return undefined;
+    const out = (0, node_child_process_1.spawnSync)('ps', ['-o', 'lstart=', '-p', String(pid)], {
+        encoding: 'utf8',
+        timeout,
+    });
+    const value = Date.parse(out.stdout?.trim() ?? '');
+    return Number.isFinite(value) ? value : undefined;
+}
+function isAgentAlive(proc) {
+    if (!Number.isSafeInteger(proc.pid) || proc.pid <= 0)
+        return false;
+    try {
+        process.kill(proc.pid, 0);
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+    if (!proc.startedAt || process.platform === 'win32')
+        return true;
+    const actual = startTime(proc.pid);
+    return actual === undefined || Math.abs(actual - proc.startedAt) < 120_000;
+}
+function claudePidFromStore(sessionId, dir = (0, node_path_1.join)((0, node_os_1.homedir)(), '.claude', 'sessions')) {
+    try {
+        for (const file of (0, node_fs_1.readdirSync)(dir)) {
+            if (!/^\d+\.json$/.test(file))
+                continue;
+            try {
+                const data = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(dir, file), 'utf8'));
+                if (data.sessionId !== sessionId || !Number.isSafeInteger(data.pid) || data.pid <= 0)
+                    continue;
+                const proc = {
+                    pid: data.pid,
+                    startedAt: typeof data.startedAt === 'number' ? data.startedAt : undefined,
+                };
+                if (isAgentAlive(proc))
+                    return proc;
+            }
+            catch {
+                /* incomplete or old sidecar */
+            }
+        }
+    }
+    catch {
+        /* no session store */
+    }
+    return null;
+}
+function ancestorPid(names, start = process.ppid, nodeCommandPattern) {
+    if (process.platform === 'win32')
+        return null;
+    const deadline = Date.now() + 750;
+    let pid = start;
+    for (let hop = 0; hop < 5 && pid > 1 && Date.now() < deadline; hop++) {
+        const out = (0, node_child_process_1.spawnSync)('ps', ['-o', 'ppid=,comm=', '-p', String(pid)], {
+            encoding: 'utf8',
+            timeout: Math.max(1, deadline - Date.now()),
+        });
+        const match = out.stdout?.trim().match(/^(\d+)\s+(.+)$/);
+        if (!match)
+            return null;
+        const command = (0, node_path_1.basename)(match[2]);
+        if (names.includes(command)) {
+            if (command !== 'node')
+                return { pid, startedAt: startTime(pid, Math.max(1, deadline - Date.now())) };
+            if (nodeCommandPattern) {
+                const argv = (0, node_child_process_1.spawnSync)('ps', ['-o', 'command=', '-p', String(pid)], {
+                    encoding: 'utf8',
+                    timeout: Math.max(1, deadline - Date.now()),
+                }).stdout?.trim();
+                if (argv && nodeCommandPattern.test(argv))
+                    return { pid, startedAt: startTime(pid, Math.max(1, deadline - Date.now())) };
+            }
+        }
+        const parent = Number(match[1]);
+        if (parent === pid)
+            return null;
+        pid = parent;
+    }
+    return null;
+}
+function resolveAgentPid(adapter, sessionId) {
+    if (adapter.processNames?.length === 0)
+        return null;
+    return ((adapter.family === 'claude' ? claudePidFromStore(sessionId) : null) ??
+        ancestorPid(adapter.processNames ?? [adapter.command], process.ppid, adapter.nodeCommandPattern));
+}
+/** Reserve under the state lock so simultaneous hooks cannot duplicate PID probes. */
+function reserveAgentPidAttempt(state, now) {
+    if (state.agentPid ||
+        state.offline ||
+        (state.agentPidResolveAttempts ?? 0) >= 5 ||
+        (state.agentPidLastResolveAt !== undefined && now - state.agentPidLastResolveAt < 60_000))
+        return false;
+    state.agentPidResolveAttempts = (state.agentPidResolveAttempts ?? 0) + 1;
+    state.agentPidLastResolveAt = now;
+    return true;
+}
+//# sourceMappingURL=liveness.js.map