sneakoscope 1.0.2 → 1.0.4

package/dist/cli/command-registry.d.ts

@@ -37,9 +37,11 @@ export declare const COMMANDS: {
     deps: CommandEntry;
     'fix-path': CommandEntry;
     doctor: CommandEntry;
+    git: CommandEntry;
     paths: CommandEntry;
     rollback: CommandEntry;
     postinstall: CommandEntry;
+    codex: CommandEntry;
     'codex-app': CommandEntry;
     'codex-lb': CommandEntry;
     auth: CommandEntry;
@@ -120,9 +122,11 @@ export declare const TYPED_COMMANDS: {
     deps: CommandEntry;
     'fix-path': CommandEntry;
     doctor: CommandEntry;
+    git: CommandEntry;
     paths: CommandEntry;
     rollback: CommandEntry;
     postinstall: CommandEntry;
+    codex: CommandEntry;
     'codex-app': CommandEntry;
     'codex-lb': CommandEntry;
     auth: CommandEntry;

package/dist/cli/command-registry.js

@@ -90,9 +90,11 @@ export const COMMANDS = {
     deps: entry('stable', 'Check local dependencies', 'dist/core/commands/basic-cli.js', subcommand(() => import(basicModule), 'depsCommand', 'dist/core/commands/basic-cli.js', 'check')),
     'fix-path': entry('stable', 'Repair hook command paths', 'dist/core/commands/basic-cli.js', basicArgs('fixPathCommand')),
     doctor: entry('stable', 'Check and repair SKS install', 'dist/commands/doctor.js', directCommand(() => import('../commands/doctor.js'), 'dist/commands/doctor.js')),
+    git: entry('beta', 'Inspect and enforce SKS git collaboration hygiene', 'dist/commands/git.js', directCommand(() => import('../commands/git.js'), 'dist/commands/git.js')),
     paths: entry('beta', 'Inspect SKS managed paths', 'dist/core/commands/paths-command.js', argsCommand(() => import('../core/commands/paths-command.js'), 'pathsCommand', 'dist/core/commands/paths-command.js')),
     rollback: entry('beta', 'List or apply managed-path rollback actions', 'dist/core/commands/rollback-command.js', argsCommand(() => import('../core/commands/rollback-command.js'), 'rollbackCommand', 'dist/core/commands/rollback-command.js')),
     postinstall: entry('stable', 'Run postinstall bootstrap', 'dist/core/commands/basic-cli.js', basicArgs('postinstallCommand')),
+    codex: entry('beta', 'Check Codex CLI compatibility and vendored hook schemas', 'dist/commands/codex.js', directCommand(() => import('../commands/codex.js'), 'dist/commands/codex.js')),
     'codex-app': entry('beta', 'Check Codex App readiness', 'dist/commands/codex-app.js', directCommand(() => import('../commands/codex-app.js'), 'dist/commands/codex-app.js')),
     'codex-lb': entry('beta', 'Inspect codex-lb status and circuit health', 'dist/commands/codex-lb.js', directCommand(() => import('../commands/codex-lb.js'), 'dist/commands/codex-lb.js')),
     auth: entry('beta', 'Alias for codex-lb auth commands', 'dist/commands/codex-lb.js', directCommand(() => import('../commands/codex-lb.js'), 'dist/commands/codex-lb.js')),

package/dist/cli/feature-commands.js

@@ -7,6 +7,9 @@ import { redactSecrets } from '../core/secret-redaction.js';
 import { evaluateHookPayload } from '../core/hooks-runtime.js';
 import { buildAllFeaturesSelftest, buildFeatureRegistry, validateFeatureRegistry, writeFeatureInventoryDocs } from '../core/feature-registry.js';
 import { recordHookPolicyMismatchWrongness } from '../core/triwiki-wrongness/wrongness-ledger.js';
+import { codexSchemaSnapshotReport } from '../core/codex-compat/codex-schema-snapshot.js';
+import { validateCodexFixtureOutputs } from '../core/codex-compat/codex-hook-schema.js';
+import { codexHookWarningCheck } from '../core/codex-compat/codex-hook-warning-detector.js';
 const flag = (args, name) => args.includes(name);
 export async function featuresCommand(sub = 'list', args = []) {
     const action = sub || 'list';
@@ -103,8 +106,46 @@ export async function hooksCommand(sub = 'explain', args = []) {
             console.log(`Decision: ${report.decision}`);
         return;
     }
+    if (action === 'codex-schema') {
+        const report = await codexSchemaSnapshotReport();
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify(report, null, 2));
+        console.log(`Codex hook schema snapshot: ${report.ok ? 'ok' : 'blocked'} (${report.baseline})`);
+        if (!report.ok)
+            process.exitCode = 1;
+        return;
+    }
+    if (action === 'codex-validate') {
+        const report = await validateCodexFixtureOutputs(root);
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify(report, null, 2));
+        console.log(`Codex hook output validation: ${report.ok ? 'ok' : 'blocked'} (${report.checked} fixture outputs)`);
+        if (!report.ok)
+            process.exitCode = 1;
+        return;
+    }
+    if (action === 'warning-check') {
+        const report = await codexHookWarningCheck(root);
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify(report, null, 2));
+        console.log(`Codex hook warning check: ${report.ok ? 'ok' : 'blocked'} (${report.warnings_count} warnings)`);
+        for (const warning of report.warnings)
+            console.log(`- ${warning}`);
+        if (!report.ok)
+            process.exitCode = 1;
+        return;
+    }
+    if (action === 'replay-codex-fixtures') {
+        const report = await codexHookWarningCheck(root);
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify(report, null, 2));
+        console.log(`Codex hook fixture replay: ${report.ok ? 'ok' : 'blocked'} (${report.warnings_count} warnings)`);
+        if (!report.ok)
+            process.exitCode = 1;
+        return;
+    }
     if (action !== 'explain') {
-        console.error('Usage: sks hooks explain|status|trust-report|replay <fixture.json> [--json]');
+        console.error('Usage: sks hooks explain|status|trust-report|replay <fixture.json>|codex-schema|codex-validate|warning-check|replay-codex-fixtures [--json]');
         process.exitCode = 1;
         return;
     }

