@with-logic/elwood 0.1.0 → 0.1.2

package/dist/runtime/session-shutdown.d.ts

@@ -1,60 +0,0 @@
-/**
- * Explicit shutdown/teardown orchestration for AgentSessionBase, extracted to keep
- * the base within the file-size cap. Implements PRD §5.3/§9.4 (C-LIFE-10): every
- * path ATTEMPTS/RETRIES the leader's process-group reap and propagates a reap failure
- * as a typed error (never swallows it), while an already-terminal session is never
- * re-signaled — node-pty does not replay the exit and the pid may be recycled.
- */
-import type { ElwoodSessionStatus } from "../core/types.ts";
-import type { PtyProcess } from "../pty/types.ts";
-import type { SessionReapPolicy } from "./session-reap.ts";
-import type { ShutdownContext, ShutdownCoordinator } from "./shutdown-coordinator.ts";
-import type { StatusEvidenceKind } from "./status-evidence.ts";
-/** Evidence kinds an explicit shutdown submits once it drives the PTY to exit. */
-export type ShutdownEvidence = "stop_completed" | "kill_completed" | "teardown_completed";
-/** The reap surface shutdown drives: the typed-throw reap plus the retryable one-shot. */
-export type ShutdownReapPolicy = Pick<SessionReapPolicy, "orThrow"> & {
-    readonly reaper: Pick<SessionReapPolicy["reaper"], "reap">;
-};
-/** The session surface the shutdown/teardown orchestration drives. */
-export type ShutdownHost = {
-    readonly pty: PtyProcess;
-    readonly stateDir: string;
-    readonly elwoodSessionId: string;
-    /** The session's stable socket home; teardown removes it whole (§8.1). */
-    readonly socketHome: string;
-    readonly reapPolicy: ShutdownReapPolicy;
-    readonly status: () => ElwoodSessionStatus;
-    readonly claimShutdown: (evidence: ShutdownEvidence) => void;
-    readonly pauseLoops: () => void;
-    readonly clearLoops: (reason: "kill" | "teardown") => Promise<void>;
-    readonly cleanupRuntime: () => Promise<void>;
-    readonly submitEvidence: (kind: StatusEvidenceKind) => void;
-};
-/** The three public shutdown verbs bound to a coordinator and lazy host. */
-type ManagedShutdown = {
-    readonly stop: () => Promise<void>;
-    readonly kill: () => Promise<void>;
-    readonly teardown: () => Promise<void>;
-};
-/** Binds `stop`/`kill`/`teardown` to one coordinator + lazily-built host (C-LIFE-10). */
-export declare function managedShutdown(coordinator: ShutdownCoordinator, host: () => ShutdownHost): ManagedShutdown;
-/**
- * Graceful stop / force kill. Does NOT re-signal when the PTY was already signaled
- * (by a prior shutdown, even one that threw before going terminal) or the session is
- * already terminal — node-pty won't replay exit (the wait would time out) and the pid
- * may be recycled. In that case it performs a one-shot survivor reap that rejects with
- * a typed error on failure and leaves the reap retryable; a first, live shutdown marks
- * signal ownership, terminates the PTY (which reaps on every path), and records
- * shutdown evidence (C-LIFE-10).
- */
-export declare function runShutdown(host: ShutdownHost, signal: "SIGTERM" | "SIGKILL", evidence: ShutdownEvidence, ctx: ShutdownContext): Promise<void>;
-/**
- * Teardown: terminate a still-live PTY (unless it was already signaled), reap
- * (retrying a prior failed reap), stop the runtime, record teardown evidence, and
- * remove owned session files. Each step runs even if an earlier one rejected, so a
- * leaked group is always reaped; a re-signal is refused once signal ownership is held.
- */
-export declare function runTeardown(host: ShutdownHost, ctx: ShutdownContext): Promise<void>;
-export {};
-//# sourceMappingURL=session-shutdown.d.ts.map

package/dist/runtime/session-shutdown.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"session-shutdown.d.ts","sourceRoot":"","sources":["../../src/runtime/session-shutdown.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACtF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAI/D,kFAAkF;AAClF,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,oBAAoB,CAAC;AAE1F,0FAA0F;AAC1F,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,iBAAiB,EAAE,SAAS,CAAC,GAAG;IACpE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAC;CAC5D,CAAC;AAEF,sEAAsE;AACtE,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,0EAA0E;IAC1E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,mBAAmB,CAAC;IAC3C,QAAQ,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC7D,QAAQ,CAAC,UAAU,EAAE,MAAM,IAAI,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE,QAAQ,CAAC,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,QAAQ,CAAC,cAAc,EAAE,CAAC,IAAI,EAAE,kBAAkB,KAAK,IAAI,CAAC;CAC7D,CAAC;AAEF,4EAA4E;AAC5E,KAAK,eAAe,GAAG;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACxC,CAAC;AAEF,yFAAyF;AACzF,wBAAgB,eAAe,CAC7B,WAAW,EAAE,mBAAmB,EAChC,IAAI,EAAE,MAAM,YAAY,GACvB,eAAe,CAMjB;AAuCD;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,SAAS,GAAG,SAAS,EAC7B,QAAQ,EAAE,gBAAgB,EAC1B,GAAG,EAAE,eAAe,GACnB,OAAO,CAAC,IAAI,CAAC,CAWf;AAkBD;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBzF"}

