sneakoscope 1.0.2 → 1.0.4

package/dist/core/codex-compat/codex-hook-schema.js

@@ -0,0 +1,109 @@
+import path from 'node:path';
+import { exists, projectRoot, readJson } from '../fsx.js';
+import { CODEX_HOOK_EVENTS, codexHookEventName, readCodexHookSchema } from './codex-schema-snapshot.js';
+export async function validateCodexHookOutput(eventLike, output) {
+    const event = codexHookEventName(eventLike) || 'UserPromptSubmit';
+    const schema = await readCodexHookSchema(event, 'output');
+    const issues = validateJsonValue(output, schema, schema, '$');
+    return { ok: issues.length === 0, event, issues };
+}
+export async function validateCodexFixtureOutputs(root) {
+    root ||= await projectRoot();
+    const fixtureRoot = path.join(root, 'test', 'fixtures', 'codex-hooks', 'rust-v0.131.0');
+    const outputs = [];
+    for (const event of CODEX_HOOK_EVENTS) {
+        const candidates = await expectedOutputFilesForEvent(fixtureRoot, event);
+        for (const file of candidates) {
+            const output = await readJson(file, {});
+            const validation = await validateCodexHookOutput(event, output);
+            outputs.push({ file, ...validation });
+        }
+    }
+    const ok = outputs.length > 0 && outputs.every((row) => row.ok);
+    return {
+        schema: 'sks.codex-hook-fixture-validation.v1',
+        ok,
+        fixture_root: fixtureRoot,
+        checked: outputs.length,
+        outputs
+    };
+}
+async function expectedOutputFilesForEvent(fixtureRoot, event) {
+    if (!(await exists(fixtureRoot)))
+        return [];
+    const fs = await import('node:fs/promises');
+    const eventStem = {
+        PreToolUse: 'pre-tool-use',
+        PermissionRequest: 'permission-request',
+        PostToolUse: 'post-tool-use',
+        PreCompact: 'pre-compact',
+        PostCompact: 'post-compact',
+        SessionStart: 'session-start',
+        UserPromptSubmit: 'user-prompt-submit',
+        Stop: 'stop'
+    }[event];
+    const entries = await fs.readdir(fixtureRoot).catch(() => []);
+    return entries
+        .filter((entry) => entry.startsWith(eventStem) && entry.endsWith('.output.expected.json'))
+        .map((entry) => path.join(fixtureRoot, entry));
+}
+function validateJsonValue(value, schema, root, pointer) {
+    const issues = [];
+    if (!schema || typeof schema !== 'object')
+        return issues;
+    if (schema.$ref)
+        return validateJsonValue(value, resolveRef(root, schema.$ref), root, pointer);
+    for (const child of schema.allOf || [])
+        issues.push(...validateJsonValue(value, child, root, pointer));
+    if (schema.const !== undefined && value !== schema.const)
+        issues.push(`${pointer}:const`);
+    if (Array.isArray(schema.enum) && !schema.enum.includes(value))
+        issues.push(`${pointer}:enum`);
+    if (schema.type) {
+        const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+        if (!types.some((type) => matchesJsonType(value, type)))
+            issues.push(`${pointer}:type:${types.join('|')}`);
+    }
+    if (schema.type === 'object' || schema.properties || schema.additionalProperties === false) {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return issues;
+        const properties = schema.properties || {};
+        const required = Array.isArray(schema.required) ? schema.required : [];
+        for (const key of required) {
+            if (!Object.prototype.hasOwnProperty.call(value, key))
+                issues.push(`${pointer}.${key}:required`);
+        }
+        if (schema.additionalProperties === false) {
+            for (const key of Object.keys(value)) {
+                if (!Object.prototype.hasOwnProperty.call(properties, key))
+                    issues.push(`${pointer}.${key}:unknown_field`);
+            }
+        }
+        for (const [key, childSchema] of Object.entries(properties)) {
+            if (Object.prototype.hasOwnProperty.call(value, key)) {
+                issues.push(...validateJsonValue(value[key], childSchema, root, `${pointer}.${key}`));
+            }
+        }
+    }
+    if (schema.type === 'array' && Array.isArray(value) && schema.items) {
+        value.forEach((item, index) => issues.push(...validateJsonValue(item, schema.items, root, `${pointer}[${index}]`)));
+    }
+    return issues;
+}
+function resolveRef(root, ref) {
+    if (!ref.startsWith('#/'))
+        return {};
+    return ref.slice(2).split('/').reduce((node, part) => node?.[part], root) || {};
+}
+function matchesJsonType(value, type) {
+    if (type === 'null')
+        return value === null;
+    if (type === 'array')
+        return Array.isArray(value);
+    if (type === 'object')
+        return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+    if (type === 'integer')
+        return Number.isInteger(value);
+    return typeof value === type;
+}
+//# sourceMappingURL=codex-hook-schema.js.map

