@wastedcode/claudemux 0.2.0

package/dist/session/boot.js

@@ -0,0 +1,216 @@
+import { AgentExitedDuringBoot, BackendUnreachable, DialogStuck, LoginRequired, ReplTimeout, WorkspaceUntrusted, } from "../errors.js";
+import { stabilize } from "../io/stabilize.js";
+import { readHookEdges } from "../observe/observer.js";
+import { sleep } from "../util/sleep.js";
+import { CLASSIFIER_BOTTOM_N, CLASSIFIER_CAPTURE } from "./constants.js";
+import { formatSessionLabel } from "./ref.js";
+/**
+ * Default total budget for boot: 60s. The dialog loop must reach a *stable*
+ * `agent.boot.isReady` within this window or `ReplTimeout` fires.
+ */
+const DEFAULT_BOOT_TIMEOUT_MS = 60_000;
+/** How long we wait between pane captures while watching for dialog advancement. */
+const POLL_INTERVAL_MS = 150;
+/**
+ * After we respond to a dialog, the pane must show *something different*
+ * within this window. If the same dialog text persists past it, we throw
+ * `DialogStuck` — the response key didn't advance the pane, which means
+ * either the matcher fired on stale scrollback or claude's input layer
+ * isn't accepting keys (the latter is a setup error worth surfacing loudly).
+ */
+const DIALOG_ADVANCE_BUDGET_MS = 5_000;
+/**
+ * Once `isReady` first matches, the pane must hold steady for this window
+ * before we declare boot complete. The empty `❯` input box can flash during
+ * the welcome / MCP-init render *before input is actually interactive* — a
+ * consumer that `send`s into a not-yet-interactive prompt loses the turn
+ * silently (the paste lands, never submits). Requiring stability lets the
+ * welcome/MCP render settle. Longer than `wait`'s idle window (250ms) because
+ * boot has more going on (box draw, remote-control line, MCP connections).
+ * See `engineer/wiki/wait-needs-a-transition-not-a-snapshot`.
+ */
+const READY_STABLE_WINDOW_MS = 1_200;
+/**
+ * Boot the session: dismiss any matching dialogs in order, then wait for ready.
+ *
+ * **Ready signal:** a hook *gate* plus a pane *settle*.
+ *   1. **`session-start` hook edge — the authoritative "started" gate.** With
+ *      hooks on (the default, `opts.rendezvousPath` set), boot will not declare
+ *      ready until this edge fires — a ready-*looking* pane is NOT trusted on
+ *      its own (the founder's "hooks, not screen-scraping" north star). The edge
+ *      lands only once input is interactive and post-dialog. With hooks off
+ *      there is no edge, so the pane is the only signal.
+ *   2. **Stable ready box — the delivery-safety settle.** Even after "started,"
+ *      a fresh REPL is still painting its welcome/MCP render, and the *first*
+ *      send pasted into that render storm is silently lost (verified). So boot
+ *      returns only once the ready box has held *stable*, guaranteeing the input
+ *      is paintable. Dialogs are handled before either check each iteration.
+ *
+ * Throws on the documented failures.
+ *
+ * @throws `WorkspaceUntrusted` if the workspace-trust dialog fires and
+ *   `trustWorkspace` was not set — thrown *before* any keystroke, so no
+ *   persistent trust flag is written.
+ * @throws `LoginRequired` if the login-method dialog fires.
+ * @throws `DialogStuck` if a recognized dialog persists after its response.
+ * @throws `AgentExitedDuringBoot` if the agent process exits (its session is
+ *   reaped) before becoming ready — most often an `agentSessionId` collision.
+ * @throws `ReplTimeout` if the total budget elapses before a stable ready.
+ */
+export async function bootSession(backend, agent, ref, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_BOOT_TIMEOUT_MS;
+    const trustWorkspace = opts.trustWorkspace ?? false;
+    const cwd = opts.cwd ?? ref.name;
+    const start = Date.now();
+    // The rendezvous is reused across resume, so it may ALREADY hold the prior
+    // life's `session-start`. Baseline the count now and wait for a NEW one — else
+    // a resume boots "ready" on a stale edge (clock-independent: count, not time).
+    const priorStarts = countSessionStarts(agent, opts.rendezvousPath);
+    while (true) {
+        if (Date.now() - start > timeoutMs) {
+            throw new ReplTimeout(formatSessionLabel(ref), timeoutMs);
+        }
+        const text = await captureDuringBoot(backend, ref, opts.agentSessionId);
+        // Try every dialog matcher in order — the first that fires wins. Dialogs
+        // are always handled before any ready check (hook or pane), so neither can
+        // declare ready while a dialog is still on screen.
+        const matched = agent.boot.dialogs.find((d) => d.matches(text));
+        if (matched) {
+            await respondToDialog(backend, ref, matched, trustWorkspace, cwd);
+            // Wait for the pane to advance past the matched dialog. If it stays,
+            // either the response didn't land or the matcher misfired on history.
+            await waitForAdvancement(backend, ref, matched);
+            continue; // re-evaluate from the top
+        }
+        // Authoritative "session has started" gate: the agent's SessionStart hook
+        // edge (when hooks are on). The edge only lands once input is interactive
+        // and post-dialog, so we DON'T trust a ready-looking pane until it fires —
+        // that is the founder's "hooks, not screen-scraping" north star. With hooks
+        // off, there is no edge, so the pane is the only signal.
+        const hooksOn = opts.rendezvousPath !== undefined;
+        const started = !hooksOn || countSessionStarts(agent, opts.rendezvousPath) > priorStarts;
+        if (!started) {
+            await sleep(POLL_INTERVAL_MS); // session not started yet — wait for the edge
+            continue;
+        }
+        // Started — but a fresh REPL is still painting its welcome/MCP render, and a
+        // paste into that render storm is silently lost (verified: the first send
+        // races a repaint). So gate the RETURN on a *stable* ready box: the hook
+        // says "started", the pane settle says "the input is paintable now." The
+        // empty box can also flash mid-render, so requiring it to hold is necessary
+        // regardless of the hook.
+        if (agent.boot.isReady(text)) {
+            const remaining = Math.max(0, timeoutMs - (Date.now() - start));
+            const r = await stabilize(backend, ref, {
+                lines: CLASSIFIER_BOTTOM_N,
+                windowMs: READY_STABLE_WINDOW_MS,
+                pollMs: POLL_INTERVAL_MS,
+                timeoutMs: Math.min(remaining, READY_STABLE_WINDOW_MS * 6),
+                ansi: true,
+            });
+            // Re-confirm ready on the settled pane (the render may have moved to a
+            // dialog or back to working; only a stable ready counts).
+            if (r.stable && agent.boot.isReady(r.text) && !anyDialog(agent, r.text)) {
+                return;
+            }
+            continue; // not stable yet (still rendering) — loop and re-evaluate
+        }
+        // Started but the box isn't ready yet (still rendering) — keep polling.
+        await sleep(POLL_INTERVAL_MS);
+    }
+}
+function anyDialog(agent, text) {
+    return agent.boot.dialogs.some((d) => d.matches(text));
+}
+/** How many `session-start` edges the rendezvous holds (0 when hooks off/absent). */
+function countSessionStarts(agent, rendezvousPath) {
+    if (rendezvousPath === undefined)
+        return 0;
+    return readHookEdges({ agent, rendezvousPath }).filter((e) => e.event === "session-start").length;
+}
+/**
+ * Capture the boot pane, distinguishing **the agent exiting before ready**
+ * from a **backend-level fault**. The agent runs with `remain-on-exit off`, so
+ * a fast exit (the dominant case: an `agentSessionId` collision — see
+ * {@link AgentExitedDuringBoot}) reaps the session; the next capture then fails
+ * because the session is gone, not because anything is wrong with us.
+ *
+ * On a capture failure we branch:
+ *   - {@link BackendUnreachable} → a server-level fault (no server / wedged /
+ *     spawn-failed) — surface it unchanged; it is not "the agent exited."
+ *   - otherwise, probe liveness: if the session is genuinely gone, the agent
+ *     exited before ready → {@link AgentExitedDuringBoot} (fast, no waiting out
+ *     the 60s `ReplTimeout`). If it is still alive, the capture hiccuped for
+ *     some other reason — surface the original error honestly.
+ *
+ * This must not mask the *alive-pane* boot failures (`LoginRequired`,
+ * `WorkspaceUntrusted`, `DialogStuck`, `ReplTimeout`): those fire on captured
+ * pane text or the timeout, never on a capture failure, so they are untouched.
+ */
+async function captureDuringBoot(backend, ref, agentSessionId) {
+    try {
+        return await backend.capture(ref, CLASSIFIER_CAPTURE);
+    }
+    catch (err) {
+        if (err instanceof BackendUnreachable)
+            throw err;
+        const alive = await backend.exists(ref).catch(() => false);
+        if (!alive) {
+            throw new AgentExitedDuringBoot(formatSessionLabel(ref), agentSessionId);
+        }
+        throw err;
+    }
+}
+/**
+ * Respond to a matched dialog.
+ *
+ * - `respond.kind === "throw"` → raise the typed error.
+ * - A **gated** dialog (an authority grant, e.g. workspace-trust) → throw the
+ *   gate's error *before sending any key* unless the consumer opted in. The
+ *   throw-before-keystroke order is load-bearing: answering the trust dialog
+ *   writes a persistent trust flag, so we must not send the key on the
+ *   fail-closed path.
+ * - `respond.kind === "key"` → send the key; non-Enter keys get an Enter
+ *   follow-up to submit (Enter is its own submit).
+ */
+async function respondToDialog(backend, ref, dialog, trustWorkspace, cwd) {
+    if (dialog.respond.kind === "throw") {
+        switch (dialog.respond.errorClass) {
+            case "LoginRequired":
+                throw new LoginRequired(formatSessionLabel(ref));
+        }
+    }
+    // Authority gate: fail closed unless opted in — BEFORE any keystroke.
+    if (dialog.gate) {
+        const optedIn = dialog.gate.option === "trustWorkspace" && trustWorkspace;
+        if (!optedIn) {
+            switch (dialog.gate.errorClass) {
+                case "WorkspaceUntrusted":
+                    throw new WorkspaceUntrusted(formatSessionLabel(ref), cwd);
+            }
+        }
+    }
+    const key = dialog.respond.key;
+    await backend.send(ref, { kind: "key", key });
+    // Numeric/letter dialog responses (1, 2, y, n) typically need an Enter to
+    // submit; Enter is its own submit, so no follow-up needed there.
+    if (key !== "Enter") {
+        await backend.send(ref, { kind: "key", key: "Enter" });
+    }
+}
+/**
+ * Wait until the pane no longer matches the just-responded dialog. If the
+ * matcher keeps firing past {@link DIALOG_ADVANCE_BUDGET_MS}, the response
+ * didn't land — throw `DialogStuck` with the dialog's id.
+ */
+async function waitForAdvancement(backend, ref, matched) {
+    const start = Date.now();
+    while (Date.now() - start < DIALOG_ADVANCE_BUDGET_MS) {
+        await sleep(POLL_INTERVAL_MS);
+        const now = await backend.capture(ref, CLASSIFIER_CAPTURE);
+        if (!matched.matches(now))
+            return;
+    }
+    throw new DialogStuck(formatSessionLabel(ref), matched.id);
+}
+//# sourceMappingURL=boot.js.map