package/dist/runtime/session-shutdown.js

@@ -1,140 +0,0 @@
-/**
- * Explicit shutdown/teardown orchestration for AgentSessionBase, extracted to keep
- * the base within the file-size cap. Implements PRD §5.3/§9.4 (C-LIFE-10): every
- * path ATTEMPTS/RETRIES the leader's process-group reap and propagates a reap failure
- * as a typed error (never swallows it), while an already-terminal session is never
- * re-signaled — node-pty does not replay the exit and the pid may be recycled.
- */
-import { elwoodError } from "../core/errors.js";
-import { terminalStatuses } from "../core/status-categories.js";
-import { removeSessionFiles } from "../state/store.js";
-import { runTeardownSteps } from "./teardown.js";
-import { terminatePty } from "./terminate.js";
-/** Binds `stop`/`kill`/`teardown` to one coordinator + lazily-built host (C-LIFE-10). */
-export function managedShutdown(coordinator, host) {
-    return {
-        stop: () => runManagedShutdown(coordinator, "stop", host),
-        kill: () => runManagedShutdown(coordinator, "kill", host),
-        teardown: () => runManagedShutdown(coordinator, "teardown", host),
-    };
-}
-// Each public verb's orchestration. The host is the ONE owner of loop pausing: `stop`
-// pauses timers and keeps definitions for resume; `kill`/`teardown` clear them (§8.4).
-const shutdownVerbs = {
-    stop: (host, ctx) => {
-        host.pauseLoops();
-        return runShutdown(host, "SIGTERM", "stop_completed", ctx);
-    },
-    kill: (host, ctx) => runKillShutdown(host, () => runShutdown(host, "SIGKILL", "kill_completed", ctx)),
-    teardown: (host, ctx) => runTeardown(host, ctx),
-};
-/**
- * Route a public `stop`/`kill`/`teardown` through the session's coordinator so the
- * PTY is signaled at most once and overlapping callers join the in-flight shutdown
- * (C-LIFE-10). The host is built lazily inside the coordinated operation, which is
- * told whether the PTY was `alreadySignaled` so a retry never re-signals it.
- */
-function runManagedShutdown(coordinator, verb, host) {
-    return coordinator.run(verb, (ctx) => shutdownVerbs[verb](host(), ctx));
-}
-/**
- * True when the PTY must NOT be signaled: either a prior shutdown already signaled it
- * (a predecessor that signaled+reaped but threw before submitting terminal status must
- * not trigger a re-signal of a possibly-recycled PID) OR the session already reached a
- * terminal status. Signal ownership is tracked INDEPENDENTLY of lifecycle status so a
- * non-terminal-but-already-signaled state still refuses a second signal (C-LIFE-10).
- */
-function mustNotSignal(host, ctx) {
-    return ctx.alreadySignaled || terminalStatuses.has(host.status());
-}
-/**
- * Graceful stop / force kill. Does NOT re-signal when the PTY was already signaled
- * (by a prior shutdown, even one that threw before going terminal) or the session is
- * already terminal — node-pty won't replay exit (the wait would time out) and the pid
- * may be recycled. In that case it performs a one-shot survivor reap that rejects with
- * a typed error on failure and leaves the reap retryable; a first, live shutdown marks
- * signal ownership, terminates the PTY (which reaps on every path), and records
- * shutdown evidence (C-LIFE-10).
- */
-export async function runShutdown(host, signal, evidence, ctx) {
-    host.claimShutdown(evidence); // Claim the exit before signaling.
-    if (mustNotSignal(host, ctx)) {
-        host.reapPolicy.orThrow(); // Typed rejection on failure; never swallows.
-        await cleanupOrThrowTermination(host);
-        return; // Already signaled / terminal: no new signal, no evidence to submit.
-    }
-    ctx.markSignaled();
-    await terminatePty(host.pty, signal, host.reapPolicy.reaper);
-    await cleanupOrThrowTermination(host);
-    host.submitEvidence(evidence);
-}
-/**
- * Runs runtime cleanup, folding its raw aggregate failure into the stable public
- * `termination_failed` error. `runCleanupSteps` rejects with a bare `Error` on the
- * assumption that its caller wraps it; `stop()`/`kill()` are that caller, so without
- * this an untyped Error would escape the public shutdown boundary (PRD §10).
- */
-async function cleanupOrThrowTermination(host) {
-    try {
-        await host.cleanupRuntime();
-    }
-    catch (error) {
-        throw elwoodError("termination_failed", "Could not clean up the Elwood runtime.", {
-            cause: error instanceof Error ? error.message : String(error),
-        });
-    }
-}
-/**
- * Teardown: terminate a still-live PTY (unless it was already signaled), reap
- * (retrying a prior failed reap), stop the runtime, record teardown evidence, and
- * remove owned session files. Each step runs even if an earlier one rejected, so a
- * leaked group is always reaped; a re-signal is refused once signal ownership is held.
- */
-export async function runTeardown(host, ctx) {
-    host.claimShutdown("teardown_completed");
-    const shouldSignal = () => !mustNotSignal(host, ctx);
-    await runPermanentShutdown(host, "teardown", () => runTeardownSteps([
-        () => {
-            if (!shouldSignal())
-                return undefined;
-            ctx.markSignaled();
-            return terminatePty(host.pty, "SIGKILL", host.reapPolicy.reaper);
-        },
-        () => host.reapPolicy.reaper.reap(), // No-op once latched; retries a failed reap.
-        () => host.cleanupRuntime(),
-        () => host.submitEvidence("teardown_completed"),
-        () => removeSessionFiles({
-            stateDir: host.stateDir,
-            elwoodSessionId: host.elwoodSessionId,
-            socketHome: host.socketHome,
-        }),
-    ]));
-}
-/** Clear durable loops first, but always finish process/file cleanup before rejecting. */
-async function runPermanentShutdown(host, reason, cleanup) {
-    let loopFailure;
-    let cleanupFailure;
-    try {
-        await host.clearLoops(reason);
-    }
-    catch (error) {
-        loopFailure = error;
-    }
-    try {
-        await cleanup();
-    }
-    catch (error) {
-        cleanupFailure = error;
-    }
-    if (loopFailure !== undefined)
-        throw loopFailure;
-    if (cleanupFailure !== undefined)
-        throw cleanupFailure;
-}
-/** Kill stops live timers first, but keeps durable definitions until termination succeeds. */
-async function runKillShutdown(host, cleanup) {
-    host.pauseLoops();
-    await cleanup();
-    await host.clearLoops("kill");
-}
-//# sourceMappingURL=session-shutdown.js.map

