@noopolis/daimon 0.2.0 → 0.2.1

package/dist/runtime/engineBrokerControlClient.d.ts

@@ -1,7 +1,9 @@
+import { type Socket } from "node:net";
 import type { EngineBrokerInferenceFailureCode, EngineBrokerInferenceResponse } from "./engineBrokerInferenceProtocol.js";
 import type { EngineBrokerTurnLimitOverrides } from "./engineBrokerTurnAccounting.js";
 import type { GrokBrokerModel, GrokBrokerReasoningEffort } from "./grokBrokerModelPolicy.js";
 import type { GrokInferencePurpose } from "./inferenceUsageLedger.js";
+import type { GrokBrokerProviderClockObservation } from "./grokBrokerProviderClock.js";
 export type EngineBrokerInferenceGrant = Omit<Extract<EngineBrokerInferenceResponse, {
     kind: "inference_grant";
 }>, "version" | "kind" | "requestId">;
@@ -18,13 +20,21 @@ export declare class EngineBrokerInferenceGrantRefused extends Error {
 export type EngineBrokerTurnOptions = Readonly<{
     limits?: EngineBrokerTurnLimitOverrides;
     model?: string;
+    processClock?: string;
+    slot?: number;
+    /** Sealed observation on completion, failure and replay; sink errors never change the turn. */
+    onProviderClock?: (observation: GrokBrokerProviderClockObservation) => void;
 }>;
 export interface EngineBrokerTurnClient {
     turn(agentId: string, wakeId: string, prompt: string, mcpEndpoint: string, signal?: AbortSignal, options?: EngineBrokerTurnOptions): Promise<string>;
 }
 export declare class EngineBrokerControlClient implements EngineBrokerTurnClient {
     private readonly socketPath;
-    constructor(socketPath?: string);
+    /** Internal transport seam; the production client always opens the Unix socket. */
+    private readonly connect;
+    constructor(socketPath?: string, 
+    /** Internal transport seam; the production client always opens the Unix socket. */
+    connect?: (path: string) => Socket);
     ready(): Promise<void>;
     /**
      * Evaluator side (organization uid only; the native relay enforces it):
@@ -38,6 +48,7 @@ export declare class EngineBrokerControlClient implements EngineBrokerTurnClient
         purpose: GrokInferencePurpose;
     }>): Promise<EngineBrokerInferenceGrant>;
     releaseInferenceGrant(grantId: string): Promise<boolean>;
+    resetSlot(slot: number): Promise<void>;
     private exchange;
     turn(agentId: string, wakeId: string, prompt: string, mcpEndpoint: string, signal?: AbortSignal, options?: EngineBrokerTurnOptions): Promise<string>;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"engineBrokerControlClient.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerControlClient.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gCAAgC,EAAgC,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AAExJ,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AACtF,OAAO,KAAK,EAAE,eAAe,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAC7F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAetE,MAAM,MAAM,0BAA0B,GAAG,IAAI,CAAC,OAAO,CAAC,6BAA6B,EAAE;IAAE,IAAI,EAAE,iBAAiB,CAAA;CAAE,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,WAAW,CAAC,CAAC;AACrJ,4HAA4H;AAC5H,qBAAa,iCAAkC,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,EAAE,gCAAgC;gBAAtC,IAAI,EAAE,gCAAgC;CAC5D;AAED;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAAE,MAAM,CAAC,EAAE,8BAA8B,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAC5G,MAAM,WAAW,sBAAsB;IAAG,IAAI,CAAC,OAAO,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,WAAW,EAAC,MAAM,EAAC,MAAM,CAAC,EAAC,WAAW,EAAC,OAAO,CAAC,EAAC,uBAAuB,GAAE,OAAO,CAAC,MAAM,CAAC,CAAC;CAAE;AACrL,qBAAa,yBAA0B,YAAW,sBAAsB;IAC1D,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,SAAyC;IAC1E,KAAK,IAAG,OAAO,CAAC,IAAI,CAAC;IAC3B;;;;;OAKG;IACG,qBAAqB,CAAC,OAAO,EAAC,QAAQ,CAAC;QAAC,KAAK,EAAC,eAAe,CAAC;QAAA,eAAe,EAAC,yBAAyB,CAAC;QAAA,OAAO,EAAC,oBAAoB,CAAA;KAAC,CAAC,GAAE,OAAO,CAAC,0BAA0B,CAAC;IAM3K,qBAAqB,CAAC,OAAO,EAAC,MAAM,GAAE,OAAO,CAAC,OAAO,CAAC;IAM5D,OAAO,CAAC,QAAQ;IACV,IAAI,CAAC,OAAO,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,WAAW,EAAC,MAAM,EAAC,MAAM,CAAC,EAAC,WAAW,EAAC,OAAO,GAAC,uBAA0B,GAAE,OAAO,CAAC,MAAM,CAAC;CAMjJ"}
+{"version":3,"file":"engineBrokerControlClient.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerControlClient.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAEzD,OAAO,KAAK,EAAE,gCAAgC,EAAgC,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AAExJ,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AACtF,OAAO,KAAK,EAAE,eAAe,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAC7F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,8BAA8B,CAAC;AAevF,MAAM,MAAM,0BAA0B,GAAG,IAAI,CAAC,OAAO,CAAC,6BAA6B,EAAE;IAAE,IAAI,EAAE,iBAAiB,CAAA;CAAE,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,WAAW,CAAC,CAAC;AACrJ,4HAA4H;AAC5H,qBAAa,iCAAkC,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,EAAE,gCAAgC;gBAAtC,IAAI,EAAE,gCAAgC;CAC5D;AAED;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAC7C,MAAM,CAAC,EAAE,8BAA8B,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAC9F,+FAA+F;IAC/F,eAAe,CAAC,EAAE,CAAC,WAAW,EAAE,kCAAkC,KAAK,IAAI,CAAC;CAC7E,CAAC,CAAC;AACH,MAAM,WAAW,sBAAsB;IAAG,IAAI,CAAC,OAAO,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,WAAW,EAAC,MAAM,EAAC,MAAM,CAAC,EAAC,WAAW,EAAC,OAAO,CAAC,EAAC,uBAAuB,GAAE,OAAO,CAAC,MAAM,CAAC,CAAC;CAAE;AACrL,qBAAa,yBAA0B,YAAW,sBAAsB;IAEpE,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,mFAAmF;IACnF,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAFP,UAAU,SAA2C;IACtE,mFAAmF;IAClE,OAAO,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAA6C;IAErF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA8B5B;;;;;OAKG;IACG,qBAAqB,CAAC,OAAO,EAAC,QAAQ,CAAC;QAAC,KAAK,EAAC,eAAe,CAAC;QAAA,eAAe,EAAC,yBAAyB,CAAC;QAAA,OAAO,EAAC,oBAAoB,CAAA;KAAC,CAAC,GAAE,OAAO,CAAC,0BAA0B,CAAC;IAM3K,qBAAqB,CAAC,OAAO,EAAC,MAAM,GAAE,OAAO,CAAC,OAAO,CAAC;IAMtD,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5C,OAAO,CAAC,QAAQ;IA6BV,IAAI,CACR,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EACpE,MAAM,CAAC,EAAE,WAAW,EAAE,OAAO,GAAE,uBAA4B,GAC1D,OAAO,CAAC,MAAM,CAAC;CA+EnB"}

package/dist/runtime/engineBrokerControlClient.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { createConnection } from "node:net";
-import { ENGINE_BROKER_VERSION, encodeEngineBrokerFrame, EngineBrokerFrameDecoder, parseEngineBrokerResponse } from "./engineBrokerProtocol.js";
+import { ENGINE_BROKER_VERSION, EngineBrokerProtocolMismatch, encodeEngineBrokerFrame, EngineBrokerFrameDecoder, parseEngineBrokerResponse, parseEngineBrokerSlot } from "./engineBrokerProtocol.js";
 import { ENGINE_BROKER_MCP_REFUSAL_REASONS } from "./engineBrokerMcpCallLog.js";
 /**
  * What the broker saw of the worker's MCP tool calls on a failed turn
@@ -25,23 +25,48 @@ export class EngineBrokerInferenceGrantRefused extends Error {
 }
 export class EngineBrokerControlClient {
     socketPath;
-    constructor(socketPath = "/run/daimon-engine-broker/control.sock") {
+    connect;
+    constructor(socketPath = "/run/daimon-engine-broker/control.sock", 
+    /** Internal transport seam; the production client always opens the Unix socket. */
+    connect = (path) => createConnection({ path })) {
         this.socketPath = socketPath;
+        this.connect = connect;
     }
-    async ready() { const requestId = randomUUID(), socket = createConnection({ path: this.socketPath }), decoder = new EngineBrokerFrameDecoder(); await new Promise((resolve, reject) => { let settled = false; const fail = () => { if (settled)
-        return; settled = true; socket.destroy(); reject(new Error("engine broker unavailable")); }; socket.once("error", fail); socket.once("close", fail); socket.once("connect", () => socket.write(encodeEngineBrokerFrame({ version: ENGINE_BROKER_VERSION, kind: "health", requestId }))); socket.on("data", (chunk) => { try {
-        for (const value of decoder.push(chunk)) {
-            const response = parseEngineBrokerResponse(value);
-            if (response.kind !== "ready" || response.requestId !== requestId || settled)
-                throw new Error();
-            settled = true;
-            socket.destroy();
-            resolve();
-        }
+    async ready() {
+        const requestId = randomUUID();
+        const socket = this.connect(this.socketPath);
+        const decoder = new EngineBrokerFrameDecoder();
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                socket.destroy();
+                reject(controlFailure(error));
+            };
+            socket.once("error", fail);
+            socket.once("close", fail);
+            socket.once("connect", () => socket.write(encodeEngineBrokerFrame({
+                version: ENGINE_BROKER_VERSION, kind: "health", requestId
+            })));
+            socket.on("data", (chunk) => {
+                try {
+                    for (const value of decoder.push(chunk)) {
+                        const response = parseEngineBrokerResponse(value);
+                        if (response.kind !== "ready" || response.requestId !== requestId || settled)
+                            throw new Error();
+                        settled = true;
+                        socket.destroy();
+                        resolve();
+                    }
+                }
+                catch (error) {
+                    fail(error);
+                }
+            });
+        });
     }
-    catch {
-        fail();
-    } }); }); }
     /**
      * Evaluator side (organization uid only; the native relay enforces it):
      * borrow the broker credential for one sequential lane of judge or optimizer
@@ -53,7 +78,7 @@ export class EngineBrokerControlClient {
         if (response.kind === "inference_grant_refused")
             throw new EngineBrokerInferenceGrantRefused(response.code);
         if (response.kind !== "inference_grant" || response.model !== request.model || response.reasoningEffort !== request.reasoningEffort || response.purpose !== request.purpose)
-            throw new Error("engine broker unavailable");
+            throw new Error(`engine broker unavailable (requires control protocol ${ENGINE_BROKER_VERSION})`);
         const { version: _version, kind: _kind, requestId: _requestId, ...grant } = response;
         return grant;
     }
@@ -62,33 +87,77 @@ export class EngineBrokerControlClient {
         if (response.kind === "inference_grant_refused")
             throw new EngineBrokerInferenceGrantRefused(response.code);
         if (response.kind !== "inference_grant_released" || response.grantId !== grantId)
-            throw new Error("engine broker unavailable");
+            throw new Error(`engine broker unavailable (requires control protocol ${ENGINE_BROKER_VERSION})`);
         return response.released;
     }
-    exchange(request) { const socket = createConnection({ path: this.socketPath }), decoder = new EngineBrokerFrameDecoder(); return new Promise((resolve, reject) => { let settled = false; const fail = () => { if (settled)
-        return; settled = true; socket.destroy(); reject(new Error("engine broker unavailable")); }; socket.once("error", fail); socket.once("close", fail); socket.once("connect", () => socket.write(encodeEngineBrokerFrame(request))); socket.on("data", (chunk) => { try {
-        for (const value of decoder.push(chunk)) {
-            const response = parseEngineBrokerResponse(value);
-            if (settled || response.requestId !== request.requestId || (response.kind !== "inference_grant" && response.kind !== "inference_grant_released" && response.kind !== "inference_grant_refused"))
-                throw new Error();
-            settled = true;
-            socket.destroy();
-            resolve(response);
-        }
+    async resetSlot(slot) {
+        const response = await this.exchange({ version: ENGINE_BROKER_VERSION, kind: "reset_slot", requestId: randomUUID(), slot: parseEngineBrokerSlot(slot) });
+        if (response.kind !== "slot_reset" || response.slot !== slot)
+            throw new Error("engine broker reset unavailable");
+    }
+    exchange(request) {
+        const socket = this.connect(this.socketPath);
+        const decoder = new EngineBrokerFrameDecoder();
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                socket.destroy();
+                reject(controlFailure(error));
+            };
+            socket.once("error", fail);
+            socket.once("close", fail);
+            socket.once("connect", () => socket.write(encodeEngineBrokerFrame(request)));
+            socket.on("data", (chunk) => {
+                try {
+                    for (const value of decoder.push(chunk)) {
+                        const response = parseEngineBrokerResponse(value);
+                        if (settled || response.requestId !== request.requestId ||
+                            (response.kind !== "inference_grant" && response.kind !== "inference_grant_released" &&
+                                response.kind !== "inference_grant_refused" && response.kind !== "slot_reset"))
+                            throw new Error();
+                        settled = true;
+                        socket.destroy();
+                        resolve(response);
+                    }
+                }
+                catch (error) {
+                    fail(error);
+                }
+            });
+        });
     }
-    catch {
-        fail();
-    } }); }); }
     async turn(agentId, wakeId, prompt, mcpEndpoint, signal, options = {}) {
-        const turnId = createHash("sha256").update(`${agentId}\0${wakeId}`).digest("hex"), requestId = randomUUID();
-        const request = { version: ENGINE_BROKER_VERSION, kind: "start_turn", requestId, turnId, agentId, wakeId, prompt, mcpEndpoint, ...(options.limits === undefined ? {} : { limits: options.limits }) };
-        const socket = createConnection({ path: this.socketPath });
+        const configured = process.env.DAIMON_ENGINE_BROKER_SLOT;
+        const slot = options.slot ?? (configured === undefined ? undefined : parseEngineBrokerSlot(/^(0|[1-9][0-9]*)$/u.test(configured) ? Number(configured) : NaN));
+        if (slot !== undefined)
+            parseEngineBrokerSlot(slot);
+        const turnId = createHash("sha256").update(`${slot === undefined ? "" : `${slot}\0`}${agentId}\0${wakeId}`).digest("hex");
+        const requestId = randomUUID();
+        const request = {
+            version: ENGINE_BROKER_VERSION, kind: "start_turn", requestId, turnId, agentId, wakeId, prompt, mcpEndpoint,
+            ...(slot === undefined ? {} : { slot }),
+            ...(options.limits === undefined ? {} : { limits: options.limits }),
+            ...(options.processClock === undefined ? {} : { processClock: options.processClock })
+        };
+        const socket = this.connect(this.socketPath);
         const decoder = new EngineBrokerFrameDecoder();
         return new Promise((resolve, reject) => {
-            let accepted = false, settled = false;
-            const fail = () => { if (settled)
-                return; settled = true; cleanup(); reject(new Error("engine broker unavailable")); };
-            const cleanup = () => { signal?.removeEventListener("abort", abort); socket.destroy(); };
+            let accepted = false;
+            let settled = false;
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(controlFailure(error));
+            };
+            const cleanup = () => {
+                signal?.removeEventListener("abort", abort);
+                socket.destroy();
+            };
             const abort = () => fail();
             signal?.addEventListener("abort", abort, { once: true });
             if (signal?.aborted)
@@ -98,7 +167,8 @@ export class EngineBrokerControlClient {
                 try {
                     for (const value of decoder.push(chunk)) {
                         const response = parseEngineBrokerResponse(value);
-                        if ((response.kind !== "accepted" && response.kind !== "completed" && response.kind !== "failed") || response.requestId !== requestId || response.turnId !== turnId)
+                        if ((response.kind !== "accepted" && response.kind !== "completed" && response.kind !== "failed") ||
+                            response.requestId !== requestId || response.turnId !== turnId)
                             throw new Error();
                         if (response.kind === "accepted") {
                             if (accepted)
@@ -110,18 +180,40 @@ export class EngineBrokerControlClient {
                             throw new Error();
                         settled = true;
                         cleanup();
+                        if (response.providerClock !== undefined) {
+                            try {
+                                options.onProviderClock?.(response.providerClock);
+                            }
+                            catch { /* Observation cannot discard a terminal result. */ }
+                        }
                         if (options.model !== undefined && response.model !== options.model) {
                             reject(new Error(`engine broker turn used model ${response.model}, not the declared ${options.model}`));
                             return;
                         }