package/dist/session/boot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot.js","sourceRoot":"","sources":["../../src/session/boot.ts"],"names":[],"mappings":"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"}

package/dist/session/constants.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The default namespace prefix used by `create`, `exists`, `kill`, `list`
+ * when the caller doesn't pass one. Two consumers on the same machine
+ * pick distinct namespaces to coexist on one shared backend server.
+ */
+export declare const DEFAULT_NAMESPACE = "claudemux";
+/**
+ * Pane height the substrate creates sessions at (`new-session -y`). The
+ * classifier never sees more than this many rows, because `capture-pane -p`
+ * returns only the visible region (never scrollback) — so a stray match in
+ * history is impossible by construction, regardless of the scan window.
+ *
+ * If this changes, {@link CLASSIFIER_BOTTOM_N} should track it.
+ */
+export declare const PANE_HEIGHT = 40;
+/**
+ * How many lines from the bottom of the visible region the classifier scans.
+ * Set to the full pane height ({@link PANE_HEIGHT}): the visible region is
+ * already only {@link PANE_HEIGHT} rows, so `slice(-CLASSIFIER_BOTTOM_N)` is
+ * the whole capture — there is no larger buffer to trim. (An earlier value of
+ * 50 implied a 50-line scan that a 40-row pane can never produce; this ties
+ * the constant to the real cap.)
+ *
+ * Shared by `session/boot.ts`, `session/handle.ts`, and `io/wait.ts` so a
+ * dialog/idle pattern is detected consistently across the boot and wait paths.
+ */
+export declare const CLASSIFIER_BOTTOM_N = 40;
+/**
+ * Capture options for any **readiness / classifier** read — bottom-N rows with
+ * ANSI styling **on** (`capture -e`). The styling is load-bearing: the agent's
+ * idle check separates the dim ghost-placeholder hint shown in an empty input
+ * box from a real (normal-intensity) draft, which is impossible on plain text
+ * (see claude `isReady`). Substring predicates (dialog headers, working) strip
+ * SGR first, so ANSI-on is safe for them too.
+ *
+ * Every readiness read uses this one shape so the `send→wait` pane fingerprints
+ * stay self-consistent (all ANSI). The *public* `capture()` is unaffected — it
+ * defaults to plain, user-facing text.
+ */
+export declare const CLASSIFIER_CAPTURE: {
+    readonly lines: 40;
+    readonly ansi: true;
+};
+/**
+ * Backend-neutral session-meta key under which {@link create} caches the
+ * agent's conversation id, and {@link adopt} reads it back. The id is a
+ * *locator* (it names a conversation and its transcript), not a secret; the
+ * real boundary is who can reach the backend's per-session store — today a
+ * per-process private tmux socket. If claudemux ever multi-tenants onto a
+ * *shared* tmux server, a co-tenant could enumerate every such key and locate
+ * others' transcripts; revisit the store's trust model then.
+ *
+ * One authoritative spelling shared by the writer and the reader so they can
+ * never drift apart.
+ */
+export declare const AGENT_SESSION_ID_META_KEY = "agent-session-id";
+//# sourceMappingURL=constants.d.ts.map