package/dist/commands/codex-lb.js

@@ -1,5 +1,7 @@
 import path from 'node:path';
-import { projectRoot } from '../core/fsx.js';
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { projectRoot, readStdin } from '../core/fsx.js';
 import { flag, readOption } from '../cli/args.js';
 import { printJson } from '../cli/output.js';
 import { codexLbMetrics, readCodexLbCircuit, recordCodexLbHealthEvent, resetCodexLbCircuit, codexLbProofEvidence } from '../core/codex-lb-circuit.js';
@@ -18,11 +20,23 @@ export async function run(command, args = []) {
     }
     if (action === 'status' || action === 'check') {
         const result = await codexLbStatus();
+        const shaped = shapeCodexLbStatus(result);
         if (flag(args, '--json'))
-            return printJson(result);
+            return printJson(shaped);
         process.stdout.write(formatCodexLbStatusText(result));
         return;
     }
+    if (action === 'doctor') {
+        const status = shapeCodexLbStatus(await codexLbStatus());
+        const metrics = codexLbMetrics(await readCodexLbCircuit(root));
+        const result = { schema: 'sks.codex-lb-doctor.v1', ok: Boolean(status.ok && metrics.ok), deep: flag(args, '--deep'), status, metrics };
+        if (flag(args, '--json'))
+            return printJson(result);
+        console.log(`codex-lb doctor: ${result.ok ? 'ok' : status.setup_needed ? 'setup_needed' : 'blocked'}`);
+        if (!result.ok)
+            process.exitCode = status.setup_needed ? 0 : 1;
+        return;
+    }
     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 };
