@noopolis/daimon 0.1.1 → 0.2.0

package/dist/pi/codexHeadlessResult.js

@@ -0,0 +1,122 @@
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const invalidResult = (detail) => new Error(`Codex CLI returned no publishable terminal response: ${detail}`);
+/**
+ * Every field Codex actually emits on `turn.completed.usage`.
+ *
+ * `cache_write_input_tokens` is NOT in this list: Codex 0.142.3 and 0.151.0
+ * both emit exactly `{input_tokens, cached_input_tokens, output_tokens,
+ * reasoning_output_tokens}`, verified against a live turn inside the runtime
+ * image and against `token_count` in a session rollout. Requiring the cache
+ * write field made `decodeCodexTurnUsage` return `undefined` for *every* real
+ * turn, so the codex half of the usage ledger recorded nothing at all while
+ * every test passed against a fixture that invented the field.
+ */
+const USAGE_TOKEN_FIELDS = [
+    "input_tokens",
+    "cached_input_tokens",
+    "output_tokens",
+    "reasoning_output_tokens"
+];
+/** Absent means zero; present-but-malformed still degrades the whole block. */
+const CACHE_WRITE_FIELD = "cache_write_input_tokens";
+const tokenCount = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+/**
+ * Advisory usage decoding: an absent or malformed block is `undefined`, never
+ * a failed published turn and never a zero-filled record. Every field must be
+ * a non-negative safe integer because a substituted zero is byte-identical to
+ * a real zero. `complete` requires a non-zero derived total and valid subset
+ * relationships. As with AGY, every emitted count remains a lower bound.
+ */
+export const decodeCodexTurnUsage = (frame, calls) => {
+    if (!isRecord(frame.usage))
+        return undefined;
+    const usage = frame.usage;
+    const counts = USAGE_TOKEN_FIELDS.map((field) => tokenCount(usage[field]));
+    if (counts.some((count) => count === undefined))
+        return undefined;
+    const cacheWrite = usage[CACHE_WRITE_FIELD] === undefined ? 0 : tokenCount(usage[CACHE_WRITE_FIELD]);
+    if (cacheWrite === undefined)
+        return undefined;
+    const [input, cacheRead, output, reasoningOutput] = counts;
+    const total = input + output;
+    return {
+        input,
+        output,
+        cacheRead,
+        cacheWrite,
+        total,
+        calls,
+        notionalUsd: 0,
+        complete: total > 0 && cacheRead <= input && reasoningOutput <= output
+    };
+};
+/**
+ * Decode Codex's NDJSON stream without mistaking tool/progress items for the
+ * reply. Unknown envelopes and item types are skipped because Codex owns the
+ * vocabulary and a future frame must not fail a turn that published.
+ * A Codex turn that spent subscription money and produced a reply must reach
+ * the organization: uncertainty about accounting degrades to `usage:
+ * undefined` and never discards publishable text. Unlike AGY's stricter
+ * envelope, Codex may omit, repeat, or follow `turn.completed` with another
+ * frame, so only exactly one completion frame supplies trustworthy usage.
+ *
+ * Success is decided from the terminal frame, not from whether a reply was
+ * published: `engineDispatcher.ts`'s runtime envelope tells every agent its
+ * terminal response is a private note to the runtime, not an outward
+ * message, and that it may "leave it empty". A `turn.completed` with no
+ * `agent_message` is therefore a sanctioned silent success — `text: ""`,
+ * never a thrown failure — and its usage still reaches the ledger exactly as
+ * a spoken turn's would; do not reinstate throwing on empty text, it would
+ * both misreport a clean turn as failed and drop its usage from the ledger
+ * silently. Only `turn.failed` with no reply already published, or a stream
+ * with neither terminal frame at all (a truncated or killed child), reject
+ * the turn; the latter gets its own detail string so a genuinely truncated
+ * stream is never confused with a legitimately silent one.
+ */
+export const decodeCodexHeadlessTurn = (output) => {
+    const lines = output.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    if (lines.length === 0)
+        throw invalidResult("empty stream");
+    let text;
+    const completed = [];
+    let failed = false;
+    let calls = 0;
+    for (const line of lines) {
+        let frame;
+        try {
+            frame = JSON.parse(line);
+        }
+        catch {
+            throw invalidResult("invalid JSON");
+        }
+        if (!isRecord(frame) || typeof frame.type !== "string")
+            throw invalidResult("invalid event");
+        if (frame.type === "turn.failed") {
+            failed = true;
+            continue;
+        }
+        if (frame.type === "turn.completed") {
+            completed.push(frame);
+            continue;
+        }
+        if (frame.type !== "item.completed" || !isRecord(frame.item) || typeof frame.item.type !== "string")
+            continue;
+        if (frame.item.type === "command_execution" || frame.item.type === "mcp_tool_call")
+            calls += 1;
+        if (frame.item.type === "agent_message" && typeof frame.item.text === "string" && frame.item.text.trim().length > 0) {
+            text = frame.item.text;
+        }
+    }
+    if (typeof text !== "string") {
+        if (failed)
+            throw invalidResult("failed turn");
+        // No reply, but a completion frame arrived: a sanctioned silent success.
+        if (completed.length === 0)
+            throw invalidResult("no terminal frame");
+        text = "";
+    }
+    const usage = !failed && completed.length === 1 ? decodeCodexTurnUsage(completed[0], calls) : undefined;
+    return usage === undefined ? { text: text.trim() } : { text: text.trim(), usage };
+};
+/** Text-only view of {@link decodeCodexHeadlessTurn}, for callers that do not meter. */
+export const decodeCodexHeadlessResult = (output) => decodeCodexHeadlessTurn(output).text;

