@with-logic/elwood 0.1.0

package/dist/core/input/abort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abort.d.ts","sourceRoot":"","sources":["../../../src/core/input/abort.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAEhF,mEAAmE;AACnE,MAAM,MAAM,aAAa,GAAG;IAAE,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC;AAE3F,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAkB5E;AAUD,wBAAgB,mBAAmB,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,CAE9D;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,KAAK,CAE1D;AAED,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAMhF"}

package/dist/core/input/abort.js

@@ -0,0 +1,44 @@
+/** Abort-aware timing and composer cleanup for queued input (PRD §5.3/§5.9). */
+export function waitForInput(ms, signal) {
+    if (signal === undefined)
+        return delayUnref(ms);
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(inputAbortError(signal));
+            return;
+        }
+        const aborted = () => {
+            clearTimeout(timer);
+            reject(inputAbortError(signal));
+        };
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", aborted);
+            resolve();
+        }, ms);
+        timer.unref?.();
+        signal.addEventListener("abort", aborted, { once: true });
+    });
+}
+/** An unreferenced sleep: a pending settle delay never keeps the host alive by itself. */
+function delayUnref(ms) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        timer.unref?.();
+    });
+}
+export function throwIfInputAborted(signal) {
+    if (signal?.aborted)
+        throw inputAbortError(signal);
+}
+export function inputAbortError(signal) {
+    return signal.reason instanceof Error ? signal.reason : new Error("Submission aborted.");
+}
+export async function clearStagedComposer(terminal) {
+    try {
+        await terminal.sendInput("\u0015\u000b");
+    }
+    catch {
+        // Best-effort: preserve the cancellation as the primary outcome.
+    }
+}
+//# sourceMappingURL=abort.js.map

package/dist/core/input/abort.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abort.js","sourceRoot":"","sources":["../../../src/core/input/abort.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAKhF,MAAM,UAAU,YAAY,CAAC,EAAU,EAAE,MAAoB;IAC3D,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,UAAU,CAAC,EAAE,CAAC,CAAC;IAChD,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YACnB,MAAM,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC;YAChC,OAAO;QACT,CAAC;QACD,MAAM,OAAO,GAAG,GAAG,EAAE;YACnB,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,MAAM,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC;QAClC,CAAC,CAAC;QACF,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;YAC5B,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC7C,OAAO,EAAE,CAAC;QACZ,CAAC,EAAE,EAAE,CAAC,CAAC;QACP,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;QAChB,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5D,CAAC,CAAC,CAAC;AACL,CAAC;AAED,0FAA0F;AAC1F,SAAS,UAAU,CAAC,EAAU;IAC5B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QACtC,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;IAClB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,MAAoB;IACtD,IAAI,MAAM,EAAE,OAAO;QAAE,MAAM,eAAe,CAAC,MAAM,CAAC,CAAC;AACrD,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,MAAmB;IACjD,OAAO,MAAM,CAAC,MAAM,YAAY,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;AAC3F,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,QAAuB;IAC/D,IAAI,CAAC;QACH,MAAM,QAAQ,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;IAC3C,CAAC;IAAC,MAAM,CAAC;QACP,iEAAiE;IACnE,CAAC;AACH,CAAC"}

package/dist/core/input/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared PTY input submission helpers for adapter sessions.
+ * Implements PRD §5.3 prompt and command submission semantics (C-API-31).
+ */
+import type { ControlSubmitMode } from "../control-queue/index.ts";
+import { type InputTerminal } from "./abort.ts";
+/** Adapter view of "the paste is still staged in the composer". */
+export type PasteGuard = {
+    readonly snapshot: () => string;
+    readonly staged: (screen: string, prompt: string) => boolean;
+    /**
+     * True when a blocking human-decision dialog is on screen. A dialog can
+     * appear during the paste-settle window; sending the submitting Enter then
+     * would confirm the dialog's highlighted option (e.g. approve a tool). The
+     * Enter is therefore held while this is true and retried once it clears.
+     */
+    readonly blocked?: () => boolean;
+};
+export declare const commandEnterDelayMs = 150;
+export declare const pasteSettleDelayMs = 150;
+export declare const pasteNudgeDelayMs = 1000;
+export declare const pasteNudgeAttempts = 2;
+/** How often the submitting Enter re-checks a blocking dialog before firing. */
+export declare const blockedPollMs = 50;
+/** Explicitly best-effort input for startup/recovery automation. */
+export declare function ignoreInputFailure(input: void | Promise<void>): void;
+/**
+ * Neutralizes caller/model text before it is framed as a bracketed paste (§5.3).
+ * Message text is data, so an embedded `ESC[201~` end sentinel (or a bare control
+ * byte) MUST NOT terminate paste mode early and turn following bytes into live
+ * keystrokes — e.g. an Enter that confirms a permission dialog. Tab, newline, and
+ * carriage return survive as legitimate multi-line text; everything else is
+ * stripped. `sendKeys` is the raw escape hatch and never goes through here.
+ */
+export declare function sanitizePasteText(text: string): string;
+export declare function writeQueuedInput(terminal: InputTerminal, input: string, mode: ControlSubmitMode, guard?: PasteGuard, signal?: AbortSignal, enterDelayMs?: number): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/core/input/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/input/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,EAEL,KAAK,aAAa,EAGnB,MAAM,YAAY,CAAC;AAEpB,mEAAmE;AACnE,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;IAC7D;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,eAAO,MAAM,kBAAkB,MAAM,CAAC;AACtC,eAAO,MAAM,iBAAiB,OAAQ,CAAC;AACvC,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,gFAAgF;AAChF,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC,oEAAoE;AACpE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAEpE;AASD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtD;AAwGD,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,iBAAiB,EACvB,KAAK,CAAC,EAAE,UAAU,EAClB,MAAM,CAAC,EAAE,WAAW,EACpB,YAAY,SAAsB,GACjC,OAAO,CAAC,IAAI,CAAC,CAoBf"}