package/dist/core/codex-compat/codex-hook-warning-detector.d.ts

@@ -0,0 +1,32 @@
+export declare function detectCodexHookOutputWarnings(eventLike: unknown, output: any): Promise<{
+    schema: string;
+    ok: boolean;
+    event: "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "PermissionRequest" | "Stop" | "PreCompact" | "PostCompact" | "SessionStart";
+    warnings: string[];
+}>;
+export declare function codexHookWarningCheck(root?: string, opts?: any): Promise<{
+    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-hook-warning-detector.d.ts.map

package/dist/core/codex-compat/codex-hook-warning-detector.js

@@ -0,0 +1,90 @@
+import path from 'node:path';
+import { projectRoot, readJson } from '../fsx.js';
+import { recordHookPolicyMismatchWrongness } from '../triwiki-wrongness/wrongness-ledger.js';
+import { CODEX_HOOK_EVENTS, codexHookEventName } from './codex-schema-snapshot.js';
+import { validateCodexFixtureOutputs, validateCodexHookOutput } from './codex-hook-schema.js';
+import { validateCodexHookConfigFiles } from './codex-config-policy.js';
+const RESERVED_PERMISSION_REQUEST_FIELDS = ['updatedInput', 'updatedPermissions', 'interrupt'];
+const LEGACY_TOP_LEVEL_KEYS = ['permissionDecision', 'permissionDecisionReason', 'updatedInput', 'additionalContext', 'hookEventName'];
+export async function detectCodexHookOutputWarnings(eventLike, output) {
+    const event = codexHookEventName(eventLike) || 'UserPromptSubmit';
+    const validation = await validateCodexHookOutput(event, output);
+    const warnings = [...validation.issues];
+    warnings.push(...snakeCaseKeyWarnings(output));
+    for (const key of LEGACY_TOP_LEVEL_KEYS) {
+        if (output && typeof output === 'object' && Object.prototype.hasOwnProperty.call(output, key))
+            warnings.push(`legacy_top_level:${key}`);
+    }
+    if (event === 'PermissionRequest') {
+        const decision = output?.hookSpecificOutput?.decision || {};
+        for (const key of RESERVED_PERMISSION_REQUEST_FIELDS) {
+            if (Object.prototype.hasOwnProperty.call(decision, key))
+                warnings.push(`permission_request_reserved:${key}`);
+        }
+    }
+    if (event === 'Stop' && output?.decision === 'block' && !String(output?.reason || '').trim())
+        warnings.push('stop_block_without_reason');
+    const actualEvent = output?.hookSpecificOutput?.hookEventName;
+    if (actualEvent && actualEvent !== event)
+        warnings.push(`hook_event_mismatch:${actualEvent}`);
+    return {
+        schema: 'sks.codex-hook-warning-detection.v1',
+        ok: warnings.length === 0,
+        event,
+        warnings: [...new Set(warnings)]
+    };
+}
+export async function codexHookWarningCheck(root, opts = {}) {
+    root ||= await projectRoot();
+    const fixtureValidation = await validateCodexFixtureOutputs(root);
+    const rows = [];
+    for (const row of fixtureValidation.outputs || []) {
+        const output = await readJson(row.file, {});
+        const warning = await detectCodexHookOutputWarnings(row.event, output);
+        rows.push({ event: row.event, file: row.file, warnings: warning.warnings, ok: warning.ok });
+    }
+    const config = await validateCodexHookConfigFiles(root);
+    const warnings = [
+        ...rows.flatMap((row) => row.warnings.map((warning) => `${path.relative(root, row.file)}:${warning}`)),
+        ...config.issues
+    ];
+    let wrongness = null;
+    if (warnings.length && opts.recordWrongness !== false) {
+        wrongness = await recordHookPolicyMismatchWrongness(root, {
+            artifact: 'test/fixtures/codex-hooks/rust-v0.131.0',
+            expected: 'Codex rust-v0.131.0 schema-compatible hook output with warning count 0',
+            actual: warnings.join(', '),
+            detail: 'Codex hook warning check failed',
+            route: '$Hooks'
+        }).catch(() => null);
+    }
+    return {
+        schema: 'sks.codex-hook-warning-check.v1',
+        ok: warnings.length === 0,
+        baseline: 'rust-v0.131.0',
+        warnings_count: warnings.length,
+        warnings,
+        events: CODEX_HOOK_EVENTS.map((event) => ({
+            event,
+            checked: rows.filter((row) => row.event === event).length,
+            ok: rows.filter((row) => row.event === event).every((row) => row.ok),
+            warnings: rows.filter((row) => row.event === event).flatMap((row) => row.warnings)
+        })),
+        config,
+        wrongness
+    };
+}
+function snakeCaseKeyWarnings(value, pointer = '$') {
+    if (!value || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value))
+        return value.flatMap((item, index) => snakeCaseKeyWarnings(item, `${pointer}[${index}]`));
+    const warnings = [];
+    for (const [key, child] of Object.entries(value)) {
+        if (/_/.test(key))
+            warnings.push(`${pointer}.${key}:snake_case`);
+        warnings.push(...snakeCaseKeyWarnings(child, `${pointer}.${key}`));
+    }
+    return warnings;
+}
+//# sourceMappingURL=codex-hook-warning-detector.js.map

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