@@ -61,33 +75,39 @@ export async function run(command, args = []) {
         return;
     }
     if (action === 'setup' || action === 'reconfigure') {
-        const host = readOption(args, '--host', readOption(args, '--domain', null));
-        const apiKey = readOption(args, '--api-key', readOption(args, '--key', null));
-        if (!host || !apiKey) {
-            const result = { ok: false, reason: 'missing_host_or_api_key' };
+        const options = await codexLbSetupOptions(args);
+        if (!options.host || !options.apiKey) {
+            const result = {
+                schema: 'sks.codex-lb-setup.v1',
+                ok: false,
+                status: 'setup_needed',
+                reason: !options.host ? 'missing_host_or_base_url' : 'missing_api_key',
+                guidance: [
+                    'Run: sks codex-lb setup',
+                    'Or: sks codex-lb setup --host <domain> --api-key-stdin --yes'
+                ]
+            };
             if (flag(args, '--json'))
                 return printJson(result);
-            console.error('Usage: sks codex-lb setup|reconfigure --host <domain> --api-key <key>');
+            console.error('codex-lb API key is not configured.');
+            console.error('Run:');
+            console.error('  sks codex-lb setup');
+            console.error('or:');
+            console.error('  sks codex-lb setup --host <domain> --api-key-stdin --yes');
             process.exitCode = 1;
             return;
         }
-        const result = await configureCodexLb({ host, apiKey });
+        const result = await configureCodexLb({ host: options.host, apiKey: options.apiKey });
+        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;
         if (flag(args, '--json'))
-            return printJson(result);
+            return printJson(shaped);
         console.log(`codex-lb configured: ${result.base_url || result.status}`);
         if (!result.ok)
             process.exitCode = 1;
         return;
     }
-    if (action === 'doctor' && flag(args, '--deep')) {
-        const result = { ...codexLbMetrics(await readCodexLbCircuit(root)), schema: 'sks.codex-lb-doctor.v1', deep: true };
-        if (flag(args, '--json'))
-            return printJson(result);
-        console.log(`codex-lb deep doctor: ${result.ok ? 'ok' : 'blocked'} (${result.circuit.state})`);
-        if (!result.ok)
-            process.exitCode = 1;
-        return;
-    }
     if (action === 'circuit' && args[1] === 'reset') {
         const result = await resetCodexLbCircuit(root);
         if (flag(args, '--json'))
@@ -121,4 +141,73 @@ export async function run(command, args = []) {
     console.error('Usage: sks codex-lb status|metrics|doctor --deep|health|repair|release|unselect|setup|circuit reset|circuit record-fixture|proof-evidence [--json]');
     process.exitCode = 1;
 }
+function shapeCodexLbStatus(status = {}) {
+    return {
+        schema: 'sks.codex-lb-status.v1',
+        ...status,
+        configured: Boolean(status.ok),
+        setup_needed: !status.ok,
+        api_key: {
+            present: Boolean(status.env_key_configured),
+            source: status.env_key_configured ? 'env-file' : null,
+            redacted: true
+        },
+        env_auto_load: Boolean(status.env_file && status.env_key_configured),
+        guidance: status.ok ? [] : [
+            'codex-lb API key is not configured.',
+            'Run: sks codex-lb setup',
+            'Or: sks codex-lb setup --host <domain> --api-key-stdin --yes'
+        ]
+    };
+}
+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));
+    if (flag(args, '--api-key-stdin'))
+        apiKey = (await readStdin()).trim();
+    let health = flag(args, '--health') || flag(args, '--check');
+    if ((!host || !apiKey) && canAskInteractive(args)) {
+        console.log('SKS codex-lb setup\n');
+        host ||= (await ask('1. codex-lb domain or base URL?\n   Example: lb.example.com or https://lb.example.com/backend-api/codex\n> ')).trim();
+        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();
+        health = !/^(n|no|아니|아니요|ㄴ)$/i.test(runHealth || 'y');
+    }
+    return { host, apiKey, health };
+}
+function canAskInteractive(args = []) {
+    return !flag(args, '--json') && !flag(args, '--yes') && Boolean(input.isTTY && output.isTTY && process.env.CI !== 'true');
+}
+async function ask(question) {
+    const rl = readline.createInterface({ input, output });
+    try {
+        return await rl.question(question);
+    }
+    finally {
+        rl.close();
+    }
+}
+async function askHidden(question) {
+    if (!input.isTTY || !output.isTTY)
+        return ask(question);
+    const rl = readline.createInterface({ input, output, terminal: true });
+    rl.stdoutMuted = true;
+    const original = rl._writeToOutput;
+    rl._writeToOutput = function writeToOutput(value) {
+        if (rl.stdoutMuted && !/\n|\r/.test(value))
+            return;
+        return original.call(rl, value);
+    };
+    try {
+        const answer = await rl.question(question);
+        output.write('\n');
+        return answer;
+    }
+    finally {
+        rl.close();
+    }
+}
 //# sourceMappingURL=codex-lb.js.map

