@open-everywhere/core 0.1.0

package/dist/agent/spend/usage-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage-events.d.ts","sourceRoot":"","sources":["../../../agent/spend/usage-events.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAGrH,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAErH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,iBAAiB,CAAC;AAEvD;kFACkF;AAClF,wBAAgB,cAAc,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,CAG/G;AAED;0DAC0D;AAC1D,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IACvC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IACvC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG;IAAE,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAE,CAIpC;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAkC5E;AAED;gFACgF;AAChF,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAEhG;AAED,sGAAsG;AACtG,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,kBAAuB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAE3G;AAED;;0DAE0D;AAC1D,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAExF"}

package/dist/agent/spend/usage-events.js

@@ -0,0 +1,132 @@
+// Per-event usage capture — the raw, append-only ledger behind per-session cost,
+// per-user analytics, and cost prediction (spend_ledger stays the pure CAPS
+// aggregate; this is the row-level sibling that carries a session_id + principal_id
+// dimension the ledger deliberately never kept — see operational/store.ts for the
+// full rationale). Thin adapter over the OperationalStore seam (SQLite local /
+// Postgres deploy) — same split as spend/store.ts and audit/audit.ts.
+//
+// BEST-EFFORT BY CONTRACT: appendUsageEvent NEVER throws to its caller (mirrors
+// appendAudit) — a dropped usage row must never break the turn/hook/tool it costs.
+import { getOperationalStore } from "../operational/provider.js";
+import { getSettings } from "../settings/settings.js";
+/**
+ * The `usage_events.detail` key carrying the GATEWAY'S OWN TRACE ID for one model call (OPE-369)
+ * — eve extracts it from `providerMetadata.gateway.generationId` (extractStepProviderMetadata) and
+ * puts it on the `step.completed` event; hooks/spend.ts stamps it here.
+ *
+ * ⭐ WHAT IT BUYS. Every other field on a usage row is OE's OWN account of a call. This is the
+ * single value that JOINS that account to the gateway's: an unexplained cost spike, a suspected
+ * mis-attribution, a row whose measured and derived $ disagree — each becomes one lookup in the
+ * gateway's console against a specific generation, instead of an argument about which of our rows
+ * corresponds to which of their line items. It is a correlation id, not a secret and not evidence:
+ * it names a record we do not own and cannot verify from here.
+ *
+ * ONE name, shared by the writer and every reader, exactly like SUBAGENT_RUN_DETAIL_KEY.
+ */
+export const GENERATION_ID_DETAIL_KEY = "generationId";
+/** Read the gateway generation id back off a row, or undefined when it carries none (every
+ *  pre-OPE-369 row, every non-gateway deployment, every non-model row). Total. */
+export function generationIdOf(row) {
+    const raw = row.detail?.[GENERATION_ID_DETAIL_KEY];
+    return typeof raw === "string" && raw.length > 0 ? raw : undefined;
+}
+/** The `spend.usageEventsTtlDays` setting (`spend.usageEventsTtlDays` overrides it) — the
+ *  opportunistic retention window, 90 days as shipped. */
+export function usageEventsTtlDays() {
+    return getSettings().spend.usageEventsTtlDays;
+}
+/**
+ * Did this call's source REPORT a cache split (OPE-1611)? Returns the `cacheTokensReported` half
+ * of a usage row, or `{}` when the question does not apply.
+ *
+ * THE RULE, in order:
+ *   1. an explicit `cacheTokensReported` on the input always wins — a writer that positively knows
+ *      the answer (a direct provider call reading the raw usage object) states it;
+ *   2. otherwise, only a row that NAMES A MODEL is asked at all. A model-less row is sandbox
+ *      RUNTIME billing (vercel-lifecycle.ts's OPE-266 writer) or another non-model source: it has
+ *      no prompt, so "did the prompt hit a cache" is not a question it can answer, and NULL —
+ *      the question was never asked — is the honest column;
+ *   3. for a model call, the answer is whether the source gave EITHER cache figure. eve's
+ *      `extractStepUsage` omits both keys entirely when the provider reported no
+ *      `inputTokenDetails`, so their presence is exactly "the provider published a figure", and
+ *      their absence is exactly "it did not".
+ *
+ * 🔴 WHAT THIS CANNOT ANSWER, and why no caller may read `true` as "the split is known": a
+ * PUBLISHED ZERO counts as published, because the rule is about the field, not its value. That is
+ * the honest reading of the input, and it is also why a zero must never be reported as "no
+ * caching" — see {@link import("../operational/store.js").UsageEventEntry.cacheTokensReported} and
+ * `spend/reporting.ts`'s `tokenAttributionNote`, which keys on the token COUNT for exactly this
+ * reason. A writer that positively knows better (a transport reading the raw provider result)
+ * overrides the inference through rule 1.
+ *
+ * Pure and total. Exported for the spend suite, which pins each arm.
+ */
+export function cacheReportedness(entry) {
+    if (entry.cacheTokensReported !== undefined)
+        return { cacheTokensReported: entry.cacheTokensReported };
+    if (entry.model === undefined)
+        return {};
+    return { cacheTokensReported: entry.cacheReadTokens !== undefined || entry.cacheWriteTokens !== undefined };
+}
+/**
+ * Append one usage event. Best-effort: never throws — a failure is logged, not
+ * raised, so cost capture can never break the turn/hook/tool it's recording.
+ *
+ * Also rides an OPPORTUNISTIC prune (~1-in-20 writes), same idiom as event_dedupe's
+ * TTL prune — no scheduled job, the cost is amortized across normal writes. A prune
+ * failure never taints the append that already succeeded (own try/catch); on
+ * Postgres it's a documented no-op (see operational/postgres.ts).
+ */
+export async function appendUsageEvent(entry) {
+    const record = {
+        ...entry,
+        ts: entry.ts ?? new Date().toISOString(),
+        inputTokens: entry.inputTokens ?? 0,
+        outputTokens: entry.outputTokens ?? 0,
+        cacheReadTokens: entry.cacheReadTokens ?? 0,
+        cacheWriteTokens: entry.cacheWriteTokens ?? 0,
+        // 🔴 THE `?? 0` ON THE TWO LINES ABOVE IS WHERE ONE HALF OF THE ATTRIBUTION DIED (OPE-1611).
+        // The caller's input still knows the difference between "the source published a cache figure"
+        // and "it published nothing at all", and the coercion erased it, so every row said 0. The sums
+        // stay as they were — a cap's neighbours read them, and a NULL there would poison those reads
+        // — and this flag carries the missing fact beside them.
+        // ⚠️ IT IS ONLY HALF. A published ZERO is not evidence of no caching either: this deployment's
+        // gateway is recorded as billing the cache discount with `usage.cachedInputTokens` reading 0
+        // (docs/security/spend-and-cost.md). So the flag answers "did the source publish a figure",
+        // never "is the figure informative", and the report line in spend/reporting.ts is written
+        // against a ZERO rather than against this flag alone.
+        ...cacheReportedness(entry),
+    };
+    try {
+        await getOperationalStore().appendUsageEvent(record);
+    }
+    catch (err) {
+        console.warn(`[open-everywhere:usage] dropped a usage event for ${entry.org}/${entry.surfaceKey}: ${String(err)}`);
+        return;
+    }
+    if (Math.random() < 0.05) {
+        try {
+            const cutoff = new Date(Date.parse(record.ts) - usageEventsTtlDays() * 24 * 60 * 60 * 1000).toISOString();
+            await getOperationalStore().pruneUsageEvents(record.org, cutoff);
+        }
+        catch (err) {
+            console.warn(`[open-everywhere:usage] opportunistic prune skipped: ${String(err)}`);
+        }
+    }
+}
+/** Every usage event for one session (org-scoped), oldest-first — see the store's
+ *  doc comment for why this returns raw rows rather than a pre-summed total. */
+export async function usageForSession(org, sessionId) {
+    return getOperationalStore().usageForSession(org, sessionId);
+}
+/** Grouped rollup by (surfaceKey, principalId, kind, routineId, surfaceMode, model) within an org. */
+export async function usageSummary(org, filter = {}) {
+    return getOperationalStore().usageSummary(org, filter);
+}
+/** Manual/administrative prune (tests, ops scripts) — production relies on the
+ *  opportunistic path inside appendUsageEvent. Returns the count removed (0 on
+ *  Postgres, by design — see operational/postgres.ts). */
+export async function pruneUsageEvents(org, olderThanTs) {
+    return getOperationalStore().pruneUsageEvents(org, olderThanTs);
+}
+//# sourceMappingURL=usage-events.js.map