@@ -0,0 +1,20 @@
+export declare const CODEX_HOOK_EVENTS: readonly ["PreToolUse", "PermissionRequest", "PostToolUse", "PreCompact", "PostCompact", "SessionStart", "UserPromptSubmit", "Stop"];
+export type CodexHookEventName = typeof CODEX_HOOK_EVENTS[number];
+export declare const CODEX_HOOK_EVENT_TO_FILE_STEM: Record<CodexHookEventName, string>;
+export declare function codexHookEventName(value: unknown): CodexHookEventName | null;
+export declare function codexHookSchemaPath(event: CodexHookEventName, direction?: 'input' | 'output'): Promise<string>;
+export declare function readCodexHookSchema(event: CodexHookEventName, direction?: 'input' | 'output'): Promise<any>;
+export declare function readCodexSchemaSnapshotMetadata(): Promise<any>;
+export declare function codexSchemaSnapshotReport(): Promise<{
+    schema: string;
+    ok: boolean;
+    baseline: string;
+    metadata: any;
+    files: {
+        event: "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "PermissionRequest" | "Stop" | "PreCompact" | "PostCompact" | "SessionStart";
+        direction: "input" | "output";
+        path: string;
+        exists: boolean;
+    }[];
+}>;
+//# sourceMappingURL=codex-schema-snapshot.d.ts.map

package/dist/core/codex-compat/codex-schema-snapshot.js