package/dist/commands/codex.d.ts

@@ -0,0 +1,2 @@
+export declare function run(_command: any, args?: any): Promise<void>;
+//# sourceMappingURL=codex.d.ts.map

package/dist/commands/codex.js

@@ -0,0 +1,47 @@
+import { flag } from '../cli/args.js';
+import { printJson } from '../cli/output.js';
+import { codexCompatibilityReport, codexDoctorReport } from '../core/codex-compat/codex-compat-report.js';
+import { codexVersionReport } from '../core/codex-compat/codex-version.js';
+import { codexSchemaSnapshotReport } from '../core/codex-compat/codex-schema-snapshot.js';
+export async function run(_command, args = []) {
+    const action = args[0] || 'compatibility';
+    if (action === 'compatibility' || action === 'compat') {
+        const result = await codexCompatibilityReport();
+        if (flag(args, '--json'))
+            return printJson(result);
+        console.log(`Codex compatibility: ${result.ok ? result.status : 'blocked'} (${result.required_baseline})`);
+        for (const warning of result.warnings || [])
+            console.log(`- ${warning}`);
+        if (!result.ok)
+            process.exitCode = 1;
+        return;
+    }
+    if (action === 'version') {
+        const result = await codexVersionReport();
+        if (flag(args, '--json'))
+            return printJson(result);
+        console.log(`Codex detected: ${result.detected.version || 'not installed'} (${result.policy.status})`);
+        return;
+    }
+    if (action === 'doctor') {
+        const result = await codexDoctorReport();
+        if (flag(args, '--json'))
+            return printJson(result);
+        console.log(`Codex doctor: ${result.ok ? 'ok' : 'blocked'}`);
+        if (!result.ok)
+            process.exitCode = 1;
+        return;
+    }
+    if (action === 'schema' || action === 'snapshot') {
+        const result = await codexSchemaSnapshotReport();
+        if (flag(args, '--json'))
+            return printJson(result);
+        console.log(`Codex hook schema snapshot: ${result.ok ? 'ok' : 'blocked'} (${result.baseline})`);
+        if (!result.ok)
+            process.exitCode = 1;
+        return;
+    }
+    console.error('Usage: sks codex compatibility|version|doctor|schema [--json]');
+    process.exitCode = 1;
+}
+//# sourceMappingURL=codex.js.map

package/dist/commands/git.d.ts

@@ -0,0 +1,2 @@
+export declare function run(_command: string, args?: string[]): Promise<unknown>;
+//# sourceMappingURL=git.d.ts.map

package/dist/commands/git.js

@@ -0,0 +1,5 @@
+import { gitCommand } from '../core/commands/git-command.js';
+export async function run(_command, args = []) {
+    return gitCommand(args);
+}
+//# sourceMappingURL=git.js.map

package/dist/commands/wiki.d.ts

