@noopolis/daimon 0.2.0 → 0.2.2

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

@@ -1 +1 @@
-{"version":3,"file":"grokBrokerCredentialReader.d.ts","sourceRoot":"","sources":["../../src/runtime/grokBrokerCredentialReader.ts"],"names":[],"mappings":"AAIA,wBAAsB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAUvH"}
+{"version":3,"file":"grokBrokerCredentialReader.d.ts","sourceRoot":"","sources":["../../src/runtime/grokBrokerCredentialReader.ts"],"names":[],"mappings":"AAIA,wBAAsB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAW3I"}

package/dist/runtime/grokBrokerCredentialReader.js

@@ -22,7 +22,8 @@ export async function readGrokBrokerCredential(file) {
         const rows = Object.values(root).filter((value) => value !== null && typeof value === "object" && !Array.isArray(value));
         if (rows.length !== 1 || typeof rows[0].key !== "string" || rows[0].key.length < 32 || typeof rows[0].refresh_token !== "string" || rows[0].refresh_token.length < 16)
             throw new Error();
-        return { accessToken: rows[0].key, digest: createHash("sha256").update(bytes).digest("hex") };
+        const expiresAt = typeof rows[0].expires_at === "string" ? Date.parse(rows[0].expires_at) : NaN;
+        return { accessToken: rows[0].key, digest: createHash("sha256").update(bytes).digest("hex"), ...(Number.isFinite(expiresAt) ? { expiresAt } : {}) };
     }
     catch {
         throw new Error("Grok broker credential authority unavailable");

package/dist/runtime/grokBrokerProjection.d.ts

@@ -1,8 +1,10 @@
+import { GROK_BROKER_TASK_CLOCK, type GrokWorkerConfigVariant } from "../contracts/grokBrokerTaskClock.js";
 import { type EngineBrokerServiceRegistration } from "./engineBrokerServiceConfig.js";
 import { type EngineBrokerTurnLimits } from "./engineBrokerTurnAccounting.js";
 import type { GrokBrokerModel, GrokBrokerReasoningEffort } from "./grokBrokerModelPolicy.js";
+import { type AgentSkill } from "./grokWorkerSkills.js";
 import { GROK_WORKER_SANDBOX_PROFILE } from "./grokWorkerSandboxProfile.js";
-export declare const GROK_BROKER_PROJECTION_VERSION: "noopolis.daimon.grok-broker-projection.v1";
+export declare const GROK_BROKER_PROJECTION_VERSION: "noopolis.daimon.grok-broker-projection.v3";
 /**
  * Everything a consumer (Spawnfile provisioning, Paideia's native adapter, the
  * root slot supervisor) needs to know about one brokered Grok agent's slot,
@@ -20,7 +22,19 @@ export type OrganizationGrokBrokerProjection = Readonly<{
     profileSha256: string;
     denyPaths: readonly string[];
     workerConfigSha256: string;
+    workerConfigVariant: GrokWorkerConfigVariant;
+    taskClock?: Omit<typeof GROK_BROKER_TASK_CLOCK, "directoryPath" | "timestampFilePath"> & Readonly<{
+        directoryPath: string;
+        timestampFilePath: string;
+    }>;
     systemPromptSha256: string;
+    /**
+     * Digest of the declared skills rendered into `$GROK_HOME/skills`
+     * (`grokWorkerSkillsSha256`). Present only when the agent declares at least
+     * one skill, so a skill-less projection is byte-identical to one computed
+     * before skills existed.
+     */
+    skillsSha256?: string;
     grokCliVersion: string;
     grokExecutableSha256: string;
     nativeAbiVersion: number;
@@ -40,6 +54,8 @@ export type OrganizationGrokBrokerProjection = Readonly<{
     }>;
 }>;
 export type OrganizationGrokBrokerProjectionOptions = Readonly<{
+    /** Clocked configs require an isolated clock directory per slot. Defaults to the unchanged production bytes. */
+    workerConfigVariant?: GrokWorkerConfigVariant;
     /** Deployment-assigned slot identity. */
     slot: number;
     workerUid: number;
@@ -70,6 +86,13 @@ export type OrganizationGrokBrokerProjectionOptions = Readonly<{
     seccompProfileSha256: string;
     /** When the caller already holds a rendered profile digest, it must equal Daimon's. */
     profileSha256?: string;
+    /**
+     * The agent's declared skills: the compiled workspace `.agents/skills` tree
+     * every engine is given (`readAgentSkillsDirectory`), which root provisioning
+     * renders into `$GROK_HOME/skills` (`renderGrokWorkerSkillsTree`). Omitted or
+     * empty means no skills.
+     */
+    skills?: readonly AgentSkill[];
 }>;
 /**
  * Resolve the public Grok broker projection for one agent.
@@ -90,7 +113,8 @@ export type OrganizationGrokBrokerProjectionOptions = Readonly<{
  * this agent (realm, bootstrap, peers, and the mask covering the acceptance
  * store) plus the caller's evaluator paths, sorted and deduplicated exactly as
  * the profile renderer does. A supplied `profileSha256` that differs is
- * refused.
+ * refused. Declared `skills` add `skillsSha256`, which the implied
+ * registration carries and the broker attests against `$GROK_HOME/skills`.
  */
 export declare function resolveOrganizationGrokBrokerProjection(config: unknown, agentId: string, options: OrganizationGrokBrokerProjectionOptions): OrganizationGrokBrokerProjection;
 /** sha256 over the projection's canonical JSON; what a slot preflight receipt binds. */

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

@@ -1 +1 @@
-{"version":3,"file":"grokBrokerProjection.d.ts","sourceRoot":"","sources":["../../src/runtime/grokBrokerProjection.ts"],"names":[],"mappings":"AAOA,OAAO,EAAkC,KAAK,+BAA+B,EAAE,MAAM,gCAAgC,CAAC;AACtH,OAAO,EAA+B,KAAK,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAE3G,OAAO,KAAK,EAAE,eAAe,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAC7F,OAAO,EAAE,2BAA2B,EAA2F,MAAM,+BAA+B,CAAC;AAGrK,eAAO,MAAM,8BAA8B,6CAAuC,CAAC;AAEnF;;;;;GAKG;AACH,MAAM,MAAM,gCAAgC,GAAG,QAAQ,CAAC;IACtD,OAAO,EAAE,OAAO,8BAA8B,CAAC;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,eAAe,CAAC;IACvB,eAAe,EAAE,yBAAyB,CAAC;IAC3C,MAAM,EAAE,sBAAsB,CAAC;IAC/B,eAAe,EAAE,MAAM,CAAC;IACxB,yHAAyH;IACzH,oBAAoB,EAAE,MAAM,CAAC;IAC7B,WAAW,EAAE,QAAQ,CAAC;QAAE,QAAQ,EAAE,gBAAgB,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAC;QAAC,eAAe,EAAE,IAAI,CAAC;QAAC,WAAW,EAAE,OAAO,2BAA2B,CAAC;QAAC,cAAc,EAAE,YAAY,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACjM,CAAC,CAAC;AAEH,MAAM,MAAM,uCAAuC,GAAG,QAAQ,CAAC;IAC7D,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,sEAAsE;IACtE,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,OAAO,GAAG,KAAK,CAAC;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,sBAAsB,CAAC;IAC/B;;;;;;;;;;;;;;OAcG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAC5B,mFAAmF;IACnF,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,gFAAgF;IAChF,oBAAoB,EAAE,MAAM,CAAC;IAC7B,uFAAuF;IACvF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uCAAuC,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,uCAAuC,GAAG,gCAAgC,CA8B5K;AAED,wFAAwF;AACxF,eAAO,MAAM,0BAA0B,GAAI,YAAY,gCAAgC,KAAG,MACpB,CAAC;AAEvE,4HAA4H;AAC5H,wBAAgB,gCAAgC,CAAC,UAAU,EAAE,gCAAgC,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAQhI;AAED;;;;GAIG;AACH,wBAAgB,6CAA6C,CAAC,YAAY,EAAE,+BAA+B,EAAE,UAAU,EAAE,gCAAgC,GAAG,IAAI,CAG/J"}
+{"version":3,"file":"grokBrokerProjection.d.ts","sourceRoot":"","sources":["../../src/runtime/grokBrokerProjection.ts"],"names":[],"mappings":"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"}

package/dist/runtime/grokBrokerProjection.js

@@ -1,3 +1,5 @@
+import { brokerTaskClockFileFor } from "./grokBrokerSlot.js";
+import { GROK_BROKER_TASK_CLOCK } from "../contracts/grokBrokerTaskClock.js";
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { canonicalJson } from "../contracts/canonicalJson.js";
@@ -6,7 +8,8 @@ import { GROK_ENGINE_BROKER } from "../contracts/runtimeContractManifest.js";
 import { grokSandboxProtectedPaths } from "./engineDispatcher.js";
 import { parseEngineBrokerServiceConfig } from "./engineBrokerServiceConfig.js";
 import { parseEngineBrokerTurnLimits } from "./engineBrokerTurnAccounting.js";
-import { grokBrokerWorkerConfigSha256 } from "./grokBrokerWorkerConfig.js";
+import { grokBrokerWorkerConfigPins, grokBrokerWorkerConfigSha256 } from "./grokBrokerWorkerConfig.js";
+import { grokWorkerSkillsSha256, parseAgentSkills } from "./grokWorkerSkills.js";
 import { GROK_WORKER_SANDBOX_PROFILE, grokWorkerEventsPathFor, renderGrokWorkerSandboxProfile, grokWorkerSandboxProfileSha256 } from "./grokWorkerSandboxProfile.js";
 import { parseOrganizationRuntimeConfig } from "./organizationRuntime.js";
 export const GROK_BROKER_PROJECTION_VERSION = GROK_ENGINE_BROKER.projectionVersion;
@@ -29,7 +32,8 @@ export const GROK_BROKER_PROJECTION_VERSION = GROK_ENGINE_BROKER.projectionVersi
  * this agent (realm, bootstrap, peers, and the mask covering the acceptance
  * store) plus the caller's evaluator paths, sorted and deduplicated exactly as
  * the profile renderer does. A supplied `profileSha256` that differs is
- * refused.
+ * refused. Declared `skills` add `skillsSha256`, which the implied
+ * registration carries and the broker attests against `$GROK_HOME/skills`.
  */
 export function resolveOrganizationGrokBrokerProjection(config, agentId, options) {
     const parsed = parseOrganizationRuntimeConfig(config);
@@ -50,19 +54,25 @@ export function resolveOrganizationGrokBrokerProjection(config, agentId, options
     const profileSha256 = grokWorkerSandboxProfileSha256(denyPaths);
     if (options.profileSha256 !== undefined && options.profileSha256 !== profileSha256)
         throw new Error("Grok broker projection profile digest mismatch");
-    const workerConfigSha256 = grokBrokerWorkerConfigSha256({ model, reasoningEffort });
-    if (workerConfigSha256 !== GROK_ENGINE_BROKER.worker.configSha256[model][reasoningEffort])
+    const workerConfigVariant = options.workerConfigVariant ?? "unclocked";
+    const workerConfigSha256 = grokBrokerWorkerConfigSha256({ model, reasoningEffort }, workerConfigVariant, options.slot);
+    const pin = grokBrokerWorkerConfigPins({ model, reasoningEffort }, options.slot)[workerConfigVariant];
+    if (workerConfigVariant === "clocked" && denyPaths.some((denied) => [brokerTaskClockFileFor(options.slot), GROK_BROKER_TASK_CLOCK.preloadPath].some((file) => file === denied || file.startsWith(`${denied}/`))))
+        throw new Error("Grok broker task clock path is denied");
+    if (workerConfigSha256 !== pin)
         throw new Error("Grok broker projection worker config drifted from the manifest");
     if (createHash("sha256").update(DAIMON_GROK_SYSTEM_PROMPT).digest("hex") !== GROK_ENGINE_BROKER.worker.systemPromptSha256)
         throw new Error("Grok broker projection system prompt drifted from the manifest");
     const artifact = GROK_ENGINE_BROKER.grokCliArtifacts[options.architecture];
     if (artifact === undefined)
         throw new Error("Grok broker projection requires a pinned architecture");
+    const skills = parseAgentSkills(options.skills ?? []);
     const profilePath = path.posix.join(options.workerHomePath, ".grok", "sandbox.toml");
     const projection = {
         version: GROK_BROKER_PROJECTION_VERSION, agentId, workspacePath: agent.workspacePath, runtimeHomePath: agent.runtimeHomePath,
-        workerUid: options.workerUid, slot: options.slot, profilePath, profileSha256, denyPaths, workerConfigSha256,
-        systemPromptSha256: GROK_ENGINE_BROKER.worker.systemPromptSha256, grokCliVersion: GROK_ENGINE_BROKER.grokCliVersion, grokExecutableSha256: artifact.sha256,
+        workerUid: options.workerUid, slot: options.slot, profilePath, profileSha256, denyPaths, workerConfigSha256, workerConfigVariant,
+        ...(workerConfigVariant === "clocked" ? { taskClock: { ...GROK_BROKER_TASK_CLOCK, directoryPath: path.posix.dirname(brokerTaskClockFileFor(options.slot)), timestampFilePath: brokerTaskClockFileFor(options.slot) } } : {}),
+        systemPromptSha256: GROK_ENGINE_BROKER.worker.systemPromptSha256, ...(skills.length === 0 ? {} : { skillsSha256: grokWorkerSkillsSha256(skills) }), grokCliVersion: GROK_ENGINE_BROKER.grokCliVersion, grokExecutableSha256: artifact.sha256,
         nativeAbiVersion: GROK_ENGINE_BROKER.nativeAbiVersion, model, reasoningEffort, limits: parseEngineBrokerTurnLimits(options.limits), usageLedgerPath: options.usageLedgerPath, seccompProfileSha256: options.seccompProfileSha256,
         attestation: { platform: "linux/landlock", enforced: true, restrictNetwork: true, profileName: GROK_WORKER_SANDBOX_PROFILE, sandboxRuntime: "bubblewrap", eventsPath: grokWorkerEventsPathFor(profilePath) }
     };
@@ -77,7 +87,8 @@ export function grokBrokerServiceRegistrationFor(projection) {
     const registration = {
         agentId: projection.agentId, slot: projection.slot, workerUid: projection.workerUid, workspace: projection.workspacePath,
         profilePath: projection.profilePath, eventsPath: projection.attestation.eventsPath, profileSha256: projection.profileSha256,
-        usageLedgerPath: projection.usageLedgerPath, limits: projection.limits, model: { id: projection.model, reasoningEffort: projection.reasoningEffort }
+        usageLedgerPath: projection.usageLedgerPath, limits: projection.limits, model: { id: projection.model, reasoningEffort: projection.reasoningEffort },
+        ...(projection.skillsSha256 === undefined ? {} : { skillsSha256: projection.skillsSha256 })
     };
     parseEngineBrokerServiceConfig({ version: "noopolis.daimon.engine-broker-service.v2", credentialHome: GROK_ENGINE_BROKER.credentialHomePath, turnStore: GROK_ENGINE_BROKER.turnStorePath, registrations: [registration] });
     return registration;

package/dist/runtime/grokBrokerProviderClock.d.ts

@@ -0,0 +1,26 @@
+export type GrokBrokerProviderClockObservation = Readonly<{
+    requests: number;
+    linesRewritten: number;
+    requestsWithoutDateLine: number;
+    /** Date-like message lines outside the injected block; absent on older seals. */
+    linesIgnored?: number;
+    /** The last rewritten line's dates; null until a line is rewritten. */
+    injectedDate: string | null;
+    taskDate: string | null;
+}>;
+export declare class GrokBrokerProviderClockRefusal extends Error {
+    readonly reason: "task_clock_date_format" | "task_clock_date_range" | "request_body_rejected";
+    constructor(reason: "task_clock_date_format" | "task_clock_date_range" | "request_body_rejected");
+}
+/** One processClock, owned by one turn; never reads the broker's ambient TZ. */
+export declare class GrokBrokerProviderClock {
+    private readonly now;
+    private readonly offsetMs;
+    private observation;
+    constructor(processClock: string, now?: () => number);
+    rewrite(body: Uint8Array): Uint8Array;
+    snapshot(): GrokBrokerProviderClockObservation;
+}
+/** Closed, dates-only observation on the v3 terminal frame and durable seal. */
+export declare function parseGrokBrokerProviderClockObservation(value: unknown): GrokBrokerProviderClockObservation;
+//# sourceMappingURL=grokBrokerProviderClock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grokBrokerProviderClock.d.ts","sourceRoot":"","sources":["../../src/runtime/grokBrokerProviderClock.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,kCAAkC,GAAG,QAAQ,CAAC;IACxD,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,uBAAuB,EAAE,MAAM,CAAC;IAChC,iFAAiF;IACjF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB,CAAC,CAAC;AAEH,qBAAa,8BAA+B,SAAQ,KAAK;IAC3C,QAAQ,CAAC,MAAM,EAAE,wBAAwB,GAAG,uBAAuB,GAAG,uBAAuB;gBAApF,MAAM,EAAE,wBAAwB,GAAG,uBAAuB,GAAG,uBAAuB;CAG1G;AAOD,gFAAgF;AAChF,qBAAa,uBAAuB;IAOA,OAAO,CAAC,QAAQ,CAAC,GAAG;IANtD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,WAAW,CAGjB;gBAEU,YAAY,EAAE,MAAM,EAAmB,GAAG,GAAE,MAAM,MAAyB;IAIvF,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU;IAuErC,QAAQ,IAAI,kCAAkC;CAG/C;AAKD,gFAAgF;AAChF,wBAAgB,uCAAuC,CAAC,KAAK,EAAE,OAAO,GAAG,kCAAkC,CAuB1G"}

package/dist/runtime/grokBrokerProviderClock.js

@@ -0,0 +1,133 @@
+import { parseBrokerProcessClock } from "./grokBrokerTaskClock.js";
+import { parseGrokBrokerProxyJson } from "./grokBrokerProxyJson.js";
+export class GrokBrokerProviderClockRefusal extends Error {
+    reason;
+    constructor(reason) {
+        super(`grok broker proxy refused: ${reason}`);
+        this.reason = reason;
+    }
+}
+const DATE = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/u;
+const DATE_LINE = /^Today's date: ([0-9]{4}-[0-9]{2}-[0-9]{2})$/u;
+const DATE_LIKE = /today['’]?s\s+date\b/iu;
+const MAX_TASK_MS = 253_402_300_799_999;
+/** One processClock, owned by one turn; never reads the broker's ambient TZ. */
+export class GrokBrokerProviderClock {
+    now;
+    offsetMs;
+    observation = {
+        requests: 0, linesRewritten: 0, requestsWithoutDateLine: 0, linesIgnored: 0,
+        injectedDate: null, taskDate: null
+    };
+    constructor(processClock, now = () => Date.now()) {
+        this.now = now;
+        this.offsetMs = Math.round(Number(parseBrokerProcessClock(processClock)) * 1000);
+    }
+    rewrite(body) {
+        this.observation = { ...this.observation, requests: this.observation.requests + 1 };
+        let parsed;
+        try {
+            parsed = parseGrokBrokerProxyJson(body);
+        }
+        catch {
+            throw new GrokBrokerProviderClockRefusal("request_body_rejected");
+        }
+        const taskMs = this.now() + this.offsetMs;
+        if (!Number.isSafeInteger(taskMs) || taskMs < 0 || taskMs > MAX_TASK_MS) {
+            throw new GrokBrokerProviderClockRefusal("task_clock_date_range");
+        }
+        // The native launcher pins TZ=UTC. Compute once per request, including
+        // history resends; a long turn may cross midnight between requests.
+        const taskDate = new Date(taskMs).toISOString().slice(0, 10);
+        let lines = 0;
+        let ignored = 0;
+        let injectedDate = null;
+        const countIgnored = (text) => text.split(/\r\n|\r|\n/u).filter((line) => DATE_LIKE.test(line)).length;
+        const rewriteText = (text, injected) => {
+            const block = injected ? /<user_info>([\s\S]*?)<\/user_info>/u.exec(text) : null;
+            if (block === null) {
+                ignored += countIgnored(text);
+                return text;
+            }
+            const before = text.slice(0, block.index), after = text.slice(block.index + block[0].length);
+            ignored += countIgnored(before) + countIgnored(after);
+            const rewritten = block[1].split(/(\r\n|\r|\n)/u).map((line) => {
+                if (!DATE_LIKE.test(line))
+                    return line;
+                const match = DATE_LINE.exec(line);
+                if (match === null)
+                    throw new GrokBrokerProviderClockRefusal("task_clock_date_format");
+                lines++;
+                injectedDate = match[1];
+                return `Today's date: ${taskDate}`;
+            }).join("");
+            return `${before}<user_info>${rewritten}</user_info>${after}`;
+        };
+        if (Array.isArray(parsed.value.messages)) {
+            let firstUser = true;
+            for (const message of parsed.value.messages) {
+                if (!isRecord(message))
+                    continue;
+                const injected = message.role === "user" && firstUser;
+                if (message.role === "user")
+                    firstUser = false;
+                if (typeof message.content === "string") {
+                    message.content = rewriteText(message.content, injected);
+                }
+                else if (Array.isArray(message.content)) {
+                    const parts = message.content.filter((part) => isRecord(part) && part.type === "text" && typeof part.text === "string");
+                    // A block or date can straddle text parts. Replacements have exactly
+                    // the same width, so slicing restores every original part boundary.
+                    const rewritten = rewriteText(parts.map((part) => part.text).join(""), injected);
+                    let start = 0;
+                    for (const part of parts) {
+                        const end = start + part.text.length;
+                        part.text = rewritten.slice(start, end);
+                        start = end;
+                    }
+                }
+            }
+        }
+        // Commit only after the entire body passes: a refused request rewrites no
+        // lines upstream, even when an earlier line had the recognized format.
+        this.observation = {
+            requests: this.observation.requests,
+            linesRewritten: this.observation.linesRewritten + lines,
+            requestsWithoutDateLine: this.observation.requestsWithoutDateLine + (lines === 0 ? 1 : 0),
+            linesIgnored: (this.observation.linesIgnored ?? 0) + ignored,
+            injectedDate: lines === 0 ? this.observation.injectedDate : injectedDate,
+            taskDate: lines === 0 ? this.observation.taskDate : taskDate
+        };
+        return lines === 0 ? parsed.body : Buffer.from(JSON.stringify(parsed.value));
+    }
+    snapshot() {
+        return { ...this.observation };
+    }
+}
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/** Closed, dates-only observation on the v3 terminal frame and durable seal. */
+export function parseGrokBrokerProviderClockObservation(value) {
+    if (!isRecord(value))
+        throw new TypeError("invalid broker frame");
+    const fields = ["requests", "linesRewritten", "requestsWithoutDateLine", "injectedDate", "taskDate"];
+    if (Object.keys(value).some((key) => !fields.includes(key) && key !== "linesIgnored") ||
+        fields.some((key) => !Object.hasOwn(value, key))) {
+        throw new TypeError("invalid broker frame");
+    }
+    for (const key of [...fields.slice(0, 3), ...(Object.hasOwn(value, "linesIgnored") ? ["linesIgnored"] : [])]) {
+        if (!Number.isSafeInteger(value[key]) || value[key] < 0) {
+            throw new TypeError("invalid broker frame");
+        }
+    }
+    const result = value;
+    if (result.requestsWithoutDateLine > result.requests ||
+        (result.linesRewritten > 0 && result.requestsWithoutDateLine === result.requests)) {
+        throw new TypeError("invalid broker frame");
+    }
+    for (const date of [result.injectedDate, result.taskDate]) {
+        if (result.linesRewritten === 0 ? date !== null : typeof date !== "string" || !DATE.test(date)) {
+            throw new TypeError("invalid broker frame");
+        }
+    }
+    return { ...result };
+}

package/dist/runtime/grokBrokerProxy.d.ts

@@ -1,12 +1,16 @@
+import { type GrokBrokerRunBudget } from "./grokBrokerRunBudget.js";
+import { type IncomingMessage, type ServerResponse } from "node:http";
 import { EngineBrokerCapabilities } from "./engineBrokerCapabilities.js";
 import { type GrokBrokerModelPolicy } from "./grokBrokerModelPolicy.js";
 import { authorizeGrokBrokerProxyRequest } from "./grokBrokerProxyRequest.js";
 import { type GrokBrokerTurnMeter } from "./grokBrokerTurnMeter.js";
 import type { GrokInferenceGrants } from "./grokInferenceGrants.js";
+import { type GrokBrokerProviderClock } from "./grokBrokerProviderClock.js";
 /** One running turn as the proxy sees it: its declared model/effort and its spend gate. */
 export type GrokBrokerProxyTurn = Readonly<{
     policy: GrokBrokerModelPolicy;
     meter: GrokBrokerTurnMeter;
+    clock?: GrokBrokerProviderClock;
 }>;
 export type GrokBrokerCredentialAuthority = Readonly<{
     accessToken(forceRefresh: boolean): Promise<string>;
@@ -30,15 +34,25 @@ export type GrokBrokerUpstream = (request: ReturnType<typeof authorizeGrokBroker
  * `grokInferenceProxy.ts`; every other bearer is looked up only among turn
  * capabilities. Without `grants` a prefixed bearer is simply refused.
  */
-export declare function startGrokBrokerProxy(authority: GrokBrokerCredentialAuthority, upstream?: GrokBrokerUpstream, policy?: GrokBrokerModelPolicy, listenPort?: number, grants?: GrokInferenceGrants): Promise<Readonly<{
+export declare function startGrokBrokerProxy(authority: GrokBrokerCredentialAuthority, upstream?: GrokBrokerUpstream, policy?: GrokBrokerModelPolicy, listenPort?: number, grants?: GrokInferenceGrants, runBudget?: GrokBrokerRunBudget): Promise<{
     port: number;
+    close: () => Promise<void>;
     capabilities: EngineBrokerCapabilities;
     registerIsolationGuard(turnId: string, guard: () => Promise<void>): void;
     revokeIsolationGuard(turnId: string): void;
     registerTurn(turnId: string, turn: GrokBrokerProxyTurn): void;
     revokeTurn(turnId: string): void;
-    close(): Promise<void>;
-}>>;
+    serve: (request: IncomingMessage, response: ServerResponse) => Promise<void>;
+}>;
+/** @internal The production request handler, usable without opening a socket. */
+export declare function createGrokBrokerProxyHandler(authority: GrokBrokerCredentialAuthority, upstream?: GrokBrokerUpstream, policy?: GrokBrokerModelPolicy, grants?: GrokInferenceGrants, runBudget?: GrokBrokerRunBudget): {
+    capabilities: EngineBrokerCapabilities;
+    registerIsolationGuard(turnId: string, guard: () => Promise<void>): void;
+    revokeIsolationGuard(turnId: string): void;
+    registerTurn(turnId: string, turn: GrokBrokerProxyTurn): void;
+    revokeTurn(turnId: string): void;
+    serve: (request: IncomingMessage, response: ServerResponse) => Promise<void>;
+};
 /**
  * A refusal the caller must not retry.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"grokBrokerProxy.d.ts","sourceRoot":"","sources":["../../src/runtime/grokBrokerProxy.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,OAAO,EAAgE,KAAK,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACtI,OAAO,EAAE,+BAA+B,EAAE,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAsD,KAAK,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAGxH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,2FAA2F;AAC3F,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IAAE,MAAM,EAAE,qBAAqB,CAAC;IAAC,KAAK,EAAE,mBAAmB,CAAA;CAAE,CAAC,CAAC;AAE1G,MAAM,MAAM,6BAA6B,GAAG,QAAQ,CAAC;IAAE,WAAW,CAAC,YAAY,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAAC,qBAAqB,CAAC,CAAC,mBAAmB,EAAC,MAAM,GAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAAC,YAAY,CAAC,mBAAmB,CAAC,EAAC,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,OAAO,CAAC,IAAI,OAAO,CAAA;CAAE,CAAC,CAAC;AACjQ,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,+BAA+B,CAAC,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CAAC,CAAC;AAE3N;;;;;;;;;;GAUG;AACH,wBAAsB,oBAAoB,CAAC,SAAS,EAAE,6BAA6B,EAAE,QAAQ,GAAE,kBAAoC,EAAE,MAAM,GAAE,qBAAwD,EAAE,UAAU,SAAS,EAAE,MAAM,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,wBAAwB,CAAC;IAAC,sBAAsB,CAAC,MAAM,EAAC,MAAM,EAAC,KAAK,EAAC,MAAI,OAAO,CAAC,IAAI,CAAC,GAAE,IAAI,CAAC;IAAC,oBAAoB,CAAC,MAAM,EAAC,MAAM,GAAE,IAAI,CAAC;IAAC,YAAY,CAAC,MAAM,EAAC,MAAM,EAAC,IAAI,EAAC,mBAAmB,GAAE,IAAI,CAAC;IAAC,UAAU,CAAC,MAAM,EAAC,MAAM,GAAE,IAAI,CAAC;IAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC,CAAC,CAMtiB;AAED;;;;;;;;GAQG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM;gBAAd,MAAM,EAAE,MAAM;CACpC"}
+{"version":3,"file":"grokBrokerProxy.d.ts","sourceRoot":"","sources":["../../src/runtime/grokBrokerProxy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAExF,OAAO,EAAgB,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAIpF,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,OAAO,EAAgE,KAAK,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACtI,OAAO,EAAE,+BAA+B,EAAE,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAA2E,KAAK,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAG7I,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAkC,KAAK,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAE5G,2FAA2F;AAC3F,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,MAAM,EAAE,qBAAqB,CAAC;IAC9B,KAAK,EAAE,mBAAmB,CAAC;IAC3B,KAAK,CAAC,EAAE,uBAAuB,CAAC;CACjC,CAAC,CAAC;AAEH,MAAM,MAAM,6BAA6B,GAAG,QAAQ,CAAC;IAAE,WAAW,CAAC,YAAY,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAAC,qBAAqB,CAAC,CAAC,mBAAmB,EAAC,MAAM,GAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAAC,YAAY,CAAC,mBAAmB,CAAC,EAAC,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,OAAO,CAAC,IAAI,OAAO,CAAA;CAAE,CAAC,CAAC;AACjQ,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,+BAA+B,CAAC,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CAAC,CAAC;AAE3N;;;;;;;;;;GAUG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,6BAA6B,EAAE,QAAQ,GAAE,kBAAoC,EACxF,MAAM,GAAE,qBAAwD,EAAE,UAAU,SAAS,EACrF,MAAM,CAAC,EAAE,mBAAmB,EAAE,SAAS,CAAC,EAAE,mBAAmB;;;;mCAoC5B,MAAM,SAAS,MAAM,OAAO,CAAC,IAAI,CAAC;iCACpC,MAAM;yBACd,MAAM,QAAQ,mBAAmB;uBAMnC,MAAM;qBACR,eAAe,YAAY,cAAc;GA5B7D;AAED,iFAAiF;AACjF,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,6BAA6B,EAAE,QAAQ,GAAE,kBAAoC,EACxF,MAAM,GAAE,qBAAwD,EAAE,MAAM,CAAC,EAAE,mBAAmB,EAAE,SAAS,CAAC,EAAE,mBAAmB;;mCAc9F,MAAM,SAAS,MAAM,OAAO,CAAC,IAAI,CAAC;iCACpC,MAAM;yBACd,MAAM,QAAQ,mBAAmB;uBAMnC,MAAM;qBACR,eAAe,YAAY,cAAc;EAI7D;AAED;;;;;;;;GAQG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM;gBAAd,MAAM,EAAE,MAAM;CACpC"}

package/dist/runtime/grokBrokerProxy.js

@@ -1,3 +1,4 @@
+import { GrokBrokerRunLimit } from "./grokBrokerRunBudget.js";
 import { createHash } from "node:crypto";
 import { createServer } from "node:http";
 import { redactCredentialText } from "../core/credentialRedaction.js";
@@ -7,9 +8,10 @@ import { ENGINE_BROKER_AUTH_STALE } from "./engineBrokerProtocol.js";
 import { DEFAULT_GROK_BROKER_MODEL_POLICY, parseGrokBrokerModelPolicy } from "./grokBrokerModelPolicy.js";
 import { authorizeGrokBrokerProxyRequest } from "./grokBrokerProxyRequest.js";
 import { GROK_SESSION_TITLE_SINK_KEY } from "./grokBrokerWorkerConfig.js";
-import { parseGrokResponseToolNames, parseGrokUpstreamUsage } from "./grokBrokerTurnMeter.js";
+import { parseGrokFinalReply, parseGrokResponseToolNames, parseGrokUpstreamUsage } from "./grokBrokerTurnMeter.js";
 import { GROK_ENGINE_BROKER } from "../contracts/runtimeContractManifest.js";
 import { serveGrokInferenceGrant } from "./grokInferenceProxy.js";
+import { GrokBrokerProviderClockRefusal } from "./grokBrokerProviderClock.js";
 /**
  * `policy` is the fallback declared model/effort (closed list); a registered
  * turn's own policy wins. A request whose turn has no registered meter is
@@ -21,15 +23,48 @@ import { serveGrokInferenceGrant } from "./grokInferenceProxy.js";
  * `grokInferenceProxy.ts`; every other bearer is looked up only among turn
  * capabilities. Without `grants` a prefixed bearer is simply refused.
  */
-export async function startGrokBrokerProxy(authority, upstream = defaultUpstream, policy = DEFAULT_GROK_BROKER_MODEL_POLICY, listenPort = 43_123, grants) {
+export async function startGrokBrokerProxy(authority, upstream = defaultUpstream, policy = DEFAULT_GROK_BROKER_MODEL_POLICY, listenPort = 43_123, grants, runBudget) {
+    const handler = createGrokBrokerProxyHandler(authority, upstream, policy, grants, runBudget);
+    const server = createServer((request, response) => { void handler.serve(request, response); });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(listenPort, "127.0.0.1", () => { server.off("error", reject); resolve(); });
+    });
+    const address = server.address();
+    return {
+        ...handler, port: address.port,
+        close: () => new Promise((resolve, reject) => {
+            server.close((error) => error === undefined ? resolve() : reject(error));
+            // A worker's idle pooled socket otherwise leaves close() without a bound.
+            server.closeAllConnections();
+        })
+    };
+}
+/** @internal The production request handler, usable without opening a socket. */
+export function createGrokBrokerProxyHandler(authority, upstream = defaultUpstream, policy = DEFAULT_GROK_BROKER_MODEL_POLICY, grants, runBudget) {
+    const admittedUpstream = async (request, signal) => {
+        signal?.throwIfAborted();
+        await runBudget?.reserve();
+        signal?.throwIfAborted();
+        return upstream(request, signal);
+    };
     const declared = parseGrokBrokerModelPolicy(policy);
     const capabilities = new EngineBrokerCapabilities();
     const guards = new Map();
     const turns = new Map();
-    const server = createServer((request, response) => { void serve(request, response, authority, upstream, capabilities, guards, turns, declared, grants); });
-    await new Promise((resolve, reject) => { server.once("error", reject); server.listen(listenPort, "127.0.0.1", () => { server.off("error", reject); resolve(); }); });
-    const address = server.address();
-    return { port: address.port, capabilities, registerIsolationGuard(turnId, guard) { guards.set(turnId, guard); }, revokeIsolationGuard(turnId) { guards.delete(turnId); }, registerTurn(turnId, turn) { turns.set(turnId, { policy: parseGrokBrokerModelPolicy(turn.policy), meter: turn.meter }); }, revokeTurn(turnId) { turns.delete(turnId); }, close: () => new Promise((resolve, reject) => { server.close((error) => error === undefined ? resolve() : reject(error)); /* `close` waits for every open connection, and a worker keeps its client pool's socket to this proxy open with nothing here accounting for it — so that wait has no bound. Ending them is this listener's to do, exactly as the MCP facade does. */ /* `close` waits for every open connection, and a worker keeps its client pool's socket to this proxy open with nothing here accounting for it — so that wait has no bound. Ending them is this listener's to do, exactly as the MCP facade does. */ server.closeAllConnections(); }) };
+    return {
+        capabilities,
+        registerIsolationGuard(turnId, guard) { guards.set(turnId, guard); },
+        revokeIsolationGuard(turnId) { guards.delete(turnId); },
+        registerTurn(turnId, turn) {
+            turns.set(turnId, {
+                policy: parseGrokBrokerModelPolicy(turn.policy), meter: turn.meter,
+                ...(turn.clock === undefined ? {} : { clock: turn.clock })
+            });
+        },
+        revokeTurn(turnId) { turns.delete(turnId); },
+        serve: (request, response) => serve(request, response, authority, admittedUpstream, capabilities, guards, turns, declared, grants)
+    };
 }
 /**
  * A refusal the caller must not retry.
@@ -55,7 +90,7 @@ async function serve(request, response, authority, upstream, capabilities, guard
     // child and launcher diagnostics are. Nothing reads them but {@link brokerFaultCause}.
     const secrets = [];
     try {
-        const body = await readBody(request);
+        let body = await readBody(request);
         const headers = Object.fromEntries(Object.entries(request.headers).map(([key, value]) => [key, Array.isArray(value) ? value[0] : value]));
         titleSink = headers.authorization === `Bearer ${GROK_SESSION_TITLE_SINK_KEY}`;
         const match = headers.authorization?.match(/^Bearer ([A-Za-z0-9_-]{40,})$/u);
@@ -78,6 +113,17 @@ async function serve(request, response, authority, upstream, capabilities, guard
         catch (error) {
             throw new GrokBrokerProxyRefusal("worker_isolation_unverified");
         }
+        // Neutralize engine context before the existing body gate or bearer read.
+        // The clock belongs to this turn, never to the slot's installed variant.
+        try {
+            if (turn.clock !== undefined)
+                body = Buffer.from(turn.clock.rewrite(body));
+        }
+        catch (error) {
+            if (error instanceof GrokBrokerProviderClockRefusal)
+                throw new GrokBrokerProxyRefusal(error.reason);
+            throw error;
+        }
         // A fenced realm is not a transient fault: the credential is gone until an
         // operator re-logs in, and 503 made Grok blind-retry it (observed: fifteen
         // retries over five minutes, $0 spent, nothing learned). Named, 400, and
@@ -102,7 +148,7 @@ async function serve(request, response, authority, upstream, capabilities, guard
             response.end('{"error":"turn request in flight"}');
             return;
         }
-        settle = (usage, toolCalls) => { turn.meter.settle(admission.index, usage, body.byteLength, toolCalls); settle = undefined; };
+        settle = (usage, toolCalls, finalReply) => { turn.meter.settle(admission.index, usage, body.byteLength, toolCalls, finalReply); settle = undefined; };
         let result = await upstream(prepared, admission.signal);
         if (result.status === 401) {
             token = authority.refreshAfterRejection ? await authority.refreshAfterRejection(rejectedDigest) : await authority.accessToken(true);
@@ -118,12 +164,21 @@ async function serve(request, response, authority, upstream, capabilities, guard
         // is already buffered here for its usage block, so what the model tried to
         // call is in hand. A decoder fault records no attempt rather than a false
         // empty one, and never disturbs the turn.
-        settle?.(usageOrEstimate(result.body, result.headers["content-type"]), toolCallsOrNothing(result.body, result.headers["content-type"]));
+        // A successful answer that called nothing and stopped is the turn's final
+        // reply: the broker ends a worker that finished but did not exit on it
+        // (`grokEngineBrokerTurnEnd.ts`), and reports it when the launcher refused
+        // the worker's stdout. Observation only, exactly like the tool names.
+        settle?.(usageOrEstimate(result.body, result.headers["content-type"]), toolCallsOrNothing(result.body, result.headers["content-type"]), result.status === 200 ? finalReplyOrNothing(result.body, result.headers["content-type"]) : undefined);
         response.writeHead(result.status, { "content-type": result.headers["content-type"] ?? "application/json", "cache-control": "no-store" });
         response.end(result.body);
     }
     catch (error) {
         settle?.(undefined);
+        if (error instanceof GrokBrokerRunLimit) {
+            response.writeHead(429, { "content-type": "application/json", "cache-control": "no-store" });
+            response.end('{"error":"run_request_limit"}');
+            return;
+        }
         // Name the refusal on the broker's own stderr (reason code only, never a body
         // or a token) so a failing turn is diagnosable without a stub harness —
         // except for the two requests every healthy turn makes anyway.
@@ -243,6 +298,15 @@ const toolCallsOrNothing = (body, contentType) => {
         return undefined;
     }
 };
+/** Instrumentation must never fail a turn: a throwing decoder reports no final reply. */
+const finalReplyOrNothing = (body, contentType) => {
+    try {
+        return parseGrokFinalReply(body, contentType);
+    }
+    catch {
+        return undefined;
+    }
+};
 /** The body gate, refused non-retryably: a rejected body is a policy miss, never a transient fault. */
 function authorizeRequestOrRefuse(...args) {
     try {

package/dist/runtime/grokBrokerProxyJson.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Preserve ordinary JSON bytes, including whitespace and escaping. Ambiguous
+ * duplicate members still normalize to the validated values, as the spend gate
+ * requires: an upstream parser must never select a different model or tool set.
+ */
+export declare function parseGrokBrokerProxyJson(body: Uint8Array): {
+    value: Record<string, unknown>;
+    body: Uint8Array;
+};
+//# sourceMappingURL=grokBrokerProxyJson.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grokBrokerProxyJson.d.ts","sourceRoot":"","sources":["../../src/runtime/grokBrokerProxyJson.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,UAAU,GAAG;IAC1D,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,IAAI,EAAE,UAAU,CAAC;CAClB,CAuBA"}

package/dist/runtime/grokBrokerProxyJson.js

@@ -0,0 +1,31 @@
+/**
+ * Preserve ordinary JSON bytes, including whitespace and escaping. Ambiguous
+ * duplicate members still normalize to the validated values, as the spend gate
+ * requires: an upstream parser must never select a different model or tool set.
+ */
+export function parseGrokBrokerProxyJson(body) {
+    const source = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(body);
+    let properties = 0;
+    const value = JSON.parse(source, (key, entry) => {
+        if (key === "__proto__")
+            throw new Error("broker proxy request rejected");
+        if (entry !== null && typeof entry === "object" && !Array.isArray(entry)) {
+            properties += Object.keys(entry).length;
+        }
+        return entry;
+    });
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("broker proxy request rejected");
+    }
+    // JSON.parse established the grammar. Match whole string tokens (including
+    // escaped quotes), so a colon inside message content cannot count as a key.
+    let sourceProperties = 0;
+    for (const token of source.matchAll(/"(?:[^"\\]|\\[\s\S])*"\s*(:)?/gu)) {
+        if (token[1] !== undefined)
+            sourceProperties++;
+    }
+    return {
+        value: value,
+        body: sourceProperties === properties ? body : Buffer.from(JSON.stringify(value))
+    };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"grokBrokerProxyRequest.d.ts","sourceRoot":"","sources":["../../src/runtime/grokBrokerProxyRequest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAC9E,OAAO,EAAgE,KAAK,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAGtI,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAC9L,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAAC;IAAE,GAAG,EAAE,qDAAqD,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CAAC;AAE9K;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,wBAAwB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,qBAAwD,GAAG,yBAAyB,CAsBhO;AASD,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAStD"}
+{"version":3,"file":"grokBrokerProxyRequest.d.ts","sourceRoot":"","sources":["../../src/runtime/grokBrokerProxyRequest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAC9E,OAAO,EAAgE,KAAK,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAGtI,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAC9L,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAAC;IAAE,GAAG,EAAE,qDAAqD,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CAAC;AAE9K;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,wBAAwB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,qBAAwD,GAAG,yBAAyB,CAmChO;AASD,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAStD"}

package/dist/runtime/grokBrokerProxyRequest.js

@@ -34,8 +34,11 @@ export function authorizeGrokBrokerProxyRequest(input, capabilities, bearer, pol
     // `__proto__` is refused at any depth: JSON.parse makes it an ordinary own
     // member, but an upstream JavaScript parser may treat it as a prototype.
     try {
-        parsed = JSON.parse(Buffer.from(input.body).toString("utf8"), (key, value) => { if (key === "__proto__")
-            throw new Error(); return value; });
+        parsed = JSON.parse(Buffer.from(input.body).toString("utf8"), (key, value) => {
+            if (key === "__proto__")
+                throw new Error("broker proxy request rejected");
+            return value;
+        });
     }
     catch {
         throw new Error("broker proxy request rejected");
@@ -48,10 +51,18 @@ export function authorizeGrokBrokerProxyRequest(input, capabilities, bearer, pol
         throw new Error("broker proxy request rejected");
     if (Object.keys(parsed).some((key) => !LEAN_BODY_MEMBERS.has(key)) || !validStreamOptions(parsed.stream_options))
         throw new Error("broker proxy request rejected");
-    // Forward what was validated, never the worker's bytes: JSON.parse keeps the
-    // last of duplicate keys, and an upstream that keeps the first would
-    // otherwise see a different `tools`/`model`/`reasoning_effort` than the gate.
-    return { url: "https://cli-chat-proxy.grok.com/v1/chat/completions", headers: { authorization: `Bearer ${bearer}`, "content-type": "application/json", "x-xai-token-auth": "xai-grok-cli", "x-grok-model-override": declared.model, "x-grok-client-version": clientVersion, "x-grok-client-identifier": "grok-shell" }, body: Buffer.from(JSON.stringify(parsed)) };
+    // Keep origin/main's production handling: UTF-8 replacement decoding, then
+    // serialize the validated object (including last-member-wins duplicates).
+    // Only a clocked turn takes the stricter date rewrite before this gate.
+    return {
+        url: "https://cli-chat-proxy.grok.com/v1/chat/completions",
+        headers: {
+            authorization: `Bearer ${bearer}`, "content-type": "application/json",
+            "x-xai-token-auth": "xai-grok-cli", "x-grok-model-override": declared.model,
+            "x-grok-client-version": clientVersion, "x-grok-client-identifier": "grok-shell"
+        },
+        body: Buffer.from(JSON.stringify(parsed))
+    };
 }
 /** Top-level members of a Grok 1.0.34 lean worker chat-completions body (live stub capture). */
 const LEAN_BODY_MEMBERS = new Set(["messages", "model", "reasoning_effort", "stream", "stream_options", "tools"]);