package/dist/core/input/index.js

@@ -0,0 +1,154 @@
+/**
+ * Shared PTY input submission helpers for adapter sessions.
+ * Implements PRD §5.3 prompt and command submission semantics (C-API-31).
+ */
+import { clearStagedComposer, throwIfInputAborted, waitForInput, } from "./abort.js";
+export const commandEnterDelayMs = 150;
+export const pasteSettleDelayMs = 150;
+export const pasteNudgeDelayMs = 1_000;
+export const pasteNudgeAttempts = 2;
+/** How often the submitting Enter re-checks a blocking dialog before firing. */
+export const blockedPollMs = 50;
+/** Explicitly best-effort input for startup/recovery automation. */
+export function ignoreInputFailure(input) {
+    void Promise.resolve(input).catch(() => undefined);
+}
+// C0 (\u0000-\u001f) and C1 (\u007f-\u009f) control chars EXCEPT tab,
+// newline, and carriage return, which are legitimate multi-line whitespace.
+// Stripping ESC (\u001b) alone already defuses the ESC[200~ / ESC[201~
+// bracketed-paste sentinels, leaving only inert `[20x~` text.
+// biome-ignore lint/suspicious/noControlCharactersInRegex: neutralizing control input is the point.
+const pasteUnsafe = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g;
+/**
+ * Neutralizes caller/model text before it is framed as a bracketed paste (§5.3).
+ * Message text is data, so an embedded `ESC[201~` end sentinel (or a bare control
+ * byte) MUST NOT terminate paste mode early and turn following bytes into live
+ * keystrokes — e.g. an Enter that confirms a permission dialog. Tab, newline, and
+ * carriage return survive as legitimate multi-line text; everything else is
+ * stripped. `sendKeys` is the raw escape hatch and never goes through here.
+ */
+export function sanitizePasteText(text) {
+    return text.replace(pasteUnsafe, "");
+}
+/**
+ * Writes a bracketed paste and submits it.
+ *
+ * The TUIs ingest bracketed pastes asynchronously; an Enter concatenated into
+ * the same PTY write races that ingestion and can be dropped, leaving the prompt
+ * staged but never submitted (long personas hit this reliably). The Enter
+ * therefore follows as a separate keystroke after a settle delay, and bounded
+ * re-Enters fire while the screen still shows staged content — a lone Enter from
+ * the staged state submits, and a surplus Enter on an empty composer is a no-op,
+ * so the recovery is safe on both adapters.
+ *
+ * While a blocking human-decision dialog is on screen, the WHOLE submission is
+ * held: neither the paste nor any Enter reaches the terminal until the dialog
+ * clears, so caller/model text can never be interpreted as the dialog's
+ * shortcuts or confirm its highlighted option (C-API-37 dialog safety). Paste
+ * text is sanitized first so an embedded end sentinel or control byte cannot
+ * escape paste mode into live keystrokes (§5.3).
+ *
+ * The returned promise resolves once the first submitting Enter has been
+ * dispatched (after the settle delay), so the control queue does not drain the
+ * next operation into the composer before this prompt has actually been
+ * submitted. Bounded recovery re-Enters continue in the background afterwards
+ * and are idempotent.
+ */
+async function writePastedPrompt(terminal, prompt, guard, signal, settleDelayMs = pasteSettleDelayMs, nudgeDelayMs = pasteNudgeDelayMs) {
+    // Hold the WHOLE submission — paste included — while a blocking dialog is on
+    // screen. A dialog can appear before an overtaking guidance's paste dispatches;
+    // pasting caller/model text into it risks the TUI interpreting shortcuts, so no
+    // bytes may reach a dialog until it clears (C-API-37 dialog safety). Only await
+    // when actually blocked, so the common path still writes the paste synchronously.
+    if (guard?.blocked?.())
+        await waitWhileBlocked(guard, signal);
+    throwIfInputAborted(signal);
+    // Sanitize: caller/model text is data, so an embedded end sentinel or control
+    // byte must not escape paste mode into live keystrokes (§5.3).
+    await terminal.sendInput(`\u001b[200~${sanitizePasteText(prompt)}\u001b[201~`);
+    const schedule = (work, ms) => {
+        const timer = setTimeout(work, ms);
+        timer.unref?.();
+    };
+    let nudges = 0;
+    const nudge = async () => {
+        // Stop once a LATER submission has begun: a stale nudge must never fire an
+        // Enter into a newer prompt's paste (the staged chip is not prompt-specific).
+        if (signal?.aborted || !guard || nudges >= pasteNudgeAttempts)
+            return;
+        // A dialog that appears after the first Enter must not be confirmed by a
+        // recovery Enter either; skip this attempt and re-check on the next tick.
+        if (guard.blocked?.()) {
+            schedule(nudge, nudgeDelayMs);
+            return;
+        }
+        nudges += 1;
+        if (!guard.staged(guard.snapshot(), prompt))
+            return;
+        try {
+            await terminal.sendInput("\r");
+        }
+        catch {
+            // Recovery nudges are best-effort after the first Enter already landed.
+        }
+        schedule(nudge, nudgeDelayMs);
+    };
+    try {
+        await waitForInput(settleDelayMs, signal);
+        // Hold the submitting Enter while a blocking dialog is on screen: firing it
+        // would confirm the dialog's highlighted option instead of submitting the
+        // staged paste (C-API-37 dialog safety). The paste stays staged behind the
+        // dialog and submits once it clears.
+        await waitWhileBlocked(guard, signal);
+        throwIfInputAborted(signal);
+        await terminal.sendInput("\r");
+    }
+    catch (error) {
+        if (signal?.aborted)
+            await clearStagedComposer(terminal);
+        throw error;
+    }
+    schedule(nudge, nudgeDelayMs);
+}
+function waitWhileBlocked(guard, signal) {
+    if (!guard?.blocked?.())
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const poll = () => {
+            if (signal?.aborted) {
+                resolve();
+                return;
+            }
+            if (!guard.blocked?.()) {
+                resolve();
+                return;
+            }
+            const timer = setTimeout(poll, blockedPollMs);
+            timer.unref?.();
+        };
+        const timer = setTimeout(poll, blockedPollMs);
+        timer.unref?.();
+    });
+}
+export async function writeQueuedInput(terminal, input, mode, guard, signal, enterDelayMs = commandEnterDelayMs) {
+    // Dispatch through a Record keyed by ControlSubmitMode: a new mode must add an
+    // entry here or the object fails to type-check, so it can never silently reuse
+    // pasted-input behavior. The map has no unreachable default arm, so 100%
+    // coverage holds (both entries are exercised).
+    const submitters = {
+        // Resolve only after the input's submitting Enter has dispatched, so the next
+        // queued operation cannot write into the composer first (FIFO).
+        pasted_input: () => writePastedPrompt(terminal, input, guard, signal),
+        // Slash-command popups (Codex) swallow an Enter that arrives in the same PTY
+        // chunk as the command text, so Enter follows as a separate keystroke. The
+        // returned promise resolves only after that Enter is dispatched, so a queued
+        // command's Enter always lands before the next operation writes.
+        command: async () => {
+            await terminal.sendInput(input);
+            await waitForInput(enterDelayMs, signal);
+            await terminal.sendInput("\r");
+        },
+    };
+    await submitters[mode]();
+}
+//# sourceMappingURL=index.js.map

