@nocville/npc 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCK_HARD_STALE_MS = exports.LOCK_WAIT_MS = exports.LOCK_STALE_MS = void 0;
+exports.withStateLock = withStateLock;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+exports.LOCK_STALE_MS = 5000;
+exports.LOCK_WAIT_MS = 2000;
+exports.LOCK_HARD_STALE_MS = 30_000;
+function alive(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+/** Exclusive cross-process lock. A timeout skips the hook; it never permits an unlocked write. */
+async function withStateLock(path, fn, waitMs = exports.LOCK_WAIT_MS) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true, mode: 0o700 });
+    const lock = `${path}.lock`;
+    const token = `${process.pid}:${(0, node_crypto_1.randomUUID)()}`;
+    const deadline = Date.now() + waitMs;
+    for (;;) {
+        try {
+            const fd = (0, node_fs_1.openSync)(lock, 'wx', 0o600);
+            try {
+                (0, node_fs_1.writeSync)(fd, token);
+            }
+            finally {
+                (0, node_fs_1.closeSync)(fd);
+            }
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            // Serialize stale reclamation so two waiters cannot unlink each other's new lock.
+            let reaper;
+            try {
+                const reapPath = `${lock}.reap`;
+                try {
+                    const oldToken = (0, node_fs_1.readFileSync)(reapPath, 'utf8');
+                    if (Date.now() - (0, node_fs_1.statSync)(reapPath).mtimeMs > exports.LOCK_STALE_MS &&
+                        (0, node_fs_1.readFileSync)(reapPath, 'utf8') === oldToken)
+                        (0, node_fs_1.unlinkSync)(reapPath);
+                }
+                catch {
+                    /* no stale reaper */
+                }
+                reaper = (0, node_fs_1.openSync)(reapPath, 'wx', 0o600);
+                (0, node_fs_1.writeSync)(reaper, token);
+                const owner = (0, node_fs_1.readFileSync)(lock, 'utf8');
+                const age = Date.now() - (0, node_fs_1.statSync)(lock).mtimeMs;
+                // PID reuse cannot block forever. State mutations are synchronous; the separate
+                // delivery lock bounds its HTTP request well below this hard ceiling.
+                if (age > exports.LOCK_HARD_STALE_MS ||
+                    (age > exports.LOCK_STALE_MS && !alive(Number(owner.split(':')[0]))))
+                    (0, node_fs_1.unlinkSync)(lock);
+            }
+            catch {
+                /* owner released, or another waiter is reclaiming it */
+            }
+            finally {
+                if (reaper !== undefined) {
+                    (0, node_fs_1.closeSync)(reaper);
+                    try {
+                        if ((0, node_fs_1.readFileSync)(`${lock}.reap`, 'utf8') === token)
+                            (0, node_fs_1.unlinkSync)(`${lock}.reap`);
+                    }
+                    catch {
+                        /* stale reaper already removed */
+                    }
+                }
+            }
+            if (Date.now() >= deadline)
+                throw new Error('Session state lock timed out');
+            await new Promise((resolve) => setTimeout(resolve, 10 + Math.random() * 15));
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        // Never unlink a replacement lock owned by another writer.
+        try {
+            if ((0, node_fs_1.readFileSync)(lock, 'utf8') === token)
+                (0, node_fs_1.unlinkSync)(lock);
+        }
+        catch {
+            /* already gone */
+        }
+    }
+}
+//# sourceMappingURL=lock.js.map

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

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEphemeralCliPath = isEphemeralCliPath;
+exports.ensureStableCliPath = ensureStableCliPath;
+exports.pruneOldRuntimes = pruneOldRuntimes;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const user_config_js_1 = require("../../core/user-config.js");
+/**
+ * Hooks must point at a cli.js that will still exist tomorrow. When setup runs
+ * from an ephemeral location — `npx @nocville/npc …` executes out of the npm
+ * cache (`~/.npm/_npx/<hash>/…`), which npm may prune at any time — we copy
+ * the package (dist + its `@nocville/node` dependency) into
+ * `~/.config/nocville/runtime/<version>/` and point hooks there instead.
+ */
+/** True when the CLI is running from npm's npx cache (or another temp dir). */
+function isEphemeralCliPath(cliPath) {
+    const p = cliPath.split(node_path_1.sep).join('/');
+    return p.includes('/_npx/') || p.includes('/.pnpm-store/') || p.includes('/dlx-');
+}
+function findPackageRoot(start, name) {
+    let dir = start;
+    for (let i = 0; i < 8; i++) {
+        const pkg = (0, node_path_1.join)(dir, 'package.json');
+        if ((0, node_fs_1.existsSync)(pkg)) {
+            try {
+                const parsed = JSON.parse((0, node_fs_1.readFileSync)(pkg, 'utf-8'));
+                if (parsed.name === name)
+                    return dir;
+            }
+            catch {
+                // keep walking
+            }
+        }
+        const parent = (0, node_path_1.dirname)(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+function readVersion(root) {
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(root, 'package.json'), 'utf-8'));
+        return parsed.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/**
+ * Always copy a valid installed runtime, including global installs removed by nvm uninstall.
+ */
+function ensureStableCliPath(cliPath, _force = true) {
+    const pkgRoot = findPackageRoot((0, node_path_1.dirname)(cliPath), '@nocville/npc');
+    if (!pkgRoot)
+        return cliPath;
+    let sdkRoot = null;
+    try {
+        const req = (0, node_module_1.createRequire)(cliPath);
+        sdkRoot = findPackageRoot((0, node_path_1.dirname)(req.resolve('@nocville/node')), '@nocville/node');
+    }
+    catch {
+        sdkRoot = null;
+    }
+    if (!sdkRoot)
+        return cliPath;
+    const req = (0, node_module_1.createRequire)(cliPath);
+    const pngRoot = findPackageRoot((0, node_path_1.dirname)(req.resolve('pngjs')), 'pngjs');
+    if (!pngRoot)
+        throw new Error('Cannot install hook runtime: pngjs is missing');
+    const version = readVersion(pkgRoot);
+    const hash = (0, node_crypto_1.createHash)('sha256');
+    const hashTree = (root) => {
+        for (const entry of (0, node_fs_1.readdirSync)(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            hash.update(entry.name);
+            const path = (0, node_path_1.join)(root, entry.name);
+            if (entry.isDirectory())
+                hashTree(path);
+            else if (entry.isFile())
+                hash.update((0, node_fs_1.readFileSync)(path));
+        }
+    };
+    for (const root of [pkgRoot, sdkRoot]) {
+        hash.update((0, node_fs_1.readFileSync)((0, node_path_1.join)(root, 'package.json')));
+        hashTree((0, node_path_1.join)(root, 'dist'));
+    }
+    hash.update((0, node_fs_1.readFileSync)((0, node_path_1.join)(pngRoot, 'package.json')));
+    hashTree((0, node_path_1.join)(pngRoot, 'lib'));
+    // Immutable snapshots also support multiple development builds of one version.
+    // Never remove files a running watchdog or the current pointer may still use.
+    const dest = (0, node_path_1.join)((0, node_path_1.dirname)((0, user_config_js_1.userConfigPath)()), 'runtime', `${version}-${hash.digest('hex').slice(0, 16)}`);
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(dest, 'dist', 'cli.js')))
+        return (0, node_path_1.join)(dest, 'dist', 'cli.js');
+    const stage = `${dest}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    try {
+        (0, node_fs_1.mkdirSync)(stage, { recursive: true, mode: 0o700 });
+        (0, node_fs_1.cpSync)((0, node_path_1.join)(pkgRoot, 'package.json'), (0, node_path_1.join)(stage, 'package.json'));
+        (0, node_fs_1.cpSync)((0, node_path_1.join)(pkgRoot, 'dist'), (0, node_path_1.join)(stage, 'dist'), { recursive: true });
+        const sdkDest = (0, node_path_1.join)(stage, 'node_modules', '@nocville', 'node');
+        (0, node_fs_1.mkdirSync)(sdkDest, { recursive: true });
+        (0, node_fs_1.cpSync)((0, node_path_1.join)(sdkRoot, 'package.json'), (0, node_path_1.join)(sdkDest, 'package.json'));
+        (0, node_fs_1.cpSync)((0, node_path_1.join)(sdkRoot, 'dist'), (0, node_path_1.join)(sdkDest, 'dist'), { recursive: true });
+        const pngDest = (0, node_path_1.join)(stage, 'node_modules', 'pngjs');
+        (0, node_fs_1.mkdirSync)(pngDest, { recursive: true });
+        (0, node_fs_1.cpSync)((0, node_path_1.join)(pngRoot, 'package.json'), (0, node_path_1.join)(pngDest, 'package.json'));
+        (0, node_fs_1.cpSync)((0, node_path_1.join)(pngRoot, 'lib'), (0, node_path_1.join)(pngDest, 'lib'), { recursive: true });
+        try {
+            (0, node_fs_1.renameSync)(stage, dest);
+        }
+        catch (error) {
+            if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(dest, 'dist', 'cli.js')))
+                throw error;
+        }
+        return (0, node_path_1.join)(dest, 'dist', 'cli.js');
+    }
+    finally {
+        (0, node_fs_1.rmSync)(stage, { recursive: true, force: true });
+    }
+}
+/** Prune only old snapshots, never the active pointer target or unknown directories. */
+function pruneOldRuntimes(runtimeDir, now = Date.now()) {
+    let active;
+    try {
+        const pointer = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(runtimeDir, 'current.json'), 'utf8'));
+        if (typeof pointer.cli !== 'string')
+            return 0;
+        active = (0, node_path_1.resolve)(pointer.cli);
+    }
+    catch {
+        return 0;
+    }
+    let removed = 0;
+    for (const entry of (0, node_fs_1.readdirSync)(runtimeDir, { withFileTypes: true })) {
+        if (!entry.isDirectory() || !/^\d[^/]*-[a-f0-9]{16}$/.test(entry.name))
+            continue;
+        const path = (0, node_path_1.resolve)(runtimeDir, entry.name);
+        if (active === path || active.startsWith(path + node_path_1.sep))
+            continue;
+        try {
+            if (now - (0, node_fs_1.statSync)(path).mtimeMs <= 7 * 86_400_000)
+                continue;
+            (0, node_fs_1.rmSync)(path, { recursive: true, force: true });
+            removed++;
+        }
+        catch {
+            /* best-effort maintenance must not break setup */
+        }
+    }
+    return removed;
+}
+//# sourceMappingURL=runtime.js.map

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

@@ -0,0 +1,390 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MIN_PUSH_GAP_MS = exports.ACTIVITY_HISTORY = void 0;
+exports.phasePresentation = phasePresentation;
+exports.projectNameOf = projectNameOf;
+exports.agentDisplayName = agentDisplayName;
+exports.sanitizeServiceId = sanitizeServiceId;
+exports.stateFilePath = stateFilePath;
+exports.readSessionState = readSessionState;
+exports.writeSessionState = writeSessionState;
+exports.deleteSessionState = deleteSessionState;
+exports.cleanupSessionStates = cleanupSessionStates;
+exports.maybeCleanupSessionStates = maybeCleanupSessionStates;
+exports.pushHistory = pushHistory;
+exports.applyTransition = applyTransition;
+exports.buildAgentPayload = buildAgentPayload;
+exports.flushSession = flushSession;
+exports.tickerLines = tickerLines;
+exports.applySubagentEvent = applySubagentEvent;
+exports.spawnDetachedFlush = spawnDetachedFlush;
+exports.spawnDetachedAgent = spawnDetachedAgent;
+exports.sleep = sleep;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_1 = require("@nocville/node");
+const text_js_1 = require("../../core/text.js");
+const lock_js_1 = require("./lock.js");
+/** Behavior hints + subStatus for a phase (shared by every agent NPC). */
+function phasePresentation(state, offline) {
+    if (offline)
+        return { subStatus: 'offline' };
+    switch (state) {
+        case 'WORKING':
+            // Head to a desk and sit while actively working.
+            return { subStatus: 'working', behavior: { activity: 'busy', busy: 'seek-desk' } };
+        case 'WAITING':
+            // Freeze and raise a hand until the human responds.
+            return {
+                subStatus: 'waiting',
+                behavior: { activity: 'waiting', waitingEmote: 'raised-hand' },
+            };
+        case 'IDLE':
+        default:
+            // Settle at the desk and doze off.
+            return {
+                subStatus: 'idle',
+                behavior: { activity: 'idle', idle: 'stay', idlePose: 'sleep' },
+            };
+    }
+}
+exports.ACTIVITY_HISTORY = 8;
+exports.DEFAULT_MIN_PUSH_GAP_MS = 1500;
+const STATE_PREFIX = 'session-';
+// ---------------------------------------------------------------- naming
+function projectNameOf(cwd) {
+    const parts = cwd.replace(/\\/g, '/').replace(/\/+$/, '').split('/');
+    return parts[parts.length - 1] || 'unknown';
+}
+/** "Claude · nocville", clamped to the API's 32-char banner limit. */
+function agentDisplayName(label, subject) {
+    return (0, text_js_1.truncate)(`${label} · ${subject}`, 32);
+}
+/** Service ids are ≤100 chars of [A-Za-z0-9_.-]. */
+function sanitizeServiceId(raw) {
+    return raw
+        .replace(/[^A-Za-z0-9_.-]+/g, '-')
+        .replace(/-+/g, '-')
+        .slice(0, 100);
+}
+// ---------------------------------------------------------------- state file
+function stateFilePath(stateDir, sessionId) {
+    const safe = sessionId.replace(/[^A-Za-z0-9_.-]/g, '_');
+    return (0, node_path_1.join)(stateDir, `${STATE_PREFIX}${safe}.json`);
+}
+function readSessionState(stateDir, sessionId) {
+    try {
+        const raw = JSON.parse((0, node_fs_1.readFileSync)(stateFilePath(stateDir, sessionId), 'utf-8'));
+        if (typeof raw['sessionId'] !== 'string')
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+/** Atomic write (temp file + rename) so concurrent readers never see half a file. */
+function writeSessionState(stateDir, state) {
+    (0, node_fs_1.mkdirSync)(stateDir, { recursive: true });
+    const path = stateFilePath(stateDir, state.sessionId);
+    const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+    (0, node_fs_1.writeFileSync)(tmp, JSON.stringify(state), 'utf-8');
+    (0, node_fs_1.renameSync)(tmp, path);
+}
+function deleteSessionState(stateDir, sessionId) {
+    const path = stateFilePath(stateDir, sessionId);
+    if ((0, node_fs_1.existsSync)(path)) {
+        try {
+            (0, node_fs_1.rmSync)(path);
+        }
+        catch {
+            // best effort
+        }
+    }
+}
+/** Remove state files older than `maxAgeMs`. Returns the number removed. */
+async function cleanupSessionStates(stateDir, maxAgeMs, now = Date.now()) {
+    if (!(0, node_fs_1.existsSync)(stateDir))
+        return 0;
+    let removed = 0;
+    for (const file of (0, node_fs_1.readdirSync)(stateDir)) {
+        if (!file.startsWith(STATE_PREFIX) || !file.endsWith('.json'))
+            continue;
+        const path = (0, node_path_1.join)(stateDir, file);
+        try {
+            if (now - (0, node_fs_1.statSync)(path).mtimeMs <= maxAgeMs)
+                continue;
+            // Recheck under the same lock as hooks, so a SessionStart cannot be deleted mid-write.
+            await (0, lock_js_1.withStateLock)(path, () => {
+                if (now - (0, node_fs_1.statSync)(path).mtimeMs > maxAgeMs) {
+                    (0, node_fs_1.unlinkSync)(path);
+                    removed++;
+                }
+            }, 0);
+        }
+        catch {
+            /* active writer, missing file or filesystem error: leave it alone */
+        }
+    }
+    return removed;
+}
+/** Cross-process hourly maintenance, invoked only on SessionStart. */
+async function maybeCleanupSessionStates(stateDir, now = Date.now()) {
+    const marker = (0, node_path_1.join)(stateDir, '.last-cleanup');
+    try {
+        return await (0, lock_js_1.withStateLock)(marker, async () => {
+            let last = NaN;
+            try {
+                last = Number((0, node_fs_1.readFileSync)(marker, 'utf8'));
+            }
+            catch {
+                /* first cleanup */
+            }
+            if (Number.isFinite(last) && now - last < 3_600_000)
+                return 0;
+            const removed = await cleanupSessionStates(stateDir, 86_400_000, now);
+            (0, node_fs_1.writeFileSync)(marker, String(now), { mode: 0o600 });
+            return removed;
+        }, 0);
+    }
+    catch {
+        return 0;
+    }
+}
+/** Prepend `line` to the history (deduping an identical head), capped. */
+function pushHistory(prev, line) {
+    const list = [...(prev ?? [])];
+    if (line && list[0] !== line)
+        list.unshift(line);
+    return list.slice(0, exports.ACTIVITY_HISTORY);
+}
+/**
+ * Apply a transition to the previous state and decide when to push.
+ * Pure — exposed for testing.
+ */
+function applyTransition(prev, input, minGapMs = exports.DEFAULT_MIN_PUSH_GAP_MS) {
+    const t = input.transition;
+    const history = pushHistory(prev?.activity, t.activity);
+    const prevHead = prev?.activity?.[0];
+    const subagents = pruneSubagents(prev?.subagents, input.now);
+    const changed = !prev ||
+        prev.state !== t.state ||
+        prev.status !== t.status ||
+        Object.keys(subagents).length !== Object.keys(prev.subagents ?? {}).length ||
+        history[0] !== prevHead ||
+        !!t.offline !== !!prev.offline ||
+        (input.name !== undefined && input.name !== prev.name);
+    const rev = (prev?.rev ?? 0) + (changed ? 1 : 0);
+    const next = {
+        ...prev,
+        sessionId: input.sessionId,
+        startedAt: prev?.startedAt ?? input.now,
+        serviceId: prev?.serviceId ?? input.serviceId,
+        state: t.state,
+        projectDir: input.projectDir,
+        lastEvent: input.eventName,
+        lastUpdate: input.now,
+        activity: history,
+        subagents,
+        name: input.name ?? prev?.name,
+        status: t.status,
+        mood: t.mood,
+        offline: t.offline || undefined,
+        rev,
+        pushedRev: prev?.pushedRev ?? 0,
+        lastPushAt: prev?.lastPushAt ?? 0,
+        flushAt: prev?.flushAt,
+    };
+    if (t.offline)
+        return { next, decision: { kind: 'now' } };
+    if (t.quiet || !changed)
+        return { next, decision: { kind: 'none' } };
+    const phaseChanged = !prev || prev.state !== t.state || !prev.lastPushAt;
+    const sinceLast = input.now - (next.lastPushAt ?? 0);
+    if (phaseChanged || sinceLast >= minGapMs) {
+        // Stamp the push time now: the push itself runs asynchronously (detached),
+        // and the next hook must already see it to coalesce.
+        next.lastPushAt = input.now;
+        return { next, decision: { kind: 'now' } };
+    }
+    // Coalesce: a flush is already pending (and not stale) → it will pick up this rev.
+    if (next.flushAt && next.flushAt > input.now - 2000)
+        return { next, decision: { kind: 'none' } };
+    const delayMs = Math.max(50, minGapMs - sinceLast);
+    next.flushAt = input.now + delayMs;
+    return { next, decision: { kind: 'defer', delayMs } };
+}
+// ---------------------------------------------------------------- push
+/** Build the status push for a session (offline sentinel when the session ended). */
+function buildAgentPayload(adapter, state, config) {
+    const subject = state.name ?? projectNameOf(state.projectDir);
+    const name = config.name ? (0, text_js_1.truncate)(config.name, 32) : agentDisplayName(adapter.label, subject);
+    const current = state.activity?.[0] ?? '';
+    const { subStatus, behavior } = phasePresentation(state.state, state.offline);
+    if (state.offline) {
+        return {
+            status: 'unknown',
+            mood: 'idle',
+            name,
+            message: 'Session ended',
+            subStatus,
+            offline: true,
+            map: config.map,
+        };
+    }
+    const screenData = {
+        layout: 'ticker',
+        values: tickerLines({ ...state, subagents: pruneSubagents(state.subagents, Date.now()) }).map((a) => ({ label: '', value: a })),
+    };
+    return {
+        status: state.status ?? 'healthy',
+        mood: state.mood ?? 'happy',
+        name,
+        message: current ? (0, text_js_1.truncate)(current, 120) : undefined,
+        archetype: 'ai-agent',
+        metrics: { sessionStartedAt: state.startedAt ?? state.lastUpdate },
+        appearance: { family: adapter.family },
+        agentStats: state.agentStats,
+        subStatus,
+        behavior,
+        alertConfig: { heartbeatInterval: state.watchdogPid ? adapter.heartbeatSeconds : 3600 },
+        screenData,
+        companion: {
+            screenType: 'desk-sign',
+            size: { w: 3, h: 1 },
+            placement: 'on-desk',
+            label: (0, text_js_1.truncate)(projectNameOf(state.projectDir), 40),
+        },
+        map: config.map,
+    };
+}
+async function defaultPush(config, serviceId, payload, timeoutMs) {
+    const client = new node_1.NocvilleClient({
+        apiUrl: config.apiUrl,
+        apiKey: config.apiKey,
+        serviceId,
+        timeout: timeoutMs,
+        retries: 0,
+        debug: config.debug,
+    });
+    return client.pushStatus(payload);
+}
+/**
+ * Push the session's current state if it has unpushed changes (or is offline),
+ * then record the push. Re-reads the state right before writing so a hook that
+ * ran concurrently isn't clobbered. Never throws.
+ */
+async function flushSession(adapter, config, sessionId, deps = {}) {
+    const path = stateFilePath(adapter.stateDir, sessionId);
+    try {
+        // Serialize HTTP delivery separately: hooks can update state throughout a request,
+        // but an older delivery can never arrive after a newer/offline one.
+        return await (0, lock_js_1.withStateLock)(`${path}.push`, async () => {
+            const state = readSessionState(adapter.stateDir, sessionId);
+            if (!state || !config.apiKey || state.offlineDeliveryStopped)
+                return false;
+            const rev = state.rev ?? 0;
+            if (!deps.force && rev <= (state.pushedRev ?? 0)) {
+                await (0, lock_js_1.withStateLock)(path, () => {
+                    const fresh = readSessionState(adapter.stateDir, sessionId);
+                    if (fresh && (fresh.rev ?? 0) === rev) {
+                        fresh.flushAt = undefined;
+                        writeSessionState(adapter.stateDir, fresh);
+                    }
+                }, deps.lockWaitMs);
+                return false;
+            }
+            const push = deps.push ??
+                ((sid, payload) => defaultPush(config, sid, payload, deps.timeoutMs ?? 4000));
+            let ok = false;
+            try {
+                const result = await push(state.serviceId, buildAgentPayload(adapter, state, config));
+                ok = result.success;
+                deps.onResult?.(result);
+            }
+            catch {
+                /* retry on next hook/watchdog tick */
+            }
+            await (0, lock_js_1.withStateLock)(path, () => {
+                const fresh = readSessionState(adapter.stateDir, sessionId);
+                if (!fresh)
+                    return;
+                // Retain terminal state until cleanup so late hooks/watchers cannot revive it.
+                if (ok) {
+                    fresh.pushedRev = Math.max(fresh.pushedRev ?? 0, rev);
+                    fresh.lastPushAt = Date.now();
+                }
+                if (!fresh.flushAt || fresh.flushAt <= Date.now())
+                    fresh.flushAt = undefined;
+                writeSessionState(adapter.stateDir, fresh);
+            }, deps.lockWaitMs);
+            return ok;
+        }, deps.lockWaitMs ?? 6000);
+    }
+    catch {
+        return false;
+    }
+}
+/** Current parent activity, up to three subagents, then recent parent history. */
+function tickerLines(state) {
+    const history = state.activity ?? [];
+    const agents = Object.values(state.subagents ?? {})
+        .sort((a, b) => b.at - a.at)
+        .slice(0, 3)
+        .map((entry) => `↳ ${entry.type}: ${entry.activity}`);
+    return [...history.slice(0, 1), ...agents, ...history.slice(1)].slice(0, exports.ACTIVITY_HISTORY);
+}
+function applySubagentEvent(prev, agentId, type, event, activity, now) {
+    const subagents = pruneSubagents(prev.subagents, now);
+    if (event === 'Stop' || event === 'SubagentStop')
+        delete subagents[agentId];
+    else if (event === 'PreToolUse')
+        subagents[agentId] = { type, activity, at: now };
+    const next = { ...prev, subagents, lastUpdate: now, lastEvent: event };
+    if (JSON.stringify(tickerLines(prev)) !== JSON.stringify(tickerLines(next)))
+        next.rev = (prev.rev ?? 0) + 1;
+    return next;
+}
+/**
+ * Hand a flush to a detached background process so the hook can exit at once.
+ * The child inherits the resolved config via env (not argv, so the key never
+ * shows up in `ps`).
+ */
+function spawnDetachedFlush(adapter, config, sessionId, delayMs, cliPath = process.argv[1], stats = false) {
+    spawnDetachedAgent(adapter, config, ['flush', sessionId, `--delay=${Math.round(delayMs)}`, ...(stats ? ['--stats'] : [])], cliPath);
+}
+function spawnDetachedAgent(adapter, config, args, cliPath = process.argv[1]) {
+    if (!cliPath)
+        return undefined;
+    const env = { ...process.env };
+    env['NOCVILLE_API_URL'] = config.apiUrl;
+    env['NOCVILLE_API_KEY'] = config.apiKey;
+    if (config.map)
+        env['NOCVILLE_MAP'] = config.map;
+    if (config.name)
+        env['NOCVILLE_NAME'] = config.name;
+    try {
+        const child = (0, node_child_process_1.spawn)(process.execPath, [cliPath, adapter.command, ...args], {
+            detached: true,
+            stdio: 'ignore',
+            env,
+            windowsHide: true,
+        });
+        child.on('error', () => {
+            /* swallow — never fail the agent */
+        });
+        child.unref();
+        return child.pid;
+    }
+    catch {
+        // swallow
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function pruneSubagents(subagents, now) {
+    return Object.fromEntries(Object.entries(subagents ?? {}).filter(([, value]) => now - value.at < 600_000));
+}
+//# sourceMappingURL=session.js.map