sneakoscope 6.1.2 → 6.2.0

package/dist/core/agents/agent-effort-policy.js

@@ -62,24 +62,31 @@ export function decideAgentEffort(input = {}) {
         ]
     };
 }
-// Official Codex subagents always use max reasoning. Clear bounded work uses
-// Luna; any judgment-bearing slice uses Sol. There is no automatic Terra or
-// lower-effort fallback.
+// Official Codex subagents use one of four fixed profiles: Luna Max for tiny
+// mechanical work, Sol High for ordinary implementation, Sol Max for
+// judgment, and Terra Medium for long-context or Codex-tool execution.
 export function decideOfficialSubagentModel(input = {}) {
     const persona = input.persona || {};
     const prompt = String(input.prompt || '');
     const role = String(persona.role || '');
     const agentId = String(input.agentId || persona.id || 'subagent');
+    const routingRole = [agentId, persona.naruto_role, persona.work_kind, role].filter(Boolean).join(' ');
+    const taskClass = /(?:implementation_specialist|ui_implementer|native_app_specialist)/i.test(routingRole)
+        ? 'implementation'
+        : /(?:explorer|docs_maintainer|long_context_analyst|computer_use_operator|browser_use_operator|image_generation_operator)/i.test(routingRole)
+            ? 'context_tools'
+            : undefined;
     const routed = decideSubagentModel({
-        title: [agentId, persona.naruto_role, persona.work_kind].filter(Boolean).join(' '),
+        title: routingRole,
         description: [prompt, persona.risk_focus, persona.write_policy].filter(Boolean).join(' '),
         role,
-        expectedOutput: (persona.output_expectations || []).join(' ')
+        expectedOutput: (persona.output_expectations || []).join(' '),
+        ...(taskClass ? { taskClass } : {})
     });
-    const effort = 'max';
+    const effort = routed.modelReasoningEffort;
     const modelCapability = codexModelEffortCapability({
         model: routed.model,
-        advertisedEfforts: ['max'],
+        advertisedEfforts: [effort],
         defaultEffort: effort
     });
     return {
@@ -99,11 +106,15 @@ export function decideOfficialSubagentModel(input = {}) {
         reason: routed.reason,
         dynamic: true,
         escalation_triggers: [
-            'UI, review, debugging, planning, architecture, integration, security, database, release, or ambiguity selects Sol Max',
-            'requiresJudgment or reasoning-sensitive evidence selects Sol Max',
-            'requested model or max effort unavailable blocks instead of silently falling back'
+            'review, debugging, planning, architecture, integration, security, database, research, release, or ambiguity selects Sol Max',
+            'mixed tool-and-judgment work is split; an unsplittable slice selects Sol Max',
+            'requested model/effort profile unavailable blocks instead of silently falling back'
         ],
-        downshift_triggers: []
+        downshift_triggers: [
+            'ordinary UI, logic, backend, or native implementation selects Sol High',
+            'long-context, Browser/Chrome, Computer Use, or image-generation execution selects Terra Medium',
+            'tiny short-context mechanical work selects Luna Max'
+        ]
     };
 }
 /** @deprecated since 6.1.1. Use decideOfficialSubagentModel. */
@@ -129,20 +140,20 @@ export function buildAgentEffortPolicy(roster = {}) {
         policy_version: 1,
         dynamic: true,
         service_tier: 'fast',
-        model_catalog_policy: narutoFamilyOnly ? 'official_subagent_luna_sol_max' : 'codex_catalog_passthrough',
-        model_constraint: narutoFamilyOnly ? ['gpt-5.6-luna', 'gpt-5.6-sol'] : null,
-        explicit_compatibility_models: narutoFamilyOnly ? ['gpt-5.6-terra'] : null,
+        model_catalog_policy: narutoFamilyOnly ? 'official_subagent_four_profile_matrix' : 'codex_catalog_passthrough',
+        model_constraint: narutoFamilyOnly ? ['gpt-5.6-luna', 'gpt-5.6-terra', 'gpt-5.6-sol'] : null,
+        explicit_compatibility_models: null,
         model_tiers: narutoFamilyOnly
-            ? ['gpt-5.6-luna-max', 'gpt-5.6-sol-max', 'gpt-5.6-terra-max']
+            ? ['gpt-5.6-luna-max', 'gpt-5.6-sol-high', 'gpt-5.6-sol-max', 'gpt-5.6-terra-medium']
             : ['codex-selected-low', 'codex-selected-medium', 'codex-selected-high', 'codex-selected-xhigh', 'glm-5.2-minimal', 'glm-5.2-low', 'glm-5.2-high', 'glm-5.2-xhigh'],
-        allowed_efforts: narutoFamilyOnly ? ['max'] : codexModelEffortCapability().advertised_efforts,
+        allowed_efforts: narutoFamilyOnly ? ['medium', 'high', 'max'] : codexModelEffortCapability().advertised_efforts,
         model_effort_capability: codexModelEffortCapability(),
         max_agents: roster.max_agents || 20,
         agent_count: roster.agent_count || decisions.length,
         concurrency: roster.concurrency || decisions.length,
         decisions,
         rule: narutoFamilyOnly
-            ? 'Official Naruto subagents automatically use GPT-5.6 Luna Max for clear bounded repeatable work and GPT-5.6 Sol Max for every reasoning-sensitive slice; an explicit user-selected Terra model remains compatible but is never selected automatically.'
+            ? 'Official Naruto subagents use GPT-5.6 Luna Max only for tiny short-context mechanical work, GPT-5.6 Sol High for ordinary implementation, GPT-5.6 Sol Max for judgment-heavy work, and GPT-5.6 Terra Medium for long-context or Browser/Chrome, Computer Use, and image-generation execution. Judgment wins when one slice cannot be safely split.'
             : 'Codex/OpenAI workers inherit the current Codex-selected model, including future catalog entries; SKS changes only advertised reasoning effort. Explicit non-Codex provider modes retain their provider model.'
     };
 }