package/dist/core/input/index.js.map

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

package/dist/core/interrupt.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared Escape-interrupt orchestration for adapter sessions.
+ * Implements PRD §5.3, §5.7, and C-API-38.
+ */
+import type { ElwoodSessionStatus, Unsubscribe } from "./types.ts";
+export declare const defaultInterruptTimeoutMs = 10000;
+/** Both adapters cancel a running turn with a bare Escape keypress. */
+export declare const interruptKey = "\u001B";
+export type InterruptEmitter = {
+    on(event: "status", handler: (event: {
+        readonly status: ElwoodSessionStatus;
+    }) => void): Unsubscribe;
+};
+/**
+ * Sends a single Escape to cancel an in-flight turn and resolves when the
+ * session next reaches `ready`. Escape is written immediately, bypassing the
+ * control queue, because an interrupt exists to stop work already in flight.
+ *
+ * A no-op that resolves without writing Escape when the session is not in a
+ * post-readiness `running`/`blocked` state: before initial readiness the
+ * `running` status is the startup bootstrap rather than a turn, and Escape at
+ * an idle composer is not neutral (Claude clears staged composer text; Codex
+ * arms its edit-previous-message affordance). Rejects with `interrupt_failed`
+ * once `timeoutMs` elapses without a `ready` transition, and with
+ * `session_not_running` if the session reaches a terminal status first. Always
+ * unsubscribes from the status emitter on settle.
+ */
+export declare function sessionInterrupt(emitter: InterruptEmitter, status: () => ElwoodSessionStatus, everReady: () => boolean, sendEscape: () => Promise<void>, timeoutMs: number | undefined): Promise<void>;
+//# sourceMappingURL=interrupt.d.ts.map

