@raidiant/notifai 0.5.0 → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,165 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html)
+and [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/).
+
+## [Unreleased]
+
+## [1.0.0] - 2026-08-13
+
+### Removed
+
+- **BREAKING** Service origin is no longer a user setting. The compiled default and the origin stored on the credential stay; override only with `--base-url` or `NOTIFAI_BASE_URL`.
+- **BREAKING** Personal project preferences leave the project tree and live under the user config directory, keyed by project root.
+
+### Added
+
+- A bounded, consented slice of the local log can be packed for feedback.
+- Test notifications are sent by kind rather than by inventing a sound.
+- The agent skill walks setup itself and treats `--sound` / `--level` as overrides.
+- Every detected harness is installed instead of picking one.
+- The interactive app offers labeled hooks install and uninstall.
+
+### Fixed
+
+- Codex hooks are written in the layer's existing representation.
+- Readiness work that cannot change the next action is skipped.
+- Unfinished import changes from the skill rewrite are dropped.
+- Setup closes are short.
+
+## [0.5.1] - 2026-08-13
+
+### Fixed
+
+- Republished the 0.5.0 source. The previous tarball carried 0.4.0's compiled output, so agent-wake modules never reached npm.
+
+## [0.5.0] - 2026-08-13
+
+### Added
+
+- Answers now reach the agent that asked without the user returning to the terminal.
+- Asynchronous Claude Code Stop hook: it returns at once and posts the answer into the same session over its inbox socket.
+- Codex Stop hook continues the turn directly, and resumes a stopped thread only behind a writer-lock probe.
+
+### Removed
+
+- **BREAKING** Presence gate and the held-turn budget. `require_idle`, `away_after_seconds`, and `hook_reply_timeout_seconds` are gone rather than deprecated.
+
+### Changed
+
+- A registered question must carry a commitment to the work each answer resumes, and that commitment must not name where the answer arrives.
+
+## [0.4.0] - 2026-08-12
+
+### Added
+
+- Agent-facing local logs.
+- Crash-safe question continuation.
+- Additive submission protocol updates required by the current CLI.
+
+## [0.3.0] - 2026-08-10
+
+### Added
+
+- Interactive app.
+- Self-describing settings: a config schema that documents and validates itself, and a themed presentation layer for the banner, help, and config views.
+
+## [0.2.1] - 2026-08-09
+
+### Added
+
+- Question queue: asks never supersede each other; only replies supersede replies.
+
+### Fixed
+
+- `init` no longer stops at a routing pointer that has not fired yet.
+
+## [0.2.0] - 2026-08-09
+
+### Changed
+
+- **BREAKING** A reply request carries a set of 1–4 questions instead of a single kind/choices pair.
+- **BREAKING** One `--choice` flag per answer. The comma delimiter is gone.
+
+### Added
+
+- Free-text or closed questions, multi-select, and typed answers beside choices.
+- `--detail` / `--detail-file`, and `ask --form` for several questions as one form.
+
+## [0.1.8] - 2026-08-08
+
+### Changed
+
+- Human-facing product spelling is Notifai.
+- Protocol dependency advanced to 0.1.2.
+
+## [0.1.7] - 2026-08-05
+
+### Changed
+
+- Release engineering and companion-install guidance.
+
+## [0.1.6] - 2026-08-05
+
+### Added
+
+- Native skills setup composed into `init`.
+
+## [0.1.5] - 2026-08-05
+
+### Added
+
+- Release pin verification.
+
+## [0.1.4] - 2026-08-05
+
+### Added
+
+- Pinned skill installer source.
+
+## [0.1.3] - 2026-08-05
+
+### Changed
+
+- Portable, time-bounded release checks.
+
+## [0.1.2] - 2026-08-05
+
+### Fixed
+
+- CLI package installable from npm.
+
+## [0.1.1] - 2026-08-05
+
+### Added
+
+- Receipt-backed setup.
+
+## [0.1.0] - 2026-08-05
+
+### Added
+
+- First public release of the `notifai` CLI under Apache-2.0.
+
+[unreleased]: https://github.com/Raidiant-io/notifai/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/Raidiant-io/notifai/compare/v0.5.1...v1.0.0
+[0.5.1]: https://github.com/Raidiant-io/notifai/compare/v0.5.0...v0.5.1
+[0.5.0]: https://github.com/Raidiant-io/notifai/compare/v0.4.0...v0.5.0
+[0.4.0]: https://github.com/Raidiant-io/notifai/compare/v0.3.0...v0.4.0
+[0.3.0]: https://github.com/Raidiant-io/notifai/compare/v0.2.1...v0.3.0
+[0.2.1]: https://github.com/Raidiant-io/notifai/compare/v0.2.0...v0.2.1
+[0.2.0]: https://github.com/Raidiant-io/notifai/compare/v0.1.8...v0.2.0
+[0.1.8]: https://github.com/Raidiant-io/notifai/compare/v0.1.7...v0.1.8
+[0.1.7]: https://github.com/Raidiant-io/notifai/compare/v0.1.6...v0.1.7
+[0.1.6]: https://github.com/Raidiant-io/notifai/compare/v0.1.5...v0.1.6
+[0.1.5]: https://github.com/Raidiant-io/notifai/compare/v0.1.4...v0.1.5
+[0.1.4]: https://github.com/Raidiant-io/notifai/compare/v0.1.3...v0.1.4
+[0.1.3]: https://github.com/Raidiant-io/notifai/compare/v0.1.2...v0.1.3
+[0.1.2]: https://github.com/Raidiant-io/notifai/compare/v0.1.1...v0.1.2
+[0.1.1]: https://github.com/Raidiant-io/notifai/compare/v0.1.0...v0.1.1
+[0.1.0]: https://github.com/Raidiant-io/notifai/releases/tag/v0.1.0