package/dist/pi/codexRolloutUsage.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Per-model-request token accounting, recovered from the rollout file Codex
+ * already writes for every non-`--ephemeral` thread.
+ *
+ * Daimon's usage ledger records exactly one row per wake, decoded from the
+ * single `turn.completed` frame on the `--json` stream. That row is a sum: it
+ * cannot say whether a wake's fresh input is one cold miss on a shared prefix
+ * that is then replayed cheaply, or a context that grows with every tool call.
+ * Those two shapes call for opposite optimisations, and the aggregate row is
+ * blind to the difference. It also drops `reasoning_output_tokens` entirely.
+ *
+ * Codex writes the missing detail to
+ * `$CODEX_HOME/sessions/<yyyy>/<mm>/<dd>/rollout-<ts>-<thread-id>.jsonl`, one
+ * usage frame per model request. Two frame shapes carry it, and both were read
+ * off real rollouts written by codex-cli 0.153.4:
+ *
+ *     {"type":"token_usage_record","payload":{"thread_id":…,"turn_id":…,
+ *       "usage":{"input_tokens":22119,"cached_input_tokens":21888,
+ *       "cache_write_input_tokens":0,"output_tokens":358,
+ *       "reasoning_output_tokens":169,"total_tokens":22477}, …}}
+ *
+ *     {"type":"event_msg","payload":{"type":"token_count","info":{
+ *       "last_token_usage":{…same fields…},"total_token_usage":{…}}}}
+ *
+ * `token_usage_record` is preferred because it names its thread and turn. The
+ * `token_count` shape is the fallback for a Codex version that predates it —
+ * the pinned runtime image's version was not available to check. The two are
+ * emitted in pairs, so they are never both counted.
+ *
+ * Reading is strictly advisory and strictly read-only: Codex owns these files,
+ * Daimon never writes, moves, or prunes them.
+ */
+/** One model request's own token usage, exactly as Codex reported it. */
+export type CodexRequestUsage = Readonly<{
+    /** 0-based position of this request within the rollout. */
+    index: number;
+    input: number;
+    cachedInput: number;
+    cacheWrite: number;
+    output: number;
+    reasoning: number;
+    total: number;
+    /**
+     * When the request began and ended, from the rollout's own frame
+     * `timestamp`s. `endedAt` is the usage frame's timestamp (Codex appends it at
+     * `response.completed`); `startedAt` is the first non-usage frame after the
+     * previous request's usage frame — the tool output or turn context that
+     * triggers the next request — falling back to the previous request's end.
+     * Either is absent when the frames carry no valid timestamp: a wake-end stamp
+     * substituted here would be indistinguishable from a measured one.
+     */
+    startedAt?: string;
+    endedAt?: string;
+}>;
+export declare const isCodexThreadId: (value: unknown) => value is string;
+/** Rollouts are model transcripts; refuse to buffer an implausible one. */
+export declare const CODEX_ROLLOUT_MAX_BYTES: number;
+/**
+ * Locate the rollout belonging to *this* turn, by thread id.
+ *
+ * The thread id comes from the `thread.started` frame Codex emits as the very
+ * first line of its own `--json` stream (verified live against codex-cli
+ * 0.153.4: `{"type":"thread.started","thread_id":"01a076d3-…"}`), and the
+ * rollout filename ends with `-<thread-id>.jsonl`. Nothing here globs for "the
+ * newest file": with concurrent agents in one container, newest-file matching
+ * would attribute one agent's requests to another's wake.
+ */
+export declare const findCodexRolloutPath: (codexHome: string, threadId: string) => Promise<string | undefined>;
+/**
+ * Every model request in one rollout, in stream order — or an empty list.
+ *
+ * "Or an empty list" is the whole contract. A rollout that yields no usage
+ * frame, or that contains a usage frame Daimon cannot decode, produces nothing:
+ * a partial or invented row here would be indistinguishable from a real
+ * measurement, and the entire point of this file is to be trusted about which
+ * of two cost shapes production actually has.
+ *
+ * Individual unparseable *lines* are skipped rather than fatal. Codex appends
+ * to this file while the turn runs, so a torn final line is an ordinary
+ * artefact of reading it, not evidence that the accounting is wrong. A usage
+ * frame that parses but whose usage block does not decode is fatal, because
+ * that is a genuine disagreement about the shape of the number.
+ *
+ * Daimon spawns one `codex exec` per wake and never resumes a thread, so one
+ * rollout is one wake. If that ever changes, this needs a turn-id filter.
+ */
+export declare const parseCodexRolloutRequests: (text: string, threadId: string) => readonly CodexRequestUsage[];
+/**
+ * Read one turn's per-request usage. Never throws.
+ *
+ * Absent, unreadable, oversized, or undecodable all answer the same way: an
+ * empty list, which the caller writes nothing for.
+ */
+export declare const readCodexRolloutRequests: (codexHome: string, threadId: string) => Promise<readonly CodexRequestUsage[]>;
+//# sourceMappingURL=codexRolloutUsage.d.ts.map

