@makaio/client-codex 1.0.0-dev-1789609124644 → 1.0.0-dev-1790087128488

package/dist/{codex-client-session-service-CsIoRrhH.mjs → codex-client-session-service-uk6l5Kri.mjs}

@@ -1,6 +1,6 @@
 import { codexCapabilityMap, createClientDefinition } from "@makaio/framework/contracts";
 import { z } from "zod";
-import { AbsolutePathSchema, BinaryNotFoundError, ClientSubjects, ClientWiringApplyResponseSchema, ClientWiringListResponseSchema, ClientWiringRemoveResponseSchema, DEFAULT_HOOK_HANDLE_TIMEOUT_MS, NOOP_HOOK_HANDLE_RESPONSE, assertAbsoluteProjectDir, atomicModifyFile, buildClientCommand, buildHookCommand, collectContributions, createClientNamespace, deriveSessionEventDescriptors, pickNonEmptyString } from "@makaio/framework/clients";
+import { AbsolutePathSchema, BinaryNotFoundError, ClientSubjects, ClientWiringApplyResponseSchema, ClientWiringListResponseSchema, ClientWiringRemoveResponseSchema, DEFAULT_HOOK_HANDLE_TIMEOUT_MS, NOOP_HOOK_HANDLE_RESPONSE, assertAbsoluteProjectDir, atomicModifyFile, buildClientCommand, buildHookCommand, collectContributions, createClientNamespace, deriveSessionEventDescriptors, pickNonEmptyString, pickNonEmptyStringValue } from "@makaio/framework/clients";
 import { MakaioBus, RequestError } from "@makaio/framework/bus";
 import { BaseService } from "@makaio/framework/service-base";
 import * as fs$1 from "node:fs/promises";
@@ -10,7 +10,7 @@ import path from "node:path";
 import * as os$1 from "node:os";
 import os from "node:os";
 import { createHash, randomUUID } from "node:crypto";
-import { CLIENT_SESSION_COMPACTION_TRIGGERS, ClientConfigPrimeSchema, SessionConfigSetupRequestSchema, SessionConfigSetupResponseSchema, SessionConfigTeardownRequestSchema, SessionConfigTeardownResponseSchema } from "@makaio/framework/contracts/client";
+import { CANONICAL_HOOK_RESPONSE_CAPABILITIES, CLIENT_SESSION_COMPACTION_TRIGGERS, ClientConfigPrimeSchema, SessionConfigSetupRequestSchema, SessionConfigSetupResponseSchema, SessionConfigTeardownRequestSchema, SessionConfigTeardownResponseSchema } from "@makaio/framework/contracts/client";
 import { isDeepStrictEqual } from "node:util";
 import { parse } from "smol-toml";
 import { lock } from "proper-lockfile";