@@ -25,7 +25,7 @@ export declare function run(_command: any, args?: any): Promise<void | {
     }[];
     active_avoidance_rules: import("../core/triwiki-wrongness/wrongness-schema.js").WrongnessAvoidanceRule[];
     retrieval_policy: string;
-} | {
+} | import("../core/git-hygiene/shared-memory-publish.js").SharedPublishResult | {
     schema: string;
     target: any;
     mission_id: string | null;

package/dist/core/bench.js

@@ -114,7 +114,7 @@ export async function runCoreBench(root = process.cwd(), { iterations = 3, tier
     return report;
 }
 async function ensureBenchTrustMission(root, script) {
-    await runProcess(process.execPath, [script, 'run', 'bench trust fixture', '--mock', '--json'], {
+    await runProcess(process.execPath, [script, 'run', 'fixture', '--mock', '--json'], {
         cwd: root,
         timeoutMs: 60_000,
         maxOutputBytes: 256 * 1024,

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

@@ -0,0 +1,58 @@
+export declare function codexCompatibilityReport(opts?: any): Promise<{
+    schema: string;
+    required_baseline: string;
+    detected: import("./codex-version.js").CodexDetectedVersion;
+    hooks_schema: {
+        snapshot: string;
+        ok: boolean;
+        files: number;
+    };
+    ok: boolean;
+    status: string;
+    warnings: string[];
+    root: any;
+}>;
+export declare function codexDoctorReport(opts?: any): Promise<{
+    schema: string;
+    ok: boolean;
+    compatibility: {
+        schema: string;
+        required_baseline: string;
+        detected: import("./codex-version.js").CodexDetectedVersion;
+        hooks_schema: {
+            snapshot: string;
+            ok: boolean;
+            files: number;
+        };
+        ok: boolean;
+        status: string;
+        warnings: string[];
+        root: any;
+    };
+    hooks: {
+        schema: string;
+        ok: boolean;
+        baseline: string;
+        warnings_count: number;
+        warnings: string[];
+        events: {
+            event: "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "PermissionRequest" | "Stop" | "PreCompact" | "PostCompact" | "SessionStart";
+            checked: number;
+            ok: boolean;
+            warnings: string[];
+        }[];
+        config: {
+            schema: string;
+            ok: boolean;
+            files: {
+                path: string;
+                exists: boolean;
+                ok: boolean;
+                issues: string[];
+            }[];
+            issues: string[];
+        };
+        wrongness: import("../triwiki-wrongness/wrongness-schema.js").WrongnessRecord | null;
+    };
+}>;
+//# sourceMappingURL=codex-compat-report.d.ts.map

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

@@ -0,0 +1,38 @@
+import { projectRoot } from '../fsx.js';
+import { codexVersionReport } from './codex-version.js';
+import { CODEX_COMPAT_SCHEMA, CODEX_REQUIRED_BASELINE_TAG } from './codex-version-policy.js';
+import { codexSchemaSnapshotReport } from './codex-schema-snapshot.js';
+import { codexHookWarningCheck } from './codex-hook-warning-detector.js';
+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);
+    return {
+        schema: CODEX_COMPAT_SCHEMA,
+        required_baseline: CODEX_REQUIRED_BASELINE_TAG,
+        detected: version.detected,
+        hooks_schema: {
+            snapshot: CODEX_REQUIRED_BASELINE_TAG,
+            ok: snapshot.ok,
+            files: snapshot.files.length
+        },
+        ok,
+        status: ok ? version.policy.status : 'blocked',
+        warnings: version.policy.warnings,
+        root
+    };
+}
+export async function codexDoctorReport(opts = {}) {
+    const root = opts.root || await projectRoot();
+    const compatibility = await codexCompatibilityReport({ ...opts, root });
+    const hooks = await codexHookWarningCheck(root, { recordWrongness: false });
+    const ok = compatibility.ok && hooks.ok;
+    return {
+        schema: 'sks.codex-doctor.v1',
+        ok,
+        compatibility,
+        hooks
+    };
+}
+//# sourceMappingURL=codex-compat-report.js.map

package/dist/core/codex-compat/codex-config-policy.d.ts

@@ -0,0 +1,18 @@
+export declare function validateCodexHookConfigText(text: unknown, opts?: any): {
+    schema: string;
+    ok: boolean;
+    source: any;
+    issues: string[];
+};
+export declare function validateCodexHookConfigFiles(root: string): Promise<{
+    schema: string;
+    ok: boolean;
+    files: {
+        path: string;
+        exists: boolean;
+        ok: boolean;
+        issues: string[];
+    }[];
+    issues: string[];
+}>;
+//# sourceMappingURL=codex-config-policy.d.ts.map

package/dist/core/codex-compat/codex-config-policy.js

@@ -0,0 +1,85 @@
+import path from 'node:path';
+import os from 'node:os';
+import { exists, readText } from '../fsx.js';
+import { CODEX_HOOK_EVENTS } from './codex-schema-snapshot.js';
+const SUPPORTED_HANDLER_FIELDS = new Set(['type', 'command', 'commandWindows', 'command_windows', 'timeout', 'async', 'statusMessage']);
+export function validateCodexHookConfigText(text, opts = {}) {
+    const issues = [];
+    const source = opts.source || 'config';
+    const value = String(text || '');
+    if (/allow_managed_hooks_only\s*=/.test(value) && /config\.toml$/.test(source)) {
+        issues.push(`${source}:allow_managed_hooks_only_in_config_toml`);
+    }
+    for (const match of value.matchAll(/\[\[hooks\.([^\]]+)\]\]/g)) {
+        const event = match[1] || '';
+        if (!CODEX_HOOK_EVENTS.includes(event))
+            issues.push(`${source}:unsupported_hook_event:${event}`);
+    }
+    for (const block of commandHookBlocks(value)) {
+        for (const key of block.keys) {
+            if (!SUPPORTED_HANDLER_FIELDS.has(key))
+                issues.push(`${source}:unsupported_hook_field:${key}`);
+        }
+    }
+    return {
+        schema: 'sks.codex-hook-config-policy.v1',
+        ok: issues.length === 0,
+        source,
+        issues
+    };
+}
+export async function validateCodexHookConfigFiles(root) {
+    const candidates = [
+        path.join(os.homedir(), '.codex', 'config.toml'),
+        path.join(root, '.codex', 'config.toml'),
+        path.join(os.homedir(), '.codex', 'requirements.toml'),
+        path.join(root, '.codex', 'requirements.toml')
+    ];
+    const files = [];
+    for (const file of candidates) {
+        if (!(await exists(file))) {
+            files.push({ path: file, exists: false, ok: true, issues: [] });
+            continue;
+        }
+        const report = validateCodexHookConfigText(await readText(file, ''), { source: file });
+        files.push({ path: file, exists: true, ok: report.ok, issues: report.issues });
+    }
+    const issues = files.flatMap((file) => file.issues);
+    return {
+        schema: 'sks.codex-hook-config-files.v1',
+        ok: issues.length === 0,
+        files,
+        issues
+    };
+}
+function commandHookBlocks(text) {
+    const lines = text.split(/\r?\n/);
+    const blocks = [];
+    let inCommand = false;
+    let keys = [];
+    for (const line of lines) {
+        if (/^\s*\[\[hooks\.[^.]+\.(?:hooks)\]\]\s*$/.test(line)) {
+            if (inCommand)
+                blocks.push({ keys });
+            inCommand = true;
+            keys = [];
+            continue;
+        }
+        if (/^\s*\[/.test(line)) {
+            if (inCommand)
+                blocks.push({ keys });
+            inCommand = false;
+            keys = [];
+            continue;
+        }
+        if (!inCommand)
+            continue;
+        const match = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=/);
+        if (match?.[1])
+            keys.push(match[1]);
+    }
+    if (inCommand)
+        blocks.push({ keys });
+    return blocks;
+}
+//# sourceMappingURL=codex-config-policy.js.map

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

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

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

@@ -0,0 +1,69 @@
+import { codexHookEventName } from './codex-schema-snapshot.js';
+export function normalizeCodexHookOutput(name, result = {}) {
+    const eventName = codexHookEventName(name) || 'UserPromptSubmit';
+    const out = { ...result };
+    const normalized = { continue: out.continue !== false };
+    if (out.stopReason)
+        normalized.stopReason = out.stopReason;
+    if (out.suppressOutput === true)
+        normalized.suppressOutput = true;
+    if (out.systemMessage)
+        normalized.systemMessage = out.systemMessage;
+    const reason = out.reason || out.permissionDecisionReason || 'SKS guard denied this action.';
+    if (eventName === 'UserPromptSubmit' || eventName === 'PostToolUse' || eventName === 'SessionStart') {
+        if (out.decision === 'block') {
+            normalized.decision = 'block';
+            normalized.reason = reason;
+        }
+        if (out.additionalContext) {
+            normalized.hookSpecificOutput = { hookEventName: eventName, additionalContext: out.additionalContext };
+        }
+        return normalized;
+    }
+    if (eventName === 'PreToolUse') {
+        const decision = out.permissionDecision || (out.decision === 'allow' ? 'allow' : null);
+        if (out.decision === 'block' || out.decision === 'deny' || decision === 'deny') {
+            normalized.hookSpecificOutput = {
+                hookEventName: 'PreToolUse',
+                permissionDecision: 'deny',
+                permissionDecisionReason: reason
+            };
+        }
+        else if (decision === 'allow' || decision === 'ask') {
+            normalized.hookSpecificOutput = {
+                hookEventName: 'PreToolUse',
+                permissionDecision: decision
+            };
+            if (decision === 'ask' || out.permissionDecisionReason)
+                normalized.hookSpecificOutput.permissionDecisionReason = reason;
+        }
+        return normalized;
+    }
+    if (eventName === 'PermissionRequest') {
+        if (out.decision === 'deny' || out.permissionDecision === 'deny') {
+            normalized.hookSpecificOutput = {
+                hookEventName: 'PermissionRequest',
+                decision: { behavior: 'deny', message: reason }
+            };
+        }
+        else if (out.decision === 'allow' || out.permissionDecision === 'allow') {
+            normalized.hookSpecificOutput = {
+                hookEventName: 'PermissionRequest',
+                decision: { behavior: 'allow', ...(out.message ? { message: out.message } : {}) }
+            };
+        }
+        return normalized;
+    }
+    if (eventName === 'Stop') {
+        if (out.decision === 'block') {
+            normalized.continue = out.continue === false ? false : normalized.continue;
+            normalized.decision = 'block';
+            normalized.reason = reason;
+            if (!normalized.stopReason && out.continue === false)
+                normalized.stopReason = reason;
+        }
+        return normalized;
+    }
+    return normalized;
+}
+//# sourceMappingURL=codex-hook-output-normalizer.js.map

package/dist/core/codex-compat/codex-hook-schema.d.ts

@@ -0,0 +1,20 @@
+import { type CodexHookEventName } from './codex-schema-snapshot.js';
+export type CodexSchemaValidation = {
+    ok: boolean;
+    event: CodexHookEventName;
+    issues: string[];
+};
+export declare function validateCodexHookOutput(eventLike: unknown, output: unknown): Promise<CodexSchemaValidation>;
+export declare function validateCodexFixtureOutputs(root?: string): Promise<{
+    schema: string;
+    ok: boolean;
+    fixture_root: string;
+    checked: number;
+    outputs: {
+        ok: boolean;
+        event: CodexHookEventName;
+        issues: string[];
+        file: string;
+    }[];
+}>;
+//# sourceMappingURL=codex-hook-schema.d.ts.map