-                        if (response.kind === "completed")
+                        if (response.kind === "completed") {
+                            if (response.cleanupDiagnostic !== undefined) {
+                                try {
+                                    console.warn(`daimon: engine broker ${response.cleanupDiagnostic}`);
+                                }
+                                catch {
+                                    // An operational warning must not discard completed work.
+                                }
+                            }
                             resolve(response.text);
-                        else
-                            reject(new Error(`engine broker turn failed (${response.code}${response.limitReason === "none" ? "" : `; limit=${response.limitReason}`}${response.diagnostic ? `; ${response.diagnostic.stage}/${response.diagnostic.failureClass}; exit=${response.diagnostic.exitCode}; signal=${response.diagnostic.termSignal}${response.diagnostic.reason === undefined ? "" : `; reason=${response.diagnostic.reason}`}` : ""}${renderMcpCalls(response.mcpCalls)})`));
+                        }
+                        else {
+                            const limit = response.limitReason === "none" ? "" : `; limit=${response.limitReason}`;
+                            const detail = response.diagnostic;
+                            const reason = detail?.reason === undefined ? "" : `; reason=${detail.reason}`;
+                            const diagnostic = detail === undefined ? "" :
+                                `; ${detail.stage}/${detail.failureClass}; exit=${detail.exitCode}; signal=${detail.termSignal}${reason}`;
+                            const cleanupDiagnostic = response.cleanupDiagnostic === undefined ? "" : `; ${response.cleanupDiagnostic}`;
+                            reject(new Error(`engine broker turn failed (${response.code}${limit}${diagnostic}${renderMcpCalls(response.mcpCalls)}${cleanupDiagnostic})`));
+                        }
                     }
                 }
