@noopolis/daimon 0.2.0 → 0.2.2

package/dist/runtime/engineBrokerService.js

@@ -1,6 +1,7 @@
+import { brokerClockObservation } from "./grokBrokerTaskClock.js";
 import { chmod, lstat, unlink } from "node:fs/promises";
 import { createServer } from "node:net";
-import { encodeEngineBrokerFrame, EngineBrokerFrameDecoder, parseEngineBrokerRequest } from "./engineBrokerProtocol.js";
+import { encodeEngineBrokerFrame, EngineBrokerFrameDecoder, EngineBrokerProtocolMismatch, parseEngineBrokerRequest } from "./engineBrokerProtocol.js";
 import { EngineBrokerTurnFailure } from "./grokEngineBroker.js";
 import { GROK_INFERENCE_PROXY_BASE_URL } from "./engineBrokerInferenceProtocol.js";
 import { GrokInferenceGrantRefused } from "./grokInferenceGrants.js";
@@ -12,7 +13,11 @@ export async function startEngineBrokerServiceWithIdentity(broker, socketPath, e
         throw new Error("engine broker service requires broker identity");
     await removeOwnedSocket(socketPath, expectedUid);
     const active = new Map(), connections = new Set();
-    const server = createServer((socket) => { connections.add(socket); socket.once("close", () => connections.delete(socket)); handle(socket, broker, active); });
+    const server = createServer((socket) => {
+        connections.add(socket);
+        socket.once("close", () => connections.delete(socket));
+        serveEngineBrokerConnection(socket, broker, active);
+    });
     await listen(server, socketPath);
     try {
         await chmod(socketPath, 0o600);
@@ -48,43 +53,88 @@ export async function startEngineBrokerServiceWithIdentity(broker, socketPath, e
  * reader has disconnected.
  */
 function handleSocketError(socket, owned) { socket.on("error", () => { owned()?.controller.abort(); socket.destroy(); }); }
-function handle(socket, broker, active) { const decoder = new EngineBrokerFrameDecoder(); let started = false, owned; handleSocketError(socket, () => owned); socket.once("close", () => owned?.controller.abort()); socket.on("data", (chunk) => { try {
-    for (const value of decoder.push(chunk)) {
-        const request = parseEngineBrokerRequest(value);
-        if (request.kind === "health") {
-            if (started)
-                throw new Error();
-            started = true;
-            const ready = broker.readiness();
-            if (ready.providerProxyPort !== 43123 || ready.mcpFacadePort !== 43124 || ready.registrations < 1 || ready.credentialStale || !ready.realmLease || !ready.workerIsolation)
-                throw new Error();
-            return send(socket, { version: request.version, kind: "ready", requestId: request.requestId, brokerUid: 2100, providerProxyPort: 43123, mcpFacadePort: 43124, registrations: ready.registrations, credentialStale: false, realmLease: true, workerIsolation: true });
+/** @internal The production connection handler, also exercised over an in-memory transport. */
+export function serveEngineBrokerConnection(socket, broker, active = new Map()) {
+    const decoder = new EngineBrokerFrameDecoder();
+    let started = false;
+    let owned;
+    handleSocketError(socket, () => owned);
+    socket.once("close", () => owned?.controller.abort());
+    socket.on("data", (chunk) => {
+        try {
+            for (const value of decoder.push(chunk)) {
+                const request = parseEngineBrokerRequest(value);
+                if (request.kind === "health") {
+                    if (started)
+                        throw new Error();
+                    started = true;
+                    const ready = broker.readiness();
+                    if (ready.providerProxyPort !== 43123 || ready.mcpFacadePort !== 43124 ||
+                        ready.registrations < 1 || ready.credentialStale || !ready.realmLease || !ready.workerIsolation) {
+                        throw new Error();
+                    }
+                    return send(socket, {
+                        version: request.version, kind: "ready", requestId: request.requestId, brokerUid: 2100,
+                        providerProxyPort: 43123, mcpFacadePort: 43124, registrations: ready.registrations,
+                        credentialStale: false, realmLease: true, workerIsolation: true
+                    });
+                }
+                if (request.kind === "cancel_turn") {
+                    if (owned?.turnId !== request.turnId)
+                        throw new Error("turn not owned by connection");
+                    owned.controller.abort();
+                    continue;
+                }
+                if (request.kind === "request_inference_grant" || request.kind === "release_inference_grant") {
+                    if (started)
+                        throw new Error();
+                    started = true;
+                    serveInferenceGrant(socket, broker, request);
+                    continue;
+                }
+                if (request.kind === "reset_slot") {
+                    if (started || broker.resetSlot === undefined)
+                        throw new Error();
+                    started = true;
+                    void broker.resetSlot(request.slot).then(() => send(socket, {
+                        version: request.version, kind: "slot_reset", requestId: request.requestId, slot: request.slot
+                    }), () => socket.destroy());
+                    continue;
+                }
+                const key = `${request.slot ?? request.agentId}:${request.turnId}`;
+                if (started || active.has(key))
+                    throw new Error();
+                started = true;
+                const controller = new AbortController();
+                owned = { turnId: request.turnId, controller };
+                active.set(key, controller);
+                socket.write(encodeEngineBrokerFrame({
+                    version: request.version, kind: "accepted", requestId: request.requestId, turnId: request.turnId
+                }));
+                void broker.turn(request.agentId, request.wakeId, request.prompt, request.mcpEndpoint, controller.signal, request.limits, request.processClock, request.slot).then((result) => send(socket, {
+                    version: request.version, kind: "completed", requestId: request.requestId, turnId: request.turnId,
+                    text: result.text, ...brokerClockObservation(result.shellClock, result.providerClock),
+                    ...(result.cleanupDiagnostic === undefined ? {} : { cleanupDiagnostic: result.cleanupDiagnostic }),
+                    workerPid: result.workerPid, workerUid: result.workerUid, workerStartTime: result.workerStartTime,
+                    outcome: "completed", usage: result.usage, model: result.model, requests: result.requests, limitReason: "none"
+                }), (error) => failed(socket, request, error, controller.signal.aborted)).finally(() => {
+                    if (active.get(key) === controller)
+                        active.delete(key);
+                    owned = undefined;
+                });
+            }
         }
-        if (request.kind === "cancel_turn") {
-            active.get(request.turnId)?.abort();
-            continue;
+        catch (error) {
+            if (error instanceof EngineBrokerProtocolMismatch && !socket.writableEnded) {
+                // Flush one small, closed diagnostic before FIN; destroy would lose it.
+                socket.pause();
+                socket.end(encodeEngineBrokerFrame(error.diagnostic));
+            }
+            else
+                socket.destroy();
         }
-        if (request.kind === "request_inference_grant" || request.kind === "release_inference_grant") {
-            if (started)
-                throw new Error();
-            started = true;
-            serveInferenceGrant(socket, broker, request);
-            continue;
-        }
-        if (started || active.has(request.turnId))
-            throw new Error();
-        started = true;
-        const controller = new AbortController();
-        owned = { turnId: request.turnId, controller };
-        active.set(request.turnId, controller);
-        socket.write(encodeEngineBrokerFrame({ version: request.version, kind: "accepted", requestId: request.requestId, turnId: request.turnId }));
-        void broker.turn(request.agentId, request.wakeId, request.prompt, request.mcpEndpoint, controller.signal, request.limits).then((result) => send(socket, { version: request.version, kind: "completed", requestId: request.requestId, turnId: request.turnId, text: result.text, workerPid: result.workerPid, workerUid: result.workerUid, workerStartTime: result.workerStartTime, outcome: "completed", usage: result.usage, model: result.model, requests: result.requests, limitReason: "none" }), (error) => failed(socket, request, error, controller.signal.aborted)).finally(() => { if (active.get(request.turnId) === controller)
-            active.delete(request.turnId); owned = undefined; });
-    }
+    });
 }
-catch {
-    socket.destroy();
-} }); }
 /**
  * Every failure the broker raises for a known registration carries its
  * accounting (a wake that tried to raise a limit: `usage: null`, zero
@@ -99,7 +149,15 @@ function failed(socket, request, error, aborted) {
         return;
     }
     const code = error instanceof EngineBrokerTurnFailure ? error.code : aborted ? "cancelled" : "engine_failed";
-    send(socket, { version: request.version, kind: "failed", requestId: request.requestId, turnId: request.turnId, code, ...(error instanceof EngineBrokerTurnFailure && error.diagnostic ? { diagnostic: error.diagnostic } : {}), ...(error instanceof EngineBrokerTurnFailure && error.mcpCalls ? { mcpCalls: error.mcpCalls } : {}), outcome: "failed", usage: accounting.usage, model: accounting.model, requests: accounting.requests, limitReason: accounting.limitReason });
+    send(socket, {
+        version: request.version, kind: "failed", requestId: request.requestId, turnId: request.turnId, code,
+        ...(error instanceof EngineBrokerTurnFailure ? brokerClockObservation(error.shellClock, error.providerClock) : {}),
+        ...(error instanceof EngineBrokerTurnFailure && error.diagnostic ? { diagnostic: error.diagnostic } : {}),
+        ...(error instanceof EngineBrokerTurnFailure && error.mcpCalls ? { mcpCalls: error.mcpCalls } : {}),
+        ...(error instanceof EngineBrokerTurnFailure && error.cleanupDiagnostic ? { cleanupDiagnostic: error.cleanupDiagnostic } : {}),
+        outcome: "failed", usage: accounting.usage, model: accounting.model,
+        requests: accounting.requests, limitReason: accounting.limitReason
+    });
 }
 /** One grant verb per connection, answered and closed; any failure becomes a closed-code refusal and never touches turn state. */
 function serveInferenceGrant(socket, broker, request) {

package/dist/runtime/engineBrokerServiceCli.js

@@ -10,7 +10,7 @@ export async function runEngineBrokerServiceCli() {
     if (process.getuid?.() !== 2100)
         throw new Error("engine broker service requires broker identity");
     const config = parseEngineBrokerServiceConfig(await readRootConfig(ENGINE_BROKER_SERVICE_CONFIG));
-    const broker = await startGrokEngineBroker({ grokCommand: "/usr/local/bin/grok", nativeClient: "/opt/daimon/bin/daimon-engine-broker", credentialHome: config.credentialHome, turnStore: config.turnStore, registrations: config.registrations, ...(config.inferenceLedgerPath === undefined ? {} : { inferenceLedgerPath: config.inferenceLedgerPath }) });
+    const broker = await startGrokEngineBroker({ grokCommand: "/usr/local/bin/grok", nativeClient: "/opt/daimon/bin/daimon-engine-broker", credentialHome: config.credentialHome, turnStore: config.turnStore, registrations: config.registrations, maxRunRequests: config.maxRunRequests, runRequestStore: config.runRequestStore, ...(config.inferenceLedgerPath === undefined ? {} : { inferenceLedgerPath: config.inferenceLedgerPath }) });
     const service = await startEngineBrokerService(broker);
     let stopping;
     const stop = () => { stopping ??= service.close(); return stopping; };

package/dist/runtime/engineBrokerServiceConfig.d.ts

@@ -1,6 +1,7 @@
 import { type EngineBrokerTurnLimits } from "./engineBrokerTurnAccounting.js";
 import { type GrokBrokerModelPolicy } from "./grokBrokerModelPolicy.js";
 export declare const ENGINE_BROKER_SERVICE_V1: "noopolis.daimon.engine-broker-service.v1";
+export declare const ENGINE_BROKER_SERVICE_V3: "noopolis.daimon.engine-broker-service.v3";
 export declare const ENGINE_BROKER_SERVICE_V2: "noopolis.daimon.engine-broker-service.v2";
 /** One root-provisioned broker slot. Every field is fixed at provisioning time; a wake can only lower `limits`. */
 export type EngineBrokerServiceRegistration = Readonly<{
@@ -15,6 +16,13 @@ export type EngineBrokerServiceRegistration = Readonly<{
     usageLedgerPath: string;
     limits: EngineBrokerTurnLimits;
     model: GrokBrokerModelPolicy;
+    /**
+     * Digest of the skills root provisioning rendered into `$GROK_HOME/skills`
+     * (`grokWorkerSkillsSha256`), attested before every turn. Optional in v2
+     * registrations and v3 slot policies; absent means the slot has no skills and
+     * the directory must not exist.
+     */
+    skillsSha256?: string;
 }>;
 /**
  * `inferenceLedgerPath` (v2, optional) is where evaluator inference grants
@@ -28,6 +36,8 @@ export type EngineBrokerServiceConfig = Readonly<{
     turnStore: string;
     registrations: readonly EngineBrokerServiceRegistration[];
     inferenceLedgerPath?: string;
+    maxRunRequests?: number;
+    runRequestStore?: string;
 }>;
 /** The per-request stream written beside a registration's usage ledger. */
 export declare const engineBrokerRequestLedgerPathFor: (usageLedgerPath: string) => string;
@@ -40,9 +50,12 @@ export declare const engineBrokerSealLedgerPathFor: (usageLedgerPath: string) =>
 /**
  * Strict `service.json` parser.
  *
+ * v3 retains seven-field registrations and binds slotPolicies by slot; agent IDs
+ * may repeat, while worker UIDs, slots and ledger streams must be distinct.
  * v2 requires every registration to declare its usage ledger, limits and model
- * (`model.id`/`model.reasoningEffort` from the closed lists); unknown keys at
- * any level are refused. v1 is still accepted and receives today's defaults:
+ * (`model.id`/`model.reasoningEffort` from the closed lists) and may declare
+ * `skillsSha256` (v3: on its slot policy); unknown keys at any level are
+ * refused. v1 is still accepted and receives today's defaults:
  * the container ledger, {@link DEFAULT_GROK_BROKER_TURN_LIMITS}, and
  * `grok-4.6`/`low`.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"engineBrokerServiceConfig.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerServiceConfig.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgE,KAAK,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC5I,OAAO,EAAuF,KAAK,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAK7J,eAAO,MAAM,wBAAwB,EAAG,0CAAmD,CAAC;AAC5F,eAAO,MAAM,wBAAwB,EAAG,0CAAmD,CAAC;AAE5F,mHAAmH;AACnH,MAAM,MAAM,+BAA+B,GAAG,QAAQ,CAAC;IACrD,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IACpI,oJAAoJ;IACpJ,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,sBAAsB,CAAC;IAC/B,KAAK,EAAE,qBAAqB,CAAC;CAC9B,CAAC,CAAC;AACH;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAAC;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,SAAS,+BAA+B,EAAE,CAAC;IAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAczL,2EAA2E;AAC3E,eAAO,MAAM,gCAAgC,GAAI,iBAAiB,MAAM,KAAG,MAAgF,CAAC;AAE5J;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,GAAI,iBAAiB,MAAM,KAAG,MAA6E,CAAC;AAEtJ;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,yBAAyB,CA6BxF"}
+{"version":3,"file":"engineBrokerServiceConfig.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerServiceConfig.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgE,KAAK,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC5I,OAAO,EAAuF,KAAK,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAK7J,eAAO,MAAM,wBAAwB,EAAG,0CAAmD,CAAC;AAC5F,eAAO,MAAM,wBAAwB,EAAG,0CAAmD,CAAC;AAC5F,eAAO,MAAM,wBAAwB,EAAG,0CAAmD,CAAC;AAE5F,mHAAmH;AACnH,MAAM,MAAM,+BAA+B,GAAG,QAAQ,CAAC;IACrD,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IACpI,oJAAoJ;IACpJ,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,sBAAsB,CAAC;IAC/B,KAAK,EAAE,qBAAqB,CAAC;IAC7B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC,CAAC;AACH;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAAC;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,SAAS,+BAA+B,EAAE,CAAC;IAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAc5O,2EAA2E;AAC3E,eAAO,MAAM,gCAAgC,GAAI,iBAAiB,MAAM,KAAG,MAAgF,CAAC;AAE5J;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,GAAI,iBAAiB,MAAM,KAAG,MAA6E,CAAC;AAEtJ;;;;;;;;;;;GAWG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,yBAAyB,CAyDxF"}

package/dist/runtime/engineBrokerServiceConfig.js

@@ -5,6 +5,7 @@ import { grokWorkerEventsPathFor } from "./grokWorkerSandboxProfile.js";
 import { TURN_REQUEST_LEDGER } from "./turnRequestLedger.js";
 import { TURN_USAGE_LEDGER } from "./turnUsageLedger.js";
 export const ENGINE_BROKER_SERVICE_V1 = "noopolis.daimon.engine-broker-service.v1";
+export const ENGINE_BROKER_SERVICE_V3 = "noopolis.daimon.engine-broker-service.v3";
 export const ENGINE_BROKER_SERVICE_V2 = "noopolis.daimon.engine-broker-service.v2";
 const V1_REGISTRATION = ["agentId", "slot", "workerUid", "workspace", "profilePath", "eventsPath", "profileSha256"];
 const V2_REGISTRATION = [...V1_REGISTRATION, "usageLedgerPath", "limits", "model"];
@@ -29,48 +30,88 @@ export const engineBrokerSealLedgerPathFor = (usageLedgerPath) => path.posix.joi
 /**
  * Strict `service.json` parser.
  *
+ * v3 retains seven-field registrations and binds slotPolicies by slot; agent IDs
+ * may repeat, while worker UIDs, slots and ledger streams must be distinct.
  * v2 requires every registration to declare its usage ledger, limits and model
- * (`model.id`/`model.reasoningEffort` from the closed lists); unknown keys at
- * any level are refused. v1 is still accepted and receives today's defaults:
+ * (`model.id`/`model.reasoningEffort` from the closed lists) and may declare
+ * `skillsSha256` (v3: on its slot policy); unknown keys at any level are
+ * refused. v1 is still accepted and receives today's defaults:
  * the container ledger, {@link DEFAULT_GROK_BROKER_TURN_LIMITS}, and
  * `grok-4.6`/`low`.
  */
 export function parseEngineBrokerServiceConfig(value) {
     if (!plain(value))
         throw invalid();
-    const v2 = value.version === ENGINE_BROKER_SERVICE_V2;
+    const v3 = value.version === ENGINE_BROKER_SERVICE_V3;
+    const v2 = v3 || value.version === ENGINE_BROKER_SERVICE_V2;
     if (!v2 && value.version !== ENGINE_BROKER_SERVICE_V1)
         throw invalid();
-    const top = ["version", "credentialHome", "turnStore", "registrations"];
+    const top = ["version", "credentialHome", "turnStore", "registrations", ...(v3 ? ["slotPolicies"] : [])];
+    if (v3 && Object.hasOwn(value, "maxRunRequests")) {
+        if (!Number.isSafeInteger(value.maxRunRequests) || value.maxRunRequests < 1)
+            throw invalid();
+        top.push("maxRunRequests");
+    }
+    if (v3 && Object.hasOwn(value, "runRequestStore")) {
+        if (!absolute(value.runRequestStore) || value.maxRunRequests === undefined)
+            throw invalid();
+        top.push("runRequestStore");
+    }
     exact(value, v2 && Object.hasOwn(value, "inferenceLedgerPath") ? [...top, "inferenceLedgerPath"] : top);
     if (!absolute(value.credentialHome) || !absolute(value.turnStore) || !Array.isArray(value.registrations) || value.registrations.length === 0)
         throw invalid();
-    const seen = new Set(), slots = new Set();
+    const policies = new Map();
+    if (v3) {
+        if (!Array.isArray(value.slotPolicies) || value.slotPolicies.length !== value.registrations.length)
+            throw invalid();
+        for (const policy of value.slotPolicies) {
+            if (!plain(policy))
+                throw invalid();
+            exact(policy, ["slot", "usageLedgerPath", "limits", "model", ...withSkills(policy)]);
+            if (!Number.isSafeInteger(policy.slot) || policy.slot < 0 || policies.has(policy.slot))
+                throw invalid();
+            policies.set(policy.slot, policy);
+        }
+    }
+    const seen = new Set(), slots = new Set(), workers = new Set();
+    const ledgers = new Set();
     const registrations = value.registrations.map((entry) => {
         if (!plain(entry))
             throw invalid();
-        exact(entry, v2 ? V2_REGISTRATION : V1_REGISTRATION);
+        exact(entry, v2 && !v3 ? [...V2_REGISTRATION, ...withSkills(entry)] : V1_REGISTRATION);
         const { agentId, slot, workerUid, workspace, profilePath, eventsPath, profileSha256 } = entry;
-        if (typeof agentId !== "string" || !agentId.trim() || seen.has(agentId) || !Number.isSafeInteger(slot) || slot < 0 || slots.has(slot) || !Number.isSafeInteger(workerUid) || workerUid < 2200 || !absolute(workspace) || !absolute(profilePath) || !absolute(eventsPath) || typeof profileSha256 !== "string" || !/^[a-f0-9]{64}$/u.test(profileSha256) || eventsPath !== grokWorkerEventsPathFor(profilePath) || !profilePath.endsWith("/sandbox.toml"))
+        if (typeof agentId !== "string" || !agentId.trim() || (!v3 && seen.has(agentId)) || !Number.isSafeInteger(slot) || slot < 0 || slots.has(slot) || !Number.isSafeInteger(workerUid) || workerUid < 2200 || workers.has(workerUid) || !absolute(workspace) || !absolute(profilePath) || !absolute(eventsPath) || typeof profileSha256 !== "string" || !/^[a-f0-9]{64}$/u.test(profileSha256) || eventsPath !== grokWorkerEventsPathFor(profilePath) || !profilePath.endsWith("/sandbox.toml"))
             throw invalid();
         seen.add(agentId);
         slots.add(slot);
+        workers.add(workerUid);
         const base = { agentId, slot: slot, workerUid: workerUid, workspace, profilePath, eventsPath, profileSha256 };
         if (!v2)
             return { ...base, usageLedgerPath: TURN_USAGE_LEDGER.filePath, limits: DEFAULT_GROK_BROKER_TURN_LIMITS, model: DEFAULT_GROK_BROKER_MODEL_POLICY };
-        const usageLedgerPath = entry.usageLedgerPath;
+        const policy = v3 ? policies.get(slot) : entry;
+        if (policy === undefined)
+            throw invalid();
+        const usageLedgerPath = policy.usageLedgerPath;
         if (!ledgerPath(usageLedgerPath) || usageLedgerPath === engineBrokerRequestLedgerPathFor(usageLedgerPath) || usageLedgerPath === engineBrokerSealLedgerPathFor(usageLedgerPath))
             throw invalid();
+        const streams = [usageLedgerPath, engineBrokerRequestLedgerPathFor(usageLedgerPath), engineBrokerSealLedgerPathFor(usageLedgerPath)];
+        if (v3 && streams.some((file) => ledgers.has(file)))
+            throw invalid();
+        streams.forEach((file) => ledgers.add(file));
         let limits;
         try {
-            limits = parseEngineBrokerTurnLimits(entry.limits);
+            limits = parseEngineBrokerTurnLimits(policy.limits);
         }
         catch {
             throw invalid();
         }
-        return { ...base, usageLedgerPath, limits, model: parseServiceModel(entry.model) };
+        if (Object.hasOwn(policy, "skillsSha256") && (typeof policy.skillsSha256 !== "string" || !/^[a-f0-9]{64}$/u.test(policy.skillsSha256)))
+            throw invalid();
+        return { ...base, usageLedgerPath, limits, model: parseServiceModel(policy.model), ...(Object.hasOwn(policy, "skillsSha256") ? { skillsSha256: policy.skillsSha256 } : {}) };
     });
-    const base = { credentialHome: value.credentialHome, turnStore: value.turnStore, registrations };
+    const base = { credentialHome: value.credentialHome, turnStore: value.turnStore, registrations,
+        ...(value.runRequestStore === undefined ? {} : { runRequestStore: value.runRequestStore }),
+        ...(value.maxRunRequests === undefined ? {} : { maxRunRequests: value.maxRunRequests }) };
     if (!Object.hasOwn(value, "inferenceLedgerPath"))
         return base;
     const inferenceLedgerPath = value.inferenceLedgerPath;
@@ -81,6 +122,7 @@ export function parseEngineBrokerServiceConfig(value) {
         throw invalid();
     return { ...base, inferenceLedgerPath };
 }
+const withSkills = (value) => Object.hasOwn(value, "skillsSha256") ? ["skillsSha256"] : [];
 const ledgerPath = (item) => absolute(item) && item.endsWith(".jsonl") && path.posix.normalize(item) === item;
 function parseServiceModel(value) {
     if (!plain(value))

package/dist/runtime/engineBrokerTurnRegistry.d.ts

@@ -48,7 +48,7 @@ export declare class EngineBrokerTurnRegistry {
 }
 /**
  * Strict record parser. v2 accepts exactly `{version,digest,state,bootId}`
- * plus `response` and its sealed `ledger` bytes when terminal, and the response must be a v2 terminal frame.
+ * 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.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"engineBrokerTurnRegistry.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerTurnRegistry.ts"],"names":[],"mappings":"AAIA,OAAO,EAAkE,KAAK,mBAAmB,EAAE,KAAK,4BAA4B,EAAE,MAAM,2BAA2B,CAAC;AACxK,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;AAK7F,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"}
+{"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

@@ -2,13 +2,14 @@ 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 { parseEngineBrokerResponse, parseEngineBrokerV1TerminalResponse } from "./engineBrokerProtocol.js";
+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 turn.
-const digest = (request) => createHash("sha256").update(JSON.stringify([request.turnId, request.agentId, request.wakeId, request.prompt, request.mcpEndpoint])).digest("hex");
+// 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
@@ -97,7 +98,7 @@ export class EngineBrokerTurnRegistry {
 }
 /**
  * Strict record parser. v2 accepts exactly `{version,digest,state,bootId}`
- * plus `response` and its sealed `ledger` bytes when terminal, and the response must be a v2 terminal frame.
+ * 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.
  */
@@ -126,7 +127,7 @@ export function parseEngineBrokerTurnRecord(text, model) {
             throw new Error("broker turn registry unavailable");
         }
         const accounting = { outcome: legacy.kind, usage: null, model, requests: 0, limitReason: "none" };
-        const response = { ...legacy, ...accounting, version: "noopolis.daimon.engine-broker.v2" };
+        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)
@@ -138,7 +139,7 @@ export function parseEngineBrokerTurnRecord(text, model) {
         return { version: ENGINE_BROKER_TURN_RECORD_V2, ...base };
     let response;
     try {
-        response = parseEngineBrokerResponse(input.response);
+        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");

package/dist/runtime/engineDispatcher.d.ts

@@ -11,6 +11,8 @@ export declare function startOrganizationRuntimeEngine(agent: OrganizationRuntim
 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.

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

@@ -1 +1 @@
-{"version":3,"file":"engineDispatcher.d.ts","sourceRoot":"","sources":["../../src/runtime/engineDispatcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAIxE,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,CA8CtB;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;AAwDD;;;GAGG;AACH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,8BAA8B,EAAE,gBAAgB,GAAE,SAAS,MAAM,EAAO,GAAG,MAAM,CAkBxH"}
+{"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"}

package/dist/runtime/engineDispatcher.js

@@ -1,4 +1,8 @@
+import { brokerProcessClock } from "./grokBrokerTaskClock.js";
+import { reportEngineTaskClockGap } from "../pi/engineTaskClock.js";
 import { attentionTools } from "./attention.js";
+import { readTaskClock } from "./taskClock.js";
+import { memoryClockOptions } from "../pi/memoryClock.js";
 import { grokDaimonToolName, grokMountedToolNamingRule } from "../contracts/grokWorkerContract.js";
 import path from "node:path";
 import { AGY_MAX_TOOL_TURNS, createCliSessionFactory, resolveCodexWakeTimeoutMs, resolveCodexWakeTokenCeiling, resolveEngineWakeLimitOverrides } from "../pi/cliSession.js";
@@ -14,6 +18,10 @@ import { recordCodexTurnRequests } from "./turnRequestLedger.js";
  * existing one-agent harness. Configuration never carries a command or env.
  */
 export async function startOrganizationRuntimeEngine(agent, controlTokenEnv, paths, agyBusAddress, grokBroker, organizationAgents, sharedProtectedPaths = [], attention) {
+    const clock = readTaskClock();
+    reportEngineTaskClockGap(agent.engine.kind);
+    if (agent.memory !== undefined)
+        memoryClockOptions(clock);
     // A declared Grok model is enforced by the broker proxy and worker config;
     // the direct path has neither, so it refuses rather than silently ignoring it.
     if (agent.engine.kind === "grok" && agent.engine.model !== undefined && grokBroker === undefined)
@@ -137,10 +145,14 @@ function adapterFor(agent, controlTokenEnv, verifyExecutable, executablePath, en
             } : {}) });
     return cliHarness(agent, sessionFactory, [controlTokenEnv], productionTools, wakeEnvironmentContext);
 }
-function grokBrokerTurnFor(agent, grokBroker, wakeEnvironmentContext) {
+/** @internal The same callback used by the production session; no native process clock enters the engine environment. */
+export function grokBrokerTurnFor(agent, grokBroker, wakeEnvironmentContext) {
     const limits = resolveEngineWakeLimitOverrides();
     const options = { ...(limits === undefined ? {} : { limits }), ...(agent.engine.model === undefined ? {} : { model: agent.engine.model }) };
-    return (prompt, endpoint, signal) => grokBroker.turn(agent.id, wakeEnvironmentContext.current ?? "wake", prompt, endpoint, signal, options);
+    return (prompt, endpoint, signal) => {
+        const processClock = brokerProcessClock();
+        return grokBroker.turn(agent.id, wakeEnvironmentContext.current ?? "wake", prompt, endpoint, signal, { ...options, ...(processClock === undefined ? {} : { processClock }) });
+    };
 }
 /**
  * CLI engines do not consume Pi's resource loader. Frame the same immutable

package/dist/runtime/engineReadiness.js

@@ -1,7 +1,7 @@
 import { constants } from "node:fs";
 import { lstat, open, realpath, stat } from "node:fs/promises";
 import path from "node:path";
-import { spawn } from "node:child_process";
+import { spawnRealTime as spawn } from "./taskClockProcess.js";
 import { createHash } from "node:crypto";
 import { cliChildEnvironment } from "../pi/cliEnvironment.js";
 import { hasRefreshablePortableCredential, portableCredentialSecretValues } from "./portableCredentialAuth.js";

package/dist/runtime/grokBrokerCredentialAuthority.d.ts

@@ -9,6 +9,7 @@ export declare class DurableGrokBrokerCredentialAuthority {
     private staleWrite;
     private lastDigest;
     private generation;
+    private ancestorDigests;
     constructor(command: string, home: string, authFile?: string);
     initialize(): Promise<void>;
     accessToken(forceRefresh: boolean): Promise<string>;

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

@@ -1 +1 @@
-{"version":3,"file":"grokBrokerCredentialAuthority.d.ts","sourceRoot":"","sources":["../../src/runtime/grokBrokerCredentialAuthority.ts"],"names":[],"mappings":"AAUA,qBAAa,oCAAoC;IAEnC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAAU,OAAO,CAAC,QAAQ,CAAC,IAAI;IAAU,OAAO,CAAC,QAAQ,CAAC,QAAQ;IADtG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0C;IAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAAC,OAAO,CAAC,KAAK,CAAS;IAAA,OAAO,CAAC,WAAW,CAAO;IAAA,OAAO,CAAC,UAAU,CAAyB;IAAA,OAAO,CAAC,UAAU,CAAkB;IAAA,OAAO,CAAC,UAAU,CAAG;gBACrP,OAAO,EAAE,MAAM,EAAmB,IAAI,EAAE,MAAM,EAAmB,QAAQ,SAA+B;IAC/H,UAAU,IAAG,OAAO,CAAC,IAAI,CAAC;IAC1B,WAAW,CAAC,YAAY,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAInD,qBAAqB,CAAC,mBAAmB,EAAC,MAAM,GAAE,OAAO,CAAC,MAAM,CAAC;IACvE,OAAO,CAAC,OAAO;IAOT,YAAY,CAAC,mBAAmB,CAAC,EAAC,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAC9D,OAAO,IAAG,OAAO;IACjB,OAAO,CAAC,SAAS;YACH,KAAK;CAKpB"}
+{"version":3,"file":"grokBrokerCredentialAuthority.d.ts","sourceRoot":"","sources":["../../src/runtime/grokBrokerCredentialAuthority.ts"],"names":[],"mappings":"AAUA,qBAAa,oCAAoC;IAGnC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAAU,OAAO,CAAC,QAAQ,CAAC,IAAI;IAAU,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAFtG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0C;IAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAAC,OAAO,CAAC,KAAK,CAAS;IAAA,OAAO,CAAC,WAAW,CAAO;IAAA,OAAO,CAAC,UAAU,CAAyB;IAAA,OAAO,CAAC,UAAU,CAAkB;IAAA,OAAO,CAAC,UAAU,CAAG;IAClR,OAAO,CAAC,eAAe,CAAyB;gBACnB,OAAO,EAAE,MAAM,EAAmB,IAAI,EAAE,MAAM,EAAmB,QAAQ,SAA+B;IAC/H,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAiC3B,WAAW,CAAC,YAAY,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAInD,qBAAqB,CAAC,mBAAmB,EAAC,MAAM,GAAE,OAAO,CAAC,MAAM,CAAC;IACvE,OAAO,CAAC,OAAO;IAYT,YAAY,CAAC,mBAAmB,CAAC,EAAC,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAC9D,OAAO,IAAG,OAAO;IACjB,OAAO,CAAC,SAAS;YACH,KAAK;CAKpB"}

package/dist/runtime/grokBrokerCredentialAuthority.js

@@ -6,7 +6,7 @@ import path from "node:path";
 import { readGrokBrokerCredential } from "./grokBrokerCredentialReader.js";
 import { refreshGrokBrokerCredential } from "./grokBrokerRefresh.js";
 import { EngineBrokerGenerationFence, EngineBrokerSingleflight } from "./engineBrokerSingleflight.js";
-import { parseBrokerCredentialJournal, recoverBrokerCredentialJournal } from "./engineBrokerCredentialJournal.js";
+import { BROKER_CREDENTIAL_MAX_ANCESTORS, parseBrokerCredentialJournal, recoverBrokerCredentialJournal } from "./engineBrokerCredentialJournal.js";
 export class DurableGrokBrokerCredentialAuthority {
     command;
     home;
@@ -18,33 +18,52 @@ export class DurableGrokBrokerCredentialAuthority {
     staleWrite;
     lastDigest;
     generation = 0;
+    ancestorDigests = [];
     constructor(command, home, authFile = path.join(home, "auth.json")) {
         this.command = command;
         this.home = home;
         this.authFile = authFile;
     }
-    async initialize() { if (this.initialized)
-        return; const credential = await readGrokBrokerCredential(this.authFile); this.lastDigest = credential.digest; const file = path.join(this.home, ".daimon-broker", "credential-journal.json"); let handle; try {
-        handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
-        const stat = await handle.stat();
-        if (!stat.isFile() || stat.uid !== process.getuid?.() || (stat.mode & 0o777) !== 0o600 || stat.size > 4096)
-            throw unavailable();
-        const journal = parseBrokerCredentialJournal(JSON.parse(await handle.readFile("utf8")));
-        if (recoverBrokerCredentialJournal(journal, credential.digest) === "stale") {
+    async initialize() {
+        if (this.initialized)
+            return;
+        const credential = await readGrokBrokerCredential(this.authFile);
+        this.lastDigest = credential.digest;
+        const file = path.join(this.home, ".daimon-broker", "credential-journal.json");
+        let handle;
+        try {
+            handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+            const stat = await handle.stat();
+            if (!stat.isFile() || stat.uid !== process.getuid?.() || (stat.mode & 0o777) !== 0o600 || stat.size > 65536)
+                throw unavailable();
+            const journal = parseBrokerCredentialJournal(JSON.parse(await handle.readFile("utf8")));
             this.generation = journal.generation;
-            await this.markStale();
-            throw unavailable();
+            if (recoverBrokerCredentialJournal(journal, credential.digest) === "stale") {
+                await this.markStale();
+                throw unavailable();
+            }
+            this.ancestorDigests = [...new Set([...(journal.ancestorDigests ?? []), journal.sourceDigest])]
+                .filter((digest) => digest !== credential.digest);
+            if (journal.state === "refreshing") {
+                // The durable credential still matches the pre-exchange source. Settle
+                // before serving it so writeback and drain need no subsequent refresh.
+                // No exchange completed: preserve the generation and existing lineage.
+                await this.write({ state: "promoted", generation: journal.generation,
+                    sourceDigest: credential.digest, promotedDigest: credential.digest });
+            }
+            this.fence.restore(journal.generation);
         }
-        this.generation = journal.generation;
-        this.fence.restore(journal.generation);
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw unavailable();
+        catch (error) {
+            // Only a missing journal on open is an unjournaled bootstrap. A failed
+            // recovery write (including ENOENT) must never publish readiness.
+            if (handle !== undefined || error.code !== "ENOENT")
+                throw unavailable();
+        }
+        finally {
+            await handle?.close().catch(() => undefined);
+        }
+        this.initialized = true;
     }
-    finally {
-        await handle?.close().catch(() => undefined);
-    } this.initialized = true; }
     async accessToken(forceRefresh) {
         if (!this.initialized)
             await this.initialize();
@@ -64,6 +83,11 @@ export class DurableGrokBrokerCredentialAuthority {
             const before = await readGrokBrokerCredential(this.authFile);
             if (rejectedTokenDigest !== undefined && createHash("sha256").update(before.accessToken).digest("hex") !== rejectedTokenDigest)
                 return before.accessToken;
+            // Never spend a refresh whose lineage cannot be persisted. Advancing expiry
+            // normally clears the history, so this bound applies to one expiry epoch.
+            const ancestors = [...new Set([...this.ancestorDigests, before.digest])];
+            if (ancestors.length > BROKER_CREDENTIAL_MAX_ANCESTORS)
+                throw unavailable();
             try {
                 await this.write({ state: "refreshing", generation, sourceDigest: before.digest });
                 await refreshGrokBrokerCredential(this.command, this.home);
@@ -72,7 +96,9 @@ export class DurableGrokBrokerCredentialAuthority {
                     throw unavailable();
                 const next = this.fence.promote(generation);
                 this.generation = next;
-                await this.write({ state: "promoted", generation: next, sourceDigest: before.digest, promotedDigest: after.digest });
+                const ancestorDigests = before.expiresAt !== undefined && after.expiresAt !== undefined && after.expiresAt > before.expiresAt ? [] : ancestors;
+                await this.write({ state: "promoted", generation: next, sourceDigest: before.digest, promotedDigest: after.digest, ancestorDigests });
+                this.ancestorDigests = ancestorDigests;
                 this.lastDigest = after.digest;
                 return after.accessToken;
             }
@@ -100,7 +126,7 @@ export class DurableGrokBrokerCredentialAuthority {
         const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
         const handle = await open(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
         try {
-            await handle.writeFile(`${JSON.stringify({ version: "noopolis.daimon.broker-credential-journal.v1", ...value })}\n`);
+            await handle.writeFile(`${JSON.stringify({ version: "noopolis.daimon.broker-credential-journal.v1", ancestorDigests: this.ancestorDigests, ...value })}\n`);
             await handle.sync();
         }
         finally {

package/dist/runtime/grokBrokerCredentialReader.d.ts

@@ -1,5 +1,6 @@
 export declare function readGrokBrokerCredential(file: string): Promise<Readonly<{
     accessToken: string;
     digest: string;
+    expiresAt?: number;
 }>>;
 //# sourceMappingURL=grokBrokerCredentialReader.d.ts.map