@noopolis/daimon 0.1.2 → 0.2.1

package/dist/runtime/engineBrokerSingleflight.js

@@ -0,0 +1,24 @@
+export class EngineBrokerSingleflight {
+    active;
+    run(operation) {
+        if (this.active !== undefined)
+            return this.active;
+        const current = operation();
+        this.active = current;
+        void current.then(() => { if (this.active === current)
+            this.active = undefined; }, () => { if (this.active === current)
+            this.active = undefined; });
+        return current;
+    }
+}
+export class EngineBrokerGenerationFence {
+    generation = 0;
+    stale = false;
+    restore(generation) { if (this.stale || this.generation !== 0 || !Number.isSafeInteger(generation) || generation < 0)
+        throw new Error("broker credential generation conflict"); this.generation = generation; }
+    snapshot() { if (this.stale)
+        throw new Error("broker credential authority is stale"); return this.generation; }
+    promote(expected) { if (this.stale || expected !== this.generation)
+        throw new Error("broker credential generation conflict"); return ++this.generation; }
+    markStale() { this.stale = true; }
+}

package/dist/runtime/engineBrokerTurnAccounting.d.ts

@@ -0,0 +1,76 @@
+import type { GrokBrokerModel } from "./grokBrokerModelPolicy.js";
+/**
+ * Numeric-only accounting the Grok engine broker seals beside every terminal
+ * turn response, and the per-turn limits it enforces.
+ *
+ * The broker is the single writer of this data (turn registry record, control
+ * response, usage ledger row). Nothing engine-controlled and non-numeric is
+ * persisted: `model` is a member of the closed declared list, never the
+ * provider's own string, and `limitReason` is a closed vocabulary.
+ *
+ * Buckets are disjoint and `total = input + cacheRead + cacheWrite + output`.
+ * `reasoning` is reported only when the source separates it; it is already
+ * inside `output` and never added to `total`.
+ */
+export type EngineBrokerTurnUsage = Readonly<{
+    input: number;
+    cacheRead: number;
+    cacheWrite: number;
+    output: number;
+    total: number;
+    reasoning?: number;
+}>;
+export declare const ENGINE_BROKER_LIMIT_REASONS: readonly ["tokens", "requests", "timeout", "none"];
+export type EngineBrokerLimitReason = (typeof ENGINE_BROKER_LIMIT_REASONS)[number];
+export type EngineBrokerTurnLimits = Readonly<{
+    maxRequests: number;
+    maxTokens: number;
+    timeoutMs: number;
+}>;
+export type EngineBrokerTurnLimitOverrides = Readonly<Partial<EngineBrokerTurnLimits>>;
+export type EngineBrokerTurnAccounting = Readonly<{
+    outcome: "completed" | "failed";
+    usage: EngineBrokerTurnUsage | null;
+    model: GrokBrokerModel;
+    requests: number;
+    limitReason: EngineBrokerLimitReason;
+}>;
+/**
+ * Bounds every declared limit must sit inside, and the v1 defaults, both from
+ * the runtime contract manifest. `maxRequests` stays at or below the
+ * launcher's compiled `--max-turns` backstop, so the broker ceiling is the one
+ * that fires first.
+ */
+export declare const ENGINE_BROKER_LIMIT_BOUNDS: {
+    readonly maxRequests: readonly [1, 48];
+    readonly maxTokens: readonly [1, 10000000];
+    readonly timeoutMs: readonly [1000, 3600000];
+};
+/** What a v1 `service.json` registration gets; equal to the Codex per-wake defaults. */
+export declare const DEFAULT_GROK_BROKER_TURN_LIMITS: EngineBrokerTurnLimits;
+type JsonRecord = Record<string, unknown>;
+/** Exactly `{maxRequests, maxTokens, timeoutMs}`, each inside its bound. */
+export declare function parseEngineBrokerTurnLimits(value: unknown, label?: string): EngineBrokerTurnLimits;
+/** A non-empty subset of the limit keys, each inside its bound. */
+export declare function parseEngineBrokerTurnLimitOverrides(value: unknown, label?: string): EngineBrokerTurnLimitOverrides;
+/**
+ * The limits one turn runs under: the registration's, lowered by the wake.
+ * A wake can never raise a declared limit; asking to is refused rather than
+ * clamped, so a misconfigured caller learns it instead of silently getting less.
+ */
+export declare function lowerEngineBrokerTurnLimits(declared: EngineBrokerTurnLimits, overrides: EngineBrokerTurnLimitOverrides | undefined): EngineBrokerTurnLimits;
+/** Four disjoint buckets plus an optional reasoning split; the total invariant is re-checked. */
+export declare function parseEngineBrokerTurnUsage(value: unknown, label?: string): EngineBrokerTurnUsage;
+export declare const sumEngineBrokerTurnUsage: (items: readonly EngineBrokerTurnUsage[]) => EngineBrokerTurnUsage | null;
+/** Validates the accounting members of a v2 terminal response against its kind. */
+export declare function parseEngineBrokerTurnAccounting(value: JsonRecord, kind: "completed" | "failed"): EngineBrokerTurnAccounting;
+/**
+ * Maps a provider-reported model key onto the declared closed-list model.
+ *
+ * Grok 1.0.34 reports `grok-4.6` usage under `grok-4.6-build` (P0). The exact
+ * declared id and its `-build` alias are accepted; anything else is a
+ * different model and yields `undefined`.
+ */
+export declare const mapGrokReportedModel: (reported: string, declared: GrokBrokerModel) => GrokBrokerModel | undefined;
+export {};
+//# sourceMappingURL=engineBrokerTurnAccounting.d.ts.map