package/dist/pi/codexRolloutUsage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codexRolloutUsage.d.ts","sourceRoot":"","sources":["../../src/pi/codexRolloutUsage.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,yEAAyE;AACzE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC,CAAC;AAUH,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MACD,CAAC;AAc1D,2EAA2E;AAC3E,eAAO,MAAM,uBAAuB,QAAmB,CAAC;AAExD;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,GAAU,WAAW,MAAM,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAoB1G,CAAC;AAqDF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,yBAAyB,GAAI,MAAM,MAAM,EAAE,UAAU,MAAM,KAAG,SAAS,iBAAiB,EAqCpG,CAAC;AAkBF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACnC,WAAW,MAAM,EACjB,UAAU,MAAM,KACf,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAUtC,CAAC"}

package/dist/pi/codexRolloutUsage.js

@@ -0,0 +1,221 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+/**
+ * A thread id is interpolated into a filename suffix, so it is constrained to
+ * the shape Codex actually emits (a UUID) before it can reach the filesystem.
+ * A value carrying `/` or `..` would otherwise steer the search out of
+ * `$CODEX_HOME`.
+ */
+const SAFE_THREAD_ID = /^[A-Za-z0-9][A-Za-z0-9-]{0,63}$/u;
+export const isCodexThreadId = (value) => typeof value === "string" && SAFE_THREAD_ID.test(value);
+/**
+ * Codex lays rollouts out as `sessions/<yyyy>/<mm>/<dd>/rollout-*.jsonl`, so
+ * three directory levels below `sessions` is the whole tree. Directory entries
+ * are walked newest-name-first, which for zero-padded date components is
+ * newest-day-first — the wake that just finished is in the first day directory
+ * examined, so the search normally reads one directory per level.
+ */
+const ROLLOUT_MAX_DEPTH = 3;
+/** A budget so a pathological sessions tree cannot turn instrumentation into a stall. */
+const ROLLOUT_MAX_ENTRIES = 20_000;
+/** Rollouts are model transcripts; refuse to buffer an implausible one. */
+export const CODEX_ROLLOUT_MAX_BYTES = 64 * 1024 * 1024;
+/**
+ * Locate the rollout belonging to *this* turn, by thread id.
+ *
+ * The thread id comes from the `thread.started` frame Codex emits as the very
+ * first line of its own `--json` stream (verified live against codex-cli
+ * 0.153.4: `{"type":"thread.started","thread_id":"01a076d3-…"}`), and the
+ * rollout filename ends with `-<thread-id>.jsonl`. Nothing here globs for "the
+ * newest file": with concurrent agents in one container, newest-file matching
+ * would attribute one agent's requests to another's wake.
+ */
+export const findCodexRolloutPath = async (codexHome, threadId) => {
+    if (!isCodexThreadId(threadId))
+        return undefined;
+    const suffix = `-${threadId}.jsonl`;
+    let budget = ROLLOUT_MAX_ENTRIES;
+    const walk = async (directory, depth) => {
+        let entries;
+        try {
+            entries = await readdir(directory, { withFileTypes: true });
+        }
+        catch {
+            return undefined;
+        }
+        budget -= entries.length;
+        if (budget < 0)
+            return undefined;
+        const match = entries.find((entry) => entry.isFile() && entry.name.startsWith("rollout-") && entry.name.endsWith(suffix));
+        if (match !== undefined)
+            return path.join(directory, match.name);
+        if (depth >= ROLLOUT_MAX_DEPTH)
+            return undefined;
+        const directories = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().reverse();
+        for (const name of directories) {
+            const found = await walk(path.join(directory, name), depth + 1);
+            if (found !== undefined)
+                return found;
+        }
+        return undefined;
+    };
+    return walk(path.join(codexHome, "sessions"), 0);
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const tokenCount = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+/**
+ * Decode one usage block, or `undefined` when any part of it is not a
+ * non-negative safe integer.
+ *
+ * The rule `turnUsageLedger.ts` and `codexHeadlessResult.ts` already hold to
+ * applies here unchanged: a substituted zero is byte-identical to a real zero,
+ * so a number is never invented. `cache_write_input_tokens` and `total_tokens`
+ * may be absent (older Codex versions omit them); absent means zero and a
+ * derived total respectively, but present-and-malformed still rejects the
+ * block. The subset relationships Codex's own totals imply — cached input
+ * inside input, reasoning output inside output — are checked rather than
+ * assumed, because a block that violates them is not describing the request
+ * this row claims to describe.
+ */
+const decodeRequestUsage = (usage, index) => {
+    if (!isRecord(usage))
+        return undefined;
+    const input = tokenCount(usage.input_tokens);
+    const cachedInput = tokenCount(usage.cached_input_tokens);
+    const output = tokenCount(usage.output_tokens);
+    const reasoning = tokenCount(usage.reasoning_output_tokens);
+    if (input === undefined || cachedInput === undefined || output === undefined || reasoning === undefined)
+        return undefined;
+    const cacheWrite = usage.cache_write_input_tokens === undefined ? 0 : tokenCount(usage.cache_write_input_tokens);
+    const total = usage.total_tokens === undefined ? input + output : tokenCount(usage.total_tokens);
+    if (cacheWrite === undefined || total === undefined)
+        return undefined;
+    if (cachedInput > input || reasoning > output)
+        return undefined;
+    return { index, input, cachedInput, cacheWrite, output, reasoning, total };
+};
+const usageBlock = (frame, threadId) => {
+    const payload = isRecord(frame.payload) ? frame.payload : undefined;
+    if (payload === undefined)
+        return undefined;
+    if (frame.type === "token_usage_record") {
+        // The file is already thread-scoped by its name; the field is checked anyway
+        // so a forked or sub-thread record can never be billed to this wake.
+        if (typeof payload.thread_id === "string" && payload.thread_id !== threadId)
+            return undefined;
+        return { usage: payload.usage };
+    }
+    if (frame.type === "event_msg" && payload.type === "token_count" && isRecord(payload.info)) {
+        return { usage: payload.info.last_token_usage };
+    }
+    return undefined;
+};
+/**
+ * Every model request in one rollout, in stream order — or an empty list.
+ *
+ * "Or an empty list" is the whole contract. A rollout that yields no usage
+ * frame, or that contains a usage frame Daimon cannot decode, produces nothing:
+ * a partial or invented row here would be indistinguishable from a real
+ * measurement, and the entire point of this file is to be trusted about which
+ * of two cost shapes production actually has.
+ *
+ * Individual unparseable *lines* are skipped rather than fatal. Codex appends
+ * to this file while the turn runs, so a torn final line is an ordinary
+ * artefact of reading it, not evidence that the accounting is wrong. A usage
+ * frame that parses but whose usage block does not decode is fatal, because
+ * that is a genuine disagreement about the shape of the number.
+ *
+ * Daimon spawns one `codex exec` per wake and never resumes a thread, so one
+ * rollout is one wake. If that ever changes, this needs a turn-id filter.
+ */
+export const parseCodexRolloutRequests = (text, threadId) => {
+    const requests = [];
+    const fallback = [];
+    let previousFallback = "";
+    const clocks = { record: requestClock(), fallback: requestClock() };
+    for (const line of text.split("\n")) {
+        if (line.trim().length === 0)
+            continue;
+        let frame;
+        try {
+            frame = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!isRecord(frame))
+            continue;
+        const block = usageBlock(frame, threadId);
+        const usageFrame = frame.type === "token_usage_record" || (frame.type === "event_msg" && isRecord(frame.payload) && frame.payload.type === "token_count");
+        if (!usageFrame) {
+            if (frame.type !== "session_meta") {
+                clocks.record.observe(frame.timestamp);
+                clocks.fallback.observe(frame.timestamp);
+            }
+            continue;
+        }
+        if (block === undefined)
+            continue;
+        if (frame.type === "token_usage_record") {
+            const decoded = decodeRequestUsage(block.usage, requests.length);
+            if (decoded === undefined)
+                return [];
+            requests.push({ ...decoded, ...clocks.record.close(frame.timestamp) });
+            continue;
+        }
+        // `token_count` is NOT one frame per request: the captured fixture carries
+        // six of them for four requests, three of which repeat one earlier
+        // `last_token_usage` verbatim because the event is re-emitted whenever the
+        // rate-limit block refreshes. Counting them would inflate the request count
+        // — the single number this whole stream exists to establish. Only a block
+        // that differs from the one before it is a new request.
+        const serialized = JSON.stringify(block.usage);
+        if (serialized === previousFallback)
+            continue;
+        previousFallback = serialized;
+        const decoded = decodeRequestUsage(block.usage, fallback.length);
+        if (decoded === undefined)
+            return [];
+        fallback.push({ ...decoded, ...clocks.fallback.close(frame.timestamp) });
+    }
+    // A Codex version that emits both shapes emits `token_usage_record` once per
+    // request, so the richer one wins outright rather than being merged into a
+    // double count. The fallback exists only for a version that has neither.
+    return requests.length > 0 ? requests : fallback;
+};
+const timestampOf = (value) => typeof value === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,9})?Z$/u.test(value) && !Number.isNaN(Date.parse(value)) ? value : undefined;
+/** Tracks one request stream's start/end stamps; see {@link CodexRequestUsage.startedAt}. */
+const requestClock = () => {
+    let start, previousEnd;
+    return {
+        observe(value) { start ??= timestampOf(value); },
+        close(value) {
+            const endedAt = timestampOf(value), startedAt = start ?? previousEnd;
+            start = undefined;
+            previousEnd = endedAt;
+            return { ...(startedAt === undefined ? {} : { startedAt }), ...(endedAt === undefined ? {} : { endedAt }) };
+        }
+    };
+};
+/**
+ * Read one turn's per-request usage. Never throws.
+ *
+ * Absent, unreadable, oversized, or undecodable all answer the same way: an
+ * empty list, which the caller writes nothing for.
+ */
+export const readCodexRolloutRequests = async (codexHome, threadId) => {
+    const file = await findCodexRolloutPath(codexHome, threadId);
+    if (file === undefined)
+        return [];
+    let text;
+    try {
+        const bytes = await readFile(file);
+        if (bytes.byteLength > CODEX_ROLLOUT_MAX_BYTES)
+            return [];
+        text = bytes.toString("utf8");
+    }
+    catch {
+        return [];
+    }
+    return parseCodexRolloutRequests(text, threadId);
+};