package/dist/core/interrupt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interrupt.d.ts","sourceRoot":"","sources":["../../src/core/interrupt.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAChD,uEAAuE;AACvE,eAAO,MAAM,YAAY,WAAW,CAAC;AAErC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,CACA,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAA;KAAE,KAAK,IAAI,GACjE,WAAW,CAAC;CAChB,CAAC;AAKF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,MAAM,mBAAmB,EACjC,SAAS,EAAE,MAAM,OAAO,EACxB,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAC/B,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,OAAO,CAAC,IAAI,CAAC,CAgCf"}

package/dist/core/interrupt.js

@@ -0,0 +1,57 @@
+/**
+ * Shared Escape-interrupt orchestration for adapter sessions.
+ * Implements PRD §5.3, §5.7, and C-API-38.
+ */
+import { elwoodError } from "./errors.js";
+import { terminalStatuses } from "./status-categories.js";
+export const defaultInterruptTimeoutMs = 10_000;
+/** Both adapters cancel a running turn with a bare Escape keypress. */
+export const interruptKey = "\u001b";
+/** Statuses with a turn (or blocking dialog) that Escape can cancel. */
+const interruptibleStatuses = new Set(["running", "blocked"]);
+/**
+ * Sends a single Escape to cancel an in-flight turn and resolves when the
+ * session next reaches `ready`. Escape is written immediately, bypassing the
+ * control queue, because an interrupt exists to stop work already in flight.
+ *
+ * A no-op that resolves without writing Escape when the session is not in a
+ * post-readiness `running`/`blocked` state: before initial readiness the
+ * `running` status is the startup bootstrap rather than a turn, and Escape at
+ * an idle composer is not neutral (Claude clears staged composer text; Codex
+ * arms its edit-previous-message affordance). Rejects with `interrupt_failed`
+ * once `timeoutMs` elapses without a `ready` transition, and with
+ * `session_not_running` if the session reaches a terminal status first. Always
+ * unsubscribes from the status emitter on settle.
+ */
+export function sessionInterrupt(emitter, status, everReady, sendEscape, timeoutMs) {
+    // No turn in flight: resolve without touching the terminal. This covers both
+    // an idle-ready session and the pre-readiness startup window, where `running`
+    // is the bootstrap status and no turn has begun.
+    if (!(everReady() && interruptibleStatuses.has(status())))
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (finish) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            offStatus();
+            finish();
+        };
+        const timer = setTimeout(() => {
+            settle(() => reject(elwoodError("interrupt_failed", "Interrupt did not return the session to ready in time.")));
+        }, timeoutMs ?? defaultInterruptTimeoutMs);
+        const offStatus = emitter.on("status", (event) => {
+            if (event.status === "ready")
+                settle(resolve);
+            if (!terminalStatuses.has(event.status))
+                return;
+            settle(() => reject(elwoodError("session_not_running", "Session ended before the interrupt completed.")));
+        });
+        sendEscape().then(undefined, (error) => {
+            settle(() => reject(error));
+        });
+    });
+}
+//# sourceMappingURL=interrupt.js.map