package/dist/runtime/engineBrokerTurnAccounting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineBrokerTurnAccounting.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerTurnAccounting.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAElE;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAC1J,eAAO,MAAM,2BAA2B,oDAA6C,CAAC;AACtF,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AACnF,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAC7G,MAAM,MAAM,8BAA8B,GAAG,QAAQ,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC,CAAC;AACvF,MAAM,MAAM,0BAA0B,GAAG,QAAQ,CAAC;IAChD,OAAO,EAAE,WAAW,GAAG,QAAQ,CAAC;IAChC,KAAK,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACpC,KAAK,EAAE,eAAe,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,uBAAuB,CAAC;CACtC,CAAC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B;;;;CAAuC,CAAC;AAE/E,wFAAwF;AACxF,eAAO,MAAM,+BAA+B,EAAE,sBAAuF,CAAC;AAGtI,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAY1C,4EAA4E;AAC5E,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,SAA8B,GAAG,sBAAsB,CAGvH;AAED,mEAAmE;AACnE,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,SAA8B,GAAG,8BAA8B,CAKvI;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,sBAAsB,EAAE,SAAS,EAAE,8BAA8B,GAAG,SAAS,GAAG,sBAAsB,CAO3J;AAED,iGAAiG;AACjG,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,SAA6B,GAAG,qBAAqB,CAUpH;AAED,eAAO,MAAM,wBAAwB,GAAI,OAAO,SAAS,qBAAqB,EAAE,KAAG,qBAAqB,GAAG,IAK1G,CAAC;AAEF,mFAAmF;AACnF,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,WAAW,GAAG,QAAQ,GAAG,0BAA0B,CAS3H;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAAI,UAAU,MAAM,EAAE,UAAU,eAAe,KAAG,eAAe,GAAG,SACnB,CAAC"}

package/dist/runtime/engineBrokerTurnAccounting.js