package/dist/pi/engineWakeLimits.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Per-wake engine bounds, and the one place they are decided.
+ *
+ * `maxToolTurns` mediates only daimon-MCP tool calls; Codex's own shell
+ * (`exec_command`) is never routed through that gate, so a single Codex turn
+ * previously had no ceiling at all — one production wake ran 23:32→23:42
+ * (unbounded wall clock) making 51 shell calls. Codex's `--json` stream
+ * reports token usage exactly once, on `turn.completed` — there is no
+ * incremental total to watch mid-turn (verified against a live multi-tool-call
+ * turn: `item.completed` fires once per tool call, but usage is reported only
+ * on the single terminal `turn.completed`) — so the token ceiling is the best
+ * bound obtainable from that wire shape: it converts an over-budget turn into
+ * an explicit, killed, named failure instead of a silent success, and the
+ * wall-clock timeout is what actually interrupts a runaway turn in progress.
+ *
+ * The names are engine-neutral: `DAIMON_ENGINE_WAKE_TIMEOUT_MS` and
+ * `DAIMON_ENGINE_WAKE_TOKEN_CEILING` bound Codex locally and are passed to the
+ * Grok broker as the wake's *lowering* limits (the broker refuses a value above
+ * its registration). The `DAIMON_CODEX_*` names remain aliases; setting both
+ * names of one bound to different values is refused rather than guessed.
+ */
+export declare const DEFAULT_CODEX_WAKE_TIMEOUT_MS = 240000;
+export declare const DEFAULT_CODEX_WAKE_TOKEN_CEILING = 300000;
+export declare const DAIMON_ENGINE_WAKE_TIMEOUT_MS_ENV = "DAIMON_ENGINE_WAKE_TIMEOUT_MS";
+export declare const DAIMON_ENGINE_WAKE_TOKEN_CEILING_ENV = "DAIMON_ENGINE_WAKE_TOKEN_CEILING";
+export declare const DAIMON_CODEX_WAKE_TIMEOUT_MS_ENV = "DAIMON_CODEX_WAKE_TIMEOUT_MS";
+export declare const DAIMON_CODEX_WAKE_TOKEN_CEILING_ENV = "DAIMON_CODEX_WAKE_TOKEN_CEILING";
+export declare const resolveCodexWakeTimeoutMs: (environment?: NodeJS.ProcessEnv) => number;
+export declare const resolveCodexWakeTokenCeiling: (environment?: NodeJS.ProcessEnv) => number;
+/**
+ * The limits a wake asks a broker to lower to: only the bounds the operator
+ * actually set, never the Codex defaults (a broker registration's declared
+ * limits already are the defaults there).
+ */
+export declare const resolveEngineWakeLimitOverrides: (environment?: NodeJS.ProcessEnv) => Readonly<{
+    timeoutMs?: number;
+    maxTokens?: number;
+}> | undefined;
+//# sourceMappingURL=engineWakeLimits.d.ts.map