package/dist/core/interrupt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interrupt.js","sourceRoot":"","sources":["../../src/core/interrupt.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG1D,MAAM,CAAC,MAAM,yBAAyB,GAAG,MAAM,CAAC;AAChD,uEAAuE;AACvE,MAAM,CAAC,MAAM,YAAY,GAAG,QAAQ,CAAC;AASrC,wEAAwE;AACxE,MAAM,qBAAqB,GAAG,IAAI,GAAG,CAAsB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC;AAEnF;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,gBAAgB,CAC9B,OAAyB,EACzB,MAAiC,EACjC,SAAwB,EACxB,UAA+B,EAC/B,SAA6B;IAE7B,6EAA6E;IAC7E,8EAA8E;IAC9E,iDAAiD;IACjD,IAAI,CAAC,CAAC,SAAS,EAAE,IAAI,qBAAqB,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC;QAAE,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IACpF,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,MAAM,MAAM,GAAG,CAAC,MAAkB,EAAQ,EAAE;YAC1C,IAAI,OAAO;gBAAE,OAAO;YACpB,OAAO,GAAG,IAAI,CAAC;YACf,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,SAAS,EAAE,CAAC;YACZ,MAAM,EAAE,CAAC;QACX,CAAC,CAAC;QACF,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;YAC5B,MAAM,CAAC,GAAG,EAAE,CACV,MAAM,CACJ,WAAW,CAAC,kBAAkB,EAAE,wDAAwD,CAAC,CAC1F,CACF,CAAC;QACJ,CAAC,EAAE,SAAS,IAAI,yBAAyB,CAAC,CAAC;QAC3C,MAAM,SAAS,GAAG,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE;YAC/C,IAAI,KAAK,CAAC,MAAM,KAAK,OAAO;gBAAE,MAAM,CAAC,OAAO,CAAC,CAAC;YAC9C,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC;gBAAE,OAAO;YAChD,MAAM,CAAC,GAAG,EAAE,CACV,MAAM,CAAC,WAAW,CAAC,qBAAqB,EAAE,+CAA+C,CAAC,CAAC,CAC5F,CAAC;QACJ,CAAC,CAAC,CAAC;QACH,UAAU,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,KAAc,EAAE,EAAE;YAC9C,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QAC9B,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/core/list-models.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Session-less model enumeration: start a throwaway session, list its models,
+ * and always tear it down. Implements PRD §5.3 and C-API-41.
+ */
+import type { ElwoodAgentSession } from "./agent-session.ts";
+import type { AgentModelOption } from "./model-rows.ts";
+/** Launch-relevant options for a throwaway model-listing probe (C-API-41). */
+export type ListModelsOptions = {
+    readonly cwd: string;
+    readonly stateDir?: string;
+    readonly autoupdate?: boolean;
+    readonly hookTimeoutMs?: number;
+    readonly strictVersionCheck?: boolean;
+    /** Bounds the picker automation, exactly as on a live session's `listModels`. */
+    readonly timeoutMs?: number;
+};
+/**
+ * The throwaway session surface a probe drives: wait for ready, list, tear down.
+ * Derived from the public session contract so it uses the SAME closed
+ * `ElwoodSessionStatus` type and cannot drift from the real methods.
+ */
+type ProbeSession = Pick<ElwoodAgentSession, "waitForStatus" | "listModels" | "teardown">;
+/** Adapter hooks for a probe: how to start the session and how to remove ALL its state. */
+export type ProbeAdapter<S extends ProbeSession> = {
+    /** Starts the throwaway session against the probe's owned state directory. */
+    readonly start: () => Promise<S>;
+    /**
+     * Removes ALL probe state (its owned temp directory and everything under it).
+     * Runs on EVERY outcome — success, readiness/picker failure, AND a start failure
+     * that already allocated a state directory or runtime files — so nothing leaks
+     * regardless of how far startup got (C-API-41). Best-effort and non-throwing.
+     */
+    readonly removeState: () => void;
+};
+/**
+ * Runs a throwaway session to its first readiness, lists its models, and cleans
+ * up EVERYTHING it allocated — the session (via `teardown`) and its owned state
+ * directory (via `removeState`) — on every outcome, so nothing is leaked (C-API-41).
+ * The probe only opens and cancels the picker, so the user's default stays
+ * untouched. A teardown/cleanup failure never masks a real list/readiness error.
+ */
+export declare function probeModels<S extends ProbeSession>(adapter: ProbeAdapter<S>, options: ListModelsOptions): Promise<readonly AgentModelOption[]>;
+export {};
+//# sourceMappingURL=list-models.d.ts.map

package/dist/core/list-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-models.d.ts","sourceRoot":"","sources":["../../src/core/list-models.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,8EAA8E;AAC9E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IACtC,iFAAiF;IACjF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF;;;;GAIG;AACH,KAAK,YAAY,GAAG,IAAI,CAAC,kBAAkB,EAAE,eAAe,GAAG,YAAY,GAAG,UAAU,CAAC,CAAC;AAE1F,2FAA2F;AAC3F,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,YAAY,IAAI;IACjD,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;IACjC;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,IAAI,CAAC;CAClC,CAAC;AAEF;;;;;;GAMG;AACH,wBAAsB,WAAW,CAAC,CAAC,SAAS,YAAY,EACtD,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,EACxB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,SAAS,gBAAgB,EAAE,CAAC,CAiBtC"}

package/dist/core/list-models.js

