sneakoscope 1.0.4 → 1.0.5

package/README.md

@@ -4,7 +4,9 @@ Fast legacy-free proof-first Codex trust layer with image-based Voxel TriWiki.
 
 Sneakoscope Codex (`sks`) is a Codex CLI/App harness that makes repeatable Codex work auditable.
 
-SKS **1.0.4** targets OpenAI Codex CLI `rust-v0.131.0`: hook outputs are validated against vendored upstream schemas, `sks codex-lb setup` is a guided/redacted setup path, and macOS Computer Use is treated as a Codex App visual evidence capability independent from MAD-SKS.
+SKS **1.0.5** seals the Codex trust harness: hook outputs are validated against both vendored OpenAI Codex CLI `rust-v0.131.0` schemas and runtime semantic parser rules, codex-lb setup survives macOS user-session launches through env-file/Keychain/launchctl-aware repair surfaces, and Computer Use is the preferred macOS visual evidence capability when available.
+
+SKS **1.0.4** introduced the `rust-v0.131.0` schema snapshot, guided codex-lb setup path, and Computer Use/MAD-SKS separation that 1.0.5 now hardens into release gates.
 
 SKS **1.0.3** adds git-collaboration hygiene for shared TriWiki memory: `sks git ...`, tracked shared shards under `.sneakoscope/wiki/**`, runtime-only ignores, shared wrongness publish/sync, and Codex App hook trust-state generation for current hook trust syntax.
 
