@with-logic/elwood 0.1.0

package/dist/core/reasoning-effort.js

@@ -0,0 +1,44 @@
+/**
+ * Per-adapter reasoning-effort enums and a shared before-spawn validator.
+ * Implements PRD §5.1/§5.2 (C-CLAUDE-20) and §5.5/§5.6 (C-CODEX-21).
+ *
+ * The two CLIs accept DIFFERENT effort sets (Codex adds `none`/`minimal`; both
+ * share `low`..`max`), and both are version-coupled to the installed CLI, so the
+ * value is a fixed per-adapter allowlist rather than a shared Elwood enum. Elwood
+ * validates BEFORE spawning: Claude's `--effort` would reject inconsistently and
+ * Codex validates server-side (a bad value launches, then fails at the first turn
+ * with a provider 400), so a start-time check turns both into one fast, clear error.
+ */
+import { elwoodError } from "./errors.js";
+export const claudeReasoningEfforts = [
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+/** Codex `model_reasoning_effort` values (codex 0.149.1, API-enforced enum). */
+export const codexReasoningEfforts = [
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+/**
+ * Narrows a caller-supplied `reasoningEffort` to the adapter's enum, throwing the
+ * typed `*_invalid_reasoning_effort` error (listing the valid values) when it is out
+ * of range. `undefined` passes through unchanged — the option is absent, not invalid.
+ * Returning the narrowed literal lets callers forward it without a second cast.
+ */
+export function validateReasoningEffort(value, valid, errorCode) {
+    if (value === undefined || valid.includes(value))
+        return value;
+    throw elwoodError(errorCode, `Invalid reasoningEffort ${JSON.stringify(value)}.`, {
+        reasoningEffort: value,
+        valid,
+    });
+}
+//# sourceMappingURL=reasoning-effort.js.map

package/dist/core/reasoning-effort.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning-effort.js","sourceRoot":"","sources":["../../src/core/reasoning-effort.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EAAwB,WAAW,EAAE,MAAM,aAAa,CAAC;AAYhE,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,KAAK;IACL,QAAQ;IACR,MAAM;IACN,OAAO;IACP,KAAK;CAC8C,CAAC;AAMtD,gFAAgF;AAChF,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,MAAM;IACN,SAAS;IACT,KAAK;IACL,QAAQ;IACR,MAAM;IACN,OAAO;IACP,KAAK;CACG,CAAC;AAGX;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB,CACrC,KAAoB,EACpB,KAAmB,EACnB,SAA0B;IAE1B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAC/D,MAAM,WAAW,CAAC,SAAS,EAAE,2BAA2B,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE;QAChF,eAAe,EAAE,KAAK;QACtB,KAAK;KACN,CAAC,CAAC;AACL,CAAC"}

package/dist/core/rendered-observers.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Applies turn-state and attention watchers to a rendered frame and submits
+ * the resulting evidence, emitting the attention activity on a real block.
+ * Implements PRD §5.3 turn and blocked detection.
+ */
+import type { ElwoodActivityEvent, ElwoodAgentKind } from "./activity/index.ts";
+import { type AttentionWatcher } from "./attention.ts";
+import { type RenderedFrame, type ScreenFactReading, type ScreenFactTable } from "./screen-facts.ts";
+import type { TurnStateWatcher } from "./turn-state.ts";
+import type { ElwoodSessionStatus, ElwoodStatusDecision, ElwoodStatusEvidence } from "./types.ts";
+export type RenderedObserverTarget = {
+    submitEvidence(kind: ElwoodStatusEvidence): Pick<ElwoodStatusDecision, "to">;
+    /** The session's current lifecycle status — lets the turn watcher release resume
+     * settling when a turn is already running from EVIDENCE (see
+     * TurnStateWatcher.observe). Typed as the bounded status union so an invalid test
+     * double or typo can't silently disable the `status === "running"` path. */
+    readonly status: ElwoodSessionStatus;
+};
+export type RenderedObservers = {
+    readonly turn: TurnStateWatcher;
+    readonly attention: AttentionWatcher;
+    /** The superset fact table (includes blocking/attention rules). */
+    readonly table: ScreenFactTable;
+    readonly agent: ElwoodAgentKind;
+    readonly elwoodSessionId: string;
+    readonly emitActivity: (event: ElwoodActivityEvent) => void;
+};
+export declare function observeRenderedFrame(observers: RenderedObservers, frame: RenderedFrame, session: RenderedObserverTarget | undefined): ScreenFactReading;
+//# sourceMappingURL=rendered-observers.d.ts.map

package/dist/core/rendered-observers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rendered-observers.d.ts","sourceRoot":"","sources":["../../src/core/rendered-observers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,EAAE,KAAK,gBAAgB,EAAyB,MAAM,gBAAgB,CAAC;AAC9E,OAAO,EACL,KAAK,aAAa,EAElB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACrB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAElG,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAAC,oBAAoB,EAAE,IAAI,CAAC,CAAC;IAC7E;;;gFAG4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC;IACrC,mEAAmE;IACnE,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,CAAC;CAC7D,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,iBAAiB,EAC5B,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,sBAAsB,GAAG,SAAS,GAC1C,iBAAiB,CAiBnB"}

package/dist/core/rendered-observers.js

@@ -0,0 +1,29 @@
+/**
+ * Applies turn-state and attention watchers to a rendered frame and submits
+ * the resulting evidence, emitting the attention activity on a real block.
+ * Implements PRD §5.3 turn and blocked detection.
+ */
+import { activityFromAttention } from "./attention.js";
+import { readScreenFacts, } from "./screen-facts.js";
+export function observeRenderedFrame(observers, frame, session) {
+    // Classify the frame once; turn and attention watchers share the reading, and the
+    // reading is returned so the caller can drive resume-readiness off the same facts.
+    const reading = readScreenFacts(observers.table, frame);
+    const turnEdge = observers.turn.observe(reading.facts, session?.status === "running");
+    if (turnEdge === "started")
+        session?.submitEvidence("rendered_turn_started");
+    if (turnEdge === "ended")
+        session?.submitEvidence("rendered_turn_ended");
+    const attention = observers.attention.observe(reading);
+    if (attention?.edge === "raised") {
+        const decision = session?.submitEvidence("blocking_prompt_shown");
+        if (session === undefined || decision?.to === "blocked") {
+            const { agent, elwoodSessionId } = observers;
+            observers.emitActivity(activityFromAttention(agent, elwoodSessionId, attention.ruleIds));
+        }
+    }
+    if (attention?.edge === "cleared")
+        session?.submitEvidence("blocking_prompt_cleared");
+    return reading;
+}
+//# sourceMappingURL=rendered-observers.js.map

package/dist/core/rendered-observers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rendered-observers.js","sourceRoot":"","sources":["../../src/core/rendered-observers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAyB,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAC9E,OAAO,EAEL,eAAe,GAGhB,MAAM,mBAAmB,CAAC;AAuB3B,MAAM,UAAU,oBAAoB,CAClC,SAA4B,EAC5B,KAAoB,EACpB,OAA2C;IAE3C,kFAAkF;IAClF,mFAAmF;IACnF,MAAM,OAAO,GAAG,eAAe,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACxD,MAAM,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,SAAS,CAAC,CAAC;IACtF,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,EAAE,cAAc,CAAC,uBAAuB,CAAC,CAAC;IAC7E,IAAI,QAAQ,KAAK,OAAO;QAAE,OAAO,EAAE,cAAc,CAAC,qBAAqB,CAAC,CAAC;IACzE,MAAM,SAAS,GAAG,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACvD,IAAI,SAAS,EAAE,IAAI,KAAK,QAAQ,EAAE,CAAC;QACjC,MAAM,QAAQ,GAAG,OAAO,EAAE,cAAc,CAAC,uBAAuB,CAAC,CAAC;QAClE,IAAI,OAAO,KAAK,SAAS,IAAI,QAAQ,EAAE,EAAE,KAAK,SAAS,EAAE,CAAC;YACxD,MAAM,EAAE,KAAK,EAAE,eAAe,EAAE,GAAG,SAAS,CAAC;YAC7C,SAAS,CAAC,YAAY,CAAC,qBAAqB,CAAC,KAAK,EAAE,eAAe,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;QAC3F,CAAC;IACH,CAAC;IACD,IAAI,SAAS,EAAE,IAAI,KAAK,SAAS;QAAE,OAAO,EAAE,cAAc,CAAC,yBAAyB,CAAC,CAAC;IACtF,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/core/screen-facts.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Declarative screen-fact tables: adapter-owned, versioned pattern rules
+ * evaluated against rendered terminal text or the OSC window title, with
+ * matched-rule explain data.
+ * Implements PRD §5.3 rendered-state detection (C-TURN-01 through C-TURN-05).
+ */
+import type { ElwoodAgentKind } from "./activity/index.ts";
+export type ScreenFactKind = "composer_visible" | "working_visible" | "interrupt_complete_visible" | "blocking_prompt_visible";
+/** Which rendered source a rule's patterns match against. */
+export type ScreenFactRegion = "screen" | "title";
+/**
+ * A rule matches EITHER via `all` (every regex tests true against the region's
+ * text) OR via `match` (a predicate over the region's text). `match` exists for
+ * rules whose recognition is not a plain regex-over-the-whole-frame test — most
+ * importantly the trust-prompt blocking rules, which must anchor on non-option
+ * lines so an option-only trust phrase cannot spoof a blocking prompt (PRD §5.1).
+ * A raw header regex applied to the full frame would misclassify such an option.
+ */
+export type ScreenFactRuleCondition = {
+    readonly all: readonly RegExp[];
+    readonly match?: never;
+} | {
+    readonly all?: never;
+    readonly match: (text: string) => boolean;
+};
+export type ScreenFactRule = {
+    /** Stable id surfaced in diagnostics and explain traces. */
+    readonly id: string;
+    readonly fact: ScreenFactKind;
+    /** Where the patterns are evaluated; defaults to the viewport text. */
+    readonly region?: ScreenFactRegion;
+} & ScreenFactRuleCondition;
+export type ScreenFactTable = {
+    readonly agent: ElwoodAgentKind;
+    /** CLI version these rules were last verified against by the e2e suites. */
+    readonly verifiedAgainst: string;
+    readonly rules: readonly ScreenFactRule[];
+};
+export type ScreenFacts = Readonly<Record<ScreenFactKind, boolean>>;
+export type MatchedScreenRule = {
+    readonly id: string;
+    readonly fact: ScreenFactKind;
+    readonly region: ScreenFactRegion;
+};
+export type ScreenFactReading = {
+    readonly facts: ScreenFacts;
+    /** The rules that matched, for explain traces. */
+    readonly matched: readonly MatchedScreenRule[];
+};
+export type RenderedFrame = {
+    readonly text: string;
+    /** The OSC window title, "" when none has been set. */
+    readonly title: string;
+};
+/**
+ * Evaluates the full table against a frame: sets every fact whose rules match
+ * (a fact is true if any of its rules match) and returns the list of matched
+ * rules — with their fact and region — for explain-trace diagnostics.
+ */
+export declare function readScreenFacts(table: ScreenFactTable, frame: RenderedFrame): ScreenFactReading;
+//# sourceMappingURL=screen-facts.d.ts.map

package/dist/core/screen-facts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen-facts.d.ts","sourceRoot":"","sources":["../../src/core/screen-facts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,MAAM,MAAM,cAAc,GACtB,kBAAkB,GAClB,iBAAiB,GACjB,4BAA4B,GAC5B,yBAAyB,CAAC;AAE9B,6DAA6D;AAC7D,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,OAAO,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,MAAM,uBAAuB,GAC/B;IAAE,QAAQ,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,GAC3D;IAAE,QAAQ,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,CAAC;AAExE,MAAM,MAAM,cAAc,GAAG;IAC3B,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,uEAAuE;IACvE,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC;CACpC,GAAG,uBAAuB,CAAC;AAE5B,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,4EAA4E;IAC5E,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;CAC3C,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC;AAEpE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,kDAAkD;IAClD,QAAQ,CAAC,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAChD,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AASF;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,aAAa,GAAG,iBAAiB,CAgB/F"}

package/dist/core/screen-facts.js

@@ -0,0 +1,36 @@
+/**
+ * Declarative screen-fact tables: adapter-owned, versioned pattern rules
+ * evaluated against rendered terminal text or the OSC window title, with
+ * matched-rule explain data.
+ * Implements PRD §5.3 rendered-state detection (C-TURN-01 through C-TURN-05).
+ */
+/** A rule fires when its `all` regexes all match, or its `match` predicate holds. */
+function ruleMatches(rule, target) {
+    return rule.all === undefined
+        ? rule.match(target)
+        : rule.all.every((pattern) => pattern.test(target));
+}
+/**
+ * Evaluates the full table against a frame: sets every fact whose rules match
+ * (a fact is true if any of its rules match) and returns the list of matched
+ * rules — with their fact and region — for explain-trace diagnostics.
+ */
+export function readScreenFacts(table, frame) {
+    const facts = {
+        composer_visible: false,
+        working_visible: false,
+        interrupt_complete_visible: false,
+        blocking_prompt_visible: false,
+    };
+    const matched = [];
+    for (const rule of table.rules) {
+        const region = rule.region ?? "screen";
+        const target = region === "title" ? frame.title : frame.text;
+        if (!ruleMatches(rule, target))
+            continue;
+        facts[rule.fact] = true;
+        matched.push({ id: rule.id, fact: rule.fact, region });
+    }
+    return { facts, matched };
+}
+//# sourceMappingURL=screen-facts.js.map

package/dist/core/screen-facts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen-facts.js","sourceRoot":"","sources":["../../src/core/screen-facts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA4DH,qFAAqF;AACrF,SAAS,WAAW,CAAC,IAAoB,EAAE,MAAc;IACvD,OAAO,IAAI,CAAC,GAAG,KAAK,SAAS;QAC3B,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QACpB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;AACxD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,KAAsB,EAAE,KAAoB;IAC1E,MAAM,KAAK,GAAoC;QAC7C,gBAAgB,EAAE,KAAK;QACvB,eAAe,EAAE,KAAK;QACtB,0BAA0B,EAAE,KAAK;QACjC,uBAAuB,EAAE,KAAK;KAC/B,CAAC;IACF,MAAM,OAAO,GAAwB,EAAE,CAAC;IACxC,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,QAAQ,CAAC;QACvC,MAAM,MAAM,GAAG,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC;QAC7D,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC;YAAE,SAAS;QACzC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QACxB,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;IACzD,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;AAC5B,CAAC"}

package/dist/core/serialize.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The shared tool-input/output serializer used across activity projection.
+ * Implements the PRD's single serialization rule (§5.4) so Claude transcript
+ * summaries and Codex activity metadata cannot diverge in how they stringify a
+ * tool's structured input/output.
+ */
+/** Serializes a value to a string, or undefined for null/undefined; never throws. */
+export declare function stringify(value: unknown): string | undefined;
+//# sourceMappingURL=serialize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/core/serialize.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,qFAAqF;AACrF,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAQ5D"}

package/dist/core/serialize.js

@@ -0,0 +1,20 @@
+/**
+ * The shared tool-input/output serializer used across activity projection.
+ * Implements the PRD's single serialization rule (§5.4) so Claude transcript
+ * summaries and Codex activity metadata cannot diverge in how they stringify a
+ * tool's structured input/output.
+ */
+/** Serializes a value to a string, or undefined for null/undefined; never throws. */
+export function stringify(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+//# sourceMappingURL=serialize.js.map

package/dist/core/serialize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.js","sourceRoot":"","sources":["../../src/core/serialize.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,qFAAqF;AACrF,MAAM,UAAU,SAAS,CAAC,KAAc;IACtC,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,SAAS,CAAC;IAC5D,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC5C,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;AACH,CAAC"}

package/dist/core/session-input-abort.d.ts

@@ -0,0 +1,10 @@
+/** Abort-aware timing and composer cleanup for queued input (PRD §5.3/§5.9). */
+/** The narrow PTY write surface the queued-input helpers drive. */
+export type InputTerminal = {
+    sendInput(data: string | Uint8Array): void | Promise<void>;
+};
+export declare function waitForInput(ms: number, signal?: AbortSignal): Promise<void>;
+export declare function throwIfInputAborted(signal?: AbortSignal): void;
+export declare function inputAbortError(signal: AbortSignal): Error;
+export declare function clearStagedComposer(terminal: InputTerminal): Promise<void>;
+//# sourceMappingURL=session-input-abort.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-input-abort.d.ts","sourceRoot":"","sources":["../../src/core/session-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/session-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=session-input-abort.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-input-abort.js","sourceRoot":"","sources":["../../src/core/session-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/session-input.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.ts";
+import { type InputTerminal } from "./session-input-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=session-input.d.ts.map

package/dist/core/session-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-input.d.ts","sourceRoot":"","sources":["../../src/core/session-input.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EAEL,KAAK,aAAa,EAGnB,MAAM,0BAA0B,CAAC;AAElC,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/session-input.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 "./session-input-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=session-input.js.map

package/dist/core/session-input.js.map

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

package/dist/core/session-wait.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Typed wait helpers over a session's status and activity event streams.
+ * Resolve immediately when the condition already holds, on a future event
+ * otherwise, reject on timeout, and reject when the session terminates first.
+ * Implements PRD §5.3 and C-API-34.
+ */
+import type { ElwoodActivityEvent } from "./activity/index.ts";
+import type { ElwoodSessionStatus, Unsubscribe } from "./types.ts";
+export type StatusWaitIo = {
+    readonly current: () => ElwoodSessionStatus;
+    readonly onStatus: (handler: (status: ElwoodSessionStatus) => void) => Unsubscribe;
+};
+export type ActivityWaitIo = {
+    readonly current: () => ElwoodSessionStatus;
+    readonly onActivity: (handler: (event: ElwoodActivityEvent) => void) => Unsubscribe;
+    readonly onStatus: (handler: (status: ElwoodSessionStatus) => void) => Unsubscribe;
+};
+/** A session view sufficient to build both wait helpers from `on`/`status`. */
+export type WaitableSession = {
+    readonly status: ElwoodSessionStatus;
+    on(event: "status", handler: (event: {
+        readonly status: ElwoodSessionStatus;
+    }) => void): Unsubscribe;
+    on(event: "activity", handler: (event: ElwoodActivityEvent) => void): Unsubscribe;
+};
+export declare function sessionWaitForStatus(session: WaitableSession, match: (status: ElwoodSessionStatus) => boolean, timeoutMs?: number): Promise<ElwoodSessionStatus>;
+export declare function sessionWaitForActivity(session: WaitableSession, match: (event: ElwoodActivityEvent) => boolean, timeoutMs?: number): Promise<ElwoodActivityEvent>;
+export declare function waitForStatus(io: StatusWaitIo, match: (status: ElwoodSessionStatus) => boolean, timeoutMs?: number): Promise<ElwoodSessionStatus>;
+export declare function waitForActivity(io: ActivityWaitIo, match: (event: ElwoodActivityEvent) => boolean, timeoutMs?: number): Promise<ElwoodActivityEvent>;
+//# sourceMappingURL=session-wait.d.ts.map

package/dist/core/session-wait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-wait.d.ts","sourceRoot":"","sources":["../../src/core/session-wait.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAG/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEnE,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,mBAAmB,CAAC;IAC5C,QAAQ,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,IAAI,KAAK,WAAW,CAAC;CACpF,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,mBAAmB,CAAC;IAC5C,QAAQ,CAAC,UAAU,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,KAAK,WAAW,CAAC;IACpF,QAAQ,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,IAAI,KAAK,WAAW,CAAC;CACpF,CAAC;AAIF,+EAA+E;AAC/E,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IACrC,EAAE,CACA,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAA;KAAE,KAAK,IAAI,GACjE,WAAW,CAAC;IACf,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,GAAG,WAAW,CAAC;CACnF,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,OAAO,EAC/C,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,mBAAmB,CAAC,CAS9B;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,OAAO,EAC9C,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,mBAAmB,CAAC,CAU9B;AAED,wBAAgB,aAAa,CAC3B,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,OAAO,EAC/C,SAAS,SAAuB,GAC/B,OAAO,CAAC,mBAAmB,CAAC,CA6B9B;AAED,wBAAgB,eAAe,CAC7B,EAAE,EAAE,cAAc,EAClB,KAAK,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,OAAO,EAC9C,SAAS,SAAuB,GAC/B,OAAO,CAAC,mBAAmB,CAAC,CAyB9B"}