@@ -0,0 +1,73 @@
+/**
+ * Session-less model enumeration: start a throwaway session, list its models,
+ * and always tear it down. Implements PRD §5.3 and C-API-41.
+ */
+import { errnoCode, toError } from "./errors.js";
+/**
+ * Runs a throwaway session to its first readiness, lists its models, and cleans
+ * up EVERYTHING it allocated — the session (via `teardown`) and its owned state
+ * directory (via `removeState`) — on every outcome, so nothing is leaked (C-API-41).
+ * The probe only opens and cancels the picker, so the user's default stays
+ * untouched. A teardown/cleanup failure never masks a real list/readiness error.
+ */
+export async function probeModels(adapter, options) {
+    let session;
+    try {
+        session = await adapter.start();
+    }
+    catch (error) {
+        // Adapter startup can allocate a state directory / runtime files BEFORE the
+        // bridge or PTY fails, so "no returned session" does not mean "nothing
+        // allocated": remove the owned state directory before rethrowing (C-API-41).
+        adapter.removeState();
+        throw error;
+    }
+    try {
+        return await runProbe(session, options);
+    }
+    finally {
+        // Always sweep the owned state directory, even after a successful teardown.
+        adapter.removeState();
+    }
+}
+async function runProbe(session, options) {
+    let models;
+    try {
+        await session.waitForStatus((status) => status === "ready");
+        models = await session.listModels(options.timeoutMs === undefined ? undefined : { timeoutMs: options.timeoutMs });
+    }
+    catch (error) {
+        // The list/readiness error is what the caller must see, so it stays the thrown
+        // error and teardown never masks it. But a FAILED teardown here can leak a
+        // probe process tree, so surface it as a bounded `cause` rather than silently
+        // discarding it: the caller keeps the primary error AND learns of the leak.
+        await teardownWithoutMasking(session, toError(error));
+        throw error;
+    }
+    // The clean path DOES surface a genuine teardown failure — a leaked probe
+    // session is a real defect the caller should learn about (C-API-41).
+    await session.teardown();
+    return models;
+}
+/**
+ * Tear down the probe on the error path without masking the primary error. A
+ * rejecting teardown can leave a probe process tree alive, so instead of
+ * discarding it we attach a bounded diagnostic (the teardown error's allowlisted
+ * errno, or its name) to the primary error's `cause` — visible to the caller,
+ * never overriding the readiness/picker error that actually explains the failure.
+ */
+async function teardownWithoutMasking(session, primary) {
+    try {
+        await session.teardown();
+    }
+    catch (teardownError) {
+        // `cause` may already be set by the primary error; only fill it when empty so
+        // we never clobber a more specific upstream cause. The token is bounded — an
+        // errno like `EPERM` or the error's constructor name — never a raw message.
+        if (primary.cause === undefined) {
+            const token = errnoCode(teardownError) ?? toError(teardownError).name;
+            primary.cause = `probe_teardown_failed:${token}`;
+        }
+    }
+}
+//# sourceMappingURL=list-models.js.map

package/dist/core/list-models.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-models.js","sourceRoot":"","sources":["../../src/core/list-models.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAkCjD;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,OAAwB,EACxB,OAA0B;IAE1B,IAAI,OAAU,CAAC;IACf,IAAI,CAAC;QACH,OAAO,GAAG,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC;IAClC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,4EAA4E;QAC5E,uEAAuE;QACvE,6EAA6E;QAC7E,OAAO,CAAC,WAAW,EAAE,CAAC;QACtB,MAAM,KAAK,CAAC;IACd,CAAC;IACD,IAAI,CAAC;QACH,OAAO,MAAM,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC1C,CAAC;YAAS,CAAC;QACT,4EAA4E;QAC5E,OAAO,CAAC,WAAW,EAAE,CAAC;IACxB,CAAC;AACH,CAAC;AAED,KAAK,UAAU,QAAQ,CACrB,OAAU,EACV,OAA0B;IAE1B,IAAI,MAAmC,CAAC;IACxC,IAAI,CAAC;QACH,MAAM,OAAO,CAAC,aAAa,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,KAAK,OAAO,CAAC,CAAC;QAC5D,MAAM,GAAG,MAAM,OAAO,CAAC,UAAU,CAC/B,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,CAC/E,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,+EAA+E;QAC/E,2EAA2E;QAC3E,8EAA8E;QAC9E,4EAA4E;QAC5E,MAAM,sBAAsB,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;QACtD,MAAM,KAAK,CAAC;IACd,CAAC;IACD,0EAA0E;IAC1E,qEAAqE;IACrE,MAAM,OAAO,CAAC,QAAQ,EAAE,CAAC;IACzB,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,sBAAsB,CAAC,OAAqB,EAAE,OAAc;IACzE,IAAI,CAAC;QACH,MAAM,OAAO,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAAC,OAAO,aAAa,EAAE,CAAC;QACvB,8EAA8E;QAC9E,6EAA6E;QAC7E,4EAA4E;QAC5E,IAAI,OAAO,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAChC,MAAM,KAAK,GAAG,SAAS,CAAC,aAAa,CAAC,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC;YACtE,OAAO,CAAC,KAAK,GAAG,yBAAyB,KAAK,EAAE,CAAC;QACnD,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/core/loops/constants.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared bounds for recurring session loops.
+ * Implements PRD §5.9 and C-LOOP-03/C-LOOP-04.
+ */
+export declare const MAX_ACTIVE_LOOPS = 50;
+export declare const MIN_LOOP_MESSAGE_BYTES = 1;
+export declare const MAX_LOOP_MESSAGE_BYTES = 65536;
+export declare const MIN_LOOP_INTERVAL_MS = 60000;
+export declare const MAX_LOOP_INTERVAL_MS = 604800000;
+export declare const IDLE_LOOP_INTERVAL_MS = 300000;
+export declare const MAX_LOOP_JITTER_MS = 30000;
+export declare const LOOP_EXPIRATION_MS = 604800000;
+//# sourceMappingURL=constants.d.ts.map