package/dist/core/agents/agent-schema.js

@@ -12,7 +12,7 @@ export const MAX_AGENT_COUNT = 20;
 export const DEFAULT_AGENT_CONCURRENCY = 4;
 /** @deprecated Legacy process-swarm queue ceiling; never an official thread cap. */
 export const MAX_NARUTO_AGENT_COUNT = 100;
-/** @deprecated Legacy clone default; official workflows use one safe default child unless --agents is explicit. */
+/** @deprecated Legacy clone default; official workflows use two default children unless --agents is explicit. */
 export const DEFAULT_NARUTO_CLONES = 8;
 export const AGENT_BACKENDS = ['fake', 'process', 'codex-sdk', 'zellij', 'ollama', 'local-llm'];
 export function normalizeAgentBackend(input) {

package/dist/core/codex/codex-config-guard.js

@@ -1,4 +1,6 @@
 import path from 'node:path';
+import fsp from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
 import { appendJsonl, ensureDir, nowIso, readText, sha256, writeTextAtomic } from '../fsx.js';
 import { diffCodexAppUiSnapshots, snapshotCodexAppUiState } from '../codex-app/codex-app-ui-state-snapshot.js';
 import { cleanupCodexConfigBackups, validateCodexConfigRoundTrip } from './codex-config-toml.js';
@@ -38,10 +40,13 @@ export async function writeCodexConfigGuarded(input) {
         return result;
     }
     const beforeSnapshot = await snapshotForConfig(root, configPath).catch(() => null);
-    let next = ensureTrailingNewline(await input.mutate(before));
+    const normalizeText = input.preserveTextFormatting === true
+        ? (value) => String(value || '')
+        : ensureTrailingNewline;
+    let next = normalizeText(await input.mutate(before));
     if (input.removeTopLevelModeLocks === true)
         next = removeLegacyTopLevelCodexModeLocks(next);
-    const preserved = input.preserveFastUiKeys === false ? { text: ensureTrailingNewline(next), keys: [] } : mergeLostFastUiKeys(before, next);
+    const preserved = input.preserveFastUiKeys === false ? { text: normalizeText(next), keys: [] } : mergeLostFastUiKeys(before, next);
     next = preserved.text;
     if (input.removeTopLevelModeLocks === true)
         next = removeLegacyTopLevelCodexModeLocks(next);
@@ -63,8 +68,29 @@ export async function writeCodexConfigGuarded(input) {
         });
         return result;
     }