@@ -0,0 +1,96 @@
+import path from 'node:path';
+import { exists, packageRoot, readJson } from '../fsx.js';
+import { CODEX_REQUIRED_BASELINE_TAG, CODEX_REQUIRED_VERSION } from './codex-version-policy.js';
+export const CODEX_HOOK_EVENTS = [
+    'PreToolUse',
+    'PermissionRequest',
+    'PostToolUse',
+    'PreCompact',
+    'PostCompact',
+    'SessionStart',
+    'UserPromptSubmit',
+    'Stop'
+];
+export const CODEX_HOOK_EVENT_TO_FILE_STEM = {
+    PreToolUse: 'pre-tool-use',
+    PermissionRequest: 'permission-request',
+    PostToolUse: 'post-tool-use',
+    PreCompact: 'pre-compact',
+    PostCompact: 'post-compact',
+    SessionStart: 'session-start',
+    UserPromptSubmit: 'user-prompt-submit',
+    Stop: 'stop'
+};
+export function codexHookEventName(value) {
+    const normalized = String(value || '').replace(/[_\s]+/g, '-').toLowerCase();
+    if (normalized === 'pre-tool' || normalized === 'pre-tool-use' || normalized === 'pretooluse')
+        return 'PreToolUse';
+    if (normalized === 'permission-request' || normalized === 'permissionrequest')
+        return 'PermissionRequest';
+    if (normalized === 'post-tool' || normalized === 'post-tool-use' || normalized === 'posttooluse')
+        return 'PostToolUse';
+    if (normalized === 'pre-compact' || normalized === 'precompact')
+        return 'PreCompact';
+    if (normalized === 'post-compact' || normalized === 'postcompact')
+        return 'PostCompact';
+    if (normalized === 'session-start' || normalized === 'sessionstart')
+        return 'SessionStart';
+    if (normalized === 'user-prompt-submit' || normalized === 'userpromptsubmit')
+        return 'UserPromptSubmit';
+    if (normalized === 'stop')
+        return 'Stop';
+    return CODEX_HOOK_EVENTS.find((event) => event.toLowerCase() === normalized.toLowerCase()) ?? null;
+}
+export async function codexHookSchemaPath(event, direction = 'output') {
+    const stem = CODEX_HOOK_EVENT_TO_FILE_STEM[event];
+    const file = `${stem}.command.${direction}.schema.json`;
+    for (const base of candidateSnapshotDirs()) {
+        const candidate = path.join(base, file);
+        if (await exists(candidate))
+            return candidate;
+    }
+    return path.join(candidateSnapshotDirs()[0] || packageRoot(), file);
+}
+export async function readCodexHookSchema(event, direction = 'output') {
+    return readJson(await codexHookSchemaPath(event, direction), {});
+}
+export async function readCodexSchemaSnapshotMetadata() {
+    for (const base of candidateSnapshotDirs()) {
+        const candidate = path.join(base, 'snapshot-metadata.json');
+        if (await exists(candidate))
+            return readJson(candidate, {});
+    }
+    return {
+        schema: 'sks.codex-hook-schema-snapshot.v1',
+        upstream: 'openai/codex',
+        tag: CODEX_REQUIRED_BASELINE_TAG,
+        codex_version: CODEX_REQUIRED_VERSION,
+        status: 'missing'
+    };
+}
+export async function codexSchemaSnapshotReport() {
+    const metadata = await readCodexSchemaSnapshotMetadata();
+    const files = [];
+    for (const event of CODEX_HOOK_EVENTS) {
+        for (const direction of ['input', 'output']) {
+            const file = await codexHookSchemaPath(event, direction);
+            files.push({ event, direction, path: file, exists: await exists(file) });
+        }
+    }
+    const ok = files.every((file) => file.exists) && metadata.tag === CODEX_REQUIRED_BASELINE_TAG;
+    return {
+        schema: 'sks.codex-hook-schema-snapshot-report.v1',
+        ok,
+        baseline: CODEX_REQUIRED_BASELINE_TAG,
+        metadata,
+        files
+    };
+}
+function candidateSnapshotDirs() {
+    const root = packageRoot();
+    return [
+        path.join(root, 'src', 'vendor', 'openai-codex', CODEX_REQUIRED_BASELINE_TAG, 'hooks'),
+        path.join(root, 'dist', 'vendor', 'openai-codex', CODEX_REQUIRED_BASELINE_TAG, 'hooks')
+    ];
+}
+//# sourceMappingURL=codex-schema-snapshot.js.map

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

@@ -0,0 +1,15 @@
+export declare const CODEX_COMPAT_SCHEMA = "sks.codex-compat.v1";
+export declare const CODEX_REQUIRED_BASELINE_TAG = "rust-v0.131.0";
+export declare const CODEX_REQUIRED_VERSION = "0.131.0";
+export declare function compareSemverLike(a: unknown, b: unknown): number;
+export declare function parseCodexVersionText(text: unknown): string | null;
+export declare function codexVersionPolicy(detected?: {
+    available?: boolean;
+    version?: string | null;
+    source?: string | null;
+}): {
+    ok: boolean;
+    status: string;
+    warnings: string[];
+};
+//# sourceMappingURL=codex-version-policy.d.ts.map

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