package/dist/session/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/session/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,cAAc,CAAC;AAE7C;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,KAAK,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,KAAc,CAAC;AAE/C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB;;;CAAsD,CAAC;AAEtF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB,qBAAqB,CAAC"}

package/dist/session/constants.js

@@ -0,0 +1,54 @@
+/**
+ * The default namespace prefix used by `create`, `exists`, `kill`, `list`
+ * when the caller doesn't pass one. Two consumers on the same machine
+ * pick distinct namespaces to coexist on one shared backend server.
+ */
+export const DEFAULT_NAMESPACE = "claudemux";
+/**
+ * Pane height the substrate creates sessions at (`new-session -y`). The
+ * classifier never sees more than this many rows, because `capture-pane -p`
+ * returns only the visible region (never scrollback) — so a stray match in
+ * history is impossible by construction, regardless of the scan window.
+ *
+ * If this changes, {@link CLASSIFIER_BOTTOM_N} should track it.
+ */
+export const PANE_HEIGHT = 40;
+/**
+ * How many lines from the bottom of the visible region the classifier scans.
+ * Set to the full pane height ({@link PANE_HEIGHT}): the visible region is
+ * already only {@link PANE_HEIGHT} rows, so `slice(-CLASSIFIER_BOTTOM_N)` is
+ * the whole capture — there is no larger buffer to trim. (An earlier value of
+ * 50 implied a 50-line scan that a 40-row pane can never produce; this ties
+ * the constant to the real cap.)
+ *
+ * Shared by `session/boot.ts`, `session/handle.ts`, and `io/wait.ts` so a
+ * dialog/idle pattern is detected consistently across the boot and wait paths.
+ */
+export const CLASSIFIER_BOTTOM_N = PANE_HEIGHT;
+/**
+ * Capture options for any **readiness / classifier** read — bottom-N rows with
+ * ANSI styling **on** (`capture -e`). The styling is load-bearing: the agent's
+ * idle check separates the dim ghost-placeholder hint shown in an empty input
+ * box from a real (normal-intensity) draft, which is impossible on plain text
+ * (see claude `isReady`). Substring predicates (dialog headers, working) strip
+ * SGR first, so ANSI-on is safe for them too.
+ *
+ * Every readiness read uses this one shape so the `send→wait` pane fingerprints
+ * stay self-consistent (all ANSI). The *public* `capture()` is unaffected — it
+ * defaults to plain, user-facing text.
+ */
+export const CLASSIFIER_CAPTURE = { lines: CLASSIFIER_BOTTOM_N, ansi: true };
+/**
+ * Backend-neutral session-meta key under which {@link create} caches the
+ * agent's conversation id, and {@link adopt} reads it back. The id is a
+ * *locator* (it names a conversation and its transcript), not a secret; the
+ * real boundary is who can reach the backend's per-session store — today a
+ * per-process private tmux socket. If claudemux ever multi-tenants onto a
+ * *shared* tmux server, a co-tenant could enumerate every such key and locate
+ * others' transcripts; revisit the store's trust model then.
+ *
+ * One authoritative spelling shared by the writer and the reader so they can
+ * never drift apart.
+ */
+export const AGENT_SESSION_ID_META_KEY = "agent-session-id";
+//# sourceMappingURL=constants.js.map