@@ -1490,6 +1490,7 @@ function normalizeCodexHook(raw, machineId) {
 
 //#endregion
 //#region src/runtime/hook-response-contracts.ts
+/** Codex 0.144.1 synchronous hook-response contract. @packageDocumentation */
 const CODEX_CLIENT_ID = "codex";
 const CODEX_CONTRACT_ID = "openai.codex-hook-response";
 /**
@@ -1505,8 +1506,15 @@ const CODEX_CONTRACT_ID = "openai.codex-hook-response";
 * Subagent creation cannot be refused (`continue: false` is parsed for
 * compatibility but does not stop the subagent), so the interaction is
 * non-blockable. Purely additive: every `1.1.0` contributor remains valid.
+*
+* `1.3.0` adds the canonical `session.token` interaction to the catalog. The
+* definition does not declare it on any Codex event yet (Codex hands its MCP
+* subprocesses no session id). When declared, the composer collects the token
+* and hands it to the in-process token sink of the client runtime; it is never
+* rendered to the client binary's stdout. Purely additive: every `1.2.0`
+* contributor remains valid.
 */
-const CODEX_CONTRACT_VERSION = "1.2.0";
+const CODEX_CONTRACT_VERSION = "1.3.0";
 /**
 * Build a frozen Codex provider envelope.
 * @param effects - Provider-native effect record.
@@ -1630,6 +1638,7 @@ function createCodexStopBlockEffect(reason) {
 }
 const CODEX_RESPONSE_CAPABILITIES = Object.freeze([
 	"context.append",
+	CANONICAL_HOOK_RESPONSE_CAPABILITIES.sessionToken,
 	CODEX_HOOK_RESPONSE_CAPABILITIES.block,
 	CODEX_HOOK_RESPONSE_CAPABILITIES.permissionDeny,
 	CODEX_HOOK_RESPONSE_CAPABILITIES.inputUpdate
@@ -1742,6 +1751,22 @@ const codexProviderContractCatalog = Object.freeze({
 function capabilities(eventName) {
 	return clientDefinition.runtimeCapabilities.hookEvents.find((event) => event.name === eventName)?.responseCapabilities ?? [];
 }
+/**
+* Extract the winning `session.token` value from the ordered effects array.
+*
+* Effects arrive in priority-descending order (highest-priority contributor
+* first), so the first matching `session.token` effect is the winner. When the
+* event does not declare the `session.token` capability the effect is dropped
+* and `undefined` is returned — this ensures the token is only collected when
+* the contributor explicitly targeted an event that supports it.
+* @param eventName - Native Codex hook event name.
+* @param effects - Deterministically ordered effects (priority-desc).
+* @returns The winning token value, or `undefined` when absent or not supported.
+*/
+function extractSessionToken(eventName, effects) {
+	if (!capabilities(eventName).includes(CANONICAL_HOOK_RESPONSE_CAPABILITIES.sessionToken)) return void 0;
+	for (const effect of effects) if ("kind" in effect && effect.kind === "session.token") return effect.value;
+}
 const FIRST_BLOCK_EVENTS = new Set([
 	CODEX_HOOK_SESSION_START,
 	CODEX_HOOK_USER_PROMPT_SUBMIT,
@@ -1869,10 +1894,44 @@ function renderCodexNativeResponse(eventName, effects) {
 	return serialize({ hookSpecificOutput });
 }
 /**
+* Derive the session-token storage scope for a Codex hook event.
+*
+* `SubagentStart` requires a non-empty `agent_id` in the payload.  The hook
+* normalizers that feed this composer reject subagent events without an id,
+* so a missing id signals a malformed event.  Forwarding without an `agentId`
+* would store the token under the parent session key and overwrite it; the
+* sink is skipped instead (returns `undefined`).
+*
+* `SessionStart` and every other event are always session-scoped.  Even when
+* a stray `agent_id` appears in the payload it is never adopted — doing so
+* would create a spurious subagent-scoped entry.
+* @param eventName - Codex hook event name.
+* @param rawPayload - The inner `payload` object from the hook envelope.
+* @returns Scope to forward to the token sink, or `undefined` to skip it.
+*/
+function resolveSessionTokenScope(eventName, rawPayload) {
+	const adapterSessionId = pickNonEmptyString(rawPayload, "session_id") ?? pickNonEmptyString(rawPayload, "thread_id");
+	if (adapterSessionId === void 0) return void 0;
+	if (eventName === "SubagentStart") {
+		const agentId = pickNonEmptyString(rawPayload, "agent_id");
+		if (agentId === void 0) return void 0;
+		return {
+			clientId: "codex",
+			adapterSessionId,
+			agentId
+		};
+	}
+	return {
+		clientId: "codex",
+		adapterSessionId
+	};
+}
+/**
 * Compose one terminal Codex native hook response.
 * @param registry - Active response contributor registry.
 * @param payload - Normalized native hook payload.
-* @param options - Request deadline, cancellation, and diagnostics hooks.
+* @param options - Request deadline, cancellation, diagnostics hooks, and
+*   optional session-token sink.
 * @returns The composed native response envelope.
 */
 async function composeCodexHookResponse(registry, payload, options) {
@@ -1888,7 +1947,13 @@ async function composeCodexHookResponse(registry, payload, options) {
 			reason: result.closedFailure.detail
 		}
 	}]);
-	return renderCodexNativeResponse(payload.eventName, result.outcomes.flatMap((outcome) => outcome.effects ?? []));
+	const effects = result.outcomes.flatMap((outcome) => outcome.effects ?? []);
+	const token = extractSessionToken(payload.eventName, effects);
+	if (token !== void 0 && options?.onSessionToken !== void 0) {
+		const scope = resolveSessionTokenScope(payload.eventName, payload.payload);
+		if (scope !== void 0) await options.onSessionToken(token, scope);
+	}
+	return renderCodexNativeResponse(payload.eventName, effects);
 }
 
 //#endregion