@@ -0,0 +1,108 @@
+import { GROK_BROKER_MODELS } from "../contracts/grokWorkerContract.js";
+import { GROK_ENGINE_BROKER } from "../contracts/runtimeContractManifest.js";
+export const ENGINE_BROKER_LIMIT_REASONS = GROK_ENGINE_BROKER.turnLimits.limitReasons;
+/**
+ * Bounds every declared limit must sit inside, and the v1 defaults, both from
+ * the runtime contract manifest. `maxRequests` stays at or below the
+ * launcher's compiled `--max-turns` backstop, so the broker ceiling is the one
+ * that fires first.
+ */
+export const ENGINE_BROKER_LIMIT_BOUNDS = GROK_ENGINE_BROKER.turnLimits.bounds;
+/** What a v1 `service.json` registration gets; equal to the Codex per-wake defaults. */
+export const DEFAULT_GROK_BROKER_TURN_LIMITS = Object.freeze({ ...GROK_ENGINE_BROKER.turnLimits.v1Defaults });
+const LIMIT_KEYS = ["maxRequests", "maxTokens", "timeoutMs"];
+const plain = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+const count = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+const invalid = (label) => new TypeError(`invalid ${label}`);
+const limitValue = (key, value, label) => {
+    const [minimum, maximum] = ENGINE_BROKER_LIMIT_BOUNDS[key];
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum || value > maximum)
+        throw invalid(label);
+    return value;
+};
+/** Exactly `{maxRequests, maxTokens, timeoutMs}`, each inside its bound. */
+export function parseEngineBrokerTurnLimits(value, label = "engine broker turn limits") {
+    if (!plain(value) || Object.keys(value).length !== LIMIT_KEYS.length || LIMIT_KEYS.some((key) => !Object.hasOwn(value, key)))
+        throw invalid(label);
+    return Object.freeze({ maxRequests: limitValue("maxRequests", value.maxRequests, label), maxTokens: limitValue("maxTokens", value.maxTokens, label), timeoutMs: limitValue("timeoutMs", value.timeoutMs, label) });
+}
+/** A non-empty subset of the limit keys, each inside its bound. */
+export function parseEngineBrokerTurnLimitOverrides(value, label = "engine broker turn limits") {
+    if (!plain(value) || Object.keys(value).length === 0 || Object.keys(value).some((key) => !LIMIT_KEYS.includes(key)))
+        throw invalid(label);
+    const result = {};
+    for (const key of LIMIT_KEYS)
+        if (Object.hasOwn(value, key))
+            result[key] = limitValue(key, value[key], label);
+    return Object.freeze(result);
+}
+/**
+ * The limits one turn runs under: the registration's, lowered by the wake.
+ * A wake can never raise a declared limit; asking to is refused rather than
+ * clamped, so a misconfigured caller learns it instead of silently getting less.
+ */
+export function lowerEngineBrokerTurnLimits(declared, overrides) {
+    if (overrides === undefined)
+        return declared;
+    for (const key of LIMIT_KEYS) {
+        const requested = overrides[key];
+        if (requested !== undefined && requested > declared[key])
+            throw new RangeError(`engine broker turn limit ${key} may only be lowered`);
+    }
+    return Object.freeze({ maxRequests: overrides.maxRequests ?? declared.maxRequests, maxTokens: overrides.maxTokens ?? declared.maxTokens, timeoutMs: overrides.timeoutMs ?? declared.timeoutMs });
+}
+/** Four disjoint buckets plus an optional reasoning split; the total invariant is re-checked. */
+export function parseEngineBrokerTurnUsage(value, label = "engine broker turn usage") {
+    const required = ["input", "cacheRead", "cacheWrite", "output", "total"];
+    if (!plain(value))
+        throw invalid(label);
+    const keys = Object.keys(value);
+    if (required.some((key) => !Object.hasOwn(value, key)) || keys.some((key) => !required.includes(key) && key !== "reasoning"))
+        throw invalid(label);
+    if (![value.input, value.cacheRead, value.cacheWrite, value.output, value.total].every(count))
+        throw invalid(label);
+    const usage = value;
+    if (usage.total !== usage.input + usage.cacheRead + usage.cacheWrite + usage.output)
+        throw invalid(label);
+    if (usage.reasoning !== undefined && (!count(usage.reasoning) || usage.reasoning > usage.output))
+        throw invalid(label);
+    return Object.freeze({ input: usage.input, cacheRead: usage.cacheRead, cacheWrite: usage.cacheWrite, output: usage.output, total: usage.total, ...(usage.reasoning === undefined ? {} : { reasoning: usage.reasoning }) });
+}
+export const sumEngineBrokerTurnUsage = (items) => {
+    if (items.length === 0)
+        return null;
+    const sum = (pick) => items.reduce((total, usage) => total + pick(usage), 0);
+    const reasoning = items.every((usage) => usage.reasoning !== undefined) ? { reasoning: sum((usage) => usage.reasoning ?? 0) } : {};
+    return Object.freeze({ input: sum((usage) => usage.input), cacheRead: sum((usage) => usage.cacheRead), cacheWrite: sum((usage) => usage.cacheWrite), output: sum((usage) => usage.output), total: sum((usage) => usage.total), ...reasoning });
+};
+/** Validates the accounting members of a v2 terminal response against its kind. */
+export function parseEngineBrokerTurnAccounting(value, kind) {
+    if (value.outcome !== kind)
+        throw invalid("broker frame");
+    if (!GROK_BROKER_MODELS.includes(value.model))
+        throw invalid("broker frame");
+    if (!count(value.requests) || value.requests > 1_024)
+        throw invalid("broker frame");
+    if (!ENGINE_BROKER_LIMIT_REASONS.includes(value.limitReason))
+        throw invalid("broker frame");
+    if (kind === "completed" && value.limitReason !== "none")
+        throw invalid("broker frame");
+    let usage = null;
+    if (value.usage !== null) {
+        try {
+            usage = parseEngineBrokerTurnUsage(value.usage);
+        }
+        catch {
+            throw invalid("broker frame");
+        }
+    }
+    return { outcome: kind, usage, model: value.model, requests: value.requests, limitReason: value.limitReason };
+}
+/**
+ * Maps a provider-reported model key onto the declared closed-list model.
+ *
+ * Grok 1.0.34 reports `grok-4.6` usage under `grok-4.6-build` (P0). The exact
+ * declared id and its `-build` alias are accepted; anything else is a
+ * different model and yields `undefined`.
+ */
+export const mapGrokReportedModel = (reported, declared) => reported === declared || reported === `${declared}-build` ? declared : undefined;