package/dist/session/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/session/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,WAAW,CAAC;AAE7C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,EAAE,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,WAAW,CAAC;AAE/C;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,KAAK,EAAE,mBAAmB,EAAE,IAAI,EAAE,IAAI,EAAW,CAAC;AAEtF;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,kBAAkB,CAAC"}

package/dist/session/create.d.ts

@@ -0,0 +1,88 @@
+import type { AgentDef } from "../agents/types.js";
+import type { Backend } from "../backends/types.js";
+import type { SessionHandle } from "../types.js";
+/**
+ * Options for {@link create}. The substrate provides sensible defaults so
+ * the canonical call is `create({ name, cwd })`.
+ */
+export interface CreateOptions {
+    /** Session name within the namespace. */
+    name: string;
+    /** Working directory the agent runs in. */
+    cwd: string;
+    /** Namespace prefix (default: `"claudemux"`). Lets two consumers coexist. */
+    namespace?: string;
+    /** Agent definition (default: claude). */
+    agent?: AgentDef;
+    /** Backend instance (default: tmux on a fresh shared socket per process). */
+    backend?: Backend;
+    /** Extra args passed to the agent's argv. */
+    extraArgs?: string[];
+    /**
+     * Choose the conversation id for this **fresh** session, instead of letting
+     * the substrate mint one. Must be a v4 UUID (validated before spawn —
+     * {@link InvalidAgentSessionId} otherwise). The chosen id is what
+     * {@link SessionHandle.agentSessionId} reports. Leave unset for the common
+     * case: the substrate mints a v4 UUID for you.
+     *
+     * Resume is **not** this option — use the first-class {@link resume} (or, for
+     * an advanced case, an `extraArgs` `--resume <id>`). Passing both this and an
+     * `extraArgs` identity flag (`--session-id` / `--resume` / `--fork-session`)
+     * is a conflict → {@link AgentSessionIdConflict}.
+     */
+    agentSessionId?: string;
+    /** Override env passed to the agent process. */
+    env?: Record<string, string>;
+    /** Boot timeout in ms (default 60_000). */
+    bootTimeoutMs?: number;
+    /**
+     * Opt in to auto-dismissing the agent's workspace-trust dialog. Default
+     * **false** (fail closed). When the agent asks to trust `cwd` and this is
+     * not set, `create` throws `WorkspaceUntrusted` before any keystroke —
+     * trusting a folder is an authority grant the substrate won't make
+     * silently. See {@link WorkspaceUntrusted} for the persistent/global-trust
+     * caveats before enabling it for untrusted-fork (PR-bot / CI) workloads.
+     */
+    trustWorkspace?: boolean;
+    /**
+     * Inject the agent's observe hooks at spawn (default **true**). Hooks give
+     * claudemux deterministic, reliable turn-lifecycle insight without scraping
+     * the TUI. Set `false` to opt out (e.g. you manage your own hooks); observe
+     * then degrades to the best-effort pane+transcript fallback. The exact
+     * injected settings are inspectable via the agent's hook spec.
+     */
+    hooks?: boolean;
+}
+/**
+ * Create a new session: spawn the agent, dismiss boot dialogs, wait for
+ * ready, return a handle.
+ *
+ * @throws `SessionExists` if a session with the same `{ namespace, name }`
+ *   already exists — the substrate never silently adopts.
+ * @throws `InvalidAgentSessionId` if `agentSessionId` is supplied but is not a
+ *   v4 UUID (thrown before spawn).
+ * @throws `AgentSessionIdConflict` if `agentSessionId` is supplied alongside an
+ *   `extraArgs` identity flag (`--session-id` / `--resume` / `--fork-session`)
+ *   — the id was chosen two ways (thrown before spawn).
+ * @throws `LoginRequired` if claude's login-method dialog fires (the
+ *   consumer must `claude auth` first).
+ * @throws `WorkspaceUntrusted` if the agent asks to trust `cwd` and
+ *   `trustWorkspace` was not set (thrown before any keystroke).
+ * @throws `DialogStuck` if a recognized boot dialog persists after its
+ *   response.
+ * @throws `AgentExitedDuringBoot` if the agent exits before becoming ready —
+ *   most often an `agentSessionId` collision (the agent refuses to silently
+ *   resume an in-use id and exits). The id is carried on the error.
+ * @throws `ReplTimeout` if the boot budget elapses before ready.
+ *
+ * @example
+ * ```ts
+ * import { create, claude } from "claudemux";
+ * const session = await create({ name: "job", cwd: process.cwd() });
+ * await session.send("Add a CHANGELOG entry");
+ * await session.wait();
+ * const text = await session.capture();
+ * ```
+ */
+export declare function create(opts: CreateOptions): Promise<SessionHandle>;
+//# sourceMappingURL=create.d.ts.map