@@ -0,0 +1,44 @@
+export const CODEX_COMPAT_SCHEMA = 'sks.codex-compat.v1';
+export const CODEX_REQUIRED_BASELINE_TAG = 'rust-v0.131.0';
+export const CODEX_REQUIRED_VERSION = '0.131.0';
+export function compareSemverLike(a, b) {
+    const pa = parseVersionParts(a);
+    const pb = parseVersionParts(b);
+    for (let i = 0; i < Math.max(pa.length, pb.length, 3); i += 1) {
+        const left = pa[i] ?? 0;
+        const right = pb[i] ?? 0;
+        if (left > right)
+            return 1;
+        if (left < right)
+            return -1;
+    }
+    return 0;
+}
+export function parseCodexVersionText(text) {
+    const match = String(text || '').match(/\b(?:rust-v)?(\d+\.\d+\.\d+)(?:[-+][0-9A-Za-z.-]+)?\b/);
+    return match?.[1] ?? null;
+}
+export function codexVersionPolicy(detected = {}) {
+    if (!detected.available || !detected.version) {
+        return {
+            ok: true,
+            status: 'integration_optional',
+            warnings: ['codex binary not detected; release schema checks use vendored rust-v0.131.0 snapshots']
+        };
+    }
+    if (compareSemverLike(detected.version, CODEX_REQUIRED_VERSION) >= 0) {
+        return { ok: true, status: 'ok', warnings: [] };
+    }
+    return {
+        ok: true,
+        status: 'compatibility_degraded',
+        warnings: [
+            `detected Codex ${detected.version} from ${detected.source || 'unknown'}; upgrade to ${CODEX_REQUIRED_BASELINE_TAG} or newer`
+        ]
+    };
+}
+function parseVersionParts(value) {
+    const parsed = parseCodexVersionText(value) || String(value || '0.0.0');
+    return parsed.split(/[.-]/).map((part) => Number.parseInt(part, 10) || 0);
+}
+//# sourceMappingURL=codex-version-policy.js.map

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

@@ -0,0 +1,16 @@
+export type CodexDetectedVersion = {
+    available: boolean;
+    version: string | null;
+    source: string | null;
+    raw?: string;
+};
+export declare function detectCodexVersion(opts?: any): Promise<CodexDetectedVersion>;
+export declare function codexVersionReport(opts?: any): Promise<{
+    detected: CodexDetectedVersion;
+    policy: {
+        ok: boolean;
+        status: string;
+        warnings: string[];
+    };
+}>;
+//# sourceMappingURL=codex-version.d.ts.map

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

