@makaio/client-codex 1.0.0-dev-1779051654000

package/dist/runtime/namespace.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Codex client namespace registration.
+ *
+ * Registers `client:codex` on the singleton bus using the shared
+ * {@link createClientNamespace} factory, which pre-registers the raw catch-all
+ * hook ingress subject `hook.received` with the canonical
+ * {@link RawClientHookPayloadSchema}.
+ *
+ * Additional subjects registered here:
+ * - `config.hooks.list` — list effective hook configuration
+ * - `config.hooks.add` — add a hook entry to a config scope
+ * - `config.hooks.remove` — remove hook entries matching a pattern
+ * - `config.prime` — blocking config-prime lifecycle hook
+ * - `wiring.list` — list all wiring entries with installation status
+ * - `wiring.apply` — install wiring entries into the target scope
+ * - `wiring.remove` — uninstall wiring entries from the target scope
+ * - `sessionConfig.setup` — seed an isolated session config directory
+ *
+ * **Subject conventions:**
+ * - Raw Codex-native events flow in the `client:codex.*` namespace only.
+ * - Normalized lifecycle observations flow in the global `client.session.*`
+ *   namespace after the {@link CodexHookNormalizer} maps them.
+ * @packageDocumentation
+ */
+/**
+ * Typed bus subjects for the Codex client namespace (`client:codex.*`).
+ *
+ * Exposes the raw hook ingress subject, config management subjects, wiring
+ * management subjects, the config-prime lifecycle hook, and the session config
+ * setup subject:
+ * - `CodexClientSubjects.hook.received` → `client:codex.hook.received`
+ * - `CodexClientSubjects.config.hooks.list` → `client:codex.config.hooks.list`
+ * - `CodexClientSubjects.config.hooks.add` → `client:codex.config.hooks.add`
+ * - `CodexClientSubjects.config.hooks.remove` → `client:codex.config.hooks.remove`
+ * - `CodexClientSubjects.config.prime` → `client:codex.config.prime`
+ * - `CodexClientSubjects.wiring.list` → `client:codex.wiring.list`
+ * - `CodexClientSubjects.wiring.apply` → `client:codex.wiring.apply`
+ * - `CodexClientSubjects.wiring.remove` → `client:codex.wiring.remove`
+ * - `CodexClientSubjects.sessionConfig.setup` → `client:codex.sessionConfig.setup`
+ */
+export declare const CodexClientSubjects: import("@makaio/framework/core").BusSubjects<import("@makaio/framework/core").FlatSubjectDefinitions<`client:${string}`, {
+    'hook.received': import("zod").ZodObject<{
+        eventName: import("zod").ZodString;
+        receivedAt: import("zod").ZodNumber;
+        payload: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+        metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    }, import("zod/v4/core").$strip>;
+} & {
+    'config.hooks.list': {
+        request: import("zod").ZodObject<{
+            projectDir: import("zod").ZodOptional<import("zod").ZodString>;
+            eventName: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            effective: import("zod").ZodArray<import("zod").ZodObject<{
+                event: import("zod").ZodString;
+                matcher: import("zod").ZodOptional<import("zod").ZodString>;
+                command: import("zod").ZodString;
+                timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+            perScope: import("zod").ZodArray<import("zod").ZodObject<{
+                scope: import("zod").ZodEnum<{
+                    global: "global";
+                    project: "project";
+                }>;
+                path: import("zod").ZodString;
+                writable: import("zod").ZodBoolean;
+                hooks: import("zod").ZodArray<import("zod").ZodObject<{
+                    event: import("zod").ZodString;
+                    matcher: import("zod").ZodOptional<import("zod").ZodString>;
+                    command: import("zod").ZodString;
+                    timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+    };
+    'config.hooks.add': {
+        request: import("zod").ZodObject<{
+            event: import("zod").ZodString;
+            matcher: import("zod").ZodOptional<import("zod").ZodString>;
+            command: import("zod").ZodString;
+            timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
+            projectDir: import("zod").ZodOptional<import("zod").ZodString>;
+            scope: import("zod").ZodEnum<{
+                global: "global";
+                project: "project";
+            }>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            added: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>;
+    };
+    'config.hooks.remove': {
+        request: import("zod").ZodObject<{
+            projectDir: import("zod").ZodOptional<import("zod").ZodString>;
+            scope: import("zod").ZodEnum<{
+                global: "global";
+                project: "project";
+            }>;
+            event: import("zod").ZodString;
+            match: import("zod").ZodObject<{
+                commandContains: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            removed: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+    };
+    'wiring.list': {
+        request: import("zod").ZodObject<{
+            projectDir: import("zod").ZodOptional<import("zod").ZodString>;
+            makaioCommand: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            entries: import("zod").ZodArray<import("zod").ZodObject<{
+                group: import("zod").ZodString;
+                name: import("zod").ZodString;
+                installed: import("zod").ZodBoolean;
+                command: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+    };
+    'wiring.apply': {
+        request: import("zod").ZodObject<{
+            scope: import("zod").ZodEnum<{
+                global: "global";
+                project: "project";
+            }>;
+            projectDir: import("zod").ZodOptional<import("zod").ZodString>;
+            makaioCommand: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            applied: import("zod").ZodNumber;
+            skipped: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+    };
+    'wiring.remove': {
+        request: import("zod").ZodObject<{
+            scope: import("zod").ZodEnum<{
+                global: "global";
+                project: "project";
+            }>;
+            projectDir: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            removed: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+    };
+    'config.prime': {
+        request: import("zod").ZodObject<{
+            clientId: import("zod").ZodString;
+            configDir: import("zod").ZodString;
+            phase: import("zod").ZodEnum<{
+                "managed-install": "managed-install";
+                "profile-create": "profile-create";
+                "session-create": "session-create";
+            }>;
+            binaryVersion: import("zod").ZodOptional<import("zod").ZodString>;
+            adapterName: import("zod").ZodOptional<import("zod").ZodString>;
+            projectDir: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            primed: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>;
+    };
+    'sessionConfig.setup': {
+        request: import("zod").ZodObject<{
+            sessionDir: import("zod").ZodString;
+            baseConfigDir: import("zod").ZodString;
+            projectDir: import("zod").ZodOptional<import("zod").ZodString>;
+            platform: import("zod").ZodEnum<{
+                darwin: "darwin";
+                linux: "linux";
+                win32: "win32";
+            }>;
+            configInheritance: import("zod").ZodEnum<{
+                "auth-only": "auth-only";
+                empty: "empty";
+                full: "full";
+            }>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            env: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+        }, import("zod/v4/core").$strip>;
+    };
+}>, `client:${string}`>;
+/**
+ * Fully-qualified namespace domain string for the Codex client.
+ *
+ * Value: `'client:codex'`
+ */
+export declare const CODEX_CLIENT_NAMESPACE: string;
+//# sourceMappingURL=namespace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.d.ts","sourceRoot":"","sources":["../../src/runtime/namespace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAqBH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAAW,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,QAAkB,CAAC"}

package/dist/runtime/package.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Codex client runtime package.
+ *
+ * Exports the {@link MakaioExtension} manifest for the Codex client runtime and
+ * re-exports the namespace subjects for client-native integrations.
+ * @packageDocumentation
+ */
+import type { IMakaioBus } from '@makaio/framework/bus';
+import type { MakaioNodeExtension } from '@makaio/framework/contracts';
+export { CodexClientSubjects, CODEX_CLIENT_NAMESPACE } from './namespace.js';
+export { CodexClientSessionService } from './codex-client-session-service.js';
+export { normalizeCodexHook } from './hook-normalizer.js';
+export type { CodexNormalizedEvent, CodexNormalizedSubject } from './hook-normalizer.js';
+/**
+ * MakaioExtension manifest for the Codex client session normalization service.
+ *
+ * Creates a {@link CodexClientSessionService} that bridges raw
+ * `client:codex.hook.received` events into normalized `client.session.*`
+ * observations when the Codex descriptor server entry activates.
+ */
+export declare const codexClientRuntimePackage: MakaioNodeExtension<IMakaioBus>;
+//# sourceMappingURL=package.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"package.d.ts","sourceRoot":"","sources":["../../src/runtime/package.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAG7D,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,YAAY,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEzF;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAWrE,CAAC"}

package/dist/runtime/package.mjs

@@ -0,0 +1,33 @@
+import { i as normalizeCodexHook, n as CODEX_CLIENT_NAMESPACE, r as CodexClientSubjects, t as CodexClientSessionService } from "../codex-client-session-service-DD2LkxP1.mjs";
+import { dep } from "@makaio/framework/contracts";
+
+//#region src/runtime/package.ts
+/**
+* Codex client runtime package.
+*
+* Exports the {@link MakaioExtension} manifest for the Codex client runtime and
+* re-exports the namespace subjects for client-native integrations.
+* @packageDocumentation
+*/
+/**
+* MakaioExtension manifest for the Codex client session normalization service.
+*
+* Creates a {@link CodexClientSessionService} that bridges raw
+* `client:codex.hook.received` events into normalized `client.session.*`
+* observations when the Codex descriptor server entry activates.
+*/
+const codexClientRuntimePackage = {
+	name: "codex.runtime",
+	displayName: "Codex Client Runtime",
+	version: "0.1.0",
+	dependencies: [dep("makaio.clients-core")],
+	/**
+	* Create the Codex client session service bound to the runtime bus.
+	* @param ctx - Runtime package context
+	* @returns Uninitialized Codex client session service
+	*/
+	create: (ctx) => new CodexClientSessionService(ctx.bus)
+};
+
+//#endregion
+export { CODEX_CLIENT_NAMESPACE, CodexClientSessionService, CodexClientSubjects, codexClientRuntimePackage, normalizeCodexHook };

package/dist/runtime/schemas.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Codex client runtime schemas and hook event name constants.
+ *
+ * Re-exports the shared raw hook payload schema for Codex client consumers.
+ * The Codex CLI uses the canonical {@link RawClientHookPayloadSchema} delivered
+ * on `client:codex.hook.received`.
+ *
+ * The hook name constants below are the canonical event names reported in the
+ * `eventName` field of {@link RawClientHookPayload} by the Codex CLI.
+ * @see https://github.com/openai/codex
+ * @packageDocumentation
+ */
+export { RawClientHookPayloadSchema, type RawClientHookPayload } from '@makaio/framework/clients';
+/**
+ * Hook events emitted by Codex that map to the v1 observed-semantics set.
+ *
+ * These are the events the normalizer translates into `client.session.*` bus
+ * emissions. Any event NOT listed here is left as raw `client:codex`
+ * namespace data only.
+ */
+export declare const CODEX_HOOK_SESSION_START = "SessionStart";
+export declare const CODEX_HOOK_USER_PROMPT_SUBMIT = "UserPromptSubmit";
+export declare const CODEX_HOOK_PRE_TOOL_USE = "PreToolUse";
+export declare const CODEX_HOOK_POST_TOOL_USE = "PostToolUse";
+export declare const CODEX_HOOK_STOP = "Stop";
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/runtime/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,0BAA0B,EAAE,KAAK,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE7F;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,iBAAiB,CAAC;AACvD,eAAO,MAAM,6BAA6B,qBAAqB,CAAC;AAChE,eAAO,MAAM,uBAAuB,eAAe,CAAC;AACpD,eAAO,MAAM,wBAAwB,gBAAgB,CAAC;AACtD,eAAO,MAAM,eAAe,SAAS,CAAC"}

package/dist/runtime/session-config-handler.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Codex session config setup handler.
+ *
+ * Implements the `client:codex.sessionConfig.setup` delegation request by
+ * materializing the Codex config files needed for an isolated session
+ * directory.
+ *
+ * The handler copies `config.toml` and `auth.json` from the base config
+ * directory (when present) into the session-scoped directory, then primes the
+ * session directory to ensure `check_for_update_on_startup = false` is set.
+ *
+ * When `sessionDir` and `baseConfigDir` resolve to the same path (the
+ * framework passes `sessionDir` as `baseConfigDir` when no profile is
+ * configured) the copy step is skipped and only the prime step runs.
+ *
+ * Returns `{ env: { CODEX_HOME: sessionDir } }` so the spawned Codex process
+ * inherits the isolated session directory as its configuration root.
+ * @packageDocumentation
+ */
+import type { SessionConfigSetupRequest, SessionConfigSetupResponse } from '@makaio/framework/contracts/client';
+/**
+ * Handle `client:codex.sessionConfig.setup` by seeding the session-scoped
+ * directory with the appropriate Codex config files.
+ *
+ * Steps:
+ * 1. Create `sessionDir` (recursive, no-op when it already exists).
+ * 2. When `sessionDir` and `baseConfigDir` are distinct paths, copy
+ * `config.toml` and `auth.json` from `baseConfigDir` into `sessionDir`
+ * (each copy is skipped when the source file does not exist).
+ * 3. Prime `sessionDir` via {@link handleCodexConfigPrime} to ensure
+ * `check_for_update_on_startup = false` is set.
+ * @param payload - Session config setup delegation payload. Only `sessionDir`,
+ *   `baseConfigDir`, and `projectDir` are used; `platform` and
+ *   `configInheritance` are accepted for interface compatibility but are not
+ *   required for Codex's simpler config model.
+ * @returns Environment variables for the spawned Codex process: `CODEX_HOME`
+ *   pointing to `sessionDir`.
+ */
+export declare function handleCodexSessionConfigSetup(payload: SessionConfigSetupRequest): Promise<SessionConfigSetupResponse>;
+//# sourceMappingURL=session-config-handler.d.ts.map

package/dist/runtime/session-config-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-config-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/session-config-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AAwBtG;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,6BAA6B,CACjD,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,0BAA0B,CAAC,CAkBrC"}

package/dist/runtime/settings-paths.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Codex client settings path resolution.
+ *
+ * Provides a pure utility for computing the filesystem paths where Codex
+ * stores its `hooks.json` configuration files — one global path under the
+ * resolved Codex config directory and an optional project-scoped path.
+ *
+ * No filesystem I/O is performed; callers are responsible for reading,
+ * writing, or watching the returned paths.
+ * @packageDocumentation
+ */
+/**
+ * Resolved filesystem paths for Codex `hooks.json` configuration files.
+ *
+ * The global path is always present.  The project-scoped path is present
+ * only when a `projectDir` was supplied to {@link resolveCodexSettingsPaths}.
+ */
+export interface CodexSettingsPaths {
+    /** Absolute path to the global `hooks.json` file — always present. */
+    readonly globalHooks: string;
+    /**
+     * Absolute path to `{projectDir}/.codex/hooks.json`.
+     *
+     * `null` when no `projectDir` was provided to
+     * {@link resolveCodexSettingsPaths}.
+     */
+    readonly projectHooks: string | null;
+}
+/**
+ * Resolve the filesystem paths for Codex `hooks.json` configuration files.
+ *
+ * This is a pure function: it performs no I/O and has no side effects.
+ * The returned paths may or may not exist on disk.
+ * @param projectDir - Absolute path to the project root directory. When
+ *   provided, {@link CodexSettingsPaths.projectHooks} is set to
+ *   `{projectDir}/.codex/hooks.json`. When omitted, `projectHooks` is `null`.
+ * @param configDir - Optional Codex config root. When omitted, the global
+ *   hooks path falls back to `~/.codex/hooks.json`.
+ * @returns Resolved paths for the global and optional project-scoped Codex
+ *   hooks configuration files.
+ */
+export declare function resolveCodexSettingsPaths(projectDir?: string, configDir?: string): CodexSettingsPaths;
+//# sourceMappingURL=settings-paths.d.ts.map

package/dist/runtime/settings-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings-paths.d.ts","sourceRoot":"","sources":["../../src/runtime/settings-paths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAQH;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,sEAAsE;IACtE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC;AAED;;;;;;;;;;;;GAYG;AAQH,wBAAgB,yBAAyB,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAMrG"}

package/dist/runtime/wiring.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Codex wiring helpers.
+ *
+ * Pure functions that translate between the Codex `hooks.json` configuration
+ * and the framework wiring contract. No bus dependency — callers are
+ * responsible for providing a {@link CodexClientSettings} instance and
+ * dispatching responses onto the bus.
+ *
+ * ## Wiring groups
+ * - `session-events` — one entry per hook event declared in the Codex client
+ *   definition that maps to a `client.session.*` framework subject.  When
+ *   fired by the Codex CLI these hooks invoke a command of the form
+ *   `makaio hook received codex <EventName>`, which the framework ingress
+ *   bridge picks up and normalises.
+ * @packageDocumentation
+ */
+import type { ClientWiringEntry, ClientWiringApplyResponse, ClientWiringRemoveResponse } from '@makaio/framework/clients';
+import type { CodexClientSettings } from './client-settings.js';
+import type { CodexScope } from '../schemas/config.js';
+/**
+ * Minimal settings API required by Codex wiring helpers.
+ *
+ * The concrete {@link CodexClientSettings} class satisfies this shape, while
+ * tests can provide a structurally typed fake without unsafe casts.
+ */
+export interface CodexWiringSettings {
+    /** List effective hook configuration. */
+    listHooks: CodexClientSettings['listHooks'];
+    /** Add a hook definition to a scope. */
+    addHook: CodexClientSettings['addHook'];
+    /** Remove hook definitions from a scope. */
+    removeHook: CodexClientSettings['removeHook'];
+}
+/**
+ * Substring used to identify Makaio-managed Codex hook commands.
+ *
+ * The full command for a given event takes the form:
+ * `<makaioCommand> hook received codex <EventName>`
+ *
+ * This sentinel is written verbatim by {@link applyCodexWiring} and used as
+ * the `commandContains` filter in {@link removeCodexWiring}.
+ */
+export declare const CODEX_HOOK_COMMAND_SENTINEL = "hook received codex";
+/**
+ * Build the wiring entry list, annotated with installation status, by
+ * comparing the expected entries against the currently installed Codex hooks.
+ *
+ * Reads hooks from the global scope only when `projectDir` is absent; includes
+ * project-scope hooks when `projectDir` is provided.
+ * @param settings - {@link CodexClientSettings} instance for hook I/O.
+ * @param makaioCommand - Base makaio shell command written into the config.
+ * @param projectDir - Optional absolute project directory.  When absent only
+ *   the global scope is checked.
+ * @returns Object containing all wiring entries with `installed` flags.
+ */
+export declare function buildCodexWiringList(settings: CodexWiringSettings, makaioCommand: string, projectDir?: string): Promise<{
+    entries: ClientWiringEntry[];
+}>;
+/**
+ * Install all session-event wiring entries into the specified scope.
+ *
+ * The operation uses replace semantics when `makaioCommand` changes: if a hook
+ * for an event already contains the sentinel but with a different command
+ * prefix, the old hook is removed before the new one is added.  When the
+ * identical command is already present the entry is skipped unchanged.
+ * @param settings - {@link CodexClientSettings} instance for hook I/O.
+ * @param scope - Target scope (`'global'` or `'project'`).
+ * @param makaioCommand - Base makaio shell command written into each hook.
+ * @param projectDir - Absolute project directory.  Required when `scope` is
+ *   `'project'`; ignored for `'global'`.
+ * @returns Counts of applied (newly written or replaced) and skipped (already
+ *   present) entries.
+ */
+export declare function applyCodexWiring(settings: CodexWiringSettings, scope: CodexScope, makaioCommand: string, projectDir?: string): Promise<ClientWiringApplyResponse>;
+/**
+ * Remove all Makaio-managed session-event wiring entries from the specified
+ * scope.
+ *
+ * Entries that are not present are silently ignored — the operation is
+ * idempotent.
+ * @param settings - {@link CodexClientSettings} instance for hook I/O.
+ * @param scope - Target scope (`'global'` or `'project'`).
+ * @param projectDir - Absolute project directory.  Required when `scope` is
+ *   `'project'`; ignored for `'global'`.
+ * @returns Count of entries actually removed from the config file.
+ */
+export declare function removeCodexWiring(settings: CodexWiringSettings, scope: CodexScope, projectDir?: string): Promise<ClientWiringRemoveResponse>;
+//# sourceMappingURL=wiring.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wiring.d.ts","sourceRoot":"","sources":["../../src/runtime/wiring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAGrH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,yCAAyC;IACzC,SAAS,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC5C,wCAAwC;IACxC,OAAO,EAAE,mBAAmB,CAAC,SAAS,CAAC,CAAC;IACxC,4CAA4C;IAC5C,UAAU,EAAE,mBAAmB,CAAC,YAAY,CAAC,CAAC;CAC/C;AAMD;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,wBAAwB,CAAC;AAkBjE;;;;;;;;;;;GAWG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,mBAAmB,EAC7B,aAAa,EAAE,MAAM,EACrB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC;IAAE,OAAO,EAAE,iBAAiB,EAAE,CAAA;CAAE,CAAC,CAgB3C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,mBAAmB,EAC7B,KAAK,EAAE,UAAU,EACjB,aAAa,EAAE,MAAM,EACrB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,yBAAyB,CAAC,CA4CpC;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,mBAAmB,EAC7B,KAAK,EAAE,UAAU,EACjB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,0BAA0B,CAAC,CAcrC"}