-                catch {
-                    fail();
+                catch (error) {
+                    fail(error);
                 }
             });
             socket.once("error", fail);
@@ -130,3 +222,7 @@ export class EngineBrokerControlClient {
         });
     }
 }
+function controlFailure(error) {
+    return error instanceof EngineBrokerProtocolMismatch ? error :
+        new Error(`engine broker unavailable (requires control protocol ${ENGINE_BROKER_VERSION})`);
+}

package/dist/runtime/engineBrokerCredentialJournal.d.ts

@@ -4,7 +4,9 @@ export type BrokerCredentialJournal = Readonly<{
     generation: number;
     sourceDigest: string;
     promotedDigest?: string;
+    ancestorDigests?: readonly string[];
 }>;
+export declare const BROKER_CREDENTIAL_MAX_ANCESTORS = 900;
 export declare function parseBrokerCredentialJournal(value: unknown): BrokerCredentialJournal;
 export declare function recoverBrokerCredentialJournal(journal: BrokerCredentialJournal, authorityDigest: string): "ready" | "stale";
 //# sourceMappingURL=engineBrokerCredentialJournal.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"engineBrokerCredentialJournal.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerCredentialJournal.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAAE,OAAO,EAAE,8CAA8C,CAAC;IAAC,KAAK,EAAE,YAAY,GAAG,UAAU,GAAG,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAG3N,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,CAKpF;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAI3H"}