package/dist/session/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/session/create.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAMjD;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,6EAA6E;IAC7E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,6EAA6E;IAC7E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6CAA6C;IAC7C,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB;;;;;;;;;;;OAWG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,2CAA2C;IAC3C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CA+BxE"}

package/dist/session/create.js

@@ -0,0 +1,66 @@
+import { SessionExists } from "../errors.js";
+import { formatSessionLabel } from "./ref.js";
+import { resolveSessionContext } from "./resolve.js";
+import { spawnBootHandle } from "./spawn-boot.js";
+import { validateAgentSessionId } from "./validate.js";
+/**
+ * Create a new session: spawn the agent, dismiss boot dialogs, wait for
+ * ready, return a handle.
+ *
+ * @throws `SessionExists` if a session with the same `{ namespace, name }`
+ *   already exists — the substrate never silently adopts.
+ * @throws `InvalidAgentSessionId` if `agentSessionId` is supplied but is not a
+ *   v4 UUID (thrown before spawn).
+ * @throws `AgentSessionIdConflict` if `agentSessionId` is supplied alongside an
+ *   `extraArgs` identity flag (`--session-id` / `--resume` / `--fork-session`)
+ *   — the id was chosen two ways (thrown before spawn).
+ * @throws `LoginRequired` if claude's login-method dialog fires (the
+ *   consumer must `claude auth` first).
+ * @throws `WorkspaceUntrusted` if the agent asks to trust `cwd` and
+ *   `trustWorkspace` was not set (thrown before any keystroke).
+ * @throws `DialogStuck` if a recognized boot dialog persists after its
+ *   response.
+ * @throws `AgentExitedDuringBoot` if the agent exits before becoming ready —
+ *   most often an `agentSessionId` collision (the agent refuses to silently
+ *   resume an in-use id and exits). The id is carried on the error.
+ * @throws `ReplTimeout` if the boot budget elapses before ready.
+ *
+ * @example
+ * ```ts
+ * import { create, claude } from "claudemux";
+ * const session = await create({ name: "job", cwd: process.cwd() });
+ * await session.send("Add a CHANGELOG entry");
+ * await session.wait();
+ * const text = await session.capture();
+ * ```
+ */
+export async function create(opts) {
+    const { ref, agent, backend } = resolveSessionContext(opts);
+    // Exists-check first. Never silently adopt an existing session — that is
+    // the lifecycle-policy footgun claudemux explicitly avoids.
+    if (await backend.exists(ref)) {
+        throw new SessionExists(formatSessionLabel(ref));
+    }
+    // Resolve the FRESH conversation id. The mint is neutral (crypto.randomUUID —
+    // no agent vocabulary); a caller-supplied id is validated as a v4 UUID. The
+    // agent's buildArgv decides how it becomes a flag and returns the id that will
+    // actually run, which `spawnBootHandle` surfaces (single source of truth).
+    const explicit = opts.agentSessionId !== undefined;
+    if (explicit) {
+        validateAgentSessionId(opts.agentSessionId);
+    }
+    const sessionId = explicit ? opts.agentSessionId : crypto.randomUUID();
+    return spawnBootHandle({
+        agent,
+        backend,
+        ref,
+        cwd: opts.cwd,
+        identity: { mode: "fresh", sessionId, explicit },
+        hooks: opts.hooks !== false,
+        ...(opts.extraArgs === undefined ? {} : { extraArgs: opts.extraArgs }),
+        ...(opts.env === undefined ? {} : { env: opts.env }),
+        ...(opts.bootTimeoutMs === undefined ? {} : { bootTimeoutMs: opts.bootTimeoutMs }),
+        ...(opts.trustWorkspace === undefined ? {} : { trustWorkspace: opts.trustWorkspace }),
+    });
+}
+//# sourceMappingURL=create.js.map