@@ -2987,8 +3052,10 @@ const CODEX_HOOK_HANDLE_COMMAND_SENTINEL = "hook handle codex";
 /**
 * Timeout for request-mode hooks on context-only (non-blockable) interactions.
 *
-* `hook handle` has no `--debounce-failure`, so a down server would stall every
-* prompt and subagent spawn for the full timeout; context-only hooks fail fast.
+* Request-mode hooks carry `--debounce-failure`, so a down server is detected
+* quickly and cool-down suppression kicks in for subsequent invocations.
+* Context-only hooks still fail fast (1 s) to bound the overhead on each prompt
+* or subagent spawn when the bus is genuinely unreachable.
 * Blockable interactions retain {@link DEFAULT_HOOK_HANDLE_TIMEOUT_MS} because
 * those must complete before the native client can proceed.
 */
@@ -3118,6 +3185,7 @@ function buildModeCommand(makaioCommand, eventName, mode) {
 	const timeoutMs = CODEX_INTERACTION_BLOCKABILITY.some((entry) => entry.interaction === eventName && entry.blockable) ? DEFAULT_HOOK_HANDLE_TIMEOUT_MS : CONTEXT_ONLY_HOOK_HANDLE_TIMEOUT_MS;
 	return buildClientCommand(makaioCommand, [
 		"--no-launch",
+		"--debounce-failure",
 		...CODEX_HOOK_HANDLE_COMMAND_SENTINEL.split(" "),
 		eventName,
 		"--timeout",
@@ -3226,6 +3294,15 @@ var CodexClientSessionService = class extends BaseService {
 	providerContractRegistry;
 	hookResponseRegistry;
 	/**
+	* In-process sink for session correlation tokens.
+	*
+	* When non-undefined, the {@link onSessionToken} callback hands the token
+	* directly to this sink so no bus payload (and no `MAKAIO_DEBUG` bus logger)
+	* ever sees the token value. Codex declares no session-token capability, so
+	* this will typically remain `undefined`.
+	*/
+	sessionTokens;
+	/**
 	* Creates a new Codex client session service.
 	* @param bus - Bus instance used for subscribing and emitting events
 	* @param settings - Optional {@link CodexClientSettings} instance for tests
@@ -3239,14 +3316,20 @@ var CodexClientSessionService = class extends BaseService {
 	*   from clients-core for registering the Codex hook response contract.
 	*   Omit in tests that do not exercise the response pipeline.
 	* @param hookResponseRegistry - Optional contributor registry used by the terminal composer.
+	* @param sessionTokens - In-process token sink from clients-core. When
+	*   supplied, the {@link onSessionToken} callback hands the token directly
+	*   to the sink — no bus payload (and no `MAKAIO_DEBUG` bus logger) ever
+	*   sees the token value. Codex declares no session-token capability, so
+	*   this will typically be `undefined`.
 	*/
-	constructor(bus = MakaioBus, settings, machineId, sessionConfigHandler = new CodexSessionConfigHandler(), providerContractRegistry, hookResponseRegistry) {
+	constructor(bus = MakaioBus, settings, machineId, sessionConfigHandler = new CodexSessionConfigHandler(), providerContractRegistry, hookResponseRegistry, sessionTokens) {
 		super(bus);
 		this.settingsOverride = settings;
 		this.machineId = machineId;
 		this.sessionConfigHandler = sessionConfigHandler;
 		this.providerContractRegistry = providerContractRegistry;
 		this.hookResponseRegistry = hookResponseRegistry;
+		this.sessionTokens = sessionTokens;
 	}
 	/**
 	* Register the raw hook ingress handler, the `hook.handle` request handler,
@@ -3343,7 +3426,10 @@ var CodexClientSessionService = class extends BaseService {
 			return composeCodexHookResponse(this.hookResponseRegistry, ctx.payload, {
 				deadline: ctx.deadline,
 				signal: ctx.signal,
-				onDiagnostics: (diagnostics) => diagnostics.forEach((diagnostic) => console.warn(`[CodexClientSessionService] Hook contributor '${diagnostic.contributorId}': ${diagnostic.message}`))
+				onDiagnostics: (diagnostics) => diagnostics.forEach((diagnostic) => console.warn(`[CodexClientSessionService] Hook contributor '${diagnostic.contributorId}': ${diagnostic.message}`)),
+				onSessionToken: (token, scope) => {
+					this.sessionTokens?.record(scope, token);
+				}
 			}).then((response) => ctx.setResult(response));
 		});
 	}
@@ -3433,6 +3519,7 @@ var CodexClientSessionService = class extends BaseService {
 	*/
 	async handleHookReceived(raw) {
 		const events = normalizeCodexHook(raw, this.machineId);
+		await this.observeRootRuntime(raw, events);
 		if (events.length === 0 && (raw.eventName === "SubagentStart" || raw.eventName === "SubagentStop")) console.warn(`[CodexClientSessionService] ${raw.eventName} hook produced no normalized events — agent_id is likely absent. The hook remains raw-only on client:codex.*.`);
 		const sharedAdapterSessionId = events[0]?.payload.adapterSessionId;
 		const isManagedSession = this.isAdapterManagedSession(sharedAdapterSessionId);
@@ -3484,6 +3571,38 @@ var CodexClientSessionService = class extends BaseService {
 		if (firstError !== void 0) throw firstError;
 	}
 	/**
+	* Enrich a supervisor-owned Codex runtime with the native session ID observed
+	* on its root `SessionStart` hook.
+	*
+	* Subagent hooks never produce `client.session.started`, so they cannot bind
+	* a root runtime. The supervisor correlation key joins observations; it does
+	* not grant ownership of an arbitrary native session.
+	* @param raw - Raw hook payload delivered on `client:codex.hook.received`.
+	* @param events - Normalized events derived from the raw hook.
+	*/
+	async observeRootRuntime(raw, events) {
+		if (raw.eventName !== "SessionStart") return;
+		const supervisorSessionId = pickNonEmptyStringValue(raw.metadata?.supervisorSessionId);
+		const rootStart = events.find((event) => event.subject === ClientSubjects.session.started);
+		const adapterSessionId = rootStart?.payload.adapterSessionId;
+		if (supervisorSessionId === void 0 || rootStart === void 0 || adapterSessionId === void 0) return;
+		try {
+			if (!(await this.bus.requestOptional(ClientSubjects.runtime.observe, {
+				clientId: CLIENT_ID,
+				source: {
+					layer: "client-hook",
+					producer: "codex-client-session-service"
+				},
+				observedAt: raw.receivedAt,
+				supervisorSessionId,
+				adapterSessionId,
+				...rootStart.payload.startMode === "clear" && { adapterSessionTransition: "root-clear" }
+			})).handled) console.warn("[CodexClientSessionService] Runtime identity join is unavailable.");
+		} catch {
+			console.warn("[CodexClientSessionService] Runtime identity join is unavailable.");
+		}
+	}
+	/**
 	* Determine whether a normalized native hook belongs to an adapter-managed
 	* session whose global observed-semantics events are already emitted by the
 	* adapter layer.

package/dist/definition.d.ts

@@ -86,6 +86,7 @@ export declare const clientDefinition: {
             name: string;
             frameworkSubject?: string | undefined;
             responseCapabilities: readonly string[];
+            minimumVersion?: string | undefined;
         }[];
     };
     managedInstall?: {

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { A as CodexConfigHooksAddResponseSchema, B as CodexScopeHookRecordSchema, D as CodexWiringSchemas, F as CodexConfigSchemas, I as CodexHookEntrySchema, L as CodexNativeCommandHookSchema, M as CodexConfigHooksListResponseSchema, N as CodexConfigHooksRemoveRequestSchema, O as AbsolutePathSchema, P as CodexConfigHooksRemoveResponseSchema, R as CodexNativeHookMatcherGroupSchema, U as clientDefinition, V as CodexScopeSchema, j as CodexConfigHooksListRequestSchema, k as CodexConfigHooksAddRequestSchema, o as CodexClientSubjects, t as CodexClientSessionService, z as CodexNativeHooksFileSchema } from "./codex-client-session-service-CsIoRrhH.mjs";
-import { t as codexPackage } from "./src-osBCBvw6.mjs";
+import { A as CodexConfigHooksAddResponseSchema, B as CodexScopeHookRecordSchema, D as CodexWiringSchemas, F as CodexConfigSchemas, I as CodexHookEntrySchema, L as CodexNativeCommandHookSchema, M as CodexConfigHooksListResponseSchema, N as CodexConfigHooksRemoveRequestSchema, O as AbsolutePathSchema, P as CodexConfigHooksRemoveResponseSchema, R as CodexNativeHookMatcherGroupSchema, U as clientDefinition, V as CodexScopeSchema, j as CodexConfigHooksListRequestSchema, k as CodexConfigHooksAddRequestSchema, o as CodexClientSubjects, t as CodexClientSessionService, z as CodexNativeHooksFileSchema } from "./codex-client-session-service-uk6l5Kri.mjs";
+import { t as codexPackage } from "./src-CoiDO0ce.mjs";
 
 export { AbsolutePathSchema, CodexClientSessionService, CodexClientSubjects, CodexConfigHooksAddRequestSchema, CodexConfigHooksAddResponseSchema, CodexConfigHooksListRequestSchema, CodexConfigHooksListResponseSchema, CodexConfigHooksRemoveRequestSchema, CodexConfigHooksRemoveResponseSchema, CodexConfigSchemas, CodexHookEntrySchema, CodexNativeCommandHookSchema, CodexNativeHookMatcherGroupSchema, CodexNativeHooksFileSchema, CodexScopeHookRecordSchema, CodexScopeSchema, CodexWiringSchemas, clientDefinition, codexPackage };

package/dist/runtime/codex-client-session-service.d.ts

@@ -39,7 +39,7 @@
  * @packageDocumentation
  */
 import type { IMakaioBus } from '@makaio/framework/bus';
-import type { ClientHookProviderContractRegistry, ClientHookResponseRegistry } from '@makaio/framework/clients';
+import type { ClientHookProviderContractRegistry, ClientHookResponseRegistry, ClientSessionTokenSink } from '@makaio/framework/clients';
 import { BaseService } from '@makaio/framework/service-base';
 import { CodexClientSettings } from './client-settings.js';
 import { CodexSessionConfigHandler } from './session-config-handler.js';
@@ -108,6 +108,15 @@ export declare class CodexClientSessionService extends BaseService {
      */
     private readonly providerContractRegistry;
     private readonly hookResponseRegistry;
+    /**
+     * In-process sink for session correlation tokens.
+     *
+     * When non-undefined, the {@link onSessionToken} callback hands the token
+     * directly to this sink so no bus payload (and no `MAKAIO_DEBUG` bus logger)
+     * ever sees the token value. Codex declares no session-token capability, so
+     * this will typically remain `undefined`.
+     */
+    private readonly sessionTokens;
     /**
      * Creates a new Codex client session service.
      * @param bus - Bus instance used for subscribing and emitting events
@@ -122,8 +131,13 @@ export declare class CodexClientSessionService extends BaseService {
      *   from clients-core for registering the Codex hook response contract.
      *   Omit in tests that do not exercise the response pipeline.
      * @param hookResponseRegistry - Optional contributor registry used by the terminal composer.
+     * @param sessionTokens - In-process token sink from clients-core. When
+     *   supplied, the {@link onSessionToken} callback hands the token directly
+     *   to the sink — no bus payload (and no `MAKAIO_DEBUG` bus logger) ever
+     *   sees the token value. Codex declares no session-token capability, so
+     *   this will typically be `undefined`.
      */
-    constructor(bus?: IMakaioBus, settings?: CodexClientSettings, machineId?: string, sessionConfigHandler?: CodexSessionConfigHandler, providerContractRegistry?: ClientHookProviderContractRegistry, hookResponseRegistry?: ClientHookResponseRegistry);
+    constructor(bus?: IMakaioBus, settings?: CodexClientSettings, machineId?: string, sessionConfigHandler?: CodexSessionConfigHandler, providerContractRegistry?: ClientHookProviderContractRegistry, hookResponseRegistry?: ClientHookResponseRegistry, sessionTokens?: ClientSessionTokenSink);
     /**
      * Register the raw hook ingress handler, the `hook.handle` request handler,
      * config management request handlers, wiring management request handlers,
@@ -185,6 +199,7 @@ export declare class CodexClientSessionService extends BaseService {
      */
     private handleRuntimeStarted;
     private handleHookReceived;
+    private observeRootRuntime;
     /**
      * Determine whether a normalized native hook belongs to an adapter-managed
      * session whose global observed-semantics events are already emitted by the

package/dist/runtime/hook-response-composer.d.ts

@@ -5,6 +5,29 @@ export interface ComposeCodexHookResponseOptions {
     readonly deadline?: number;
     readonly signal?: AbortSignal;
     readonly onDiagnostics?: (diagnostics: readonly CollectionDiagnostic[]) => void;
+    /**
+     * Receives a `session.token` effect for the runtime to record; never
+     * rendered to the client binary's stdout. When several contributors deliver
+     * a token, the highest-priority contributor wins (first in the
+     * deterministically ordered effects array). Omit when token recording is not
+     * required.
+     *
+     * The sink is skipped (not called) when:
+     * - Both `session_id` and `thread_id` are absent from the payload.
+     * - The event is `SubagentStart` and `agent_id` is absent or empty —
+     *   forwarding without an agent id would overwrite the parent session entry.
+     *
+     * For `SessionStart` and all other events, `agent_id` is ignored even when
+     * present in the payload.
+     * @param token - Opaque correlation token value.
+     * @param scope - Client id, adapter session id, and optional agent id for
+     *   SubagentStart. The client id is always `'codex'` from this composer.
+     */
+    readonly onSessionToken?: (token: string, scope: {
+        clientId: string;
+        adapterSessionId: string;
+        agentId?: string;
+    }) => void | Promise<void>;
 }
 /**
  * Reduce ordered effects into one provider-valid Codex response.
@@ -22,7 +45,8 @@ export declare function renderCodexNativeResponse(eventName: string, effects: re
  * Compose one terminal Codex native hook response.
  * @param registry - Active response contributor registry.
  * @param payload - Normalized native hook payload.
- * @param options - Request deadline, cancellation, and diagnostics hooks.
+ * @param options - Request deadline, cancellation, diagnostics hooks, and
+ *   optional session-token sink.
  * @returns The composed native response envelope.
  */
 export declare function composeCodexHookResponse(registry: ClientHookResponseRegistry, payload: RawClientHookPayload, options?: ComposeCodexHookResponseOptions): Promise<ClientHookHandleResponse>;

package/dist/runtime/hook-response-contracts.d.ts

@@ -1,4 +1,3 @@
-/** Codex 0.144.1 synchronous hook-response contract. @packageDocumentation */
 import type { InteractionBlockability, ProviderContractCatalogEntry, ProviderContributionEnvelope } from '@makaio/framework/contracts/client';
 export declare const CODEX_CLIENT_ID = "codex";
 export declare const CODEX_CONTRACT_ID = "openai.codex-hook-response";
@@ -15,8 +14,15 @@ export declare const CODEX_CONTRACT_ID = "openai.codex-hook-response";
  * Subagent creation cannot be refused (`continue: false` is parsed for
  * compatibility but does not stop the subagent), so the interaction is
  * non-blockable. Purely additive: every `1.1.0` contributor remains valid.
+ *
+ * `1.3.0` adds the canonical `session.token` interaction to the catalog. The
+ * definition does not declare it on any Codex event yet (Codex hands its MCP
+ * subprocesses no session id). When declared, the composer collects the token
+ * and hands it to the in-process token sink of the client runtime; it is never
+ * rendered to the client binary's stdout. Purely additive: every `1.2.0`
+ * contributor remains valid.
  */
-export declare const CODEX_CONTRACT_VERSION = "1.2.0";
+export declare const CODEX_CONTRACT_VERSION = "1.3.0";
 export type CodexBlockEffects = Readonly<{
     decision: 'block';
     reason: string;

package/dist/runtime/package.mjs

@@ -1,4 +1,4 @@
-import { C as createCodexStopBlockEffect, E as normalizeCodexHook, H as CODEX_HOOK_RESPONSE_CAPABILITIES, S as createCodexSessionStartContextEffect, T as createCodexUserPromptSubmitContextEffect, _ as createCodexPreToolUseBlockEffect, a as CODEX_CLIENT_NAMESPACE, b as createCodexPreToolUseUpdateEffect, c as CODEX_CLIENT_ID, d as CODEX_INTERACTION_BLOCKABILITY, f as CODEX_RESPONSE_CAPABILITIES, g as createCodexPostToolUseContextEffect, h as createCodexPostToolUseBlockEffect, i as withCodexNativeAuthSourceLock, l as CODEX_CONTRACT_ID, m as codexProviderContractCatalog, n as buildCodexNativeAuthSourceLockPath, o as CodexClientSubjects, p as CODEX_SUPPORTED_INTERACTIONS, r as executeCodexNativeAuthSourceLock, s as composeCodexHookResponse, t as CodexClientSessionService, u as CODEX_CONTRACT_VERSION, v as createCodexPreToolUseContextEffect, w as createCodexUserPromptSubmitBlockEffect, x as createCodexSessionStartBlockEffect, y as createCodexPreToolUseDenyEffect } from "../codex-client-session-service-CsIoRrhH.mjs";
+import { C as createCodexStopBlockEffect, E as normalizeCodexHook, H as CODEX_HOOK_RESPONSE_CAPABILITIES, S as createCodexSessionStartContextEffect, T as createCodexUserPromptSubmitContextEffect, _ as createCodexPreToolUseBlockEffect, a as CODEX_CLIENT_NAMESPACE, b as createCodexPreToolUseUpdateEffect, c as CODEX_CLIENT_ID, d as CODEX_INTERACTION_BLOCKABILITY, f as CODEX_RESPONSE_CAPABILITIES, g as createCodexPostToolUseContextEffect, h as createCodexPostToolUseBlockEffect, i as withCodexNativeAuthSourceLock, l as CODEX_CONTRACT_ID, m as codexProviderContractCatalog, n as buildCodexNativeAuthSourceLockPath, o as CodexClientSubjects, p as CODEX_SUPPORTED_INTERACTIONS, r as executeCodexNativeAuthSourceLock, s as composeCodexHookResponse, t as CodexClientSessionService, u as CODEX_CONTRACT_VERSION, v as createCodexPreToolUseContextEffect, w as createCodexUserPromptSubmitBlockEffect, x as createCodexSessionStartBlockEffect, y as createCodexPreToolUseDenyEffect } from "../codex-client-session-service-uk6l5Kri.mjs";
 import { dep } from "@makaio/framework/contracts";
 import { ClientsCoreToken } from "@makaio/framework/clients";
 
@@ -44,7 +44,7 @@ const codexClientRuntimePackage = {
 	create: (ctx) => {
 		const clientsCore = ctx.getService(ClientsCoreToken);
 		if (!clientsCore) throw new Error("codex.runtime requires makaio.clients-core");
-		return new CodexClientSessionService(ctx.bus, void 0, ctx.machineId, void 0, clientsCore.providerContractRegistry, clientsCore.hookResponseRegistry);
+		return new CodexClientSessionService(ctx.bus, void 0, ctx.machineId, void 0, clientsCore.providerContractRegistry, clientsCore.hookResponseRegistry, clientsCore.sessionTokens);
 	}
 };
 

package/dist/runtime/wiring.d.ts

@@ -46,8 +46,10 @@ export declare const CODEX_HOOK_HANDLE_COMMAND_SENTINEL = "hook handle codex";
 /**
  * Timeout for request-mode hooks on context-only (non-blockable) interactions.
  *
- * `hook handle` has no `--debounce-failure`, so a down server would stall every
- * prompt and subagent spawn for the full timeout; context-only hooks fail fast.
+ * Request-mode hooks carry `--debounce-failure`, so a down server is detected
+ * quickly and cool-down suppression kicks in for subsequent invocations.
+ * Context-only hooks still fail fast (1 s) to bound the overhead on each prompt
+ * or subagent spawn when the bus is genuinely unreachable.
  * Blockable interactions retain {@link DEFAULT_HOOK_HANDLE_TIMEOUT_MS} because
  * those must complete before the native client can proceed.
  */

package/dist/server.mjs

@@ -1,4 +1,4 @@
-import { t as codexPackage } from "./src-osBCBvw6.mjs";
+import { t as codexPackage } from "./src-CoiDO0ce.mjs";
 import { codexClientRuntimePackage } from "./runtime/package.mjs";
 
 //#region src/server.ts

package/dist/{src-osBCBvw6.mjs → src-CoiDO0ce.mjs}

@@ -1,4 +1,4 @@
-import { U as clientDefinition } from "./codex-client-session-service-CsIoRrhH.mjs";
+import { U as clientDefinition } from "./codex-client-session-service-uk6l5Kri.mjs";
 
 //#region src/package.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makaio/client-codex",
-  "version": "1.0.0-dev-1789609124644",
+  "version": "1.0.0-dev-1790087128488",
   "type": "module",
   "main": "dist/index.mjs",
   "exports": {