package/dist/runtime/engineBrokerTurnRegistry.d.ts

@@ -0,0 +1,57 @@
+import { type EngineBrokerRequest, type EngineBrokerTerminalResponse } from "./engineBrokerProtocol.js";
+import type { GrokBrokerModel } from "./grokBrokerModelPolicy.js";
+import { type BrokerTurnLedgerLines } from "./grokEngineBrokerLedger.js";
+type Start = Extract<EngineBrokerRequest, {
+    kind: "start_turn";
+}>;
+type Terminal = EngineBrokerTerminalResponse;
+export declare const ENGINE_BROKER_TURN_RECORD_V1: "noopolis.daimon.engine-broker-turn.v1";
+export declare const ENGINE_BROKER_TURN_RECORD_V2: "noopolis.daimon.engine-broker-turn.v2";
+type Observed = Readonly<{
+    version: typeof ENGINE_BROKER_TURN_RECORD_V1 | typeof ENGINE_BROKER_TURN_RECORD_V2;
+    digest: string;
+    state: "active" | "terminal";
+    bootId: string;
+    response?: Terminal;
+    ledger?: BrokerTurnLedgerLines;
+}>;
+/**
+ * Durable per-turn state. Record v2 stores the terminal response *with* its
+ * sealed accounting (usage, outcome, model, requests, limitReason), so a replay
+ * returns exactly what was metered and never meters again: metering happens
+ * only on the path that returned `"start"`.
+ */
+export declare class EngineBrokerTurnRegistry {
+    private readonly root;
+    private readonly bootId;
+    private readonly syncDirectoryOf;
+    /** `syncDirectoryOf` is injectable only so the post-publish failure path can be exercised under test. */
+    constructor(root: string, bootId?: string, syncDirectoryOf?: (directory: string) => Promise<void>);
+    /** `model` is the registration's declared model, used only to upgrade a v1 record on replay. */
+    begin(request: Start, model: GrokBrokerModel): Promise<"start" | {
+        replay: Terminal;
+        ledger: BrokerTurnLedgerLines;
+    }>;
+    /**
+     * `ledger` is the exact ledger bytes this turn owes, sealed with it so a replay can finish an interrupted append.
+     *
+     * The rename is the publish point. A failure before it rejects (nothing was
+     * published); a failure after it — the directory fsync — must not, because
+     * the terminal record is already the visible truth and a caller that saw a
+     * rejection would believe the turn unsealed and write a contradicting
+     * record over it. That durability gap is reported as `directorySynced: false`
+     * instead: the record is published but may not survive a power loss.
+     */
+    finish(request: Start, response: Terminal, ledger?: BrokerTurnLedgerLines): Promise<Readonly<{
+        directorySynced: boolean;
+    }>>;
+}
+/**
+ * Strict record parser. v2 accepts exactly `{version,digest,state,bootId}`
+ * plus `response` and its sealed `ledger` bytes when terminal, and the response may be a v2, v3 or v4 terminal frame (older frames upgrade on read).
+ * v1 records keep their historical looser shape and are upgraded on read: no
+ * usage (`null`), zero requests, `limitReason: "none"`, the declared model.
+ */
+export declare function parseEngineBrokerTurnRecord(text: string, model: GrokBrokerModel): Observed;
+export {};
+//# sourceMappingURL=engineBrokerTurnRegistry.d.ts.map