package/dist/agent/spend/usage-events.js.map

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

package/dist/agent/stall/bash-hang-guard.d.ts

@@ -0,0 +1,133 @@
+import type { ToolDefinition } from "eve/tools";
+/**
+ * How long to wait for one `bash` call before giving up with a diagnostic.
+ *
+ * THIS NUMBER IS CHOSEN ON CAPABILITY GROUNDS. It is NOT derived from any observed platform
+ * ceiling, because no such ceiling exists — see below before changing it in either direction.
+ *
+ * WHAT THE ARGUMENT USED TO BE, AND WHY IT IS DEAD. The value was 240 000 ms, justified as:
+ * *"the framework's own ceiling is ~341s, so nothing above that can return AT ALL, and a 240s cap
+ * gives up only the 101s sliver between the two."* That made the cap look free. It was not.
+ *
+ * WHAT WAS MEASURED (OPE-132, 2026-07-29). Two rounds. The load-bearing numbers are reproduced
+ * HERE, not left in an operator-local note, because this comment is the durable record.
+ *
+ * Round 1, against the REAL Vercel Sandbox API through eve's own pinned `@vercel/sandbox` 2.8.0,
+ * replicating eve's exact call shape (`runCommand({cmd:"bash", args:["-lc",…], detached:true})` →
+ * `Promise.all([drain(logs()), wait()])`), run from an operator laptop:
+ *   • `for i in $(seq 1 400); do echo tick; sleep 1; done`  → exit 0 at 400.1s, all 400 lines
+ *     delivered.                                    ⇒ there is no WALL-CLOCK cap at ~341s.
+ *   • `sleep 360; echo done` → exit 0 at 359.6s, and `sleep 700; echo done` → exit 0 at 699.9s,
+ *     both emitting nothing at all until the final line.   ⇒ there is no IDLE cap at ~341s either.
+ *   • `python3 -m http.server 8000 &` — the VERBATIM prod hang shape — held the log stream open
+ *     with ZERO bytes for 753s and was still open when the probe's own deadline aborted it.
+ *                                        ⇒ the hang is not bounded at ~341s; it may not be bounded.
+ *
+ * Round 2 closed round 1's ONE uncontrolled variable — every probe above ran off a laptop, while
+ * the three 341.1–341.2s samples came from inside a Vercel Fluid function. Run IN PRODUCTION with
+ * `bash.timeoutMs`, driving a real trusted mention so the seat delegated a task worker and
+ * the `bash` call executed inside the live turn function:
+ *   • the same 400-tick loop → **RETURNED, 400 tick lines, exit 0, ~400s**.
+ *                     ⇒ there is no ~341s cut in THIS DEPLOYMENT'S EGRESS PATH either.
+ *
+ * Nor is there a constant to point at: no value in the 290 000–399 999 ms band exists anywhere in
+ * eve's or this repo's source, and the SDK explicitly DISABLES the only client-side idle timer in
+ * the path (`new Agent({ bodyTimeout: 0 })` in `@vercel/sandbox`'s `base-client.js`). eve 0.27.5 —
+ * the version prod was running when the three 341s samples were taken — bundles the same SDK with
+ * the same `bodyTimeout: 0`, so "the 0.27.11 bump already fixed it" is false as well.
+ *
+ * ⚠️ THE THREE 341.1–341.2s SAMPLES REMAIN UNEXPLAINED, with a 0.1s spread. Everything above says
+ * what they CANNOT have been. Nothing says what they WERE. This comment deliberately offers no
+ * replacement story — inventing one is the exact failure that produced the original claim.
+ *
+ * WHAT SURVIVED, AND IT IS THE PART THIS MODULE RESTS ON. The MECHANISM is confirmed independently:
+ * `wait()` reported `durationMs: 600023` for `bash -lc 'sleep 600 &'` — a shell that exits in
+ * milliseconds. The platform therefore considers a command finished only when its PIPES close, not
+ * when its process exits, so an unredirected background child holds the whole call open. Layer 1
+ * (detect + refuse) keeps its FULL justification and is untouched by any of the above.
+ *
+ * WHY 600s. With no ceiling above it, this cap is a BACKSTOP for the hang shapes layer 1 cannot
+ * parse (a nested script that daemonises, an `npm run dev` wrapper, a `make` target that forks) —
+ * not a budget for legitimate long work, which layer 1's own discipline says to BACKGROUND to a log
+ * and poll (`… > /tmp/build.log 2>&1 &`). So it wants to sit comfortably above any command a model
+ * would reasonably run in the foreground, and comfortably below the session window:
+ *   • measurement puts real foreground work at ~400s and returning cleanly, so a cap must exceed
+ *     that or it amputates work now PROVEN to complete. This is why it is not lower.
+ *   • the sandbox SESSION window (`sandbox.timeoutMs`, default 1 800 000 ms) is the ceiling
+ *     that IS real. It is a *remaining-window* amount — it shrinks across a turn — so a trip at
+ *     600s still leaves the majority of a fresh window for the model to read the diagnostic and
+ *     react. This is why it is not higher.
+ * A hang costs the full cap in wall-clock before the model learns anything, which is the whole
+ * cost of raising it; 10 minutes is the point where that cost stays tolerable and the amputation
+ * risk is gone.
+ *
+ * Override with `bash.timeoutMs`; `0`/`off`/`false` disables the timeout entirely.
+ *
+ * 🔴 IF YOU CHANGE THIS, CHANGE THE PROSE TOO. `agent/instructions.md` states the number to the
+ * MODEL and `docs/deploy/configuration-reference.md` states it to the OPERATOR; neither reads this
+ * constant. A stale number there is not cosmetic — the agent recites it to users as fact (observed
+ * 2026-07-29: it asserted "about 4 minutes" on a deployment where the cap was disabled entirely).
+ */
+export declare const DEFAULT_BASH_TIMEOUT_MS: number;
+/** Configured timeout: the deployment's `bash.timeoutMs` setting, overridden by
+ *  `bash.timeoutMs` if that names a positive integer, or `0` when explicitly disabled.
+ *  Unparseable input falls back to the configured value (fail-safe: keep the guard on).
+ *  Read per-call so ops can flip it without a redeploy — `getSettings()` resolves fresh. */
+export declare function bashTimeoutMs(): number;
+/** Whether layer 1 (detect + fail fast) is armed. `bash.backgroundGuard`/`0`/`false`
+ *  disables it — the escape hatch for a shell form the detector reads wrong. */
+export declare function backgroundGuardEnabled(): boolean;
+interface CommandScan {
+    /** Unquoted text of each segment terminated by a LONE `&` (i.e. backgrounded). */
+    readonly background: readonly string[];
+    /** The whole command with quoted spans dropped — used for the `wait` carve-out. */
+    readonly unquoted: string;
+    /** Set when the command contains a heredoc: the body is not shell-parseable by this
+     *  scanner, so detection bails rather than guess. */
+    readonly hasHeredoc: boolean;
+}
+/**
+ * Quote- and escape-aware scan splitting a command into segments and picking out the ones a lone
+ * `&` backgrounds. Quoted text contributes NOTHING to a segment, so an `&` (or a `>`) inside
+ * `node -e '…'` can never be mistaken for shell syntax — which matters, because the prod repro
+ * was exactly that shape.
+ *
+ * `&&` is a sequencer, `>&` (as in `2>&1`) and `&>` (combined redirect) are redirection syntax —
+ * none of the three background anything, so only a truly lone `&` splits.
+ */
+export declare function scanCommand(command: string): CommandScan;
+/**
+ * Does this segment redirect BOTH stdout and stderr away from the inherited pipes? Only then can
+ * the run's streams close while the process lives on.
+ *
+ * `&>file` / `&>>file` covers both at once. Otherwise stdout needs a plain `>`/`>>` (optionally
+ * `1>`) and stderr needs `2>`/`2>>`. The `[^0-9<>&]` prefix class is what stops `2>&1`'s own `>`
+ * being counted as a stdout redirect — the single most likely way to get this wrong.
+ */
+export declare function redirectsBothStreams(segment: string): boolean;
+/**
+ * TRUE when the command backgrounds at least one segment whose output is still on the inherited
+ * pipes — i.e. the shape that hangs the call (observed at ~341s in three prod sessions, and held
+ * open for 753s without dying when re-measured; see DEFAULT_BASH_TIMEOUT_MS).
+ *
+ * Fail-open on anything ambiguous: a heredoc (unparseable body) and any command mentioning the
+ * `wait` builtin (`cmd & wait` reaps the child, so its streams DO close) are both let through. A
+ * missed hang costs the timeout; a false refusal costs a real command, so ambiguity resolves the
+ * permissive way.
+ */
+export declare function backgroundsWithoutRedirect(command: string): boolean;
+/** Layer 1's refusal: names the cause and hands back the corrected form. */
+export declare function unredirectedBackgroundMessage(): string;
+/** Layer 2's diagnostic: bounded failure that names the likely cause. */
+export declare function bashTimeoutMessage(ms: number): string;
+/**
+ * Wrap the `bash` tool with both layers. Applied INSIDE the stall guard
+ * (`withStallGuard("bash", withBashHangGuard(bash))`) so an armed spin is still short-circuited
+ * before any of this runs.
+ *
+ * Every trip emits telemetry (`oe.feature.used`, closed vocabulary) and an append-only audit row
+ * so a prod hang is queryable per-org — the same evidence shape guard.ts's nudge uses.
+ */
+export declare function withBashHangGuard<I, O>(tool: ToolDefinition<I, O>): ToolDefinition<I, O>;
+export {};
+//# sourceMappingURL=bash-hang-guard.d.ts.map