package/dist/pi/engineWakeLimits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineWakeLimits.d.ts","sourceRoot":"","sources":["../../src/pi/engineWakeLimits.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,6BAA6B,SAAU,CAAC;AACrD,eAAO,MAAM,gCAAgC,SAAU,CAAC;AACxD,eAAO,MAAM,iCAAiC,kCAAkC,CAAC;AACjF,eAAO,MAAM,oCAAoC,qCAAqC,CAAC;AACvF,eAAO,MAAM,gCAAgC,iCAAiC,CAAC;AAC/E,eAAO,MAAM,mCAAmC,oCAAoC,CAAC;AAgBrF,eAAO,MAAM,yBAAyB,GAAI,cAAa,MAAM,CAAC,UAAwB,KAAG,MACoC,CAAC;AAC9H,eAAO,MAAM,4BAA4B,GAAI,cAAa,MAAM,CAAC,UAAwB,KAAG,MAC0C,CAAC;AAEvI;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,GAAI,cAAa,MAAM,CAAC,UAAwB,KAAG,QAAQ,CAAC;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,SAKrJ,CAAC"}

package/dist/pi/engineWakeLimits.js

@@ -0,0 +1,55 @@
+/**
+ * Per-wake engine bounds, and the one place they are decided.
+ *
+ * `maxToolTurns` mediates only daimon-MCP tool calls; Codex's own shell
+ * (`exec_command`) is never routed through that gate, so a single Codex turn
+ * previously had no ceiling at all — one production wake ran 23:32→23:42
+ * (unbounded wall clock) making 51 shell calls. Codex's `--json` stream
+ * reports token usage exactly once, on `turn.completed` — there is no
+ * incremental total to watch mid-turn (verified against a live multi-tool-call
+ * turn: `item.completed` fires once per tool call, but usage is reported only
+ * on the single terminal `turn.completed`) — so the token ceiling is the best
+ * bound obtainable from that wire shape: it converts an over-budget turn into
+ * an explicit, killed, named failure instead of a silent success, and the
+ * wall-clock timeout is what actually interrupts a runaway turn in progress.
+ *
+ * The names are engine-neutral: `DAIMON_ENGINE_WAKE_TIMEOUT_MS` and
+ * `DAIMON_ENGINE_WAKE_TOKEN_CEILING` bound Codex locally and are passed to the
+ * Grok broker as the wake's *lowering* limits (the broker refuses a value above
+ * its registration). The `DAIMON_CODEX_*` names remain aliases; setting both
+ * names of one bound to different values is refused rather than guessed.
+ */
+export const DEFAULT_CODEX_WAKE_TIMEOUT_MS = 240_000;
+export const DEFAULT_CODEX_WAKE_TOKEN_CEILING = 300_000;
+export const DAIMON_ENGINE_WAKE_TIMEOUT_MS_ENV = "DAIMON_ENGINE_WAKE_TIMEOUT_MS";
+export const DAIMON_ENGINE_WAKE_TOKEN_CEILING_ENV = "DAIMON_ENGINE_WAKE_TOKEN_CEILING";
+export const DAIMON_CODEX_WAKE_TIMEOUT_MS_ENV = "DAIMON_CODEX_WAKE_TIMEOUT_MS";
+export const DAIMON_CODEX_WAKE_TOKEN_CEILING_ENV = "DAIMON_CODEX_WAKE_TOKEN_CEILING";
+const positiveInteger = (value, name) => {
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0)
+        throw new Error(`${name} must be a positive integer`);
+    return parsed;
+};
+const declared = (environment, neutral, alias) => {
+    const primary = environment[neutral], legacy = environment[alias];
+    const value = primary === undefined ? undefined : positiveInteger(primary, neutral);
+    const aliased = legacy === undefined ? undefined : positiveInteger(legacy, alias);
+    if (value !== undefined && aliased !== undefined && value !== aliased)
+        throw new Error(`${neutral} and ${alias} disagree; set one`);
+    return value ?? aliased;
+};
+export const resolveCodexWakeTimeoutMs = (environment = process.env) => declared(environment, DAIMON_ENGINE_WAKE_TIMEOUT_MS_ENV, DAIMON_CODEX_WAKE_TIMEOUT_MS_ENV) ?? DEFAULT_CODEX_WAKE_TIMEOUT_MS;
+export const resolveCodexWakeTokenCeiling = (environment = process.env) => declared(environment, DAIMON_ENGINE_WAKE_TOKEN_CEILING_ENV, DAIMON_CODEX_WAKE_TOKEN_CEILING_ENV) ?? DEFAULT_CODEX_WAKE_TOKEN_CEILING;
+/**
+ * The limits a wake asks a broker to lower to: only the bounds the operator
+ * actually set, never the Codex defaults (a broker registration's declared
+ * limits already are the defaults there).
+ */
+export const resolveEngineWakeLimitOverrides = (environment = process.env) => {
+    const timeoutMs = declared(environment, DAIMON_ENGINE_WAKE_TIMEOUT_MS_ENV, DAIMON_CODEX_WAKE_TIMEOUT_MS_ENV);
+    const maxTokens = declared(environment, DAIMON_ENGINE_WAKE_TOKEN_CEILING_ENV, DAIMON_CODEX_WAKE_TOKEN_CEILING_ENV);
+    if (timeoutMs === undefined && maxTokens === undefined)
+        return undefined;
+    return { ...(timeoutMs === undefined ? {} : { timeoutMs }), ...(maxTokens === undefined ? {} : { maxTokens }) };
+};