-    if (next === ensureTrailingNewline(before)) {
-        await writeTextAtomic(configPath, next, { mode: 0o600 });
+    const expectedBefore = normalizeText(before);
+    if (next === expectedBefore) {
+        if (input.verifyUnchangedBeforeWrite === true) {
+            const observed = await readConfigCommitSnapshot(configPath);
+            const expectedExists = input.expectedBeforeExists ?? true;
+            if (!configCommitSnapshotMatches(observed, expectedExists, before)) {
+                return recordConcurrentConfigChange({
+                    root,
+                    reportPath: input.reportPath,
+                    cause,
+                    configPath,
+                    before,
+                    expectedExists,
+                    observed,
+                    backupPath: null,
+                    repairedKeys: preserved.keys,
+                    forbiddenTopLevel
+                });
+            }
+        }
+        else {
+            await writeTextAtomic(configPath, next, { mode: 0o600 });
+        }
         const result = { ok: true, status: 'present', config_path: configPath, backup_path: null, changed: false, repaired_keys: preserved.keys, forbidden_top_level: forbiddenTopLevel };
         if (preserved.keys.length || forbiddenTopLevel.length) {
             await recordCodexConfigGuard(root, input.reportPath, {
@@ -79,9 +105,37 @@ export async function writeCodexConfigGuarded(input) {
         }
         return result;
     }
-    const backupPath = before.trim() ? await backupCodexConfig(configPath, before, input.backupTag || cause) : null;
-    await ensureDir(path.dirname(configPath));
-    await writeTextAtomic(configPath, next, { mode: 0o600 });
+    let backupPath = null;
+    if (input.verifyUnchangedBeforeWrite === true) {
+        const expectedExists = input.expectedBeforeExists ?? true;
+        const commit = await commitCodexConfigIfUnchanged({
+            configPath,
+            before,
+            next,
+            expectedExists,
+            backupTag: input.backupTag || cause
+        });
+        if (!commit.ok) {
+            return recordConcurrentConfigChange({
+                root,
+                reportPath: input.reportPath,
+                cause,
+                configPath,
+                before,
+                expectedExists,
+                observed: commit.observed,
+                backupPath: commit.backupPath,
+                repairedKeys: preserved.keys,
+                forbiddenTopLevel
+            });
+        }
+        backupPath = commit.backupPath;
+    }
+    else {
+        backupPath = before.trim() ? await backupCodexConfig(configPath, before, input.backupTag || cause) : null;
+        await ensureDir(path.dirname(configPath));
+        await writeTextAtomic(configPath, next, { mode: 0o600 });
+    }
     const afterSnapshot = await snapshotForConfig(root, configPath).catch(() => null);
     const diff = beforeSnapshot && afterSnapshot ? diffCodexAppUiSnapshots(beforeSnapshot, afterSnapshot) : null;
     const result = {
@@ -115,6 +169,123 @@ export async function writeCodexConfigGuarded(input) {
     });
     return { ...result, report_path: reportPath };
 }
+function configCommitSnapshotMatches(observed, expectedExists, expectedText) {
+    return observed.ok
+        && observed.exists === expectedExists
+        && sha256(observed.text) === sha256(expectedText);
+}
+async function recordConcurrentConfigChange(input) {
+    const result = {
+        ok: false,
+        status: 'concurrent_change_detected',
+        config_path: input.configPath,
+        backup_path: input.backupPath,
+        changed: false,
+        repaired_keys: input.repairedKeys,
+        forbidden_top_level: input.forbiddenTopLevel
+    };
+    await recordCodexConfigGuard(input.root, input.reportPath, {
+        cause: input.cause,
+        config_path: input.configPath,
+        ok: false,
+        status: result.status,
+        expected_exists: input.expectedExists,
+        observed_exists: input.observed.exists,
+        expected_sha256: sha256(input.before),
+        observed_sha256: input.observed.ok ? sha256(input.observed.text) : null,
+        observed_status: input.observed.status,
+        backup_path: input.backupPath,
+        changed: false
+    });
+    return result;
+}
+async function commitCodexConfigIfUnchanged(input) {
+    await ensureDir(path.dirname(input.configPath));
+    const token = `${Date.now().toString(36)}-${process.pid}-${randomBytes(6).toString('hex')}`;
+    const candidatePath = `${input.configPath}.sks-commit-${token}.tmp`;
+    let backupPath = null;
+    try {
+        await writeTextAtomic(candidatePath, input.next, { mode: 0o600 });
+        const observed = await readConfigCommitSnapshot(input.configPath);
+        if (!configCommitSnapshotMatches(observed, input.expectedExists, input.before)) {
+            return { ok: false, backupPath, observed };
+        }
+        if (input.expectedExists) {
+            backupPath = `${input.configPath}.sks-${safeBackupTag(input.backupTag)}-${token}.bak`;
+            try {
+                await fsp.rename(input.configPath, backupPath);
+            }
+            catch {
+                return { ok: false, backupPath: null, observed: await readConfigCommitSnapshot(input.configPath) };
+            }
+            const claimed = await readConfigCommitSnapshot(backupPath);
+            if (!configCommitSnapshotMatches(claimed, true, input.before)) {
+                await restoreClaimedConfigIfAbsent(backupPath, input.configPath, claimed);
+                return { ok: false, backupPath, observed: claimed };
+            }
+            try {
+                await fsp.chmod(backupPath, 0o600);
+                const now = new Date();
+                await fsp.utimes(backupPath, now, now);
+            }
+            catch {
+                await restoreClaimedConfigIfAbsent(backupPath, input.configPath, claimed);
+                return { ok: false, backupPath, observed: await readConfigCommitSnapshot(input.configPath) };
+            }
+            const afterClaim = await readConfigCommitSnapshot(input.configPath);
+            if (!afterClaim.ok || afterClaim.exists) {
+                if (!afterClaim.exists)
+                    await restoreClaimedConfigIfAbsent(backupPath, input.configPath, claimed);
+                return { ok: false, backupPath, observed: await readConfigCommitSnapshot(input.configPath) };
+            }
+        }
+        try {
+            await fsp.link(candidatePath, input.configPath);
+        }
+        catch {
+            if (backupPath) {
+                const claimed = await readConfigCommitSnapshot(backupPath);
+                await restoreClaimedConfigIfAbsent(backupPath, input.configPath, claimed);
+            }
+            return { ok: false, backupPath, observed: await readConfigCommitSnapshot(input.configPath) };
+        }
+        await fsp.chmod(input.configPath, 0o600).catch(() => undefined);
+        await cleanupCodexConfigBackups(input.configPath, { keepPerTag: 3, maxAgeMs: 30 * 24 * 60 * 60 * 1000 }).catch(() => undefined);
+        return { ok: true, backupPath };
+    }
+    finally {
+        await fsp.rm(candidatePath, { force: true }).catch(() => undefined);
+    }
+}
+async function restoreClaimedConfigIfAbsent(backupPath, configPath, claimed) {
+    if (!claimed.ok || !claimed.exists || claimed.status !== 'regular')
+        return;
+    await fsp.link(backupPath, configPath).catch(() => undefined);
+}
+function safeBackupTag(value) {
+    return String(value || 'codex-config').replace(/[^A-Za-z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 96) || 'codex-config';
+}
+async function readConfigCommitSnapshot(configPath) {
+    let stat;
+    try {
+        stat = await fsp.lstat(configPath);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return { ok: true, exists: false, text: '', status: 'missing' };
+        return { ok: false, exists: false, text: '', status: 'read_failed' };
+    }
+    if (stat.isSymbolicLink())
+        return { ok: false, exists: true, text: '', status: 'symlink' };
+    if (!stat.isFile())
+        return { ok: false, exists: true, text: '', status: 'non_regular' };
+    try {
+        return { ok: true, exists: true, text: await fsp.readFile(configPath, 'utf8'), status: 'regular' };
+    }
+    catch {
+        return { ok: false, exists: true, text: '', status: 'read_failed' };
+    }
+}
 export function extractTomlTable(text, tableName) {
     const source = String(text || '');
     const header = `[${tableName}]`;

package/dist/core/codex/codex-config-readability.js

@@ -50,16 +50,29 @@ export async function inspectCodexConfigReadability(rootInput = process.cwd(), o
             }
             add({ name: 'config_symlink', ok: !isSymlink || symlinkDetail.allowed === true, detail: symlinkDetail });
         }
-        if (process.platform === 'darwin') {
-            add(await commandCheck('macos_acl_ls_le', 'ls', ['-le', configPath], root));
-            const acl = checks.find((check) => check.name === 'macos_acl_ls_le');
+        const readChecksPromise = Promise.all([
+            nodeReadCheck(configPath),
+            childReadCheck(configPath, root),
+            codexCliConfigLoadCheck(root, configPath, opts)
+        ]);
+        // These are independent read-only metadata probes. Running them serially
+        // multiplied a single TCC/ACL timeout by three on the MAD launch path.
+        const macChecksPromise = process.platform === 'darwin'
+            ? Promise.all([
+                commandCheck('macos_acl_ls_le', 'ls', ['-le', configPath], root),
+                commandCheck('macos_flags_ls_lO', 'ls', ['-lO', configPath], root),
+                commandCheck('macos_xattr', 'xattr', ['-l', configPath], root, { allowExitCodes: [0, 1] })
+            ])
+            : Promise.resolve(null);
+        const [[nodeRead, childRead, codexLoad], macChecks] = await Promise.all([readChecksPromise, macChecksPromise]);
+        if (macChecks) {
+            const [acl, flags, xattrs] = macChecks;
+            add(acl);
             if (/\bdeny\b.*\b(read|readattr|readextattr|readsecurity|search)\b/i.test(String(acl?.detail?.stdout || '')))
                 blockers.add('acl_denied');
-            const flags = await commandCheck('macos_flags_ls_lO', 'ls', ['-lO', configPath], root);
             add(flags);
             if (/\b(uchg|schg|restricted)\b/.test(String(flags.detail?.stdout || '')))
                 blockers.add('flags_locked');
-            const xattrs = await commandCheck('macos_xattr', 'xattr', ['-l', configPath], root, { allowExitCodes: [0, 1] });
             add(xattrs);
             add({ name: 'macos_quarantine_xattr', ok: !/com\.apple\.quarantine/.test(String(xattrs.detail?.stdout || '')), detail: { present: /com\.apple\.quarantine/.test(String(xattrs.detail?.stdout || '')) } });
             if (/com\.apple\.quarantine/.test(String(xattrs.detail?.stdout || '')))
@@ -68,9 +81,9 @@ export async function inspectCodexConfigReadability(rootInput = process.cwd(), o
         else {
             add({ name: 'macos_metadata', ok: true, status: 'skipped_non_macos' });
         }
-        add(await nodeReadCheck(configPath));
-        add(await childReadCheck(configPath, root));
-        add(await codexCliConfigLoadCheck(root, configPath, opts));
+        add(nodeRead);
+        add(childRead);
+        add(codexLoad);
     }
     else {
         add({ name: 'config_file_checks', ok: true, status: 'skipped_config_missing', detail: { config_path: configPath } });

package/dist/core/codex/codex-config-toml.js

@@ -52,9 +52,8 @@ export async function cleanupCodexConfigBackups(configPath, opts = {}) {
     const now = Date.now();
     const groups = new Map();
     for (const file of entries) {
-        if (!file.startsWith(`${base}.`))
-            continue;
-        if (!/(?:^|[.-])(?:sks-|bak-|struct-bak-)|\.bak$/.test(file))
+        const tag = ownedBackupTag(base, file);
+        if (!tag)
             continue;
         const abs = path.join(dir, file);
         let stat;
@@ -66,7 +65,6 @@ export async function cleanupCodexConfigBackups(configPath, opts = {}) {
         }
         if (!stat.isFile())
             continue;
-        const tag = backupTag(base, file);
         const group = groups.get(tag) || [];
         group.push({ file, abs, mtimeMs: stat.mtimeMs });
         groups.set(tag, group);
@@ -87,16 +85,21 @@ export async function cleanupCodexConfigBackups(configPath, opts = {}) {
     }
     return { cleaned: removed.length, files: removed };
 }
-function backupTag(base, file) {
+function ownedBackupTag(base, file) {
+    if (!file.startsWith(`${base}.`))
+        return null;
     const suffix = file.slice(`${base}.`.length);
-    const sks = suffix.match(/^sks-([^-]+)-/);
-    if (sks?.[1])
-        return `sks-${sks[1]}`;
-    if (suffix.startsWith('struct-bak-'))
+    if (/^sks-[A-Za-z0-9_.-]+\.bak$/.test(suffix)) {
+        const group = suffix.match(/^sks-([^-]+)-/)?.[1] || suffix.slice('sks-'.length, -'.bak'.length);
+        return `sks-${group}`;
+    }
+    if (/^struct-bak-[A-Za-z0-9_.-]+$/.test(suffix))
         return 'struct-bak';
-    if (suffix.startsWith('bak-'))
+    if (/^bak-[A-Za-z0-9_.-]+$/.test(suffix))
         return 'bak';
-    return 'misc';
+    if (/^codex-app-ui-repair-[A-Za-z0-9_.-]+\.bak$/.test(suffix))
+        return 'codex-app-ui-repair';
+    return null;
 }
 function messageOf(err) {
     return err instanceof Error ? err.message : String(err);