+{"version":3,"file":"engineBrokerCredentialJournal.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerCredentialJournal.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAAE,OAAO,EAAE,8CAA8C,CAAC;IAAC,KAAK,EAAE,YAAY,GAAG,UAAU,GAAG,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC,CAAC;AAEhQ,eAAO,MAAM,+BAA+B,MAAM,CAAC;AAGnD,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,CAWpF;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAI3H"}

package/dist/runtime/engineBrokerCredentialJournal.js

@@ -1,9 +1,18 @@
+// At most 61 KiB including the rest of the record; all readers allow 64 KiB.
+export const BROKER_CREDENTIAL_MAX_ANCESTORS = 900;
 const DIGEST = /^[a-f0-9]{64}$/u;
 export function parseBrokerCredentialJournal(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value))
         throw new TypeError("invalid credential journal");
     const input = value;
     const fields = input.state === "refreshing" ? ["version", "state", "generation", "sourceDigest"] : ["version", "state", "generation", "sourceDigest", "promotedDigest"];
+    if (Object.hasOwn(input, "ancestorDigests")) {
+        fields.push("ancestorDigests");
+        if (!Array.isArray(input.ancestorDigests) || input.ancestorDigests.length > BROKER_CREDENTIAL_MAX_ANCESTORS ||
+            input.ancestorDigests.some((entry) => typeof entry !== "string" || !DIGEST.test(entry)) ||
+            new Set(input.ancestorDigests).size !== input.ancestorDigests.length)
+            throw new TypeError("invalid credential journal");
+    }
     if (Object.keys(input).length !== fields.length || fields.some((key) => !Object.hasOwn(input, key)) || input.version !== "noopolis.daimon.broker-credential-journal.v1" || !["refreshing", "promoted", "stale"].includes(String(input.state)) || !Number.isSafeInteger(input.generation) || input.generation < 0 || !DIGEST.test(String(input.sourceDigest)) || (input.state !== "refreshing" && !DIGEST.test(String(input.promotedDigest))))
         throw new TypeError("invalid credential journal");
     return input;

package/dist/runtime/engineBrokerInferenceProtocol.d.ts