package/dist/runtime/engineBrokerTurnRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineBrokerTurnRegistry.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerTurnRegistry.ts"],"names":[],"mappings":"AAIA,OAAO,EAAmK,KAAK,mBAAmB,EAAE,KAAK,4BAA4B,EAAE,MAAM,2BAA2B,CAAC;AACzQ,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EAAwD,KAAK,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAE/H,KAAK,KAAK,GAAG,OAAO,CAAC,mBAAmB,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC;AAClE,KAAK,QAAQ,GAAG,4BAA4B,CAAC;AAC7C,eAAO,MAAM,4BAA4B,EAAG,uCAAgD,CAAC;AAC7F,eAAO,MAAM,4BAA4B,EAAG,uCAAgD,CAAC;AAM7F,KAAK,QAAQ,GAAG,QAAQ,CAAC;IAAE,OAAO,EAAE,OAAO,4BAA4B,GAAG,OAAO,4BAA4B,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,QAAQ,GAAG,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAAC,MAAM,CAAC,EAAE,qBAAqB,CAAA;CAAE,CAAC,CAAC;AAEpO;;;;;GAKG;AACH,qBAAa,wBAAwB;IAEvB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAAS,OAAO,CAAC,QAAQ,CAAC,MAAM;IAAqB,OAAO,CAAC,QAAQ,CAAC,eAAe;IADtH,yGAAyG;gBAC5E,IAAI,EAAE,MAAM,EAAkB,MAAM,GAAC,MAAmB,EAAkB,eAAe,GAAC,CAAC,SAAS,EAAC,MAAM,KAAG,OAAO,CAAC,IAAI,CAAe;IACtK,gGAAgG;IAC1F,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,GAAG;QAAE,MAAM,EAAE,QAAQ,CAAC;QAAC,MAAM,EAAE,qBAAqB,CAAA;KAAE,CAAC;IAW3H;;;;;;;;;OASG;IACG,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAE,qBAAgD,GAAG,OAAO,CAAC,QAAQ,CAAC;QAAE,eAAe,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAO5J;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,QAAQ,CAyB1F"}

package/dist/runtime/engineBrokerTurnRegistry.js