package/dist/runtime/session-shutdown.js.map

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

package/dist/runtime/session-status-wiring.d.ts

@@ -1,38 +0,0 @@
-/**
- * Connects lifecycle status transitions to the control queue, loops, event
- * delivery, and cleanup (PRD §5.3/§5.9, C-API-42). Status and activity events are
- * emitted here; a throwing status listener PROPAGATES by design — the
- * `initial_ready` transition relies on it to trigger its release-and-warn fallback.
- * The engine commits its live `current` status BEFORE emitting, so a throw here can
- * never leave the emitted event disagreeing with that live status (§8.2).
- */
-import { type ElwoodActivityEvent, type ElwoodAgentKind } from "../core/activity.ts";
-import type { CompactEmitter } from "../core/compact.ts";
-import type { ControlQueue } from "../core/control-queue.ts";
-import type { ElwoodSessionStatus, Unsubscribe } from "../core/types.ts";
-import type { LoopEventEmitter, SessionLoops } from "./session-loops.ts";
-import { SessionStatusEngine } from "./status-evidence.ts";
-type StatusEvent = {
-    readonly elwoodSessionId: string;
-    readonly status: ElwoodSessionStatus;
-};
-/** The emitter surface a session's status, compact, loop, and activity wiring needs. */
-export type SessionStatusEmitter = CompactEmitter & LoopEventEmitter & {
-    emit(event: "status", payload: StatusEvent): void;
-    emit(event: "activity", payload: ElwoodActivityEvent): void;
-    on(event: "activity", handler: (event: ElwoodActivityEvent) => void): Unsubscribe;
-};
-type StatusWiringInput = {
-    readonly agent: ElwoodAgentKind;
-    readonly elwoodSessionId: string;
-    readonly emitter: SessionStatusEmitter;
-    readonly queue: ControlQueue;
-    readonly loops: SessionLoops;
-    readonly markReady: () => void;
-    readonly cleanup: () => void;
-};
-export declare function createSessionStatusEngine(input: StatusWiringInput): SessionStatusEngine;
-/** Deliver the status event and its derived activity event (a listener throw propagates). */
-export declare function emitStatusEvents(emitter: SessionStatusEmitter, agent: ElwoodAgentKind, id: string, status: ElwoodSessionStatus): void;
-export {};
-//# sourceMappingURL=session-status-wiring.d.ts.map

package/dist/runtime/session-status-wiring.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"session-status-wiring.d.ts","sourceRoot":"","sources":["../../src/runtime/session-status-wiring.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAE3D,KAAK,WAAW,GAAG;IAAE,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAAC;AAE9F,wFAAwF;AACxF,MAAM,MAAM,oBAAoB,GAAG,cAAc,GAC/C,gBAAgB,GAAG;IACjB,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;IAClD,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC5D,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,GAAG,WAAW,CAAC;CACnF,CAAC;AAEJ,KAAK,iBAAiB,GAAG;IACvB,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,oBAAoB,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,IAAI,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B,CAAC;AAEF,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,iBAAiB,GAAG,mBAAmB,CAyBvF;AAED,6FAA6F;AAC7F,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,oBAAoB,EAC7B,KAAK,EAAE,eAAe,EACtB,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,mBAAmB,GAC1B,IAAI,CAGN"}