package/README.md

@@ -12,6 +12,11 @@ npm install -g @raidiant/notifai
 notifai init
 ```
 
+If you do not want a global bin, `npx --yes @raidiant/notifai@<version>` is
+supported. Pin the version. `hooks install` then writes that same pinned npx
+invocation into the harness adapter. This is slower than a real install and
+is not the default path.
+
 `init` walks the setup one step at a time and tells you the single next
 thing to do. Run it again after each step; it works out what remains.
 
@@ -55,10 +60,12 @@ For a harness that cannot resume an idle agent turn, `notifai send
 notifai hooks install
 ```
 
-Wires question routing into Claude Code, Codex, Cursor or OpenCode. This
-is what lets an agent's question reach your phone without the agent
-having to cooperate — no question detection, no state in a context window
-that compaction will eat.
+Wires question routing into every supported harness detected on this
+machine (Claude Code, Codex, Cursor, OpenCode). `notifai init` does the
+same and, at a terminal, lets you keep the detected set, pick a subset,
+or add one it did not see. This is what lets an agent's question reach
+your phone without the agent having to cooperate — no question detection,
+no state in a context window that compaction will eat.
 
 Every harness definition calls one stable user-level adapter at
 `~/.notifai/bin/hook-adapter`. Node, package manager, CLI version, checkout,

package/dist/claude-wake.d.ts

@@ -0,0 +1,101 @@
+import type { EscalationDeliveryRoute } from './hooks.js';
+/** Claude Code's currently observed inbox protocol. Unknown versions fail closed. */
+export declare const CLAUDE_PEER_PROTOCOL = 1;
+/** The first Claude Code release that publishes a session inbox socket. */
+export declare const CLAUDE_MIN_INBOX_VERSION = "2.1.224";
+/** macOS verifies own-child ancestry only while the posting process is alive. */
+export declare const CLAUDE_POST_SEND_LIVENESS_MS = 8000;
+export type ClaudeLiveStatus = 'idle' | 'busy';
+export interface ClaudeSessionDescriptor {
+    pid: number;
+    sessionId: string;
+    cwd: string;
+    startedAt: number;
+    procStart: string;
+    version: string;
+    peerProtocol: number;
+    messagingSocketPath: string;
+    status: string;
+}
+export interface ClaudeAgentObservation {
+    pid: number;
+    sessionId: string;
+    startedAt: number;
+    status: string;
+}
+export interface ClaudeWakeAdapters {
+    listAgents(): Promise<unknown>;
+    readDescriptor(pid: number): unknown;
+    sendSocket(socketPath: string, line: string): Promise<void>;
+    resume(sessionId: string, cwd: string, context: string): Promise<void>;
+    sleep(milliseconds: number): Promise<void>;
+}
+export type ClaudeWakeObservation = {
+    state: 'live-idle' | 'live-busy';
+    descriptor: ClaudeSessionDescriptor;
+} | {
+    state: 'stopped';
+} | {
+    state: 'unknown';
+    reason: string;
+};
+/**
+ * Observe one exact Claude Code session without guessing.
+ *
+ * `claude agents --json` is the liveness oracle: Claude Code itself validates
+ * each registry row against both PID and process start time before returning it.
+ * The descriptor supplies the socket and peer protocol, but is never trusted as
+ * proof that a process still owns the session.
+ */
+export declare function observeClaudeSession(sessionId: string, adapters: Pick<ClaudeWakeAdapters, 'listAgents' | 'readDescriptor'>): Promise<ClaudeWakeObservation>;
+export type ClaudeInboxReadiness = {
+    state: 'ready';
+    socketPath: string;
+    version: string;
+} | {
+    state: 'unavailable';
+    reason: string;
+};
+/**
+ * Whether an answer could reach this exact Claude session over its inbox
+ * socket, decided from evidence already on disk.
+ *
+ * Read-only by construction: it reads the session descriptor and asks whether
+ * the socket file exists, and never connects to it. A diagnostic that delivers
+ * a message is not a diagnostic.
+ *
+ * Every negative answer here is a degradation, not a failure — the accepted
+ * journal still replays the answer at the session's next turn. What it buys is
+ * that the reason is nameable in advance instead of being discovered as
+ * silence. The common one is `--bare`, which binds no socket at all (and runs
+ * no hooks either, so nothing would have registered a question in the first
+ * place).
+ */
+export declare function inspectClaudeInbox(options: {
+    pid: number;
+    platform: NodeJS.Platform;
+    readDescriptor: (pid: number) => unknown;
+    socketExists: (socketPath: string) => boolean;
+}): ClaudeInboxReadiness;
+/**
+ * Claude's own-child delivery route.
+ *
+ * A successful socket write proves delivery to Claude Code, not model
+ * consumption — and this route reports exactly that, no more. It reports
+ * `delivered` all the same, because the write is the strongest acknowledgement
+ * this route can ever obtain: the message it posts starts a brand-new turn
+ * rather than continuing this one, so no later hook will confirm anything about
+ * it. An answer delivered once and settled is strictly better than an answer
+ * redelivered on every turn-end for ever.
+ *
+ * Every path that hands nothing over reports `held`, so the accepted journal
+ * replays it. Unknown state deliberately returns without throwing, so the
+ * journal becomes `hold-for-next-turn` instead of failing the hook.
+ */
+export declare function claudeWakeRoute(options: {
+    sessionId: string;
+    cwd: string;
+    sourcePid: number;
+    adapters?: ClaudeWakeAdapters;
+}): EscalationDeliveryRoute;
+export declare function systemClaudeWakeAdapters(env?: NodeJS.ProcessEnv): ClaudeWakeAdapters;

package/dist/claude-wake.js

@@ -0,0 +1,397 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createConnection } from 'node:net';
+/** Claude Code's currently observed inbox protocol. Unknown versions fail closed. */
+export const CLAUDE_PEER_PROTOCOL = 1;
+/** The first Claude Code release that publishes a session inbox socket. */
+export const CLAUDE_MIN_INBOX_VERSION = '2.1.224';
+/** The inbox socket is a Unix domain socket; no Windows implementation exists. */
+const INBOX_PLATFORMS = new Set(['darwin', 'linux']);
+/** macOS verifies own-child ancestry only while the posting process is alive. */
+export const CLAUDE_POST_SEND_LIVENESS_MS = 8_000;
+const LIVE_STATUSES = new Set(['idle', 'busy']);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseAgent(value) {
+    if (!isRecord(value))
+        return null;
+    if (typeof value['pid'] !== 'number' ||
+        !Number.isInteger(value['pid']) ||
+        value['pid'] <= 0 ||
+        typeof value['sessionId'] !== 'string' ||
+        value['sessionId'] === '' ||
+        typeof value['startedAt'] !== 'number' ||
+        !Number.isFinite(value['startedAt']) ||
+        typeof value['status'] !== 'string') {
+        return null;
+    }
+    return {
+        pid: value['pid'],
+        sessionId: value['sessionId'],
+        startedAt: value['startedAt'],
+        status: value['status'],
+    };
+}
+function parseDescriptor(value) {
+    if (!isRecord(value))
+        return null;
+    if (typeof value['pid'] !== 'number' ||
+        !Number.isInteger(value['pid']) ||
+        value['pid'] <= 0 ||
+        typeof value['sessionId'] !== 'string' ||
+        value['sessionId'] === '' ||
+        typeof value['cwd'] !== 'string' ||
+        value['cwd'] === '' ||
+        typeof value['startedAt'] !== 'number' ||
+        !Number.isFinite(value['startedAt']) ||
+        typeof value['procStart'] !== 'string' ||
+        value['procStart'] === '' ||
+        typeof value['version'] !== 'string' ||
+        value['version'] === '' ||
+        typeof value['peerProtocol'] !== 'number' ||
+        !Number.isInteger(value['peerProtocol']) ||
+        typeof value['messagingSocketPath'] !== 'string' ||
+        value['messagingSocketPath'] === '' ||
+        typeof value['status'] !== 'string') {
+        return null;
+    }
+    return {
+        pid: value['pid'],
+        sessionId: value['sessionId'],
+        cwd: value['cwd'],
+        startedAt: value['startedAt'],
+        procStart: value['procStart'],
+        version: value['version'],
+        peerProtocol: value['peerProtocol'],
+        messagingSocketPath: value['messagingSocketPath'],
+        status: value['status'],
+    };
+}
+/**
+ * Observe one exact Claude Code session without guessing.
+ *
+ * `claude agents --json` is the liveness oracle: Claude Code itself validates
+ * each registry row against both PID and process start time before returning it.
+ * The descriptor supplies the socket and peer protocol, but is never trusted as
+ * proof that a process still owns the session.
+ */
+export async function observeClaudeSession(sessionId, adapters) {
+    let listed;
+    try {
+        listed = await adapters.listAgents();
+    }
+    catch (err) {
+        return {
+            state: 'unknown',
+            reason: `claude agents probe failed: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    if (!Array.isArray(listed)) {
+        return { state: 'unknown', reason: 'claude agents returned an invalid document' };
+    }
+    const matchingRaw = listed.filter((value) => isRecord(value) && value['sessionId'] === sessionId);
+    if (matchingRaw.length === 0)
+        return { state: 'stopped' };
+    if (matchingRaw.length !== 1) {
+        return { state: 'unknown', reason: 'claude agents returned duplicate session owners' };
+    }
+    const agent = parseAgent(matchingRaw[0]);
+    if (agent === null) {
+        return { state: 'unknown', reason: 'claude agents returned an invalid matching row' };
+    }
+    let descriptorRaw;
+    try {
+        descriptorRaw = adapters.readDescriptor(agent.pid);
+    }
+    catch (err) {
+        return {
+            state: 'unknown',
+            reason: `Claude session descriptor could not be read: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    const descriptor = parseDescriptor(descriptorRaw);
+    if (descriptor === null) {
+        return { state: 'unknown', reason: 'Claude session descriptor has an unknown shape' };
+    }
+    if (descriptor.pid !== agent.pid ||
+        descriptor.sessionId !== agent.sessionId ||
+        descriptor.startedAt !== agent.startedAt) {
+        return { state: 'unknown', reason: 'Claude liveness probe and descriptor disagree' };
+    }
+    if (descriptor.peerProtocol !== CLAUDE_PEER_PROTOCOL) {
+        return {
+            state: 'unknown',
+            reason: `unsupported Claude peer protocol ${descriptor.peerProtocol}`,
+        };
+    }
+    if (!LIVE_STATUSES.has(agent.status)) {
+        return { state: 'unknown', reason: `Claude session status ${agent.status} is not wakeable` };
+    }
+    return {
+        state: agent.status === 'idle' ? 'live-idle' : 'live-busy',
+        descriptor,
+    };
+}
+/** Ordered comparison of dotted release numbers, ignoring any suffix. */
+function versionAtLeast(version, minimum) {
+    const parse = (value) => value.split('.').map((part) => Number.parseInt(part, 10) || 0);
+    const left = parse(version);
+    const right = parse(minimum);
+    for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+        const a = left[index] ?? 0;
+        const b = right[index] ?? 0;
+        if (a !== b)
+            return a > b;
+    }
+    return true;
+}
+/**
+ * Whether an answer could reach this exact Claude session over its inbox
+ * socket, decided from evidence already on disk.
+ *
+ * Read-only by construction: it reads the session descriptor and asks whether
+ * the socket file exists, and never connects to it. A diagnostic that delivers
+ * a message is not a diagnostic.
+ *
+ * Every negative answer here is a degradation, not a failure — the accepted
+ * journal still replays the answer at the session's next turn. What it buys is
+ * that the reason is nameable in advance instead of being discovered as
+ * silence. The common one is `--bare`, which binds no socket at all (and runs
+ * no hooks either, so nothing would have registered a question in the first
+ * place).
+ */
+export function inspectClaudeInbox(options) {
+    if (!INBOX_PLATFORMS.has(options.platform)) {
+        return {
+            state: 'unavailable',
+            reason: `Claude Code publishes no inbox socket on ${options.platform}; it exists on macOS and Linux only`,
+        };
+    }
+    let raw;
+    try {
+        raw = options.readDescriptor(options.pid);
+    }
+    catch (err) {
+        return {
+            state: 'unavailable',
+            reason: `no session descriptor for pid ${options.pid} (${err instanceof Error ? err.message : String(err)}); a session started with \`--bare\` binds no inbox socket`,
+        };
+    }
+    const descriptor = parseDescriptor(raw);
+    if (descriptor === null) {
+        return {
+            state: 'unavailable',
+            reason: `the session descriptor for pid ${options.pid} has an unknown shape`,
+        };
+    }
+    if (descriptor.peerProtocol !== CLAUDE_PEER_PROTOCOL) {
+        return {
+            state: 'unavailable',
+            reason: `this session speaks inbox protocol ${descriptor.peerProtocol}, and only ${CLAUDE_PEER_PROTOCOL} is known; refusing to guess at an undocumented wire format`,
+        };
+    }
+    if (!versionAtLeast(descriptor.version, CLAUDE_MIN_INBOX_VERSION)) {
+        return {
+            state: 'unavailable',
+            reason: `Claude Code ${descriptor.version} is older than ${CLAUDE_MIN_INBOX_VERSION}, which is where the inbox socket starts`,
+        };
+    }
+    if (!options.socketExists(descriptor.messagingSocketPath)) {
+        return {
+            state: 'unavailable',
+            reason: `the descriptor names ${descriptor.messagingSocketPath}, but no socket exists there`,
+        };
+    }
+    return {
+        state: 'ready',
+        socketPath: descriptor.messagingSocketPath,
+        version: descriptor.version,
+    };
+}
+function socketLine(context) {
+    return `${JSON.stringify({
+        type: 'user',
+        message: { role: 'user', content: context },
+    })}\n`;
+}
+/**
+ * Claude's own-child delivery route.
+ *
+ * A successful socket write proves delivery to Claude Code, not model
+ * consumption — and this route reports exactly that, no more. It reports
+ * `delivered` all the same, because the write is the strongest acknowledgement
+ * this route can ever obtain: the message it posts starts a brand-new turn
+ * rather than continuing this one, so no later hook will confirm anything about
+ * it. An answer delivered once and settled is strictly better than an answer
+ * redelivered on every turn-end for ever.
+ *
+ * Every path that hands nothing over reports `held`, so the accepted journal
+ * replays it. Unknown state deliberately returns without throwing, so the
+ * journal becomes `hold-for-next-turn` instead of failing the hook.
+ */
+export function claudeWakeRoute(options) {
+    const adapters = options.adapters ?? systemClaudeWakeAdapters();
+    let sourceDescriptor = null;
+    try {
+        const parsed = parseDescriptor(adapters.readDescriptor(options.sourcePid));
+        if (parsed !== null &&
+            parsed.sessionId === options.sessionId &&
+            parsed.pid === options.sourcePid) {
+            sourceDescriptor = parsed;
+        }
+    }
+    catch {
+        // Delivery fails closed below; route construction must never break the hook.
+    }
+    return {
+        kind: 'inbox-socket',
+        async deliver(event) {
+            const observation = await observeClaudeSession(options.sessionId, adapters);
+            if (observation.state === 'unknown') {
+                return {
+                    notes: [`holding the accepted answer for the next turn: ${observation.reason}`],
+                    log: { route: 'hold-for-next-turn', stage: 'queued', reason: observation.reason },
+                    acknowledgement: 'held',
+                };
+            }
+            if (sourceDescriptor === null) {
+                const reason = 'the Stop-hook process cannot prove exact Claude session ownership';
+                return {
+                    notes: [`holding the accepted answer for the next turn: ${reason}`],
+                    log: { route: 'hold-for-next-turn', stage: 'queued', reason },
+                    acknowledgement: 'held',
+                };
+            }
+            if (observation.state === 'stopped') {
+                // Probe immediately before spawn. A prior descriptor or dead socket is
+                // never sufficient: resuming a live session creates a divergent ghost.
+                const confirmed = await observeClaudeSession(options.sessionId, adapters);
+                if (confirmed.state !== 'stopped') {
+                    const reason = confirmed.state === 'unknown'
+                        ? confirmed.reason
+                        : 'the Claude session became live before cold resume';
+                    return {
+                        notes: [`holding the accepted answer for the next turn: ${reason}`],
+                        log: { route: 'hold-for-next-turn', stage: 'queued', reason },
+                        acknowledgement: 'held',
+                    };
+                }
+                await adapters.resume(options.sessionId, sourceDescriptor.cwd, event.context);
+                return {
+                    notes: ['cold-resumed the stopped Claude session with its accepted answer'],
+                    log: { route: 'cold-resume', stage: 'delivered' },
+                    acknowledgement: 'delivered',
+                };
+            }
+            if (observation.descriptor.pid !== options.sourcePid ||
+                sourceDescriptor.startedAt !== observation.descriptor.startedAt) {
+                const reason = 'the Stop-hook process is not the observed exact Claude session child';
+                return {
+                    notes: [`holding the accepted answer for the next turn: ${reason}`],
+                    log: { route: 'hold-for-next-turn', stage: 'queued', reason },
+                    acknowledgement: 'held',
+                };
+            }
+            await adapters.sendSocket(observation.descriptor.messagingSocketPath, socketLine(event.context));
+            await adapters.sleep(CLAUDE_POST_SEND_LIVENESS_MS);
+            return {
+                notes: [
+                    observation.state === 'live-idle'
+                        ? 'posted the accepted answer to the live Claude session'
+                        : 'queued the accepted answer for the busy Claude session',
+                ],
+                log: {
+                    route: 'inbox-socket',
+                    stage: 'delivered',
+                    session_state: observation.state,
+                },
+                // The write completed: Claude Code holds the message. Nothing later
+                // reports on it, so this is where the journal settles.
+                acknowledgement: 'delivered',
+            };
+        },
+    };
+}
+function runClaude(args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('claude', args, {
+            ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+            ...(options.env === undefined ? {} : { env: options.env }),
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const stdout = [];
+        const stderr = [];
+        child.stdout?.on('data', (chunk) => stdout.push(Buffer.from(chunk)));
+        child.stderr?.on('data', (chunk) => stderr.push(Buffer.from(chunk)));
+        child.once('error', reject);
+        child.once('exit', (code, signal) => {
+            if (code === 0) {
+                resolve(Buffer.concat(stdout).toString());
+                return;
+            }
+            reject(new Error(`claude ${args[0] ?? ''} exited ${code === null ? `on ${String(signal)}` : String(code)}: ${Buffer.concat(stderr).toString().trim()}`));
+        });
+    });
+}
+function coldResumeEnvironment(env) {
+    const next = { ...env };
+    for (const key of Object.keys(next)) {
+        if (key === 'CLAUDECODE' || key === 'CLAUDE_PID' || key.startsWith('CLAUDE_CODE_')) {
+            delete next[key];
+        }
+    }
+    return next;
+}
+export function systemClaudeWakeAdapters(env = process.env) {
+    return {
+        async listAgents() {
+            const output = await runClaude(['agents', '--json'], { env });
+            return JSON.parse(output);
+        },
+        readDescriptor(pid) {
+            const file = path.join(os.homedir(), '.claude', 'sessions', `${pid}.json`);
+            return JSON.parse(readFileSync(file, 'utf8'));
+        },
+        sendSocket(socketPath, line) {
+            return new Promise((resolve, reject) => {
+                const socket = createConnection(socketPath);
+                let settled = false;
+                const fail = (err) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    socket.destroy();
+                    reject(err);
+                };
+                socket.once('error', fail);
+                socket.once('connect', () => {
+                    socket.end(line, () => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        resolve();
+                    });
+                });
+            });
+        },
+        async resume(sessionId, cwd, context) {
+            if (!existsSync(cwd))
+                throw new Error(`Claude session cwd no longer exists: ${cwd}`);
+            await runClaude([
+                '-p',
+                '--resume',
+                sessionId,
+                '--output-format',
+                'json',
+                context,
+            ], { cwd, env: coldResumeEnvironment(env) });
+        },
+        sleep(milliseconds) {
+            return new Promise((resolve) => setTimeout(resolve, milliseconds));
+        },
+    };
+}
+//# sourceMappingURL=claude-wake.js.map