package/dist/session/create.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.js","sourceRoot":"","sources":["../../src/session/create.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAuDvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,KAAK,UAAU,MAAM,CAAC,IAAmB;IAC9C,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC;IAE5D,yEAAyE;IACzE,4DAA4D;IAC5D,IAAI,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,aAAa,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC;IACnD,CAAC;IAED,8EAA8E;IAC9E,4EAA4E;IAC5E,+EAA+E;IAC/E,2EAA2E;IAC3E,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,KAAK,SAAS,CAAC;IACnD,IAAI,QAAQ,EAAE,CAAC;QACb,sBAAsB,CAAC,IAAI,CAAC,cAAwB,CAAC,CAAC;IACxD,CAAC;IACD,MAAM,SAAS,GAAG,QAAQ,CAAC,CAAC,CAAE,IAAI,CAAC,cAAyB,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;IAEnF,OAAO,eAAe,CAAC;QACrB,KAAK;QACL,OAAO;QACP,GAAG;QACH,GAAG,EAAE,IAAI,CAAC,GAAG;QACb,QAAQ,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE;QAChD,KAAK,EAAE,IAAI,CAAC,KAAK,KAAK,KAAK;QAC3B,GAAG,CAAC,IAAI,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC;QACtE,GAAG,CAAC,IAAI,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC;QACpD,GAAG,CAAC,IAAI,CAAC,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC;QAClF,GAAG,CAAC,IAAI,CAAC,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC;KACtF,CAAC,CAAC;AACL,CAAC"}