package/dist/pi/grokHeadlessResult.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Token accounting for one turn, as the engine itself reported it.
+ *
+ * These are subscription-backed CLIs, so nothing here is billed: the counts are
+ * real quota consumption and `notionalUsd` is what the same turn would have cost
+ * at metered API rates. Kept away from anything named `cost` so a later reader
+ * cannot mistake it for a charge.
+ *
+ * Field provenance is the `streaming-messages-json` terminal `result` frame,
+ * which production hardcodes (`grokBrokerWorkerConfig.ts`). Its `result.usage`
+ * is the Messages API `message.usage` shape with three *disjoint* prompt-side
+ * buckets, so the full turn cost is
+ * `input_tokens + cache_read_input_tokens + cache_creation_input_tokens + output_tokens`.
+ */
+export type GrokTurnUsage = Readonly<{
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+    calls: number;
+    notionalUsd: number;
+    complete: boolean;
+}>;
+export type GrokHeadlessTurn = Readonly<{
+    text: string;
+    usage?: GrokTurnUsage;
+}>;
+/**
+ * Decode Grok's terminal message stream without treating progress messages as a
+ * reply, and extract the turn's own token accounting from the same frame.
+ */
+export declare const decodeGrokHeadlessTurn: (output: string) => GrokHeadlessTurn;
+/** Text-only view of {@link decodeGrokHeadlessTurn}, for callers that do not meter. */
+export declare const decodeGrokHeadlessResult: (output: string) => string;
+//# sourceMappingURL=grokHeadlessResult.d.ts.map

package/dist/pi/grokHeadlessResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grokHeadlessResult.d.ts","sourceRoot":"","sources":["../../src/pi/grokHeadlessResult.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,aAAa,CAAA;CAAE,CAAC,CAAC;AA8DjF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,MAAM,KAAG,gBA+BvD,CAAC;AAEF,uFAAuF;AACvF,eAAO,MAAM,wBAAwB,GAAI,QAAQ,MAAM,KAAG,MAA6C,CAAC"}