@@ -19,6 +21,31 @@ SKS does not try to clone every other harness. It focuses on one thing: making C
 ![Sneakoscope Codex architecture and pipeline](https://raw.githubusercontent.com/mandarange/Sneakoscope-Codex/dev/docs/assets/sneakoscope-architecture-pipeline.jpg)
 
 
+## 1.0.5 Ultimate Harness Seal
+
+SKS 1.0.5 treats Codex hook semantic compatibility as stricter than schema compatibility. `sks hooks warning-check --json` and `npm run hooks:semantic-check` fail if an output uses `permissionDecision:"ask"`, PreToolUse `allow` without `updatedInput`, Stop `continue:false`, `stopReason`, `suppressOutput`, snake_case keys, unknown fields, or legacy top-level hook decisions.
+
+codex-lb setup now has a durable setup/repair path:
+
+```bash
+sks codex-lb setup --host lb.example.com --api-key-stdin --yes --json
+sks codex-lb status --json
+sks codex-lb doctor --deep --json
+npm run codex-lb:missing-env-regression
+```
+
+The API key is written only to redacted status surfaces. The env file is `~/.codex/sks-codex-lb.env`, metadata is `~/.codex/sks-codex-lb.json`, and reports expose only a redacted presence state plus a fingerprint. Raw `CODEX_LB_API_KEY` missing-env errors are release failures.
+
+Computer Use is a Codex App/macOS capability, not a MAD-SKS or DB permission. Visual routes use:
+
+```bash
+sks computer-use status --json
+sks computer-use require --route '$QA-LOOP' --json
+npm run computer-use:visual-route-fixture
+```
+
+If Codex App or macOS blocks the capability, SKS records `external_capability_blocked`, `codex_app_missing`, `macos_permission_missing`, or the closest structured status and does not fabricate UI evidence.
+
 ## 1.0.4 Codex CLI Compatibility
 
 SKS 1.0.4 targets OpenAI Codex CLI `rust-v0.131.0`. Hook outputs are validated against vendored upstream schemas, so SKS fails release checks if it emits deprecated hook shapes or unknown fields. `sks codex-lb setup` now guides users through domain/base URL and API key setup, stores secrets securely, and prevents raw `CODEX_LB_API_KEY` missing messages. On macOS, Computer Use is treated as a first-class Codex App visual evidence capability and is never blocked by MAD-SKS or a generic SKS safety policy.

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "1.0.4"
+version = "1.0.5"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "1.0.4"
+version = "1.0.5"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 1.0.4"),
+        Some("--version") => println!("sks-rs 1.0.5"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '1.0.4';
+const FAST_PACKAGE_VERSION = '1.0.5';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--version' || args[0] === '-v' || args[0] === 'version') {

package/dist/build-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema": "sks.dist-build.v2",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "typescript": true,
   "mjs_runtime_files": 0,
   "files": [
@@ -188,10 +188,14 @@
     "core/codex-compat/codex-compat-report.js",
     "core/codex-compat/codex-config-policy.d.ts",
     "core/codex-compat/codex-config-policy.js",
+    "core/codex-compat/codex-hook-output-builders.d.ts",
+    "core/codex-compat/codex-hook-output-builders.js",
     "core/codex-compat/codex-hook-output-normalizer.d.ts",
     "core/codex-compat/codex-hook-output-normalizer.js",
     "core/codex-compat/codex-hook-schema.d.ts",
     "core/codex-compat/codex-hook-schema.js",
+    "core/codex-compat/codex-hook-semantic-validator.d.ts",
+    "core/codex-compat/codex-hook-semantic-validator.js",
     "core/codex-compat/codex-hook-warning-detector.d.ts",
     "core/codex-compat/codex-hook-warning-detector.js",
     "core/codex-compat/codex-schema-snapshot.d.ts",
@@ -202,6 +206,8 @@
     "core/codex-compat/codex-version.js",
     "core/codex-lb-circuit.d.ts",
     "core/codex-lb-circuit.js",
+    "core/codex-lb/codex-lb-env.d.ts",
+    "core/codex-lb/codex-lb-env.js",
     "core/codex-model-guard.d.ts",
     "core/codex-model-guard.js",
     "core/commands/autoresearch-command.d.ts",

package/dist/cli/install-helpers.d.ts

@@ -58,8 +58,11 @@ export type ConfigureCodexLbResult = {
     status: string;
     config_path?: string;
     env_path?: string;
+    metadata_path?: string;
     base_url?: string;
     env_key?: string;
+    keychain?: Record<string, unknown>;
+    warnings?: string[];
     auth_reconcile?: CodexLbAuthReconcileResult;
     codex_lb?: CodexLbStatusSnapshot;
     codex_environment?: CodexLbEnvSyncResult;
@@ -97,6 +100,24 @@ export declare function codexLbStatus(opts?: any): Promise<{
     env_file: boolean;
     env_key_configured: boolean;
     env_base_url_configured: boolean;
+    env_loader: {
+        configured: boolean;
+        missing: string[];
+        source: import("../core/codex-lb/codex-lb-env.js").CodexLbEnvSource;
+        source_priority: import("../core/codex-lb/codex-lb-env.js").CodexLbEnvSource[];
+        api_key: {
+            present: boolean;
+            source: import("../core/codex-lb/codex-lb-env.js").CodexLbEnvSource | null;
+            redacted: true;
+            fingerprint: string | null;
+        };
+        keychain: {
+            checked: boolean;
+            available: boolean;
+            status: string;
+        };
+        env_paths: string[];
+    };
     base_url: string | null;
     auth_path: any;
     auth_mode: string;
@@ -185,6 +206,24 @@ export declare function maybePromptCodexLbSetupForLaunch(args?: any, opts?: any)
     env_file: boolean;
     env_key_configured: boolean;
     env_base_url_configured: boolean;
+    env_loader: {
+        configured: boolean;
+        missing: string[];
+        source: import("../core/codex-lb/codex-lb-env.js").CodexLbEnvSource;
+        source_priority: import("../core/codex-lb/codex-lb-env.js").CodexLbEnvSource[];
+        api_key: {
+            present: boolean;
+            source: import("../core/codex-lb/codex-lb-env.js").CodexLbEnvSource | null;
+            redacted: true;
+            fingerprint: string | null;
+        };
+        keychain: {
+            checked: boolean;
+            available: boolean;
+            status: string;
+        };
+        env_paths: string[];
+    };
     base_url: string | null;
     auth_path: any;
     auth_mode: string;
@@ -205,6 +244,24 @@ export declare function maybePromptCodexLbSetupForLaunch(args?: any, opts?: any)
     env_file: boolean;
     env_key_configured: boolean;
     env_base_url_configured: boolean;
+    env_loader: {
+        configured: boolean;
+        missing: string[];
+        source: import("../core/codex-lb/codex-lb-env.js").CodexLbEnvSource;
+        source_priority: import("../core/codex-lb/codex-lb-env.js").CodexLbEnvSource[];
+        api_key: {
+            present: boolean;
+            source: import("../core/codex-lb/codex-lb-env.js").CodexLbEnvSource | null;
+            redacted: true;
+            fingerprint: string | null;
+        };
+        keychain: {
+            checked: boolean;
+            available: boolean;
+            status: string;
+        };
+        env_paths: string[];
+    };
     base_url: string | null;
     auth_path: any;
     auth_mode: string;

package/dist/cli/install-helpers.js

@@ -11,6 +11,7 @@ import { context7ConfigToml, DOLLAR_SKILL_NAMES, GETDESIGN_REFERENCE, hasContext
 import { codexLaunchCommand, platformTmuxInstallHint, tmuxReadiness, tmuxReadinessCatchFallback } from '../core/tmux-ui.js';
 import { reconcileCodexAppUpgradeProcesses } from '../core/codex-app.js';
 import { recordCodexLbHealthEvent } from '../core/codex-lb-circuit.js';
+import { loadCodexLbEnv, writeCodexLbKeychain, codexLbMetadataPath } from '../core/codex-lb/codex-lb-env.js';
 const DEFAULT_CODEX_APP_PLUGINS = [
     ['browser', 'openai-bundled'],
     ['chrome', 'openai-bundled'],
@@ -293,7 +294,7 @@ async function restorePostinstallCodexLbConfigSnapshot(snapshot) {
 export function normalizeCodexLbBaseUrl(input = '') {
     let host = String(input || '').trim();
     if (!host)
-        host = 'http://127.0.0.1:2455';
+        return '';
     if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(host))
         host = `https://${host}`;
     host = host.replace(/\/+$/, '');
@@ -303,16 +304,35 @@ export async function configureCodexLb(opts = {}) {
     const home = opts.home || process.env.HOME || os.homedir();
     const configPath = opts.configPath || codexLbConfigPath(home);
     const envPath = opts.envPath || codexLbEnvPath(home);
-    const baseUrl = normalizeCodexLbBaseUrl(opts.host || opts.baseUrl);
+    const rawHost = String(opts.host || opts.baseUrl || '');
+    const baseUrl = normalizeCodexLbBaseUrl(rawHost);
     const apiKey = String(opts.apiKey || '').trim();
+    if (!baseUrl)
+        return { ok: false, status: 'missing_host_or_base_url', config_path: configPath, env_path: envPath };
+    if (/[\u0000-\u001f\u007f\s]/.test(rawHost.trim()))
+        return { ok: false, status: 'invalid_host_or_base_url', config_path: configPath, env_path: envPath, error: 'host_or_base_url_contains_whitespace_or_control_character' };
     if (!apiKey)
         return { ok: false, status: 'missing_api_key', config_path: configPath, env_path: envPath };
+    const insecureLocalWarning = /^http:\/\//i.test(baseUrl) && !/^http:\/\/(?:localhost|127\.0\.0\.1|\[::1\])(?::|\/|$)/i.test(baseUrl) && !opts.allowInsecureHttp
+        ? ['codex-lb base URL uses http outside localhost; prefer https or pass an explicit allow flag in the calling surface.']
+        : [];
     await ensureDir(path.dirname(configPath));
     const current = await readText(configPath, '');
     const next = normalizeCodexFastModeUiConfig(upsertCodexLbConfig(current, baseUrl));
     await writeTextAtomic(configPath, next);
     await writeTextAtomic(envPath, `export CODEX_LB_BASE_URL=${shellSingleQuote(baseUrl)}\nexport CODEX_LB_API_KEY=${shellSingleQuote(apiKey)}\n`);
     await fsp.chmod(envPath, 0o600).catch(() => { });
+    const keyFingerprint = await sha256Text(apiKey);
+    const metadataPath = opts.metadataPath || codexLbMetadataPath(home);
+    await writeTextAtomic(metadataPath, `${JSON.stringify({
+        schema: 'sks.codex-lb-metadata.v1',
+        base_url: baseUrl,
+        updated_at: new Date().toISOString(),
+        source: opts.source || 'setup',
+        api_key: { redacted: true, sha256: keyFingerprint }
+    }, null, 2)}\n`);
+    await fsp.chmod(metadataPath, 0o600).catch(() => { });
+    const keychain = opts.keychain ? await writeCodexLbKeychain(apiKey, opts).catch((err) => ({ ok: false, status: 'keychain_store_failed', error: err.message })) : { ok: false, status: 'skipped' };
     const codexEnvironment = await syncCodexLbProviderEnvironment({ env_path: envPath, base_url: baseUrl }, { ...opts, home });
     const codexLogin = await maybeSyncCodexLbSharedLogin(apiKey, { ...opts, home, force: true });
     const codexLb = await codexLbStatus({ ...opts, home, configPath, envPath });
@@ -324,8 +344,11 @@ export async function configureCodexLb(opts = {}) {
         status: ok ? 'configured' : (codexEnvironment.status || codexLogin.status),
         config_path: configPath,
         env_path: envPath,
+        metadata_path: metadataPath,
         base_url: baseUrl,
         env_key: 'CODEX_LB_API_KEY',
+        keychain,
+        warnings: insecureLocalWarning,
         auth_reconcile: authReconcile,
         codex_lb: finalCodexLb,
         codex_environment: codexEnvironment,
@@ -340,13 +363,14 @@ export async function codexLbStatus(opts = {}) {
     const config = await readText(configPath, '');
     const envExists = await exists(envPath);
     const envText = envExists ? await readText(envPath, '') : '';
+    const envLoad = await loadCodexLbEnv({ ...opts, home, envPath });
     const authPath = opts.authPath || codexAuthPath(home);
     const authText = await readText(authPath, '');
     const authMode = codexAuthModeSummary(authText);
-    const envKeyConfigured = Boolean(parseCodexLbEnvKey(envText));
+    const envKeyConfigured = Boolean(envLoad.api_key.present);
     const providerConfigured = /\[model_providers\.codex-lb\]/.test(config);
     const selected = hasTopLevelCodexLbSelected(config);
-    const baseUrl = codexLbProviderBaseUrl(config) || parseCodexLbEnvBaseUrl(envText) || null;
+    const baseUrl = codexLbProviderBaseUrl(config) || envLoad.base_url || null;
     const providerRequiresOpenAiAuth = codexLbProviderRequiresOpenAiAuth(config);
     return {
         ok: providerConfigured && envKeyConfigured && Boolean(baseUrl) && providerRequiresOpenAiAuth,
@@ -357,7 +381,16 @@ export async function codexLbStatus(opts = {}) {
         selected,
         env_file: envExists,
         env_key_configured: envKeyConfigured,
-        env_base_url_configured: Boolean(parseCodexLbEnvBaseUrl(envText)),
+        env_base_url_configured: Boolean(envLoad.base_url),
+        env_loader: {
+            configured: envLoad.configured,
+            missing: envLoad.missing,
+            source: envLoad.source,
+            source_priority: envLoad.source_priority,
+            api_key: envLoad.api_key,
+            keychain: envLoad.keychain,
+            env_paths: envLoad.env_paths
+        },
         base_url: baseUrl,
         auth_path: authPath,
         auth_mode: authMode.mode,
@@ -1482,6 +1515,10 @@ function redactSecretText(text = '', secrets = []) {
     }
     return out;
 }
+async function sha256Text(value = '') {
+    const { createHash } = await import('node:crypto');
+    return createHash('sha256').update(String(value || '')).digest('hex');
+}
 function escapeRegExp(value) {
     return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }

package/dist/commands/codex-lb.js

@@ -39,7 +39,8 @@ export async function run(command, args = []) {
     }
     if (action === 'health' || action === 'verify-chain' || action === 'chain') {
         const status = await codexLbStatus();
-        const result = status.ok ? await checkCodexLbResponseChain(status, { force: true, root }) : { ok: false, status: 'not_configured', codex_lb: status };
+        const blocker = !status.env_key_configured ? 'missing_env_key' : !status.base_url ? 'missing_base_url' : 'not_configured';
+        const result = status.ok ? await checkCodexLbResponseChain(status, { force: true, root }) : { ok: false, status: blocker, codex_lb: status };
         if (flag(args, '--json'))
             return printJson(result);
         console.log(`codex-lb response chain: ${result.ok ? 'ok' : `failed (${result.status})`}`);
@@ -97,7 +98,7 @@ export async function run(command, args = []) {
             process.exitCode = 1;
             return;
         }
-        const result = await configureCodexLb({ host: options.host, apiKey: options.apiKey });
+        const result = await configureCodexLb({ host: options.host, apiKey: options.apiKey, keychain: options.keychain });
         const shaped = { schema: 'sks.codex-lb-setup.v1', ...result, api_key: { present: Boolean(options.apiKey), redacted: true }, env_file_chmod: '0600' };
         if (options.health)
             shaped.chain_health = result.ok ? await checkCodexLbResponseChain(result, { force: true, root }) : null;
@@ -147,11 +148,13 @@ function shapeCodexLbStatus(status = {}) {
         ...status,
         configured: Boolean(status.ok),
         setup_needed: !status.ok,
+        repair_available: !status.ok,
         api_key: {
             present: Boolean(status.env_key_configured),
-            source: status.env_key_configured ? 'env-file' : null,
+            source: status.env_loader?.api_key?.source || null,
             redacted: true
         },
+        env_loader: status.env_loader || null,
         env_auto_load: Boolean(status.env_file && status.env_key_configured),
         guidance: status.ok ? [] : [
             'codex-lb API key is not configured.',
@@ -164,6 +167,7 @@ async function codexLbSetupOptions(args = []) {
     const baseUrl = readOption(args, '--base-url', null);
     let host = baseUrl || readOption(args, '--host', readOption(args, '--domain', null));
     let apiKey = readOption(args, '--api-key', readOption(args, '--key', null));
+    let keychain = flag(args, '--keychain');
     if (flag(args, '--api-key-stdin'))
         apiKey = (await readStdin()).trim();
     let health = flag(args, '--health') || flag(args, '--check');
@@ -173,10 +177,12 @@ async function codexLbSetupOptions(args = []) {
         apiKey ||= (await askHidden('2. API key?\n   Input hidden. Value will be stored securely and never printed.\n> ')).trim();
         await ask('3. Use this codex-lb as default for Codex launches? [Y/n] ');
         await ask('4. Write shell env loader to ~/.codex/sks-codex-lb.env? [Y/n] ');
-        const runHealth = (await ask('5. Run health check now? [Y/n] ')).trim();
+        const storeKeychain = (await ask('5. Store the key in macOS Keychain when available? [Y/n] ')).trim();
+        keychain = !/^(n|no|아니|아니요|ㄴ)$/i.test(storeKeychain || 'y');
+        const runHealth = (await ask('6. Run health check now? [Y/n] ')).trim();
         health = !/^(n|no|아니|아니요|ㄴ)$/i.test(runHealth || 'y');
     }
-    return { host, apiKey, health };
+    return { host, apiKey, health, keychain };
 }
 function canAskInteractive(args = []) {
     return !flag(args, '--json') && !flag(args, '--yes') && Boolean(input.isTTY && output.isTTY && process.env.CI !== 'true');

package/dist/commands/wiki.d.ts

@@ -15,7 +15,7 @@ export declare function run(_command: any, args?: any): Promise<void | {
     };
     active_records: {
         id: string;
-        kind: "incorrect_claim" | "overconfident_claim" | "stale_evidence" | "missing_evidence" | "test_failure" | "route_misclassification" | "scout_error" | "visual_anchor_error" | "image_bbox_error" | "db_safety_false_positive" | "db_safety_false_negative" | "hook_policy_mismatch" | "codex_lb_health_misread" | "mock_real_confusion" | "user_intent_misread" | "artifact_schema_error" | "trust_status_overclaim";
+        kind: "incorrect_claim" | "overconfident_claim" | "stale_evidence" | "missing_evidence" | "test_failure" | "route_misclassification" | "scout_error" | "visual_anchor_error" | "image_bbox_error" | "db_safety_false_positive" | "db_safety_false_negative" | "hook_policy_mismatch" | "hook_semantic_mismatch" | "codex_lb_health_misread" | "codex_lb_missing_env_raw_message" | "computer_use_policy_misclassification" | "mock_real_confusion" | "user_intent_misread" | "artifact_schema_error" | "trust_status_overclaim";
         severity: "high" | "low" | "medium" | "critical";
         route: string | null;
         claim: string;

package/dist/core/codex-compat/codex-compat-report.d.ts

@@ -6,6 +6,22 @@ export declare function codexCompatibilityReport(opts?: any): Promise<{
         snapshot: string;
         ok: boolean;
         files: number;
+        metadata: {
+            upstream: any;
+            tag: any;
+            commit: any;
+            captured_at: any;
+        };
+    };
+    hooks_semantic: {
+        ok: boolean;
+        warnings_count: number;
+        events: {
+            event: "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "PermissionRequest" | "Stop" | "PreCompact" | "PostCompact" | "SessionStart";
+            checked: number;
+            ok: boolean;
+            warnings: string[];
+        }[];
     };
     ok: boolean;
     status: string;
@@ -23,6 +39,22 @@ export declare function codexDoctorReport(opts?: any): Promise<{
             snapshot: string;
             ok: boolean;
             files: number;
+            metadata: {
+                upstream: any;
+                tag: any;
+                commit: any;
+                captured_at: any;
+            };
+        };
+        hooks_semantic: {
+            ok: boolean;
+            warnings_count: number;
+            events: {
+                event: "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "PermissionRequest" | "Stop" | "PreCompact" | "PostCompact" | "SessionStart";
+                checked: number;
+                ok: boolean;
+                warnings: string[];
+            }[];
         };
         ok: boolean;
         status: string;

package/dist/core/codex-compat/codex-compat-report.js

@@ -7,7 +7,8 @@ export async function codexCompatibilityReport(opts = {}) {
     const root = opts.root || await projectRoot();
     const version = await codexVersionReport(opts);
     const snapshot = await codexSchemaSnapshotReport();
-    const ok = Boolean(version.policy.ok && snapshot.ok);
+    const hooks = await codexHookWarningCheck(root, { recordWrongness: false });
+    const ok = Boolean(version.policy.ok && snapshot.ok && hooks.ok);
     return {
         schema: CODEX_COMPAT_SCHEMA,
         required_baseline: CODEX_REQUIRED_BASELINE_TAG,
@@ -15,11 +16,22 @@ export async function codexCompatibilityReport(opts = {}) {
         hooks_schema: {
             snapshot: CODEX_REQUIRED_BASELINE_TAG,
             ok: snapshot.ok,
-            files: snapshot.files.length
+            files: snapshot.files.length,
+            metadata: {
+                upstream: snapshot.metadata?.upstream || null,
+                tag: snapshot.metadata?.tag || null,
+                commit: snapshot.metadata?.commit || null,
+                captured_at: snapshot.metadata?.captured_at || null
+            }
+        },
+        hooks_semantic: {
+            ok: hooks.ok,
+            warnings_count: hooks.warnings_count,
+            events: hooks.events
         },
         ok,
         status: ok ? version.policy.status : 'blocked',
-        warnings: version.policy.warnings,
+        warnings: [...version.policy.warnings, ...(hooks.ok ? [] : hooks.warnings)],
         root
     };
 }

package/dist/core/codex-compat/codex-hook-output-builders.d.ts

@@ -0,0 +1,45 @@
+import { type CodexHookEventName } from './codex-schema-snapshot.js';
+export type CodexHookOutput = Record<string, unknown>;
+export declare function buildPreToolUseContinue(options?: {
+    systemMessage?: string;
+}): CodexHookOutput;
+export declare function buildPreToolUseDeny(reason: unknown, options?: {
+    systemMessage?: string;
+}): CodexHookOutput;
+export declare function buildPreToolUseAllowRewrite(updatedInput: unknown, options?: {
+    systemMessage?: string;
+}): CodexHookOutput;
+export declare function buildPermissionRequestAllow(options?: {
+    systemMessage?: string;
+}): CodexHookOutput;
+export declare function buildPermissionRequestDeny(message: unknown, options?: {
+    systemMessage?: string;
+}): CodexHookOutput;
+export declare function buildPostToolUseContinue(options?: {
+    additionalContext?: string;
+    systemMessage?: string;
+}): CodexHookOutput;
+export declare function buildPostToolUseBlock(reason: unknown, options?: {
+    systemMessage?: string;
+}): CodexHookOutput;
+export declare function buildUserPromptSubmitContinue(options?: {
+    additionalContext?: string;
+    systemMessage?: string;
+}): CodexHookOutput;
+export declare function buildUserPromptSubmitBlock(reason: unknown, options?: {
+    systemMessage?: string;
+}): CodexHookOutput;
+export declare function buildStopContinue(options?: {
+    systemMessage?: string;
+}): CodexHookOutput;
+export declare function buildStopBlock(reason: unknown, options?: {
+    systemMessage?: string;
+}): CodexHookOutput;
+export declare function buildCompactContinue(event?: Extract<CodexHookEventName, 'PreCompact' | 'PostCompact'>, options?: {
+    systemMessage?: string;
+}): CodexHookOutput;
+export declare function buildSessionStartContinue(options?: {
+    additionalContext?: string;
+    systemMessage?: string;
+}): CodexHookOutput;
+//# sourceMappingURL=codex-hook-output-builders.d.ts.map

package/dist/core/codex-compat/codex-hook-output-builders.js

@@ -0,0 +1,122 @@
+import {} from './codex-schema-snapshot.js';
+export function buildPreToolUseContinue(options = {}) {
+    return withOptionalSystemMessage({ continue: true }, options.systemMessage);
+}
+export function buildPreToolUseDeny(reason, options = {}) {
+    const trimmed = requiredReason(reason, 'PreToolUse deny requires a non-empty reason');
+    return withOptionalSystemMessage({
+        continue: true,
+        hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: 'deny',
+            permissionDecisionReason: trimmed
+        }
+    }, options.systemMessage);
+}
+export function buildPreToolUseAllowRewrite(updatedInput, options = {}) {
+    if (updatedInput === undefined || updatedInput === null) {
+        throw new Error('PreToolUse allow rewrite requires updatedInput');
+    }
+    return withOptionalSystemMessage({
+        continue: true,
+        hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: 'allow',
+            updatedInput
+        }
+    }, options.systemMessage);
+}
+export function buildPermissionRequestAllow(options = {}) {
+    return withOptionalSystemMessage({
+        continue: true,
+        hookSpecificOutput: {
+            hookEventName: 'PermissionRequest',
+            decision: { behavior: 'allow' }
+        }
+    }, options.systemMessage);
+}
+export function buildPermissionRequestDeny(message, options = {}) {
+    const trimmed = requiredReason(message, 'PermissionRequest deny requires a non-empty message');
+    return withOptionalSystemMessage({
+        continue: true,
+        hookSpecificOutput: {
+            hookEventName: 'PermissionRequest',
+            decision: { behavior: 'deny', message: trimmed }
+        }
+    }, options.systemMessage);
+}
+export function buildPostToolUseContinue(options = {}) {
+    const output = { continue: true };
+    const additionalContext = optionalText(options.additionalContext);
+    if (additionalContext) {
+        output.hookSpecificOutput = {
+            hookEventName: 'PostToolUse',
+            additionalContext
+        };
+    }
+    return withOptionalSystemMessage(output, options.systemMessage);
+}
+export function buildPostToolUseBlock(reason, options = {}) {
+    return withOptionalSystemMessage({
+        continue: true,
+        decision: 'block',
+        reason: requiredReason(reason, 'PostToolUse block requires a non-empty reason')
+    }, options.systemMessage);
+}
+export function buildUserPromptSubmitContinue(options = {}) {
+    const output = { continue: true };
+    const additionalContext = optionalText(options.additionalContext);
+    if (additionalContext) {
+        output.hookSpecificOutput = {
+            hookEventName: 'UserPromptSubmit',
+            additionalContext
+        };
+    }
+    return withOptionalSystemMessage(output, options.systemMessage);
+}
+export function buildUserPromptSubmitBlock(reason, options = {}) {
+    return withOptionalSystemMessage({
+        continue: true,
+        decision: 'block',
+        reason: requiredReason(reason, 'UserPromptSubmit block requires a non-empty reason')
+    }, options.systemMessage);
+}
+export function buildStopContinue(options = {}) {
+    return withOptionalSystemMessage({ continue: true }, options.systemMessage);
+}
+export function buildStopBlock(reason, options = {}) {
+    return withOptionalSystemMessage({
+        continue: true,
+        decision: 'block',
+        reason: requiredReason(reason, 'Stop block requires a non-empty reason')
+    }, options.systemMessage);
+}
+export function buildCompactContinue(event = 'PreCompact', options = {}) {
+    void event;
+    return withOptionalSystemMessage({ continue: true }, options.systemMessage);
+}
+export function buildSessionStartContinue(options = {}) {
+    const output = { continue: true };
+    const additionalContext = optionalText(options.additionalContext);
+    if (additionalContext) {
+        output.hookSpecificOutput = {
+            hookEventName: 'SessionStart',
+            additionalContext
+        };
+    }
+    return withOptionalSystemMessage(output, options.systemMessage);
+}
+function withOptionalSystemMessage(output, systemMessage) {
+    const message = optionalText(systemMessage);
+    return message ? { ...output, systemMessage: message } : output;
+}
+function requiredReason(value, fallback) {
+    const trimmed = optionalText(value);
+    if (!trimmed)
+        throw new Error(fallback);
+    return trimmed;
+}
+function optionalText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+//# sourceMappingURL=codex-hook-output-builders.js.map

package/dist/core/codex-compat/codex-hook-output-normalizer.d.ts

@@ -1,2 +1,2 @@
-export declare function normalizeCodexHookOutput(name: unknown, result?: any): any;
+export declare function normalizeCodexHookOutput(name: unknown, result?: any): import("./codex-hook-output-builders.js").CodexHookOutput;
 //# sourceMappingURL=codex-hook-output-normalizer.d.ts.map