package/dist/session/default-backend.d.ts

@@ -0,0 +1,27 @@
+import type { Backend } from "../backends/types.js";
+/**
+ * Single-source socket-name resolution. Precedence (highest first):
+ *
+ *   `explicit` (`--socket` flag) > `CLAUDEMUX_SOCKET` env > `defaultSocketName()`
+ *
+ * Every candidate is **trimmed**, and the trimmed value is what's both gated
+ * AND returned — so `" claudemux "` resolves to the same socket as the bare
+ * default, instead of a silently-divergent `-L ' claudemux '` server that
+ * re-opens the cross-process rendezvous bug the P0 fix closed (QA P2,
+ * [[decisions/0006-default-backend-rendezvous-identity]]). A whitespace-only
+ * value is treated as "not set" and falls through to the next candidate.
+ *
+ * Lives in this bootstrap module so the backend leaf
+ * (`backends/tmux/socket.ts`) stays a pure function — env/flag composition
+ * is a bootstrap concern, not a backend concern.
+ */
+export declare function resolveSocket(explicit?: string): string;
+export declare function sharedDefaultBackend(): Backend;
+/**
+ * Build a backend with an explicit socket name. Used by the CLI when the
+ * caller passes `--socket <name>` to opt out of the process-wide shared
+ * default. Each call returns a fresh instance (no caching) — the caller
+ * owns the lifetime.
+ */
+export declare function backendWithSocket(socket: string): Backend;
+//# sourceMappingURL=default-backend.d.ts.map