package/dist/agent/stall/bash-hang-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash-hang-guard.d.ts","sourceRoot":"","sources":["../../../agent/stall/bash-hang-guard.ts"],"names":[],"mappings":"AAsCA,OAAO,KAAK,EAAe,cAAc,EAAE,MAAM,WAAW,CAAC;AAK7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAwC,CAAC;AAE/E;;;4FAG4F;AAC5F,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED;gFACgF;AAChF,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAID,UAAU,WAAW;IACnB,kFAAkF;IAClF,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,mFAAmF;IACnF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;yDACqD;IACrD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAyDxD;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAK7D;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAMnE;AAID,4EAA4E;AAC5E,wBAAgB,6BAA6B,IAAI,MAAM,CAQtD;AAED,yEAAyE;AACzE,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAQrD;AAuBD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CA+BxF"}

package/dist/agent/stall/bash-hang-guard.js

@@ -0,0 +1,303 @@
+// Bash HANG GUARD — turn the framework `bash` tool's silent, unbounded stall into a bounded,
+// actionable failure. Sibling of guard.ts (a stalled tool call is the same class of problem as a
+// spinning one: the loop stops making progress) but a different mechanism, so it lives in its own
+// file and wraps INSIDE the stall guard at tools/sandbox_tools.ts.
+//
+// THE BUG IT GUARDS (diagnosed 2026-07-25 from three independent prod worker transcripts). eve's
+// bash tool (node_modules/eve/dist/src/execution/sandbox/bash.js, via tools/provided/bash.js) calls `session.run({command})`
+// and resolves only when the command's stdout/stderr streams CLOSE. A backgrounded long-lived
+// process INHERITS those pipes, so they never close and the call blocks. In each of the three prod
+// sessions it blocked for 341.1–341.2s and then surfaced as undici's opaque `terminated`. Treat
+// that duration as an OBSERVATION, not a bound: re-measured against the same API in 2026-07-29 the
+// identical command held its stream open for 753s and was still open when the probe was aborted
+// (see DEFAULT_BASH_TIMEOUT_MS below for the full evidence and what remains open).
+//   • `python3 -m http.server 8000 &`                                  → hung 341.2s
+//   • `nohup node -e '…' &`                     (nohup, NO redirect)   → hung 341.2s
+//   • `node -e '…listen(8000)' &` then `sleep 1 && curl …`             → hung 341.1s
+// And the counter-example that proves the mechanism:
+//   • `nohup python3 -m http.server 8000 > /dev/null 2>&1 &`           → returned in 1.4s
+// `nohup` is irrelevant. OUTPUT REDIRECTION IS THE WHOLE THING — and that half is independently
+// confirmed by measurement (again, see below). Any user who asks the agent to start a dev server
+// hits this today, and docs/capabilities/browser-qa.md advertises exactly that loop, so it sits on
+// the happy path.
+//
+// TWO LAYERS, both fail-open and neither one rewriting the model's command:
+//   1. DETECT + FAIL FAST — a command that backgrounds a segment with a bare `&` and redirects
+//      neither stdout nor stderr is refused BEFORE it runs, with the corrected form in the error.
+//      Deliberately NOT a silent `> /dev/null 2>&1` rewrite: appending a redirect discards output
+//      the model may have wanted and changes the semantics of a command it authored. A recoverable
+//      tool error costs one cheap turn and leaves the model in charge of its own command.
+//   2. TIME OUT — the backstop for every form layer 1 doesn't recognise (a nested script that
+//      daemonises, an `npm run dev` wrapper, a `make` target that forks). Bounded wait, then a
+//      diagnostic that NAMES the likely cause instead of undici's `terminated`.
+//
+// Both refuse by THROWING — a per-action recoverable tool error the model reads and continues from,
+// the same shape guard.ts's nudge uses (and for the same reasons: returning a value would fail the
+// tool's own outputSchema, and an `approval:` gate doesn't replay-lookup on OE's resumed sessions).
+// The underlying `bash` result is never mutated.
+import { auditToolAction } from "../audit/tool-action.js";
+import { emitTelemetry } from "../observability/telemetry.js";
+import { SETTINGS, getSettings } from "../settings/settings.js";
+/**
+ * How long to wait for one `bash` call before giving up with a diagnostic.
+ *
+ * THIS NUMBER IS CHOSEN ON CAPABILITY GROUNDS. It is NOT derived from any observed platform
+ * ceiling, because no such ceiling exists — see below before changing it in either direction.
+ *
+ * WHAT THE ARGUMENT USED TO BE, AND WHY IT IS DEAD. The value was 240 000 ms, justified as:
+ * *"the framework's own ceiling is ~341s, so nothing above that can return AT ALL, and a 240s cap
+ * gives up only the 101s sliver between the two."* That made the cap look free. It was not.
+ *
+ * WHAT WAS MEASURED (OPE-132, 2026-07-29). Two rounds. The load-bearing numbers are reproduced
+ * HERE, not left in an operator-local note, because this comment is the durable record.
+ *
+ * Round 1, against the REAL Vercel Sandbox API through eve's own pinned `@vercel/sandbox` 2.8.0,
+ * replicating eve's exact call shape (`runCommand({cmd:"bash", args:["-lc",…], detached:true})` →
+ * `Promise.all([drain(logs()), wait()])`), run from an operator laptop:
+ *   • `for i in $(seq 1 400); do echo tick; sleep 1; done`  → exit 0 at 400.1s, all 400 lines
+ *     delivered.                                    ⇒ there is no WALL-CLOCK cap at ~341s.
+ *   • `sleep 360; echo done` → exit 0 at 359.6s, and `sleep 700; echo done` → exit 0 at 699.9s,
+ *     both emitting nothing at all until the final line.   ⇒ there is no IDLE cap at ~341s either.
+ *   • `python3 -m http.server 8000 &` — the VERBATIM prod hang shape — held the log stream open
+ *     with ZERO bytes for 753s and was still open when the probe's own deadline aborted it.
+ *                                        ⇒ the hang is not bounded at ~341s; it may not be bounded.
+ *
+ * Round 2 closed round 1's ONE uncontrolled variable — every probe above ran off a laptop, while
+ * the three 341.1–341.2s samples came from inside a Vercel Fluid function. Run IN PRODUCTION with
+ * `bash.timeoutMs`, driving a real trusted mention so the seat delegated a task worker and
+ * the `bash` call executed inside the live turn function:
+ *   • the same 400-tick loop → **RETURNED, 400 tick lines, exit 0, ~400s**.
+ *                     ⇒ there is no ~341s cut in THIS DEPLOYMENT'S EGRESS PATH either.
+ *
+ * Nor is there a constant to point at: no value in the 290 000–399 999 ms band exists anywhere in
+ * eve's or this repo's source, and the SDK explicitly DISABLES the only client-side idle timer in
+ * the path (`new Agent({ bodyTimeout: 0 })` in `@vercel/sandbox`'s `base-client.js`). eve 0.27.5 —
+ * the version prod was running when the three 341s samples were taken — bundles the same SDK with
+ * the same `bodyTimeout: 0`, so "the 0.27.11 bump already fixed it" is false as well.
+ *
+ * ⚠️ THE THREE 341.1–341.2s SAMPLES REMAIN UNEXPLAINED, with a 0.1s spread. Everything above says
+ * what they CANNOT have been. Nothing says what they WERE. This comment deliberately offers no
+ * replacement story — inventing one is the exact failure that produced the original claim.
+ *
+ * WHAT SURVIVED, AND IT IS THE PART THIS MODULE RESTS ON. The MECHANISM is confirmed independently:
+ * `wait()` reported `durationMs: 600023` for `bash -lc 'sleep 600 &'` — a shell that exits in
+ * milliseconds. The platform therefore considers a command finished only when its PIPES close, not
+ * when its process exits, so an unredirected background child holds the whole call open. Layer 1
+ * (detect + refuse) keeps its FULL justification and is untouched by any of the above.
+ *
+ * WHY 600s. With no ceiling above it, this cap is a BACKSTOP for the hang shapes layer 1 cannot
+ * parse (a nested script that daemonises, an `npm run dev` wrapper, a `make` target that forks) —
+ * not a budget for legitimate long work, which layer 1's own discipline says to BACKGROUND to a log
+ * and poll (`… > /tmp/build.log 2>&1 &`). So it wants to sit comfortably above any command a model
+ * would reasonably run in the foreground, and comfortably below the session window:
+ *   • measurement puts real foreground work at ~400s and returning cleanly, so a cap must exceed
+ *     that or it amputates work now PROVEN to complete. This is why it is not lower.
+ *   • the sandbox SESSION window (`sandbox.timeoutMs`, default 1 800 000 ms) is the ceiling
+ *     that IS real. It is a *remaining-window* amount — it shrinks across a turn — so a trip at
+ *     600s still leaves the majority of a fresh window for the model to read the diagnostic and
+ *     react. This is why it is not higher.
+ * A hang costs the full cap in wall-clock before the model learns anything, which is the whole
+ * cost of raising it; 10 minutes is the point where that cost stays tolerable and the amputation
+ * risk is gone.
+ *
+ * Override with `bash.timeoutMs`; `0`/`off`/`false` disables the timeout entirely.
+ *
+ * 🔴 IF YOU CHANGE THIS, CHANGE THE PROSE TOO. `agent/instructions.md` states the number to the
+ * MODEL and `docs/deploy/configuration-reference.md` states it to the OPERATOR; neither reads this
+ * constant. A stale number there is not cosmetic — the agent recites it to users as fact (observed
+ * 2026-07-29: it asserted "about 4 minutes" on a deployment where the cap was disabled entirely).
+ */
+export const DEFAULT_BASH_TIMEOUT_MS = SETTINGS.bash.timeoutMs.shipped;
+/** Configured timeout: the deployment's `bash.timeoutMs` setting, overridden by
+ *  `bash.timeoutMs` if that names a positive integer, or `0` when explicitly disabled.
+ *  Unparseable input falls back to the configured value (fail-safe: keep the guard on).
+ *  Read per-call so ops can flip it without a redeploy — `getSettings()` resolves fresh. */
+export function bashTimeoutMs() {
+    return getSettings().bash.timeoutMs;
+}
+/** Whether layer 1 (detect + fail fast) is armed. `bash.backgroundGuard`/`0`/`false`
+ *  disables it — the escape hatch for a shell form the detector reads wrong. */
+export function backgroundGuardEnabled() {
+    return getSettings().bash.backgroundGuard;
+}
+/**
+ * Quote- and escape-aware scan splitting a command into segments and picking out the ones a lone
+ * `&` backgrounds. Quoted text contributes NOTHING to a segment, so an `&` (or a `>`) inside
+ * `node -e '…'` can never be mistaken for shell syntax — which matters, because the prod repro
+ * was exactly that shape.
+ *
+ * `&&` is a sequencer, `>&` (as in `2>&1`) and `&>` (combined redirect) are redirection syntax —
+ * none of the three background anything, so only a truly lone `&` splits.
+ */
+export function scanCommand(command) {
+    const background = [];
+    let unquoted = "";
+    let seg = "";
+    let quote = null;
+    let hasHeredoc = false;
+    for (let i = 0; i < command.length; i++) {
+        const c = command[i];
+        if (quote) {
+            // Inside single quotes nothing escapes; inside double quotes a backslash escapes one char.
+            if (c === "\\" && quote === '"')
+                i++;
+            else if (c === quote)
+                quote = null;
+            continue;
+        }
+        if (c === "\\") {
+            i++; // escaped char is literal — never syntax
+            continue;
+        }
+        if (c === "'" || c === '"') {
+            quote = c;
+            continue;
+        }
+        unquoted += c;
+        if (c === "<" && command[i + 1] === "<") {
+            hasHeredoc = true;
+            break;
+        }
+        if (c === "&") {
+            if (command[i + 1] === "&") {
+                // `&&` — sequencer, starts a new segment.
+                unquoted += "&";
+                i++;
+                seg = "";
+                continue;
+            }
+            if (command[i - 1] === ">" || command[i + 1] === ">") {
+                // `>&` (2>&1, >&2) or `&>` (combined) — redirection syntax, stays in the segment.
+                seg += c;
+                continue;
+            }
+            background.push(seg);
+            seg = "";
+            continue;
+        }
+        if (c === ";" || c === "\n" || c === "|") {
+            if (c === "|" && command[i + 1] === "|") {
+                unquoted += "|";
+                i++;
+            }
+            seg = "";
+            continue;
+        }
+        seg += c;
+    }
+    return { background, unquoted, hasHeredoc };
+}
+/**
+ * Does this segment redirect BOTH stdout and stderr away from the inherited pipes? Only then can
+ * the run's streams close while the process lives on.
+ *
+ * `&>file` / `&>>file` covers both at once. Otherwise stdout needs a plain `>`/`>>` (optionally
+ * `1>`) and stderr needs `2>`/`2>>`. The `[^0-9<>&]` prefix class is what stops `2>&1`'s own `>`
+ * being counted as a stdout redirect — the single most likely way to get this wrong.
+ */
+export function redirectsBothStreams(segment) {
+    if (/&>{1,2}/.test(segment))
+        return true;
+    const stdout = /(?:^|[^0-9<>&])1?>{1,2}/.test(segment);
+    const stderr = /(?:^|[^0-9<>&])2>{1,2}/.test(segment);
+    return stdout && stderr;
+}
+/**
+ * TRUE when the command backgrounds at least one segment whose output is still on the inherited
+ * pipes — i.e. the shape that hangs the call (observed at ~341s in three prod sessions, and held
+ * open for 753s without dying when re-measured; see DEFAULT_BASH_TIMEOUT_MS).
+ *
+ * Fail-open on anything ambiguous: a heredoc (unparseable body) and any command mentioning the
+ * `wait` builtin (`cmd & wait` reaps the child, so its streams DO close) are both let through. A
+ * missed hang costs the timeout; a false refusal costs a real command, so ambiguity resolves the
+ * permissive way.
+ */
+export function backgroundsWithoutRedirect(command) {
+    const { background, unquoted, hasHeredoc } = scanCommand(command);
+    if (hasHeredoc)
+        return false;
+    if (background.length === 0)
+        return false;
+    if (/\bwait\b/.test(unquoted))
+        return false;
+    return background.some((seg) => seg.trim() !== "" && !redirectsBothStreams(seg));
+}
+// --- model-visible messages (exported for tests) ---------------------------------------------
+/** Layer 1's refusal: names the cause and hands back the corrected form. */
+export function unredirectedBackgroundMessage() {
+    return ("`bash` did NOT run this command. It backgrounds a process with `&` but redirects neither " +
+        "stdout nor stderr, so the backgrounded process keeps the workspace's output stream open and " +
+        "this call would hang until it is cut off, rather than returning. Re-run it with BOTH streams redirected — " +
+        "`<command> > /tmp/out.log 2>&1 &` (or `> /dev/null 2>&1 &` if you don't need the output) — " +
+        "then poll the log or the port to check it came up.");
+}
+/** Layer 2's diagnostic: bounded failure that names the likely cause. */
+export function bashTimeoutMessage(ms) {
+    return (`\`bash\` gave up waiting after ${Math.round(ms / 1000)}s — the command's output stream never ` +
+        "closed, so this call could not return. Most likely cause: did you background a process without " +
+        "redirecting stdout/stderr? A background job MUST redirect both (`<command> > /tmp/out.log " +
+        "2>&1 &`) or this call can never return. The command may still be running in the workspace — " +
+        "check the log or the port with a short command rather than re-running it.");
+}
+// --- the wrapper ------------------------------------------------------------------------------
+/** Wait for `promise`, or reject with the timeout diagnostic after `ms`. The losing promise is
+ *  left to settle on its own (we cannot cancel a sandbox run) with its rejection absorbed, so a
+ *  late failure can't surface as an unhandled rejection and take the process down. */
+async function raceTimeout(promise, ms) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(bashTimeoutMessage(ms))), ms);
+        timer.unref?.();
+    });
+    promise.catch(() => {
+        /* absorbed — the race already reported, or will report, the outcome */
+    });
+    try {
+        return await Promise.race([promise, timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+/**
+ * Wrap the `bash` tool with both layers. Applied INSIDE the stall guard
+ * (`withStallGuard("bash", withBashHangGuard(bash))`) so an armed spin is still short-circuited
+ * before any of this runs.
+ *
+ * Every trip emits telemetry (`oe.feature.used`, closed vocabulary) and an append-only audit row
+ * so a prod hang is queryable per-org — the same evidence shape guard.ts's nudge uses.
+ */
+export function withBashHangGuard(tool) {
+    return {
+        ...tool,
+        // 🔴 VALUE-RETURNING TOOLS ONLY. The timeout RACE resolves the tool result, so this wrapper
+        // cannot forward a streaming (`AsyncIterable`) result — racing one would consume it, and eve
+        // accepts `Promise<O>`, never `Promise<AsyncIterable<O>>`. It wraps `bash`, which returns a
+        // value; the narrows below record that.
+        async execute(input, ctx) {
+            const command = typeof input?.command === "string" ? (input.command) : "";
+            if (backgroundGuardEnabled() && backgroundsWithoutRedirect(command)) {
+                emitTelemetry("oe.feature.used", { "oe.feature": "bash_hang_guard", "oe.outcome": "failed" });
+                await auditToolAction(ctx, "bash.background_unredirected", { tool: "bash" });
+                console.warn("[open-everywhere:bash-hang-guard] refused a backgrounded command with no output redirection");
+                throw new Error(unredirectedBackgroundMessage());
+            }
+            const ms = bashTimeoutMs();
+            if (ms <= 0)
+                return (await tool.execute(input, ctx));
+            try {
+                return (await raceTimeout(Promise.resolve(tool.execute(input, ctx)), ms));
+            }
+            catch (err) {
+                if (err instanceof Error && err.message === bashTimeoutMessage(ms)) {
+                    emitTelemetry("oe.feature.used", { "oe.feature": "bash_hang_guard", "oe.outcome": "unverified" });
+                    await auditToolAction(ctx, "bash.timeout", { tool: "bash", timeoutMs: ms });
+                    console.warn(`[open-everywhere:bash-hang-guard] bash timed out after ${ms}ms`);
+                }
+                throw err;
+            }
+        },
+    };
+}
+//# sourceMappingURL=bash-hang-guard.js.map

package/dist/agent/stall/bash-hang-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash-hang-guard.js","sourceRoot":"","sources":["../../../agent/stall/bash-hang-guard.ts"],"names":[],"mappings":"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"}