package/dist/runtime/session-status-wiring.js

@@ -1,41 +0,0 @@
-/**
- * Connects lifecycle status transitions to the control queue, loops, event
- * delivery, and cleanup (PRD §5.3/§5.9, C-API-42). Status and activity events are
- * emitted here; a throwing status listener PROPAGATES by design — the
- * `initial_ready` transition relies on it to trigger its release-and-warn fallback.
- * The engine commits its live `current` status BEFORE emitting, so a throw here can
- * never leave the emitted event disagreeing with that live status (§8.2).
- */
-import { activityFromStatus, } from "../core/activity.js";
-import { SessionStatusEngine } from "./status-evidence.js";
-export function createSessionStatusEngine(input) {
-    // Both a turn in progress and a blocking dialog suspend delivery the same way:
-    // the queue stops draining and due loops wait (§5.9: "a due loop waits while the
-    // session is running, blocked, or otherwise unable to accept a message"). Neither
-    // implies a NEW turn — that is `turnStarted`, driven by the queue's own submission.
-    const suspend = () => {
-        input.loops.running();
-        input.queue.suspendReadiness();
-    };
-    return new SessionStatusEngine({
-        onReady: input.markReady,
-        emitStatus: (status) => emitStatusEvents(input.emitter, input.agent, input.elwoodSessionId, status),
-        queueRunning: suspend,
-        queueReady: () => {
-            input.loops.ready();
-            input.queue.markReady();
-        },
-        queueBlocked: suspend,
-        queueClose: () => {
-            input.loops.pause();
-            input.queue.close();
-        },
-        cleanup: input.cleanup,
-    });
-}
-/** Deliver the status event and its derived activity event (a listener throw propagates). */
-export function emitStatusEvents(emitter, agent, id, status) {
-    emitter.emit("status", { elwoodSessionId: id, status });
-    emitter.emit("activity", activityFromStatus(agent, id, status));
-}
-//# sourceMappingURL=session-status-wiring.js.map

package/dist/runtime/session-status-wiring.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"session-status-wiring.js","sourceRoot":"","sources":["../../src/runtime/session-status-wiring.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACL,kBAAkB,GAGnB,MAAM,qBAAqB,CAAC;AAK7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAsB3D,MAAM,UAAU,yBAAyB,CAAC,KAAwB;IAChE,+EAA+E;IAC/E,iFAAiF;IACjF,kFAAkF;IAClF,oFAAoF;IACpF,MAAM,OAAO,GAAG,GAAG,EAAE;QACnB,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QACtB,KAAK,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAC;IACjC,CAAC,CAAC;IACF,OAAO,IAAI,mBAAmB,CAAC;QAC7B,OAAO,EAAE,KAAK,CAAC,SAAS;QACxB,UAAU,EAAE,CAAC,MAAM,EAAE,EAAE,CACrB,gBAAgB,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,eAAe,EAAE,MAAM,CAAC;QAC7E,YAAY,EAAE,OAAO;QACrB,UAAU,EAAE,GAAG,EAAE;YACf,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;YACpB,KAAK,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC;QAC1B,CAAC;QACD,YAAY,EAAE,OAAO;QACrB,UAAU,EAAE,GAAG,EAAE;YACf,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;YACpB,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACtB,CAAC;QACD,OAAO,EAAE,KAAK,CAAC,OAAO;KACvB,CAAC,CAAC;AACL,CAAC;AAED,6FAA6F;AAC7F,MAAM,UAAU,gBAAgB,CAC9B,OAA6B,EAC7B,KAAsB,EACtB,EAAU,EACV,MAA2B;IAE3B,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;IACxD,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,kBAAkB,CAAC,KAAK,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;AAClE,CAAC"}

package/dist/runtime/session-status.d.ts

@@ -1,7 +0,0 @@
-/**
- * Shared lifecycle status helpers for in-memory sessions.
- * Implements PRD §5 lifecycle guarantees.
- */
-import type { ElwoodSessionStatus } from "../core/types.ts";
-export declare function canTransition(current: ElwoodSessionStatus, next: ElwoodSessionStatus): boolean;
-//# sourceMappingURL=session-status.d.ts.map

package/dist/runtime/session-status.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"session-status.d.ts","sourceRoot":"","sources":["../../src/runtime/session-status.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAE5D,wBAAgB,aAAa,CAAC,OAAO,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAW9F"}

package/dist/runtime/session-status.js

@@ -1,22 +0,0 @@
-/**
- * Shared lifecycle status helpers for in-memory sessions.
- * Implements PRD §5 lifecycle guarantees.
- */
-import { terminalStatuses } from "../core/status-categories.js";
-export function canTransition(current, next) {
-    if (current === next)
-        return false;
-    if (current === "torn_down")
-        return false;
-    // `teardown` is the final cleanup and may supersede any earlier terminal
-    // status (e.g. tearing down an already-exited session).
-    if (next === "torn_down")
-        return true;
-    // Otherwise a terminated session keeps its first terminal status: no
-    // terminal status transitions to another, so a racing `exited` cannot
-    // override a controlled `stopped`/`killed`.
-    if (terminalStatuses.has(current))
-        return false;
-    return true;
-}
-//# sourceMappingURL=session-status.js.map