package/dist/session/default-backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-backend.d.ts","sourceRoot":"","sources":["../../src/session/default-backend.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAMvD;AAkBD,wBAAgB,oBAAoB,IAAI,OAAO,CAK9C;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEzD"}

package/dist/session/default-backend.js

@@ -0,0 +1,58 @@
+import { tmuxBackend } from "../backends/tmux/index.js";
+import { defaultSocketName } from "../backends/tmux/socket.js";
+/**
+ * Single-source socket-name resolution. Precedence (highest first):
+ *
+ *   `explicit` (`--socket` flag) > `CLAUDEMUX_SOCKET` env > `defaultSocketName()`
+ *
+ * Every candidate is **trimmed**, and the trimmed value is what's both gated
+ * AND returned — so `" claudemux "` resolves to the same socket as the bare
+ * default, instead of a silently-divergent `-L ' claudemux '` server that
+ * re-opens the cross-process rendezvous bug the P0 fix closed (QA P2,
+ * [[decisions/0006-default-backend-rendezvous-identity]]). A whitespace-only
+ * value is treated as "not set" and falls through to the next candidate.
+ *
+ * Lives in this bootstrap module so the backend leaf
+ * (`backends/tmux/socket.ts`) stays a pure function — env/flag composition
+ * is a bootstrap concern, not a backend concern.
+ */
+export function resolveSocket(explicit) {
+    const fromFlag = explicit?.trim();
+    if (fromFlag)
+        return fromFlag;
+    const fromEnv = process.env.CLAUDEMUX_SOCKET?.trim();
+    if (fromEnv)
+        return fromEnv;
+    return defaultSocketName();
+}
+/**
+ * Process-wide default backend. Lazily constructed on first use so an
+ * `import { exists } from "claudemux"` doesn't spawn a tmux server just by
+ * loading the module.
+ *
+ * The socket name is **stable** (default `"claudemux"`, overridable via
+ * `CLAUDEMUX_SOCKET`). Stability is load-bearing for the CLI: each
+ * `claudemux <verb>` invocation is a cold Node process, and they must
+ * discover each other's sessions. A per-process random socket would break
+ * the entire CLI user journey — see `brain/initiatives/.../qa.md` §P0-1
+ * and `brain/decisions/0006-default-backend-rendezvous-identity.md`.
+ *
+ * Internal — never exported from `src/index.ts`.
+ */
+let cached = null;
+export function sharedDefaultBackend() {
+    if (cached === null) {
+        cached = tmuxBackend({ socket: resolveSocket() });
+    }
+    return cached;
+}
+/**
+ * Build a backend with an explicit socket name. Used by the CLI when the
+ * caller passes `--socket <name>` to opt out of the process-wide shared
+ * default. Each call returns a fresh instance (no caching) — the caller
+ * owns the lifetime.
+ */
+export function backendWithSocket(socket) {
+    return tmuxBackend({ socket });
+}
+//# sourceMappingURL=default-backend.js.map

package/dist/session/default-backend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-backend.js","sourceRoot":"","sources":["../../src/session/default-backend.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAG/D;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,aAAa,CAAC,QAAiB;IAC7C,MAAM,QAAQ,GAAG,QAAQ,EAAE,IAAI,EAAE,CAAC;IAClC,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC9B,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,gBAAgB,EAAE,IAAI,EAAE,CAAC;IACrD,IAAI,OAAO;QAAE,OAAO,OAAO,CAAC;IAC5B,OAAO,iBAAiB,EAAE,CAAC;AAC7B,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,IAAI,MAAM,GAAmB,IAAI,CAAC;AAElC,MAAM,UAAU,oBAAoB;IAClC,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,MAAM,GAAG,WAAW,CAAC,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE,CAAC,CAAC;IACpD,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAc;IAC9C,OAAO,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;AACjC,CAAC"}