@@ -0,0 +1,159 @@
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { mkdir, open, readFile, rename, unlink } from "node:fs/promises";
+import path from "node:path";
+import { ENGINE_BROKER_VERSION, parseEngineBrokerResponse, parseEngineBrokerV1TerminalResponse, parseEngineBrokerV2TerminalResponse, parseEngineBrokerV3TerminalResponse } from "./engineBrokerProtocol.js";
+import { EMPTY_BROKER_TURN_LEDGER, parseBrokerTurnLedgerLines } from "./grokEngineBrokerLedger.js";
+export const ENGINE_BROKER_TURN_RECORD_V1 = "noopolis.daimon.engine-broker-turn.v1";
+export const ENGINE_BROKER_TURN_RECORD_V2 = "noopolis.daimon.engine-broker-turn.v2";
+// The digest deliberately excludes `limits` and the protocol version, so a v1
+// record written before the upgrade still identifies the same unclocked turn.
+// A supplied process clock changes execution and must conflict with any other value.
+const digest = (request) => createHash("sha256").update(JSON.stringify([request.turnId, request.agentId, request.wakeId, request.prompt, request.mcpEndpoint, ...(request.processClock === undefined ? [] : [request.processClock])])).digest("hex");
+const safe = (turnId) => `${createHash("sha256").update(turnId).digest("hex")}.json`;
+/**
+ * Durable per-turn state. Record v2 stores the terminal response *with* its
+ * sealed accounting (usage, outcome, model, requests, limitReason), so a replay
+ * returns exactly what was metered and never meters again: metering happens
+ * only on the path that returned `"start"`.
+ */
+export class EngineBrokerTurnRegistry {
+    root;
+    bootId;
+    syncDirectoryOf;
+    /** `syncDirectoryOf` is injectable only so the post-publish failure path can be exercised under test. */
+    constructor(root, bootId = randomUUID(), syncDirectoryOf = syncDirectory) {
+        this.root = root;
+        this.bootId = bootId;
+        this.syncDirectoryOf = syncDirectoryOf;
+    }
+    /** `model` is the registration's declared model, used only to upgrade a v1 record on replay. */
+    async begin(request, model) {
+        await mkdir(this.root, { recursive: true, mode: 0o700 });
+        const file = path.join(this.root, safe(request.turnId));
+        const expected = digest(request);
+        try {
+            const handle = await open(file, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
+            try {
+                await handle.writeFile(`${JSON.stringify({ version: ENGINE_BROKER_TURN_RECORD_V2, digest: expected, state: "active", bootId: this.bootId })}\n`);
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            await this.syncDirectoryOf(this.root);
+            return "start";
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw new Error("broker turn registry unavailable");
+        }
+        const observed = parseEngineBrokerTurnRecord(await readFile(file, "utf8"), model);
+        if (observed.digest !== expected)
+            throw new Error("broker turn conflict");
+        if (observed.state === "terminal" && observed.response !== undefined)
+            return { replay: observed.response, ledger: observed.ledger ?? EMPTY_BROKER_TURN_LEDGER };
+        if (observed.state === "active" && observed.bootId !== this.bootId) {
+            const response = { version: request.version, kind: "failed", requestId: request.requestId, turnId: request.turnId, code: "engine_failed", outcome: "failed", usage: null, model, requests: 0, limitReason: "none" };
+            await this.finish(request, response);
+            return { replay: response, ledger: EMPTY_BROKER_TURN_LEDGER };
+        }
+        throw new Error("broker turn already active");
+    }
+    /**
+     * `ledger` is the exact ledger bytes this turn owes, sealed with it so a replay can finish an interrupted append.
+     *
+     * The rename is the publish point. A failure before it rejects (nothing was
+     * published); a failure after it — the directory fsync — must not, because
+     * the terminal record is already the visible truth and a caller that saw a
+     * rejection would believe the turn unsealed and write a contradicting
+     * record over it. That durability gap is reported as `directorySynced: false`
+     * instead: the record is published but may not survive a power loss.
+     */
+    async finish(request, response, ledger = EMPTY_BROKER_TURN_LEDGER) {
+        const file = path.join(this.root, safe(request.turnId));
+        const temporary = `${file}.${randomUUID()}.tmp`;
+        const handle = await open(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
+        try {
+            await handle.writeFile(`${JSON.stringify({ version: ENGINE_BROKER_TURN_RECORD_V2, digest: digest(request), state: "terminal", bootId: this.bootId, response, ledger })}\n`);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        try {
+            await rename(temporary, file);
+        }
+        finally {
+            await unlink(temporary).catch(() => undefined);
+        }
+        try {
+            await this.syncDirectoryOf(this.root);
+            return { directorySynced: true };
+        }
+        catch {
+            return { directorySynced: false };
+        }
+    }
+}
+/**
+ * Strict record parser. v2 accepts exactly `{version,digest,state,bootId}`
+ * plus `response` and its sealed `ledger` bytes when terminal, and the response may be a v2, v3 or v4 terminal frame (older frames upgrade on read).
+ * v1 records keep their historical looser shape and are upgraded on read: no
+ * usage (`null`), zero requests, `limitReason: "none"`, the declared model.
+ */
+export function parseEngineBrokerTurnRecord(text, model) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        throw new Error("broker turn registry unavailable");
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error("broker turn registry unavailable");
+    const input = value;
+    if (typeof input.digest !== "string" || !/^[a-f0-9]{64}$/u.test(input.digest) || typeof input.bootId !== "string" || (input.state !== "active" && input.state !== "terminal"))
+        throw new Error("broker turn registry unavailable");
+    const base = { digest: input.digest, state: input.state, bootId: input.bootId };
+    if (input.version === ENGINE_BROKER_TURN_RECORD_V1) {
+        if (input.state !== "terminal" || input.response === undefined)
+            return { version: ENGINE_BROKER_TURN_RECORD_V1, ...base };
+        let legacy;
+        try {
+            legacy = parseEngineBrokerV1TerminalResponse(input.response);
+        }
+        catch {
+            throw new Error("broker turn registry unavailable");
+        }
+        const accounting = { outcome: legacy.kind, usage: null, model, requests: 0, limitReason: "none" };
+        const response = { ...legacy, ...accounting, version: ENGINE_BROKER_VERSION };
+        return { version: ENGINE_BROKER_TURN_RECORD_V1, ...base, response };
+    }
+    if (input.version !== ENGINE_BROKER_TURN_RECORD_V2)
+        throw new Error("broker turn conflict");
+    const fields = input.state === "terminal" ? ["version", "digest", "state", "bootId", "response", "ledger"] : ["version", "digest", "state", "bootId"];
+    if (Object.keys(input).length !== fields.length || fields.some((field) => !Object.hasOwn(input, field)))
+        throw new Error("broker turn registry unavailable");
+    if (input.state === "active")
+        return { version: ENGINE_BROKER_TURN_RECORD_V2, ...base };
+    let response;
+    try {
+        response = input.response?.version === "noopolis.daimon.engine-broker.v2" ? parseEngineBrokerV2TerminalResponse(input.response) : input.response?.version === "noopolis.daimon.engine-broker.v3" ? parseEngineBrokerV3TerminalResponse(input.response) : parseEngineBrokerResponse(input.response);
+    }
+    catch {
+        throw new Error("broker turn registry unavailable");
+    }
+    if (response.kind !== "completed" && response.kind !== "failed")
+        throw new Error("broker turn registry unavailable");
+    const ledger = parseBrokerTurnLedgerLines(input.ledger, response.turnId);
+    if ((response.usage === null) !== (ledger.usage === null))
+        throw new Error("broker turn registry unavailable");
+    return { version: ENGINE_BROKER_TURN_RECORD_V2, ...base, response, ledger };
+}
+async function syncDirectory(directory) { const handle = await open(directory, constants.O_RDONLY); try {
+    await handle.sync();
+}
+finally {
+    await handle.close();
+} }

package/dist/runtime/engineDispatcher.d.ts

@@ -0,0 +1,38 @@
+import { type AttentionRegistry } from "./attention.js";
+import type { AgentHandle } from "../core/types.js";
+import type { OrganizationRuntimeAgentConfig } from "./organizationRuntime.js";
+import type { OrganizationRuntimePathAuthority } from "./physicalReadiness.js";
+import type { EngineBrokerTurnClient } from "./engineBrokerControlClient.js";
+/**
+ * The production-only bridge from a closed runtime engine intent to Daimon's
+ * existing one-agent harness. Configuration never carries a command or env.
+ */
+export declare function startOrganizationRuntimeEngine(agent: OrganizationRuntimeAgentConfig, controlTokenEnv: string, paths?: ReturnType<OrganizationRuntimePathAuthority["forAgent"]>, agyBusAddress?: string, grokBroker?: EngineBrokerTurnClient, organizationAgents?: readonly OrganizationRuntimeAgentConfig[], sharedProtectedPaths?: readonly string[], attention?: AttentionRegistry): Promise<AgentHandle>;
+export declare function grokSandboxProtectedPaths(currentAgentId: string, organizationAgents: readonly OrganizationRuntimeAgentConfig[], sharedProtectedPaths?: readonly string[]): readonly string[];
+export declare function codexSandboxProtectedPaths(currentAgentId: string, currentAgent: OrganizationRuntimeAgentConfig, currentEngineHomePath: string, organizationAgents: readonly OrganizationRuntimeAgentConfig[], sharedProtectedPaths?: readonly string[]): readonly string[];
+export declare function codexSandboxReadablePaths(currentAgent: OrganizationRuntimeAgentConfig): readonly string[];
+/** @internal The same callback used by the production session; no native process clock enters the engine environment. */
+export declare function grokBrokerTurnFor(agent: OrganizationRuntimeAgentConfig, grokBroker: EngineBrokerTurnClient, wakeEnvironmentContext: import("../pi/piAgentWakeSupport.js").PiWakeEnvironmentContextRef): (prompt: string, endpoint: string, signal: AbortSignal) => Promise<string>;
+/**
+ * CLI engines do not consume Pi's resource loader. Frame the same immutable
+ * identity in JSON so arbitrary names/instructions cannot change its shape.
+ */
+/**
+ * The caller-owned prompt preamble.
+ *
+ * It names the mounted tools explicitly, because a CLI engine reaches Daimon's
+ * tools over MCP and an agent whose instructions name another engine's tool
+ * spelling can finish a turn having called nothing. The declared names are the
+ * caller's own configuration, not engine-supplied text.
+ *
+ * On Grok the bare names are not the callable ones: every Daimon tool is a
+ * deferred MCP tool of server `daimon`, and Grok 1.0.34 refuses an unqualified
+ * name before any HTTP ("Tool names must be qualified as `server__tool`"). This
+ * envelope used to instruct exactly that refused form. The correct rule is not
+ * restated here — it is rendered by `grokMountedToolNamingRule` in the same
+ * contract module that renders the worker's pinned system prompt, so the two
+ * texts cannot contradict each other again. Every other engine's sentence is
+ * unchanged, byte for byte.
+ */
+export declare function identityEnvelope(agent: OrganizationRuntimeAgentConfig, mountedToolNames?: readonly string[]): string;
+//# sourceMappingURL=engineDispatcher.d.ts.map

package/dist/runtime/engineDispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineDispatcher.d.ts","sourceRoot":"","sources":["../../src/runtime/engineDispatcher.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAMxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAQpD,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,0BAA0B,CAAC;AAC/E,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,wBAAwB,CAAC;AAE/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAM7E;;;GAGG;AACH,wBAAsB,8BAA8B,CAClD,KAAK,EAAE,8BAA8B,EACrC,eAAe,EAAE,MAAM,EACvB,KAAK,CAAC,EAAE,UAAU,CAAC,gCAAgC,CAAC,UAAU,CAAC,CAAC,EAChE,aAAa,CAAC,EAAE,MAAM,EACtB,UAAU,CAAC,EAAE,sBAAsB,EACnC,kBAAkB,CAAC,EAAE,SAAS,8BAA8B,EAAE,EAC9D,oBAAoB,GAAE,SAAS,MAAM,EAAO,EAC5C,SAAS,CAAC,EAAE,iBAAiB,GAC5B,OAAO,CAAC,WAAW,CAAC,CAiDtB;AAED,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,MAAM,EACtB,kBAAkB,EAAE,SAAS,8BAA8B,EAAE,EAC7D,oBAAoB,GAAE,SAAS,MAAM,EAAO,GAC3C,SAAS,MAAM,EAAE,CAYnB;AAED,wBAAgB,0BAA0B,CACxC,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,8BAA8B,EAC5C,qBAAqB,EAAE,MAAM,EAC7B,kBAAkB,EAAE,SAAS,8BAA8B,EAAE,EAC7D,oBAAoB,GAAE,SAAS,MAAM,EAAO,GAC3C,SAAS,MAAM,EAAE,CAQnB;AAED,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,8BAA8B,GAC3C,SAAS,MAAM,EAAE,CAEnB;AAkDD,yHAAyH;AACzH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,8BAA8B,EAAE,UAAU,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,OAAO,6BAA6B,EAAE,2BAA2B,IAG5L,QAAQ,MAAM,EAAE,UAAU,MAAM,EAAE,QAAQ,WAAW,qBAI9D;AAED;;;GAGG;AACH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,8BAA8B,EAAE,gBAAgB,GAAE,SAAS,MAAM,EAAO,GAAG,MAAM,CAkBxH"}