sneakoscope 3.1.4 → 3.1.6

package/dist/core/codex-app/codex-hook-approval-probe.js

@@ -0,0 +1,188 @@
+import path from 'node:path';
+import { findCodexBinary } from '../codex-adapter.js';
+import { readCodexHookActualState } from '../codex-hooks/codex-hook-actual-discovery.js';
+import { nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
+import { isRecord } from './codex-app-types.js';
+export async function probeCodexHookApprovalState(root, input = {}) {
+    const env = input.env || process.env;
+    const sources = [];
+    const fixture = normalizeApprovalState(env.SKS_CODEX_HOOK_APPROVAL_FIXTURE);
+    if (fixture) {
+        const report = buildProbe(fixture !== 'unknown', fixture, [{
+                source: 'config',
+                ok: fixture !== 'unknown',
+                evidence: [`fixture:${fixture}`],
+                blockers: fixture === 'unknown' ? ['fixture_unknown'] : []
+            }]);
+        return persist(root, report, input.writeReport !== false);
+    }
+    const actual = await readCodexHookActualState(root).catch((err) => ({
+        schema: 'sks.codex-hook-actual-state.v1',
+        ok: false,
+        root,
+        sources: [],
+        managed_dirs: [],
+        entries: [],
+        unsupported_handlers: [],
+        invalid_matchers: [],
+        dual_representation: [],
+        warnings: [],
+        blockers: [messageOf(err)]
+    }));
+    const actualState = approvalFromActualState(actual);
+    sources.push({
+        source: 'hook-actual-state',
+        ok: actual.ok !== false,
+        evidence: [
+            `entries:${actual.entries.length}`,
+            `trusted:${actual.entries.filter((entry) => entry.trust_status === 'Trusted' || entry.trust_status === 'Managed').length}`,
+            `modified:${actual.entries.filter((entry) => entry.trust_status === 'Modified').length}`,
+            `untrusted:${actual.entries.filter((entry) => entry.trust_status === 'Untrusted').length}`
+        ],
+        blockers: actual.blockers
+    });
+    const doctor = await probeCodexDoctorApproval(input.codexBin, env);
+    sources.push(doctor.source);
+    const doctorState = doctor.approval_state;
+    const state = strongestApprovalState([actualState, doctorState]);
+    const detectable = state !== 'unknown';
+    const blockers = [
+        ...sources.flatMap((source) => source.blockers),
+        ...(state === 'modified_requires_reapproval' ? ['hook_modified_requires_reapproval'] : [])
+    ];
+    const warnings = [
+        ...(state === 'unknown' ? ['hook_approval_state_unknown'] : []),
+        ...(actual.entries.length > 0 && state === 'unknown' ? ['hooks_installed_but_approval_unknown'] : [])
+    ];
+    const report = {
+        schema: 'sks.codex-hook-approval-probe.v1',
+        generated_at: nowIso(),
+        ok: blockers.length === 0 && state !== 'pending_review' && state !== 'modified_requires_reapproval',
+        detectable,
+        approval_state: state,
+        sources_checked: sources,
+        blockers,
+        warnings
+    };
+    return persist(root, report, input.writeReport !== false);
+}
+function approvalFromActualState(actual) {
+    if (actual.entries.length === 0)
+        return 'not_installed';
+    if (actual.entries.some((entry) => entry.trust_status === 'Modified'))
+        return 'modified_requires_reapproval';
+    if (actual.entries.some((entry) => entry.trust_status === 'Untrusted'))
+        return 'pending_review';
+    if (actual.entries.every((entry) => entry.trust_status === 'Trusted' || entry.trust_status === 'Managed'))
+        return 'approved';
+    return 'unknown';
+}
+async function probeCodexDoctorApproval(codexBin, env) {
+    const bin = codexBin || env.CODEX_BIN || await findCodexBinary().catch(() => null);
+    if (!bin) {
+        return { approval_state: 'unknown', source: { source: 'codex-doctor-json', ok: false, evidence: [], blockers: ['codex_cli_missing'] } };
+    }
+    const run = await runProcess(bin, ['doctor', '--json'], { env, timeoutMs: 8000, maxOutputBytes: 256 * 1024 }).catch((err) => ({
+        code: 1,
+        stdout: '',
+        stderr: messageOf(err)
+    }));
+    const text = `${run.stdout || ''}${run.stderr || ''}`.trim();
+    if (run.code !== 0 || !text) {
+        return {
+            approval_state: 'unknown',
+            source: { source: 'codex-doctor-json', ok: false, evidence: text ? [text.slice(0, 240)] : [], blockers: ['codex_doctor_json_unavailable'] }
+        };
+    }
+    try {
+        const parsed = JSON.parse(text);
+        const state = findApprovalState(parsed);
+        return {
+            approval_state: state || 'unknown',
+            source: {
+                source: 'codex-doctor-json',
+                ok: Boolean(state),
+                evidence: state ? [`approval_state:${state}`] : ['doctor_json_no_hook_approval_field'],
+                blockers: state ? [] : ['hook_approval_not_exposed_by_codex_doctor']
+            }
+        };
+    }
+    catch {
+        return {
+            approval_state: 'unknown',
+            source: { source: 'codex-doctor-json', ok: false, evidence: [text.slice(0, 240)], blockers: ['codex_doctor_json_parse_failed'] }
+        };
+    }
+}
+function findApprovalState(value) {
+    if (!isRecord(value))
+        return null;
+    for (const key of ['hook_approval_state', 'approval_state', 'hookApprovalState']) {
+        const state = normalizeApprovalState(value[key]);
+        if (state)
+            return state;
+    }
+    for (const nested of Object.values(value)) {
+        if (Array.isArray(nested)) {
+            for (const item of nested) {
+                const found = findApprovalState(item);
+                if (found)
+                    return found;
+            }
+        }
+        else if (isRecord(nested)) {
+            const found = findApprovalState(nested);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+function normalizeApprovalState(value) {
+    const raw = String(value || '').trim().toLowerCase().replace(/[-\s]+/g, '_');
+    if (raw === 'approved' || raw === 'trusted' || raw === 'managed')
+        return 'approved';
+    if (raw === 'pending' || raw === 'pending_review' || raw === 'untrusted')
+        return 'pending_review';
+    if (raw === 'modified' || raw === 'modified_requires_reapproval')
+        return 'modified_requires_reapproval';
+    if (raw === 'not_installed' || raw === 'missing')
+        return 'not_installed';
+    if (raw === 'unknown')
+        return 'unknown';
+    return null;
+}
+function strongestApprovalState(states) {
+    if (states.includes('modified_requires_reapproval'))
+        return 'modified_requires_reapproval';
+    if (states.includes('pending_review'))
+        return 'pending_review';
+    if (states.includes('approved'))
+        return 'approved';
+    if (states.every((state) => state === 'not_installed'))
+        return 'not_installed';
+    if (states.includes('not_installed') && states.length === 1)
+        return 'not_installed';
+    return 'unknown';
+}
+function buildProbe(detectable, approvalState, sources) {
+    return {
+        schema: 'sks.codex-hook-approval-probe.v1',
+        generated_at: nowIso(),
+        ok: approvalState === 'approved' || approvalState === 'not_installed',
+        detectable,
+        approval_state: approvalState,
+        sources_checked: sources,
+        blockers: sources.flatMap((source) => source.blockers),
+        warnings: approvalState === 'unknown' ? ['hook_approval_state_unknown'] : []
+    };
+}
+async function persist(root, report, writeReport) {
+    if (writeReport)
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-hook-approval-probe.json'), report).catch(() => undefined);
+    return report;
+}
+function messageOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+//# sourceMappingURL=codex-hook-approval-probe.js.map

package/dist/core/codex-app/codex-hook-lifecycle.js

@@ -1,14 +1,24 @@
-// @ts-nocheck
 import path from 'node:path';
 import { nowIso, writeJsonAtomic } from '../fsx.js';
 import { readCodexHookActualState } from '../codex-hooks/codex-hook-actual-discovery.js';
 import { installManagedCodexHooks } from '../codex-hooks/codex-hook-managed-install.js';
+import { probeCodexHookApprovalState } from './codex-hook-approval-probe.js';
 export async function buildCodexHookLifecycle(input = {}) {
     const root = path.resolve(input.root || process.cwd());
     const install = input.apply === true
-        ? await installManagedCodexHooks(root).catch((err) => ({ ok: false, blockers: [err?.message || String(err)] }))
+        ? await installManagedCodexHooks(root).catch((err) => ({ ok: false, blockers: [messageOf(err)] }))
         : null;
-    const actual = await readCodexHookActualState(root).catch((err) => ({ ok: false, entries: [], blockers: [err?.message || String(err)] }));
+    const actual = await readCodexHookActualState(root).catch((err) => ({ ok: false, entries: [], blockers: [messageOf(err)] }));
+    const probe = await probeCodexHookApprovalState(root).catch((err) => ({
+        schema: 'sks.codex-hook-approval-probe.v1',
+        generated_at: nowIso(),
+        ok: false,
+        detectable: false,
+        approval_state: 'unknown',
+        sources_checked: [],
+        blockers: [messageOf(err)],
+        warnings: ['hook_approval_probe_failed']
+    }));
     const events = {
         UserPromptSubmit: ['route_classifier', 'goal_to_loop_compiler', 'permission_profile_badge'],
         PreToolUse: ['requested_scope_guard', 'mad_db_priority_resolver', 'side_effect_zero_gate'],
@@ -16,25 +26,39 @@ export async function buildCodexHookLifecycle(input = {}) {
         Stop: ['continuation_enforcer', 'final_proof_check', 'loop_resume_hint'],
         Notification: ['operator_status', 'zellij_anchor', 'codex_app_status']
     };
-    const installedEvents = new Set((actual.entries || []).map((entry) => entry.event));
+    const installedEvents = new Set(Array.isArray(actual.entries) ? actual.entries.map((entry) => String(entry.event || '')) : []);
     const report = {
         schema: 'sks.codex-hook-lifecycle.v1',
         generated_at: nowIso(),
-        ok: actual.ok !== false,
+        ok: actual.ok !== false && probe.approval_state !== 'modified_requires_reapproval',
         apply: input.apply === true,
-        approval_state: 'unknown',
-        approval_state_detectable: false,
+        approval_state: probe.approval_state,
+        approval_state_detectable: probe.detectable,
         lifecycle: Object.fromEntries(Object.entries(events).map(([event, actions]) => [event, {
+                event,
                 actions,
+                sks_action: actions.join(','),
                 installed: installedEvents.has(event),
-                approval_state: 'unknown'
+                approval_state: installedEvents.has(event) ? probe.approval_state : 'not_installed',
+                counted_as_evidence: installedEvents.has(event) && probe.approval_state === 'approved'
             }])),
         actual_state: actual,
         install,
-        blockers: actual.blockers || [],
-        warnings: ['hook_approval_state_unknown']
+        probe,
+        blockers: [
+            ...(Array.isArray(actual.blockers) ? actual.blockers.map(String) : []),
+            ...(probe.approval_state === 'modified_requires_reapproval' ? ['hook_modified_requires_reapproval'] : [])
+        ],
+        warnings: [
+            ...probe.warnings,
+            ...(probe.approval_state === 'pending_review' ? ['hook_approval_pending_review'] : []),
+            ...(probe.approval_state === 'unknown' ? ['hook_approval_state_unknown'] : [])
+        ]
     };
     await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-hook-lifecycle.json'), report).catch(() => undefined);
     return report;
 }
+function messageOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
 //# sourceMappingURL=codex-hook-lifecycle.js.map

package/dist/core/codex-app/codex-init-deep.js

@@ -1,7 +1,8 @@
-// @ts-nocheck
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { ensureDir, nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { guardContextForRoute, guardedRm } from '../safety/mutation-guard.js';
+import { createRequestedScopeContract } from '../safety/requested-scope-contract.js';
 export async function runCodexInitDeep(input = {}) {
     const root = path.resolve(input.root || process.cwd());
     const dirs = await scoreDirectories(root);
@@ -9,29 +10,154 @@ export async function runCodexInitDeep(input = {}) {
     const contextDir = path.join(root, '.sneakoscope', 'context');
     const generatedPath = path.join(contextDir, 'AGENTS.generated.md');
     const markdown = renderGeneratedAgents(selected);
+    const directoryLocalAgents = { created: [], updated: [], skipped: [], backup_paths: [], backups_created: 0, backups_pruned: [], unchanged_files: [], changed_only_backup: true, blockers: [] };
+    const backupRetention = Math.max(0, Number(process.env.SKS_INIT_DEEP_BACKUP_RETENTION || 5) || 5);
     if (input.apply === true) {
         await ensureDir(contextDir);
         await writeTextAtomic(generatedPath, markdown);
+        if (input.directoryLocal === true) {
+            for (const row of selected) {
+                const agentsPath = path.join(root, row.dir, 'AGENTS.md');
+                try {
+                    await ensureDir(path.dirname(agentsPath));
+                    const existing = await fs.readFile(agentsPath, 'utf8').catch(() => '');
+                    const next = mergeManagedBlockPreview(existing, 'SKS INIT-DEEP MANAGED SECTION', renderDirectoryAgentsBlock(row));
+                    if (existing === next) {
+                        directoryLocalAgents.unchanged_files.push(path.relative(root, agentsPath));
+                        continue;
+                    }
+                    if (existing.trim()) {
+                        const beforeHash = hashText(existing);
+                        const backup = `${agentsPath}.sks-backup-${beforeHash.slice(0, 12)}-${Date.now()}`;
+                        await fs.copyFile(agentsPath, backup);
+                        directoryLocalAgents.backup_paths.push(path.relative(root, backup));
+                        directoryLocalAgents.backups_created += 1;
+                    }
+                    await writeTextAtomic(agentsPath, next);
+                    const pruned = await pruneBackups(root, agentsPath, backupRetention);
+                    directoryLocalAgents.backups_pruned.push(...pruned.map((file) => path.relative(root, file)));
+                    const status = existing.trim() ? (existing.includes('BEGIN SKS INIT-DEEP MANAGED SECTION') ? 'updated' : 'appended') : 'created';
+                    if (status === 'created')
+                        directoryLocalAgents.created.push(path.relative(root, agentsPath));
+                    else
+                        directoryLocalAgents.updated.push(path.relative(root, agentsPath));
+                }
+                catch (err) {
+                    directoryLocalAgents.skipped.push(path.relative(root, agentsPath));
+                    directoryLocalAgents.blockers.push(`${path.relative(root, agentsPath)}:${messageOf(err)}`);
+                }
+            }
+        }
     }
     const report = {
         schema: 'sks.codex-init-deep.v1',
         generated_at: nowIso(),
-        ok: true,
+        ok: directoryLocalAgents.blockers.length === 0,
         apply: input.apply === true,
         root,
         generated_path: path.relative(root, generatedPath),
         root_agents_preserved: true,
         directory_guidance: selected,
-        blockers: []
+        directory_local_agents: directoryLocalAgents,
+        blockers: directoryLocalAgents.blockers
     };
     await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-init-deep.json'), report).catch(() => undefined);
     return report;
 }
+function mergeManagedBlockPreview(current, markerName, content) {
+    const begin = `<!-- BEGIN ${markerName} -->`;
+    const end = `<!-- END ${markerName} -->`;
+    const block = `${begin}\n${content.trim()}\n${end}\n`;
+    if (!current.trim())
+        return `${block}\n`;
+    const beginIdx = current.indexOf(begin);
+    const endIdx = current.indexOf(end);
+    if (beginIdx >= 0 && endIdx >= beginIdx) {
+        const afterEnd = endIdx + end.length;
+        return `${current.slice(0, beginIdx)}${block}${current.slice(afterEnd).replace(/^\n/, '')}`;
+    }
+    return `${current.replace(/\s*$/, '\n\n')}${block}\n`;
+}
+async function pruneBackups(root, agentsPath, keep) {
+    if (keep < 1)
+        return [];
+    const dir = path.dirname(agentsPath);
+    const base = path.basename(agentsPath);
+    const rows = await fs.readdir(dir).catch(() => []);
+    const backups = rows
+        .filter((name) => name.startsWith(`${base}.sks-backup-`))
+        .map((name) => path.join(dir, name))
+        .sort();
+    const remove = backups.slice(0, Math.max(0, backups.length - keep));
+    const contract = createRequestedScopeContract({
+        route: 'codex-app:init-deep',
+        userRequest: 'Prune only SKS init-deep AGENTS.md backup files after creating a fresh backup.',
+        projectRoot: root
+    });
+    const guard = guardContextForRoute(root, contract, 'prune SKS init-deep backup retention');
+    for (const file of remove)
+        await guardedRm(guard, file, { force: true }).catch(() => undefined);
+    return remove;
+}
+function hashText(text) {
+    let hash = 2166136261;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
 export async function readInitDeepMemory(root) {
     const file = path.join(root, '.sneakoscope', 'context', 'AGENTS.generated.md');
     const text = await fs.readFile(file, 'utf8').catch(() => '');
     return text.trim() ? { path: file, text } : null;
 }
+export async function readInitDeepMemoryHints(root, scopePaths = []) {
+    const resolvedRoot = path.resolve(root);
+    const hints = [];
+    const generated = await readInitDeepMemory(resolvedRoot).catch(() => null);
+    if (generated) {
+        hints.push({
+            path: path.relative(resolvedRoot, generated.path),
+            scope: '.',
+            summary: generated.text.split(/\r?\n/).filter((line) => /^##\s+/.test(line)).slice(0, 8).join(' | ')
+        });
+    }
+    const candidateDirs = new Set();
+    for (const scopePath of scopePaths) {
+        const absolute = path.resolve(resolvedRoot, scopePath);
+        if (!absolute.startsWith(resolvedRoot))
+            continue;
+        const stat = await fs.stat(absolute).catch(() => null);
+        let dir = stat?.isFile() ? path.dirname(absolute) : absolute;
+        while (dir.startsWith(resolvedRoot)) {
+            candidateDirs.add(dir);
+            if (dir === resolvedRoot)
+                break;
+            dir = path.dirname(dir);
+        }
+    }
+    for (const dir of [...candidateDirs].sort((a, b) => b.length - a.length)) {
+        const file = path.join(dir, 'AGENTS.md');
+        const text = await fs.readFile(file, 'utf8').catch(() => '');
+        if (!text.trim())
+            continue;
+        const managed = extractManagedSection(text, 'SKS INIT-DEEP MANAGED SECTION');
+        const userSummary = text.replace(/<!-- BEGIN [\s\S]*?<!-- END [^>]+-->/g, '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(0, 4).join(' | ');
+        const summary = [managed ? managed.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(0, 4).join(' | ') : '', userSummary ? `user:${userSummary}` : ''].filter(Boolean).join(' || ');
+        if (summary) {
+            hints.push({
+                path: path.relative(resolvedRoot, file),
+                scope: path.relative(resolvedRoot, dir) || '.',
+                summary
+            });
+        }
+    }
+    const unique = new Map();
+    for (const hint of hints)
+        unique.set(`${hint.path}:${hint.scope}`, hint);
+    return [...unique.values()].slice(0, 12);
+}
 async function scoreDirectories(root) {
     const counts = new Map();
     await walk(path.join(root, 'src'), root, counts);
@@ -60,6 +186,8 @@ async function walk(dir, root, counts, depth = 0) {
                 await walk(full, root, counts, depth + 1);
         }
         else if (row.isFile()) {
+            if (row.name.includes('.sks-backup-'))
+                continue;
             const relDir = path.relative(root, path.dirname(full)).split(path.sep).join('/');
             const entry = counts.get(relDir) || { file_count: 0, langs: new Set() };
             entry.file_count += 1;
@@ -84,4 +212,27 @@ function renderGeneratedAgents(rows) {
         ])
     ].join('\n');
 }
+function renderDirectoryAgentsBlock(row) {
+    return [
+        `# SKS Init-Deep Local Guidance: ${row.dir}`,
+        '',
+        `- Files observed: ${row.file_count}`,
+        `- Languages: ${row.languages.join(', ') || 'unknown'}`,
+        `- Guidance: ${row.guidance}`,
+        '- Preserve user-authored content outside this managed block.',
+        '- Hydrate TriWiki/current source before risky edits in this directory.'
+    ].join('\n');
+}
+function extractManagedSection(text, markerName) {
+    const begin = `<!-- BEGIN ${markerName} -->`;
+    const end = `<!-- END ${markerName} -->`;
+    const beginIdx = text.indexOf(begin);
+    const endIdx = text.indexOf(end);
+    if (beginIdx < 0 || endIdx < beginIdx)
+        return '';
+    return text.slice(beginIdx + begin.length, endIdx).trim();
+}
+function messageOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
 //# sourceMappingURL=codex-init-deep.js.map

package/dist/core/codex-app/codex-skill-sync.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
@@ -14,19 +13,19 @@ const SKS_SKILLS = [
     '$Computer-Use',
     '$Init-Deep'
 ];
-const LAZYCODEX_RESERVED = new Set(['ulw-loop', 'ulw-plan', 'start-work']);
+const EXTERNAL_ROUTE_RESERVED = new Set(['ulw-loop', 'ulw-plan', 'start-work']);
 export async function syncCodexSksSkills(input) {
     const root = path.resolve(input.root);
     const skillsRoot = input.skillsRoot || path.join(process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), 'skills');
     const existing = await listSkillNames(skillsRoot);
-    const collisions = existing.filter((name) => LAZYCODEX_RESERVED.has(name));
+    const collisions = existing.filter((name) => EXTERNAL_ROUTE_RESERVED.has(name));
     const desired = SKS_SKILLS.map((skill) => skillName(skill));
     const created = [];
     const skipped = [];
     if (input.apply === true) {
         await ensureDir(skillsRoot);
         for (const name of desired) {
-            if (LAZYCODEX_RESERVED.has(name)) {
+            if (EXTERNAL_ROUTE_RESERVED.has(name)) {
                 skipped.push(name);
                 continue;
             }
@@ -53,10 +52,10 @@ export async function syncCodexSksSkills(input) {
         existing_skills: existing,
         created,
         skipped,
-        lazycodex_reserved_present: collisions,
+        external_route_names_preserved: collisions,
         interop: {
             mode: 'coexist',
-            clobbered_lazycodex: false,
+            clobbered_external_routes: false,
             clobbered_user_skills: false
         },
         blockers: []
@@ -72,20 +71,96 @@ function skillName(value) {
     return value.replace(/^\$/, '').toLowerCase();
 }
 function skillContent(name) {
+    const profile = skillProfile(name);
     const body = [
         '---',
         `name: ${name}`,
-        `description: SKS managed Codex App route bridge for $${name}.`,
+        `description: SKS managed Codex App route bridge for ${profile.command}.`,
         '---',
         '',
         '<!-- BEGIN SKS MANAGED SKILL -->',
-        `Invoke the matching SKS route for $${name}. Do not overwrite user or LazyCodex/OmO skills.`,
-        `checksum: ${hash(name)}`,
+        `Command: ${profile.command}`,
+        `Purpose: ${profile.purpose}`,
+        `Use when: ${profile.when}`,
+        `Route: ${profile.command}`,
+        `Evidence: ${profile.evidence}`,
+        'Safety: keep route state bounded, preserve user and external route assets, and stop on hard blockers instead of fabricating fallback behavior.',
+        'Proof paths: write the route-local mission artifact named in Evidence before claiming completion.',
+        'Failure recovery: if a proof path cannot be produced, record the blocker and continue only when the selected SKS route has another allowed evidence path.',
+        `Fallback: ${profile.fallback}`,
+        `checksum: ${hash(`${name}:${profile.command}:${profile.evidence}:${profile.fallback}`)}`,
         '<!-- END SKS MANAGED SKILL -->',
         ''
     ].join('\n');
     return body;
 }
+function skillProfile(name) {
+    const table = {
+        loop: {
+            command: '$Loop',
+            purpose: 'compile persisted route work into bounded loop plans with continuation evidence.',
+            when: 'a mission needs stage-by-stage execution, memory hints, or resume-safe artifacts.',
+            evidence: '.sneakoscope/loops/** plus codex-app-execution-profile.json',
+            fallback: 'use message-role routing when native agent_type is not verified.'
+        },
+        naruto: {
+            command: '$Naruto',
+            purpose: 'fan out bounded native worker lanes for high-scale review or implementation.',
+            when: 'parallel lanes are explicitly selected by the route and parent integration remains owner.',
+            evidence: 'naruto work graph, worker ledgers, and execution profile payloads.',
+            fallback: 'degrade to message-role workers without dropping proof artifacts.'
+        },
+        'qa-loop': {
+            command: '$QA-LOOP',
+            purpose: 'dogfood UI/API behavior with gate artifacts and current execution profile.',
+            when: 'route completion needs human-proxy verification or app handoff checks.',
+            evidence: 'qa-loop gate/result ledgers and codex-app-execution-profile.json.',
+            fallback: 'record the unavailable surface as blocked rather than inventing visual proof.'
+        },
+        research: {
+            command: '$Research',
+            purpose: 'run evidence-bound research cycles with source routing and synthesis ledgers.',
+            when: 'the request depends on discovery, evaluation, or external-source claims.',
+            evidence: 'research plan, source ledger, cycle record, and execution profile routing.',
+            fallback: 'mark unavailable source tools explicitly and avoid unsupported live-accuracy claims.'
+        },
+        dfix: {
+            command: '$DFix',
+            purpose: 'perform tiny direct fixes without the full Team route.',
+            when: 'copy/config/docs/labels/spacing/translation/mechanical edits are truly narrow.',
+            evidence: 'focused diff plus DFix Honest check.',
+            fallback: 'route broad implementation through Team/Loop instead.'
+        },
+        'image-ux-review': {
+            command: '$Image-UX-Review',
+            purpose: 'produce generated annotated UI review images and extract issue ledgers.',
+            when: 'visual UX critique is requested from screenshots or app captures.',
+            evidence: 'source inventory, generated annotation images, extracted issue ledger.',
+            fallback: 'block if raster annotation cannot be produced.'
+        },
+        'computer-use': {
+            command: '$Computer-Use',
+            purpose: 'operate native macOS desktop apps through the fast Computer Use lane.',
+            when: 'the task depends on non-web desktop UI or OS settings.',
+            evidence: 'desktop interaction notes/screenshots where available.',
+            fallback: 'use Browser/Chrome only for web targets.'
+        },
+        'init-deep': {
+            command: '$Init-Deep',
+            purpose: 'refresh project-local memory, directory AGENTS sections, and loop memory hints.',
+            when: 'a route needs deeper local context or directory-specific instruction recall.',
+            evidence: '.sneakoscope/context/AGENTS.generated.md and managed directory AGENTS blocks.',
+            fallback: 'preserve user content and skip directories that cannot be safely updated.'
+        }
+    };
+    return table[name] || {
+        command: `$${name}`,
+        purpose: 'bridge an SKS managed Codex App route.',
+        when: 'the matching SKS route is explicitly requested.',
+        evidence: '.sneakoscope route artifacts.',
+        fallback: 'record blockers with evidence.'
+    };
+}
 function hash(value) {
     return crypto.createHash('sha256').update(`sks-skill:${value}`).digest('hex').slice(0, 12);
 }

package/dist/core/codex-native/codex-native-capability-cache.js

@@ -0,0 +1,21 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { writeJsonAtomic } from '../fsx.js';
+const CACHE_RELATIVE_PATH = '.sneakoscope/reports/codex-native-feature-matrix.json';
+export function codexNativeCapabilityCachePath(root) {
+    return path.join(root, CACHE_RELATIVE_PATH);
+}
+export async function readCodexNativeCapabilityCache(root) {
+    const file = codexNativeCapabilityCachePath(root);
+    const text = await fs.readFile(file, 'utf8').catch(() => null);
+    if (!text)
+        return null;
+    const parsed = JSON.parse(text);
+    return parsed?.schema === 'sks.codex-native-feature-matrix.v1' ? parsed : null;
+}
+export async function writeCodexNativeCapabilityCache(root, matrix) {
+    const file = codexNativeCapabilityCachePath(root);
+    await writeJsonAtomic(file, matrix);
+    return file;
+}
+//# sourceMappingURL=codex-native-capability-cache.js.map