@@ -0,0 +1,87 @@
+import { runProcess, which } from '../fsx.js';
+import { codexVersionPolicy, parseCodexVersionText } from './codex-version-policy.js';
+export async function detectCodexVersion(opts = {}) {
+    const codexBin = opts.codexBin || await which('codex').catch(() => null);
+    if (codexBin) {
+        const fromVersion = await detectFromCommand(codexBin, ['--version'], 'codex --version', opts);
+        if (fromVersion.version)
+            return fromVersion;
+        const fromHelp = await detectFromCommand(codexBin, ['--help'], 'codex --help', opts);
+        if (fromHelp.version)
+            return fromHelp;
+    }
+    const npmDetected = await detectFromNpm(opts);
+    if (npmDetected.version)
+        return npmDetected;
+    const brewDetected = await detectFromBrew(opts);
+    if (brewDetected.version)
+        return brewDetected;
+    return { available: false, version: null, source: null };
+}
+export async function codexVersionReport(opts = {}) {
+    const detected = await detectCodexVersion(opts);
+    const policy = codexVersionPolicy(detected);
+    return {
+        detected,
+        policy
+    };
+}
+async function detectFromCommand(bin, args, source, opts) {
+    const result = await runProcess(bin, args, {
+        timeoutMs: opts.timeoutMs || 3000,
+        maxOutputBytes: 16 * 1024,
+        env: opts.env || process.env
+    }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
+    const raw = `${result.stdout || ''}\n${result.stderr || ''}`.trim();
+    const version = parseCodexVersionText(raw);
+    return {
+        available: Boolean(version),
+        version,
+        source: version ? source : null,
+        raw
+    };
+}
+async function detectFromNpm(opts) {
+    const npmBin = opts.npmBin || await which('npm').catch(() => null);
+    if (!npmBin)
+        return { available: false, version: null, source: null };
+    const result = await runProcess(npmBin, ['list', '-g', '@openai/codex', '--json', '--depth=0'], {
+        timeoutMs: opts.timeoutMs || 5000,
+        maxOutputBytes: 64 * 1024,
+        env: opts.env || process.env
+    }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
+    if (!result.stdout)
+        return { available: false, version: null, source: null, raw: result.stderr || '' };
+    try {
+        const parsed = JSON.parse(result.stdout);
+        const version = parsed?.dependencies?.['@openai/codex']?.version || null;
+        return { available: Boolean(version), version, source: version ? 'npm @openai/codex' : null, raw: result.stdout };
+    }
+    catch {
+        return { available: false, version: null, source: null, raw: result.stdout };
+    }
+}
+async function detectFromBrew(opts) {
+    const brewBin = opts.brewBin || await which('brew').catch(() => null);
+    if (!brewBin)
+        return { available: false, version: null, source: null };
+    const result = await runProcess(brewBin, ['info', '--cask', 'codex', '--json=v2'], {
+        timeoutMs: opts.timeoutMs || 5000,
+        maxOutputBytes: 64 * 1024,
+        env: opts.env || process.env
+    }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
+    if (result.code !== 0 || !result.stdout)
+        return { available: false, version: null, source: null, raw: result.stderr || '' };
+    const parsed = await parseJsonText(result.stdout);
+    const version = parsed?.casks?.[0]?.version || null;
+    return { available: Boolean(version), version, source: version ? 'Homebrew cask codex' : null, raw: result.stdout };
+}
+async function parseJsonText(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=codex-version.js.map

package/dist/core/commands/computer-use-command.js

@@ -4,9 +4,53 @@ import { createMission, findLatestMission } from '../mission.js';
 import { flag } from '../../cli/args.js';
 import { printJson } from '../../cli/output.js';
 import { maybeFinalizeRoute } from '../proof/auto-finalize.js';
+import { computerUseStatusReport } from '../computer-use-status.js';
 export async function computerUseCommand(command, args = []) {
     const root = await projectRoot();
     const action = args[0] || 'import';
+    if (action === 'status' || action === 'doctor') {
+        const result = await computerUseStatusReport();
+        if (flag(args, '--json'))
+            return printJson(result);
+        console.log(`Computer Use status: ${result.status}`);
+        if (result.guidance?.length)
+            for (const line of result.guidance)
+                console.log(`- ${line}`);
+        if (!result.ok && action === 'doctor')
+            process.exitCode = result.status === 'not_macos' ? 0 : 1;
+        return;
+    }
+    if (action === 'enable') {
+        const result = await computerUseStatusReport();
+        const response = {
+            schema: 'sks.computer-use-enable.v1',
+            ok: result.status === 'available',
+            status: result.status,
+            macos: process.platform === 'darwin',
+            guidance: [
+                'Open Codex App and grant Screen Recording/Accessibility if macOS prompts.',
+                'SKS does not widen MAD-SKS or DB permissions for Computer Use.'
+            ],
+            current: result
+        };
+        if (flag(args, '--json'))
+            return printJson(response);
+        console.log(`Computer Use enable: ${response.ok ? 'available' : response.status}`);
+        for (const line of response.guidance)
+            console.log(`- ${line}`);
+        return;
+    }
+    if (action === 'require') {
+        const routeArg = args.includes('--route') ? args[args.indexOf('--route') + 1] : null;
+        const result = await computerUseStatusReport();
+        const response = { schema: 'sks.computer-use-require.v1', ok: result.status === 'available', route: routeArg || null, status: result.status, evidence: result.evidence, blocker: result.status === 'available' ? null : result.status };
+        if (flag(args, '--json'))
+            return printJson(response);
+        console.log(`Computer Use requirement for ${routeArg || 'route'}: ${response.ok ? 'available' : `blocked (${response.blocker})`}`);
+        if (!response.ok)
+            process.exitCode = 1;
+        return;
+    }
     if (action === 'import-fixture')
         return importFixture(root, command, args);
     const missionArg = args.find((arg) => !String(arg).startsWith('--')) || 'latest';

package/dist/core/commands/git-command.d.ts

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