@@ -1,10 +1,11 @@
+import { GROK_ENGINE_BROKER } from "../contracts/runtimeContractManifest.js";
 import type { EngineBrokerTurnLimits } from "./engineBrokerTurnAccounting.js";
 import type { GrokBrokerModel, GrokBrokerReasoningEffort } from "./grokBrokerModelPolicy.js";
 import type { GrokInferencePurpose } from "./inferenceUsageLedger.js";
 export declare const ENGINE_BROKER_INFERENCE_FAILURE_CODES: readonly ["auth_stale", "grant_limit", "invalid_request", "unavailable"];
 export type EngineBrokerInferenceFailureCode = (typeof ENGINE_BROKER_INFERENCE_FAILURE_CODES)[number];
 export declare const GROK_INFERENCE_PROXY_BASE_URL: "http://127.0.0.1:43123/v1";
-type V = "noopolis.daimon.engine-broker.v2";
+type V = typeof GROK_ENGINE_BROKER.controlProtocolVersion;
 export type EngineBrokerInferenceRequest = Readonly<{
     version: V;
     kind: "request_inference_grant";
@@ -43,7 +44,7 @@ export type EngineBrokerInferenceResponse = Readonly<{
     code: EngineBrokerInferenceFailureCode;
 }>;
 type JsonRecord = Record<string, unknown>;
-/** `input` has already passed the v2 envelope checks; `requestId` is the parsed id. */
+/** `input` has already passed the current envelope checks; `requestId` is the parsed id. */
 export declare function parseEngineBrokerInferenceRequest(input: JsonRecord, requestId: string, version: V): EngineBrokerInferenceRequest;
 export declare function parseEngineBrokerInferenceResponse(input: JsonRecord, requestId: string, version: V): EngineBrokerInferenceResponse;
 export declare const isEngineBrokerInferenceRequestKind: (kind: unknown) => boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"engineBrokerInferenceProtocol.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerInferenceProtocol.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAC7F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAgBtE,eAAO,MAAM,qCAAqC,0EAAoB,CAAC;AACvE,MAAM,MAAM,gCAAgC,GAAG,CAAC,OAAO,qCAAqC,CAAC,CAAC,MAAM,CAAC,CAAC;AACtG,eAAO,MAAM,6BAA6B,6BAAyG,CAAC;AAEpJ,KAAK,CAAC,GAAG,kCAAkC,CAAC;AAC5C,MAAM,MAAM,4BAA4B,GACpC,QAAQ,CAAC;IAAE,OAAO,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,yBAAyB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,eAAe,CAAC;IAAC,eAAe,EAAE,yBAAyB,CAAC;IAAC,OAAO,EAAE,oBAAoB,CAAA;CAAE,CAAC,GAC/K,QAAQ,CAAC;IAAE,OAAO,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,yBAAyB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAClG,MAAM,MAAM,6BAA6B,GACrC,QAAQ,CAAC;IAAE,OAAO,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,6BAA6B,CAAC;IAAC,KAAK,EAAE,eAAe,CAAC;IAAC,eAAe,EAAE,yBAAyB,CAAC;IAAC,OAAO,EAAE,oBAAoB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,sBAAsB,CAAA;CAAE,CAAC,GACzS,QAAQ,CAAC;IAAE,OAAO,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,0BAA0B,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC,GACjH,QAAQ,CAAC;IAAE,OAAO,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,yBAAyB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,gCAAgC,CAAA;CAAE,CAAC,CAAC;AAEzH,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAO1C,uFAAuF;AACvF,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,4BAA4B,CAUhI;AAED,wBAAgB,kCAAkC,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,6BAA6B,CAoBlI;AAED,eAAO,MAAM,kCAAkC,GAAI,MAAM,OAAO,KAAG,OAAmF,CAAC;AACvJ,eAAO,MAAM,mCAAmC,GAAI,MAAM,OAAO,KAAG,OAAkH,CAAC"}
+{"version":3,"file":"engineBrokerInferenceProtocol.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerInferenceProtocol.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAC7F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAgBtE,eAAO,MAAM,qCAAqC,0EAAoB,CAAC;AACvE,MAAM,MAAM,gCAAgC,GAAG,CAAC,OAAO,qCAAqC,CAAC,CAAC,MAAM,CAAC,CAAC;AACtG,eAAO,MAAM,6BAA6B,6BAAyG,CAAC;AAEpJ,KAAK,CAAC,GAAG,OAAO,kBAAkB,CAAC,sBAAsB,CAAC;AAC1D,MAAM,MAAM,4BAA4B,GACpC,QAAQ,CAAC;IAAE,OAAO,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,yBAAyB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,eAAe,CAAC;IAAC,eAAe,EAAE,yBAAyB,CAAC;IAAC,OAAO,EAAE,oBAAoB,CAAA;CAAE,CAAC,GAC/K,QAAQ,CAAC;IAAE,OAAO,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,yBAAyB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAClG,MAAM,MAAM,6BAA6B,GACrC,QAAQ,CAAC;IAAE,OAAO,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,6BAA6B,CAAC;IAAC,KAAK,EAAE,eAAe,CAAC;IAAC,eAAe,EAAE,yBAAyB,CAAC;IAAC,OAAO,EAAE,oBAAoB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,sBAAsB,CAAA;CAAE,CAAC,GACzS,QAAQ,CAAC;IAAE,OAAO,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,0BAA0B,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC,GACjH,QAAQ,CAAC;IAAE,OAAO,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,yBAAyB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,gCAAgC,CAAA;CAAE,CAAC,CAAC;AAEzH,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAO1C,4FAA4F;AAC5F,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,4BAA4B,CAUhI;AAED,wBAAgB,kCAAkC,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,6BAA6B,CAoBlI;AAED,eAAO,MAAM,kCAAkC,GAAI,MAAM,OAAO,KAAG,OAAmF,CAAC;AACvJ,eAAO,MAAM,mCAAmC,GAAI,MAAM,OAAO,KAAG,OAAkH,CAAC"}