package/dist/core/loops/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/core/loops/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,sBAAsB,IAAI,CAAC;AACxC,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAC7C,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAC3C,eAAO,MAAM,oBAAoB,YAAc,CAAC;AAChD,eAAO,MAAM,qBAAqB,SAAU,CAAC;AAC7C,eAAO,MAAM,kBAAkB,QAAS,CAAC;AACzC,eAAO,MAAM,kBAAkB,YAAc,CAAC"}

package/dist/core/loops/constants.js

@@ -0,0 +1,13 @@
+/**
+ * Shared bounds for recurring session loops.
+ * Implements PRD §5.9 and C-LOOP-03/C-LOOP-04.
+ */
+export const MAX_ACTIVE_LOOPS = 50;
+export const MIN_LOOP_MESSAGE_BYTES = 1;
+export const MAX_LOOP_MESSAGE_BYTES = 65_536;
+export const MIN_LOOP_INTERVAL_MS = 60_000;
+export const MAX_LOOP_INTERVAL_MS = 604_800_000;
+export const IDLE_LOOP_INTERVAL_MS = 300_000;
+export const MAX_LOOP_JITTER_MS = 30_000;
+export const LOOP_EXPIRATION_MS = 604_800_000;
+//# sourceMappingURL=constants.js.map

package/dist/core/loops/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/core/loops/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AACnC,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC;AACxC,MAAM,CAAC,MAAM,sBAAsB,GAAG,MAAM,CAAC;AAC7C,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC;AAC3C,MAAM,CAAC,MAAM,oBAAoB,GAAG,WAAW,CAAC;AAChD,MAAM,CAAC,MAAM,qBAAqB,GAAG,OAAO,CAAC;AAC7C,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC;AACzC,MAAM,CAAC,MAAM,kBAAkB,GAAG,WAAW,CAAC"}

package/dist/core/loops/jitter.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Stable ID-derived, delay-only jitter for recurring-loop creation.
+ * Implements PRD §5.9 and C-LOOP-04.
+ */
+export declare function deriveLoopJitterMs(loopId: string, cadenceIntervalMs: number): number;
+//# sourceMappingURL=jitter.d.ts.map

package/dist/core/loops/jitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jitter.d.ts","sourceRoot":"","sources":["../../../src/core/loops/jitter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,MAAM,CAGpF"}

package/dist/core/loops/jitter.js

@@ -0,0 +1,20 @@
+/**
+ * Stable ID-derived, delay-only jitter for recurring-loop creation.
+ * Implements PRD §5.9 and C-LOOP-04.
+ */
+import { MAX_LOOP_JITTER_MS } from "./constants.js";
+const FNV_OFFSET_BASIS = 0x81_1c_9d_c5;
+const FNV_PRIME = 0x01_00_01_93;
+export function deriveLoopJitterMs(loopId, cadenceIntervalMs) {
+    const cap = Math.min(Math.floor(cadenceIntervalMs / 10), MAX_LOOP_JITTER_MS);
+    return hashLoopId(loopId) % (cap + 1);
+}
+function hashLoopId(loopId) {
+    let hash = FNV_OFFSET_BASIS;
+    for (const byte of new TextEncoder().encode(loopId)) {
+        hash ^= byte;
+        hash = Math.imul(hash, FNV_PRIME);
+    }
+    return hash >>> 0;
+}
+//# sourceMappingURL=jitter.js.map