package/dist/runtime/session-status.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"session-status.js","sourceRoot":"","sources":["../../src/runtime/session-status.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAGhE,MAAM,UAAU,aAAa,CAAC,OAA4B,EAAE,IAAyB;IACnF,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IACnC,IAAI,OAAO,KAAK,WAAW;QAAE,OAAO,KAAK,CAAC;IAC1C,yEAAyE;IACzE,wDAAwD;IACxD,IAAI,IAAI,KAAK,WAAW;QAAE,OAAO,IAAI,CAAC;IACtC,qEAAqE;IACrE,sEAAsE;IACtE,4CAA4C;IAC5C,IAAI,gBAAgB,CAAC,GAAG,CAAC,OAAO,CAAC;QAAE,OAAO,KAAK,CAAC;IAChD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/runtime/shutdown-coordinator.d.ts

@@ -1,57 +0,0 @@
-/**
- * Serializes a session's overlapping stop/kill/teardown so the PTY is signaled at
- * most once (PRD §5.3/§9.4, C-LIFE-10). Concurrent shutdown calls can each snapshot
- * a non-terminal status and race into `terminatePty`; if the OS process exits before
- * node-pty's exit callback updates status, a later caller could signal the numeric
- * PID again AFTER the kernel recycled it, and duplicate waiters / first-wins evidence
- * could mislabel a force-killed exit as merely stopped.
- *
- * Two pieces of state, tracked SEPARATELY, make this safe and still retryable:
- *   - `signaled` — sticky, set the first time any shutdown signals the PTY. It is
- *     NEVER cleared. A later caller that finds it set does NOT re-signal solely
- *     because the lifecycle status is still non-terminal (a predecessor that
- *     signaled+reaped but threw before submitting terminal status must not cause a
- *     re-signal of a possibly-recycled PID); it may still reap/cleanup/teardown.
- *   - `inFlight` — the current in-flight run, CLEARED on settlement (with identity
- *     protection). A failed `stop()`/`kill()`/`teardown()` therefore does not return
- *     a permanently rejected promise to every later caller: once it settles, a later
- *     call starts a fresh operation that RETRIES reap/cleanup/removal without
- *     re-signaling the PTY (C-LIFE-10 retry posture).
- */
-/** Ordered so a later request can tell whether it escalates the in-flight one. */
-export type ShutdownLevel = "stop" | "kill" | "teardown";
-/** What a coordinated shutdown operation is told about prior signal ownership. */
-export type ShutdownContext = {
-    /** True once ANY prior shutdown signaled the PTY — do not re-signal, only reap/cleanup. */
-    readonly alreadySignaled: boolean;
-    /** Record that this operation is about to signal the PTY (idempotent). */
-    readonly markSignaled: () => void;
-};
-type ShutdownOperation = (context: ShutdownContext) => Promise<void>;
-/**
- * One coordinator per session. `run` is claimed synchronously: it records the
- * in-flight request before returning control, so a concurrent caller entering the
- * same tick sees it and joins instead of starting a second, racing shutdown.
- */
-export declare class ShutdownCoordinator {
-    private inFlight;
-    private signaled;
-    /**
-     * Claim (or join) the in-flight shutdown for `level`, running `operation` only
-     * when this call actually owns work:
-     *   - No in-flight run: this caller owns it; `operation` runs immediately.
-     *   - In-flight run of an equal-or-higher level: JOIN it (await the same promise);
-     *     `operation` never runs, so the PTY is not signaled a second time.
-     *   - In-flight run of a LOWER level (escalation): chain `operation` AFTER the
-     *     in-flight run settles, so it observes the terminal status that run produced.
-     * The operation is told whether the PTY was `alreadySignaled` so it reaps/cleans
-     * up instead of re-signaling. On settlement `inFlight` is cleared (identity-guarded)
-     * so a later call can retry a failed reap/cleanup without re-signaling.
-     */
-    run(level: ShutdownLevel, operation: ShutdownOperation): Promise<void>;
-    /** Drop the active entry once it settles, but never clobber a newer one. */
-    private clear;
-    private context;
-}
-export {};
-//# sourceMappingURL=shutdown-coordinator.d.ts.map

package/dist/runtime/shutdown-coordinator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shutdown-coordinator.d.ts","sourceRoot":"","sources":["../../src/runtime/shutdown-coordinator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,kFAAkF;AAClF,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,CAAC;AAIzD,kFAAkF;AAClF,MAAM,MAAM,eAAe,GAAG;IAC5B,2FAA2F;IAC3F,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,0EAA0E;IAC1E,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAC;CACnC,CAAC;AAEF,KAAK,iBAAiB,GAAG,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAGrE;;;;GAIG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAuB;IAGvC,OAAO,CAAC,QAAQ,CAAS;IAEzB;;;;;;;;;;;OAWG;IACH,GAAG,CAAC,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBtE,4EAA4E;IAC5E,OAAO,CAAC,KAAK;IAIb,OAAO,CAAC,OAAO;CAQhB"}

package/dist/runtime/shutdown-coordinator.js

@@ -1,77 +0,0 @@
-/**
- * Serializes a session's overlapping stop/kill/teardown so the PTY is signaled at
- * most once (PRD §5.3/§9.4, C-LIFE-10). Concurrent shutdown calls can each snapshot
- * a non-terminal status and race into `terminatePty`; if the OS process exits before
- * node-pty's exit callback updates status, a later caller could signal the numeric
- * PID again AFTER the kernel recycled it, and duplicate waiters / first-wins evidence
- * could mislabel a force-killed exit as merely stopped.
- *
- * Two pieces of state, tracked SEPARATELY, make this safe and still retryable:
- *   - `signaled` — sticky, set the first time any shutdown signals the PTY. It is
- *     NEVER cleared. A later caller that finds it set does NOT re-signal solely
- *     because the lifecycle status is still non-terminal (a predecessor that
- *     signaled+reaped but threw before submitting terminal status must not cause a
- *     re-signal of a possibly-recycled PID); it may still reap/cleanup/teardown.
- *   - `inFlight` — the current in-flight run, CLEARED on settlement (with identity
- *     protection). A failed `stop()`/`kill()`/`teardown()` therefore does not return
- *     a permanently rejected promise to every later caller: once it settles, a later
- *     call starts a fresh operation that RETRIES reap/cleanup/removal without
- *     re-signaling the PTY (C-LIFE-10 retry posture).
- */
-const levelRank = { stop: 0, kill: 1, teardown: 2 };
-/**
- * One coordinator per session. `run` is claimed synchronously: it records the
- * in-flight request before returning control, so a concurrent caller entering the
- * same tick sees it and joins instead of starting a second, racing shutdown.
- */
-export class ShutdownCoordinator {
-    inFlight;
-    // Sticky: once the PTY is signaled it must never be signaled again (recycled PID),
-    // independently of whether a run reached a terminal status before it settled.
-    signaled = false;
-    /**
-     * Claim (or join) the in-flight shutdown for `level`, running `operation` only
-     * when this call actually owns work:
-     *   - No in-flight run: this caller owns it; `operation` runs immediately.
-     *   - In-flight run of an equal-or-higher level: JOIN it (await the same promise);
-     *     `operation` never runs, so the PTY is not signaled a second time.
-     *   - In-flight run of a LOWER level (escalation): chain `operation` AFTER the
-     *     in-flight run settles, so it observes the terminal status that run produced.
-     * The operation is told whether the PTY was `alreadySignaled` so it reaps/cleans
-     * up instead of re-signaling. On settlement `inFlight` is cleared (identity-guarded)
-     * so a later call can retry a failed reap/cleanup without re-signaling.
-     */
-    run(level, operation) {
-        const current = this.inFlight;
-        if (current && levelRank[current.level] >= levelRank[level])
-            return current.promise;
-        const invoke = () => operation(this.context());
-        // No in-flight run: this caller owns it and starts SYNCHRONOUSLY (no microtask gap
-        // before the PTY signal). An escalation chains AFTER the lower-level in-flight run
-        // so it observes the terminal status that run produced; the predecessor's rejection
-        // is absorbed here (each shutdown still surfaces its own failure to its own caller).
-        const promise = current ? current.promise.then(invoke, invoke) : invoke();
-        const entry = { level, promise };
-        this.inFlight = entry;
-        // Clear on settlement so a settled failure never permanently blocks a retry — but
-        // only if this is still the active entry (a newer run must not be clobbered). The
-        // rejection is swallowed on THIS observer only; the `promise` returned to the
-        // caller still rejects so each shutdown surfaces its own failure.
-        promise.then(() => this.clear(entry), () => this.clear(entry));
-        return promise;
-    }
-    /** Drop the active entry once it settles, but never clobber a newer one. */
-    clear(entry) {
-        if (this.inFlight === entry)
-            this.inFlight = undefined;
-    }
-    context() {
-        return {
-            alreadySignaled: this.signaled,
-            markSignaled: () => {
-                this.signaled = true;
-            },
-        };
-    }
-}
-//# sourceMappingURL=shutdown-coordinator.js.map

package/dist/runtime/shutdown-coordinator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"shutdown-coordinator.js","sourceRoot":"","sources":["../../src/runtime/shutdown-coordinator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAKH,MAAM,SAAS,GAA4C,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC;AAa7F;;;;GAIG;AACH,MAAM,OAAO,mBAAmB;IACtB,QAAQ,CAAuB;IACvC,mFAAmF;IACnF,8EAA8E;IACtE,QAAQ,GAAG,KAAK,CAAC;IAEzB;;;;;;;;;;;OAWG;IACH,GAAG,CAAC,KAAoB,EAAE,SAA4B;QACpD,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC9B,IAAI,OAAO,IAAI,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,SAAS,CAAC,KAAK,CAAC;YAAE,OAAO,OAAO,CAAC,OAAO,CAAC;QACpF,MAAM,MAAM,GAAG,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;QAC/C,mFAAmF;QACnF,mFAAmF;QACnF,oFAAoF;QACpF,qFAAqF;QACrF,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QAC1E,MAAM,KAAK,GAAa,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAC3C,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,kFAAkF;QAClF,kFAAkF;QAClF,8EAA8E;QAC9E,kEAAkE;QAClE,OAAO,CAAC,IAAI,CACV,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EACvB,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,4EAA4E;IACpE,KAAK,CAAC,KAAe;QAC3B,IAAI,IAAI,CAAC,QAAQ,KAAK,KAAK;YAAE,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC;IACzD,CAAC;IAEO,OAAO;QACb,OAAO;YACL,eAAe,EAAE,IAAI,CAAC,QAAQ;YAC9B,YAAY,EAAE,GAAG,EAAE;gBACjB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACvB,CAAC;SACF,CAAC;IACJ,CAAC;CACF"}

package/dist/runtime/startup-buffer.d.ts

@@ -1,33 +0,0 @@
-/**
- * Bounded, release-able collector for the first PTY output of a session.
- *
- * The startup usability check (see startup.ts, `assertStartupUsable`) reads the
- * agent's early output exactly once at ~500ms to detect a crash or auth banner.
- * The PTY data handler is never detached for the session's lifetime, so a naive
- * `startupOutput += data` accumulates a second unbounded in-memory transcript
- * for the WHOLE session even though only the startup snapshot is ever consumed.
- *
- * This collector appends only while the startup gate is open and caps the buffer
- * so a chatty CLI cannot balloon it; once `release()` is called (right after the
- * usability check reads it) further chunks are dropped and the retained string is
- * cleared, so no per-session transcript lingers. Implements PRD §9.1 startup
- * usability and §9.4 resource cleanup.
- */
-import type { PtyExit } from "../pty/types.ts";
-import { type StartupAdapter } from "./startup.ts";
-export type StartupBuffer = {
-    /** Appends a PTY chunk while the gate is open; a no-op once released. */
-    readonly push: (data: string) => void;
-    /** Returns the collected startup output (empty once released). */
-    readonly read: () => string;
-    /** Stops collecting and clears the retained buffer for the rest of the session. */
-    readonly release: () => void;
-};
-export declare function createStartupBuffer(cap?: number): StartupBuffer;
-/**
- * Runs the ~500ms startup usability check against `buffer`, then releases it on
- * every path (success OR failure) so the collector stops appending and clears
- * its retained string for the rest of the session (§9.1, §9.4).
- */
-export declare function assertStartupThenRelease(adapter: StartupAdapter, buffer: StartupBuffer, exit: () => PtyExit | undefined): Promise<void>;
-//# sourceMappingURL=startup-buffer.d.ts.map

package/dist/runtime/startup-buffer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"startup-buffer.d.ts","sourceRoot":"","sources":["../../src/runtime/startup-buffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAuB,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAMxE,MAAM,MAAM,aAAa,GAAG;IAC1B,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,kEAAkE;IAClE,QAAQ,CAAC,IAAI,EAAE,MAAM,MAAM,CAAC;IAC5B,mFAAmF;IACnF,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,GAAG,GAAE,MAA2B,GAAG,aAAa,CAiBnF;AAED;;;;GAIG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,MAAM,OAAO,GAAG,SAAS,GAC9B,OAAO,CAAC,IAAI,CAAC,CAMf"}

package/dist/runtime/startup-buffer.js

@@ -1,53 +0,0 @@
-/**
- * Bounded, release-able collector for the first PTY output of a session.
- *
- * The startup usability check (see startup.ts, `assertStartupUsable`) reads the
- * agent's early output exactly once at ~500ms to detect a crash or auth banner.
- * The PTY data handler is never detached for the session's lifetime, so a naive
- * `startupOutput += data` accumulates a second unbounded in-memory transcript
- * for the WHOLE session even though only the startup snapshot is ever consumed.
- *
- * This collector appends only while the startup gate is open and caps the buffer
- * so a chatty CLI cannot balloon it; once `release()` is called (right after the
- * usability check reads it) further chunks are dropped and the retained string is
- * cleared, so no per-session transcript lingers. Implements PRD §9.1 startup
- * usability and §9.4 resource cleanup.
- */
-import { assertStartupUsable } from "./startup.js";
-// Startup output is tiny (a banner, a prompt); this cap is comfortably larger
-// than any real startup screen while still bounding a misbehaving CLI.
-const STARTUP_BUFFER_CAP = 64 * 1024;
-export function createStartupBuffer(cap = STARTUP_BUFFER_CAP) {
-    let buffer = "";
-    let open = true;
-    return {
-        push(data) {
-            if (!open || buffer.length >= cap)
-                return;
-            buffer += data;
-            if (buffer.length > cap)
-                buffer = buffer.slice(0, cap);
-        },
-        read() {
-            return buffer;
-        },
-        release() {
-            open = false;
-            buffer = "";
-        },
-    };
-}
-/**
- * Runs the ~500ms startup usability check against `buffer`, then releases it on
- * every path (success OR failure) so the collector stops appending and clears
- * its retained string for the rest of the session (§9.1, §9.4).
- */
-export async function assertStartupThenRelease(adapter, buffer, exit) {
-    try {
-        await assertStartupUsable({ adapter, exit, output: () => buffer.read() });
-    }
-    finally {
-        buffer.release();
-    }
-}
-//# sourceMappingURL=startup-buffer.js.map

package/dist/runtime/startup-buffer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"startup-buffer.js","sourceRoot":"","sources":["../../src/runtime/startup-buffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,mBAAmB,EAAuB,MAAM,cAAc,CAAC;AAExE,8EAA8E;AAC9E,uEAAuE;AACvE,MAAM,kBAAkB,GAAG,EAAE,GAAG,IAAI,CAAC;AAWrC,MAAM,UAAU,mBAAmB,CAAC,MAAc,kBAAkB;IAClE,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,IAAI,IAAI,GAAG,IAAI,CAAC;IAChB,OAAO;QACL,IAAI,CAAC,IAAY;YACf,IAAI,CAAC,IAAI,IAAI,MAAM,CAAC,MAAM,IAAI,GAAG;gBAAE,OAAO;YAC1C,MAAM,IAAI,IAAI,CAAC;YACf,IAAI,MAAM,CAAC,MAAM,GAAG,GAAG;gBAAE,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QACzD,CAAC;QACD,IAAI;YACF,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,OAAO;YACL,IAAI,GAAG,KAAK,CAAC;YACb,MAAM,GAAG,EAAE,CAAC;QACd,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,OAAuB,EACvB,MAAqB,EACrB,IAA+B;IAE/B,IAAI,CAAC;QACH,MAAM,mBAAmB,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IAC5E,CAAC;YAAS,CAAC;QACT,MAAM,CAAC,OAAO,EAAE,CAAC;IACnB,CAAC;AACH,CAAC"}

package/dist/runtime/startup-cleanup.d.ts

@@ -1,43 +0,0 @@
-/**
- * Best-effort startup cleanup that preserves the original startup error.
- * Implements PRD §9.1 and §10 error stability.
- */
-import type { PtyProcess } from "../pty/types.ts";
-export type StartupTerminationTimeouts = {
-    readonly gracefulMs: number;
-    readonly forceMs: number;
-};
-export type StartupCleanupResources = {
-    readonly before?: () => void;
-    readonly bridge?: {
-        readonly stop: () => Promise<void>;
-    };
-    readonly pty?: PtyProcess;
-    readonly terminal?: {
-        readonly dispose: () => void;
-    };
-    readonly after?: () => void;
-    /** Overrides the bounded PTY termination window (tests only; production defaults). */
-    readonly terminationTimeouts?: StartupTerminationTimeouts;
-};
-/**
- * Wraps the ENTIRE `start*FromRecord` body so the fresh per-launch socket FILE the
- * launch minted is removed on ANY failure before the session takes ownership — a
- * failed state/runtime write, bridge start, PTY start, or guarded post-spawn step
- * otherwise leaks a socket under `/tmp/elwood-*` (§9.1). It removes only THIS launch's
- * own file, never the shared stable home a concurrent launch may still own; the home is
- * deterministic, so the session's next start/resume/teardown collects any empty
- * leftover. On success ownership transfers to the returned session (teardown removes the
- * whole home). The cleanup is contained so it never replaces the original startup error.
- */
-export declare function withSocketHomeCleanup<T>(removeOwnSocketFile: () => void, build: () => Promise<T>): Promise<T>;
-export declare function cleanupStartupResources(resources: StartupCleanupResources): Promise<void>;
-/**
- * Runs the post-session-construction startup steps behind ONE cleanup boundary
- * (PRD §9.1, §9.4): if `region` rejects — a failed startup assertion, a PTY write
- * fault, anything — the now-live PTY, bridge, terminal, and any watcher
- * are torn down via `cleanupStartupResources` before the original error rethrows, so
- * a rejected `startClaude`/`startCodex` never leaks live resources.
- */
-export declare function guardStartupRegion(region: () => Promise<void>, resources: StartupCleanupResources): Promise<void>;
-//# sourceMappingURL=startup-cleanup.d.ts.map

package/dist/runtime/startup-cleanup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"startup-cleanup.d.ts","sourceRoot":"","sources":["../../src/runtime/startup-cleanup.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAIlD,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,CAAC;IACzD,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAA;KAAE,CAAC;IACrD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;IAC5B,sFAAsF;IACtF,QAAQ,CAAC,mBAAmB,CAAC,EAAE,0BAA0B,CAAC;CAC3D,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAsB,qBAAqB,CAAC,CAAC,EAC3C,mBAAmB,EAAE,MAAM,IAAI,EAC/B,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACtB,OAAO,CAAC,CAAC,CAAC,CAWZ;AAMD,wBAAsB,uBAAuB,CAAC,SAAS,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CAa/F;AAUD;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAC3B,SAAS,EAAE,uBAAuB,GACjC,OAAO,CAAC,IAAI,CAAC,CAOf"}