package/dist/runtime/engineBrokerInferenceProtocol.js

@@ -1,11 +1,11 @@
 import { GROK_BROKER_MODELS, GROK_BROKER_REASONING_EFFORTS } from "../contracts/grokWorkerContract.js";
 import { GROK_ENGINE_BROKER } from "../contracts/runtimeContractManifest.js";
 /**
- * Evaluator inference grant frames, additive kinds of control protocol v2.
+ * Evaluator inference grant frames, introduced in v2 and carried by current v3.
  *
  * Both ends ship in this package (the organization-side client and the broker
- * service), so the kinds join v2 without a version bump; a broker that
- * predates them refuses the unknown kind and closes the connection, which the
+ * service), the kinds originally joined v2 without a version bump. A broker that
+ * predates a kind refuses it and closes the connection, which the
  * client reports as `unavailable`. The native relay forwards frames opaquely
  * and admits only the organization uid on `control.sock` (`SO_PEERCRED`), so
  * that check is what limits grants to the evaluator side.
@@ -24,7 +24,7 @@ const member = (list, value) => { if (!list.includes(value))
 const grantId = (value) => { if (typeof value !== "string" || !/^[a-f0-9]{32}$/u.test(value))
     throw invalid(); return value; };
 const TOKEN = new RegExp(`^${SPEC.tokenPrefix}[A-Za-z0-9_-]{43}$`, "u");
-/** `input` has already passed the v2 envelope checks; `requestId` is the parsed id. */
+/** `input` has already passed the current envelope checks; `requestId` is the parsed id. */
 export function parseEngineBrokerInferenceRequest(input, requestId, version) {
     if (input.kind === "request_inference_grant") {
         exact(input, ["version", "kind", "requestId", "model", "reasoningEffort", "purpose"]);

package/dist/runtime/engineBrokerMcpCallLog.d.ts

@@ -132,6 +132,11 @@ export interface EngineBrokerMcpTunnelHandle {
     deliver(): void;
     close(): void;
 }
+/** Whether a turn has a tool call in flight, and when one last started or ended (the turn's registration before any). */
+export type EngineBrokerMcpActivity = Readonly<{
+    inFlight: number;
+    lastActivityAt: number;
+}>;
 export declare class EngineBrokerMcpCallLog {
     private readonly now;
     private readonly turns;
@@ -155,6 +160,12 @@ export declare class EngineBrokerMcpCallLog {
     refuse(turnId: string, reason: EngineBrokerMcpRefusalReason): void;
     /** A POST whose body the facade refused to read (over its own bound), which is a call it cannot name. */
     undecodable(turnId: string): void;
+    /**
+     * Tool-call activity only — never the GET tunnel, which stays open for the
+     * whole session whether or not anything happens. This is what an idle
+     * watchdog reads: a call in flight is work, an open tunnel is not.
+     */
+    activity(turnId: string): EngineBrokerMcpActivity | undefined;
     observe(turnId: string): EngineBrokerMcpCallObservation | undefined;
 }
 //# sourceMappingURL=engineBrokerMcpCallLog.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"engineBrokerMcpCallLog.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerMcpCallLog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iCAAiC,KAAK,CAAC;AACpD,eAAO,MAAM,8BAA8B,cAAc,CAAC;AAC1D,eAAO,MAAM,gCAAgC,gBAAgB,CAAC;AAC9D,mEAAmE;AACnE,eAAO,MAAM,2BAA2B,QAAsD,CAAC;AAG/F,qGAAqG;AACrG,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAE9C;;;;;;;GAOG;AACH,eAAO,MAAM,iCAAiC,qEAAsE,CAAC;AACrH,MAAM,MAAM,4BAA4B,GAAG,CAAC,OAAO,iCAAiC,CAAC,CAAC,MAAM,CAAC,CAAC;AAC9F,sKAAsK;AACtK,MAAM,MAAM,iCAAiC,GAAG,QAAQ,CAAC,MAAM,CAAC,4BAA4B,EAAE,MAAM,CAAC,CAAC,CAAC;AAEvG,MAAM,MAAM,8BAA8B,GAAG,QAAQ,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAC/F,6HAA6H;AAC7H,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC;AACzF;;;;GAIG;AACH,MAAM,MAAM,gCAAgC,GAAG,QAAQ,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,SAAS,yBAAyB,EAAE,CAAA;CAAE,CAAC,CAAC;AAC3J;;;;GAIG;AACH,MAAM,MAAM,8BAA8B,GAAG,QAAQ,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,SAAS,8BAA8B,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,gCAAgC,CAAC;IAAC,QAAQ,CAAC,EAAE,iCAAiC,CAAA;CAAE,CAAC,CAAC;AAElQ,kHAAkH;AAClH,MAAM,WAAW,yBAAyB;IAAG,MAAM,IAAI,IAAI,CAAC;IAAC,KAAK,IAAI,IAAI,CAAA;CAAE;AAE5E,qHAAqH;AACrH,MAAM,WAAW,2BAA2B;IAAG,OAAO,IAAI,IAAI,CAAC;IAAC,KAAK,IAAI,IAAI,CAAA;CAAE;AAY/E,qBAAa,sBAAsB;IAErB,OAAO,CAAC,QAAQ,CAAC,GAAG;IADhC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;gBACvB,GAAG,GAAE,MAAM,MAAiB;IAEzD,8FAA8F;IAC9F,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAC1B,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAE3B,qGAAqG;IACrG,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,SAAS,GAAG,yBAAyB;IA8B9E;;;;OAIG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,2BAA2B;IAavD;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,4BAA4B,GAAG,IAAI;IAElE,yGAAyG;IACzG,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAEjC,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,8BAA8B,GAAG,SAAS;CAmBpE"}
+{"version":3,"file":"engineBrokerMcpCallLog.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerMcpCallLog.ts"],"names":[],"mappings":"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"}

package/dist/runtime/engineBrokerMcpCallLog.js

@@ -97,7 +97,7 @@ export class EngineBrokerMcpCallLog {
         this.now = now;
     }
     /** A turn the facade registered. Re-opening an id resets it: a turn id is unique per turn. */
-    open(turnId) { this.turns.set(turnId, { started: 0, answered: 0, undecoded: 0, live: new Set(), ended: [], tunnelsOpened: 0, tunnelsClosed: 0, tunnelsDelivered: 0, openTunnels: new Set(), refusals: noRefusals() }); }
+    open(turnId) { this.turns.set(turnId, { started: 0, answered: 0, undecoded: 0, live: new Set(), ended: [], tunnelsOpened: 0, tunnelsClosed: 0, tunnelsDelivered: 0, openTunnels: new Set(), refusals: noRefusals(), activityAt: this.now() }); }
     close(turnId) { this.turns.delete(turnId); }
     /** A POST body the facade is about to relay. Anything that is not a `tools/call` records nothing. */
     begin(turnId, body) {
@@ -114,6 +114,7 @@ export class EngineBrokerMcpCallLog {
         const startedAt = this.now();
         const records = names.map((name) => ({ name, startedAt }));
         log.started += records.length;
+        log.activityAt = startedAt;
         for (const record of records)
             log.live.add(record);
         let settled = false;
@@ -122,6 +123,7 @@ export class EngineBrokerMcpCallLog {
                 if (settled)
                     return;
                 settled = true;
+                log.activityAt = this.now();
                 log.answered += records.length;
                 for (const record of records)
                     log.live.delete(record);
@@ -131,6 +133,7 @@ export class EngineBrokerMcpCallLog {
                     return;
                 settled = true;
                 const endedAt = this.now();
+                log.activityAt = endedAt;
                 for (const record of records) {
                     log.live.delete(record);
                     record.endedAt = endedAt;
@@ -172,6 +175,15 @@ export class EngineBrokerMcpCallLog {
     /** A POST whose body the facade refused to read (over its own bound), which is a call it cannot name. */
     undecodable(turnId) { const log = this.turns.get(turnId); if (log !== undefined)
         log.undecoded += 1; }
+    /**
+     * Tool-call activity only — never the GET tunnel, which stays open for the
+     * whole session whether or not anything happens. This is what an idle
+     * watchdog reads: a call in flight is work, an open tunnel is not.
+     */
+    activity(turnId) {
+        const log = this.turns.get(turnId);
+        return log === undefined ? undefined : { inFlight: log.live.size, lastActivityAt: log.activityAt };
+    }
     observe(turnId) {
         const log = this.turns.get(turnId);
         if (log === undefined)

package/dist/runtime/engineBrokerMcpFacade.d.ts

@@ -1,5 +1,5 @@
 import { type ServerResponse } from "node:http";
-import { type EngineBrokerMcpCallObservation } from "./engineBrokerMcpCallLog.js";
+import { type EngineBrokerMcpActivity, type EngineBrokerMcpCallObservation } from "./engineBrokerMcpCallLog.js";
 export declare const ENGINE_BROKER_MCP_FACADE_PORT = 43124;
 /** Requests one worker round may legitimately make: its `search_tool`, its `use_tool`, and one spare for a retry or a second discovery. */
 export declare const ENGINE_BROKER_MCP_ROUND_REQUESTS = 3;
@@ -25,10 +25,13 @@ export declare const ENGINE_BROKER_MCP_SESSION_REQUESTS = 5;
  * two multiplicands above each say what they are.
  */
 export declare const ENGINE_BROKER_MCP_CAPABILITY_REQUESTS: number;
+/** Fallback only: a brokered turn passes `engineBrokerCapabilityTtlMs(limits.timeoutMs)`. */
 export declare const ENGINE_BROKER_MCP_CAPABILITY_TTL_MS: number;
 export declare function startEngineBrokerMcpFacade(): Promise<{
-    register(agentId: string, turnId: string, endpoint: string): string;
+    register(agentId: string, turnId: string, endpoint: string, ttlMs?: number): string;
     revoke(turnId: string): void;
+    /** Tool-call activity for the broker's idle watchdog; `undefined` for a turn never registered. */
+    activity: (turnId: string) => EngineBrokerMcpActivity | undefined;
     /**
      * What the facade saw of this turn's tool calls, GET tunnels and refusals,
      * or `undefined` for a turn

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

@@ -1 +1 @@
-{"version":3,"file":"engineBrokerMcpFacade.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerMcpFacade.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsC,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAIpF,OAAO,EAA0B,KAAK,8BAA8B,EAAuE,MAAM,6BAA6B,CAAC;AA4C/K,eAAO,MAAM,6BAA6B,QAAS,CAAC;AAEpD,2IAA2I;AAC3I,eAAO,MAAM,gCAAgC,IAAI,CAAC;AAClD,uJAAuJ;AACvJ,eAAO,MAAM,kCAAkC,IAAI,CAAC;AACpD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,qCAAqC,QAAgG,CAAC;AACnJ,eAAO,MAAM,mCAAmC,QAAc,CAAC;AAI/D,wBAAsB,0BAA0B;sBA0G1B,MAAM,UAAU,MAAM,YAAY,MAAM,GAAG,MAAM;mBAQpD,MAAM,GAAG,IAAI;IAM5B;;;;OAIG;sBACe,MAAM,KAAG,8BAA8B,GAAG,SAAS;iBACpD,OAAO,CAAC,IAAI,CAAC;GAUjC;AAoED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAehG"}
+{"version":3,"file":"engineBrokerMcpFacade.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerMcpFacade.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsC,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAIpF,OAAO,EAA0B,KAAK,uBAAuB,EAAE,KAAK,8BAA8B,EAAuE,MAAM,6BAA6B,CAAC;AA4C7M,eAAO,MAAM,6BAA6B,QAAS,CAAC;AAEpD,2IAA2I;AAC3I,eAAO,MAAM,gCAAgC,IAAI,CAAC;AAClD,uJAAuJ;AACvJ,eAAO,MAAM,kCAAkC,IAAI,CAAC;AACpD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,qCAAqC,QAAgG,CAAC;AACnJ,6FAA6F;AAC7F,eAAO,MAAM,mCAAmC,QAAc,CAAC;AAI/D,wBAAsB,0BAA0B;sBA0G1B,MAAM,UAAU,MAAM,YAAY,MAAM,UAAS,MAAM,GAAyC,MAAM;mBAQzG,MAAM,GAAG,IAAI;IAM5B,kGAAkG;uBAC/E,MAAM,KAAG,uBAAuB,GAAG,SAAS;IAC/D;;;;OAIG;sBACe,MAAM,KAAG,8BAA8B,GAAG,SAAS;iBACpD,OAAO,CAAC,IAAI,CAAC;GAUjC;AAoED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAehG"}

package/dist/runtime/engineBrokerMcpFacade.js

@@ -70,6 +70,7 @@ export const ENGINE_BROKER_MCP_SESSION_REQUESTS = 5;
  * two multiplicands above each say what they are.
  */
 export const ENGINE_BROKER_MCP_CAPABILITY_REQUESTS = GROK_WORKER_MAX_TURNS * ENGINE_BROKER_MCP_ROUND_REQUESTS + ENGINE_BROKER_MCP_SESSION_REQUESTS;
+/** Fallback only: a brokered turn passes `engineBrokerCapabilityTtlMs(limits.timeoutMs)`. */
 export const ENGINE_BROKER_MCP_CAPABILITY_TTL_MS = 15 * 60_000;
 class FacadeRefusal extends Error {
 }
@@ -188,7 +189,7 @@ export async function startEngineBrokerMcpFacade() {
         server.listen(ENGINE_BROKER_MCP_FACADE_PORT, "127.0.0.1", () => { server.off("error", reject); resolve(); });
     });
     return {
-        register(agentId, turnId, endpoint) {
+        register(agentId, turnId, endpoint, ttlMs = ENGINE_BROKER_MCP_CAPABILITY_TTL_MS) {
             const url = new URL(endpoint);
             if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || url.pathname !== "/mcp")
                 throw new TypeError("invalid scoped MCP mount");
@@ -196,7 +197,7 @@ export async function startEngineBrokerMcpFacade() {
                 throw new Error("MCP turn already registered");
             targets.set(turnId, url.href);
             calls.open(turnId);
-            return capabilities.issue(agentId, turnId, ENGINE_BROKER_MCP_CAPABILITY_TTL_MS, ENGINE_BROKER_MCP_CAPABILITY_REQUESTS);
+            return capabilities.issue(agentId, turnId, ttlMs, ENGINE_BROKER_MCP_CAPABILITY_REQUESTS);
         },
         revoke(turnId) {
             targets.delete(turnId);
@@ -204,6 +205,8 @@ export async function startEngineBrokerMcpFacade() {
             endTurnStreams(turnId);
             calls.close(turnId);
         },
+        /** Tool-call activity for the broker's idle watchdog; `undefined` for a turn never registered. */
+        activity: (turnId) => calls.activity(turnId),
         /**
          * What the facade saw of this turn's tool calls, GET tunnels and refusals,
          * or `undefined` for a turn

package/dist/runtime/engineBrokerNativeClient.js

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { spawnRealTime as spawn } from "./taskClockProcess.js";
 import { redactCredentialText } from "../core/credentialRedaction.js";
 import { boundedDiagnosticWindow, CLI_ENGINE_MAX_DIAGNOSTIC_BYTES } from "../pi/cliChildOutput.js";
 import { terminateChild, trackCliChild } from "../pi/cliProcess.js";
@@ -19,7 +19,7 @@ export class NativeBrokerTurnFailure extends Error {
     }
 }
 export async function runNativeBrokerTurn(executable, input, signal) {
-    const frame = encodeNativeBrokerTurn(input), child = trackCliChild(spawn(executable, ["--client"], { detached: process.platform !== "win32", env: { LANG: "C", LC_ALL: "C", TZ: "UTC" }, stdio: ["pipe", "pipe", "ignore"], ...(signal === undefined ? {} : { signal }) }));
+    const frame = encodeNativeBrokerTurn(input), child = trackCliChild(spawn(executable, ["--client"], { detached: process.platform !== "win32", env: { LANG: "C", LC_ALL: "C", TZ: "UTC", DAIMON_BROKER_PID: String(process.pid) }, stdio: ["pipe", "pipe", "ignore"], ...(signal === undefined ? {} : { signal }) }));
     const chunks = [];
     let bytes = 0;
     child.stdout.on("data", (chunk) => { bytes += chunk.length; if (bytes <= ENGINE_BROKER_NATIVE_RESULT_BYTES + MAX_OUTPUT)