package/dist/core/loops/jitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jitter.js","sourceRoot":"","sources":["../../../src/core/loops/jitter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEpD,MAAM,gBAAgB,GAAG,aAAa,CAAC;AACvC,MAAM,SAAS,GAAG,aAAa,CAAC;AAEhC,MAAM,UAAU,kBAAkB,CAAC,MAAc,EAAE,iBAAyB;IAC1E,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,iBAAiB,GAAG,EAAE,CAAC,EAAE,kBAAkB,CAAC,CAAC;IAC7E,OAAO,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;AACxC,CAAC;AAED,SAAS,UAAU,CAAC,MAAc;IAChC,IAAI,IAAI,GAAG,gBAAgB,CAAC;IAC5B,KAAK,MAAM,IAAI,IAAI,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;QACpD,IAAI,IAAI,IAAI,CAAC;QACb,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IACpC,CAAC;IACD,OAAO,IAAI,KAAK,CAAC,CAAC;AACpB,CAAC"}

package/dist/core/loops/loop-controls.d.ts

@@ -0,0 +1,8 @@
+/** Shared recurring-loop control contract. Implements PRD §5.8/§5.9 and C-LOOP-01/C-LOOP-20. */
+import type { ElwoodLoopRequest, ElwoodLoopSnapshot } from "./types.ts";
+export interface LoopControls {
+    createLoop(request: ElwoodLoopRequest): Promise<ElwoodLoopSnapshot>;
+    listLoops(): Promise<readonly ElwoodLoopSnapshot[]>;
+    cancelLoop(loopId: string): Promise<void>;
+}
+//# sourceMappingURL=loop-controls.d.ts.map

package/dist/core/loops/loop-controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop-controls.d.ts","sourceRoot":"","sources":["../../../src/core/loops/loop-controls.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAEhG,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAExE,MAAM,WAAW,YAAY;IAC3B,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACpE,SAAS,IAAI,OAAO,CAAC,SAAS,kBAAkB,EAAE,CAAC,CAAC;IACpD,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C"}

package/dist/core/loops/loop-controls.js

@@ -0,0 +1,3 @@
+/** Shared recurring-loop control contract. Implements PRD §5.8/§5.9 and C-LOOP-01/C-LOOP-20. */
+export {};
+//# sourceMappingURL=loop-controls.js.map

package/dist/core/loops/loop-controls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop-controls.js","sourceRoot":"","sources":["../../../src/core/loops/loop-controls.ts"],"names":[],"mappings":"AAAA,gGAAgG"}

package/dist/core/loops/parser.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Explicit parser for caller-provided `/loop` command UX.
+ * Implements PRD §5.9 and C-LOOP-02/C-LOOP-03.
+ */
+import type { ElwoodLoopRequest } from "./types.ts";
+export declare function parseLoopCommand(command: string): ElwoodLoopRequest | undefined;
+//# sourceMappingURL=parser.d.ts.map

package/dist/core/loops/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/core/loops/parser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAYpD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAmB/E"}

package/dist/core/loops/parser.js

@@ -0,0 +1,37 @@
+/**
+ * Explicit parser for caller-provided `/loop` command UX.
+ * Implements PRD §5.9 and C-LOOP-02/C-LOOP-03.
+ */
+import { validateLoopRequest } from "./validate.js";
+const intervalFactors = {
+    s: 1_000,
+    m: 60_000,
+    h: 3_600_000,
+    d: 86_400_000,
+};
+export function parseLoopCommand(command) {
+    if (!command.startsWith("/loop"))
+        return undefined;
+    const delimiter = command.at(5);
+    if (delimiter !== undefined && !/\s/u.test(delimiter))
+        return undefined;
+    const remainder = command.slice(5).replace(/^\s+/u, "");
+    if (remainder === "")
+        return validateLoopRequest({ mode: "idle", message: "" });
+    const tokenEnd = remainder.search(/\s/u);
+    const token = tokenEnd < 0 ? remainder : remainder.slice(0, tokenEnd);
+    if (!isPositiveIntervalToken(token)) {
+        return validateLoopRequest({ mode: "idle", message: remainder });
+    }
+    const message = tokenEnd < 0 ? "" : remainder.slice(tokenEnd).replace(/^\s+/u, "");
+    const unit = token.at(-1);
+    const value = Number(token.slice(0, -1));
+    const intervalMs = value * intervalFactors[unit];
+    return validateLoopRequest({ mode: "fixed", intervalMs, message });
+}
+function isPositiveIntervalToken(token) {
+    if (!/^\d+[smhd]$/u.test(token))
+        return false;
+    return /[1-9]/u.test(token.slice(0, -1));
+}
+//# sourceMappingURL=parser.js.map