sneakoscope 6.0.3 → 6.1.2

package/dist/core/agents/agent-runner-codex-exec.js

@@ -4,6 +4,7 @@ import { managedProxyEnvForChild } from '../codex/managed-proxy-env.js';
 import { agentWorkerEnv, validateAgentWorkerResult } from './agent-worker-pipeline.js';
 import { fastModeEnv, resolveFastModePolicy } from './fast-mode-policy.js';
 import { buildCodexExecArgs } from '../codex/codex-cli-syntax-builder.js';
+import { codexLbRecoveryBlockedProcessResult, withCodexLbCliLaunchRecovery } from '../codex-control/codex-lb-launch-recovery.js';
 export function buildCodexExecAgentArgs(agent, prompt, opts = {}) {
     const resultFile = opts.resultFile || defaultCodexResultFile(agent, opts);
     const sandbox = opts.workspaceWrite ? 'workspace-write' : 'read-only';
@@ -44,6 +45,7 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
         const command = buildCodexExecAgentArgs(agent, opts.prompt || slice?.description || '', opts);
         const proxyEnv = managedProxyEnvForChild({ ...process.env, ...(opts.env || {}) });
         const report = await writeCodexProcessReport(opts.agentRoot || opts.cwd || process.cwd(), agent, {
+            project_hash: opts.projectHash || agent.project_hash || agent.root_hash || null,
             command: [opts.codexBin || 'codex', ...command.args],
             profile: opts.profile || null,
             result_file: command.resultFile,
@@ -71,9 +73,21 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
     const stderrFile = path.join(logRoot, 'codex-exec.stderr.log');
     const allowedCommandsFile = path.join(opts.agentRoot || opts.cwd || process.cwd(), 'agent-allowed-commands.json');
     const workerEnv = agentWorkerEnv(agent, allowedCommandsFile);
-    const proxyEnv = managedProxyEnvForChild({ ...process.env, ...(opts.env || {}) });
-    const result = await runProcess(opts.codexBin || 'codex', command.args, { cwd: opts.cwd || process.cwd(), env: { ...(opts.env || {}), ...proxyEnv, ...fastModeEnv(fastPolicy), ...workerEnv }, timeoutMs: opts.timeoutMs || 30 * 60 * 1000, maxOutputBytes: 256 * 1024, stdoutFile, stderrFile });
+    const effectiveEnv = { ...process.env, ...(opts.env || {}) };
+    const proxyEnv = managedProxyEnvForChild(effectiveEnv);
+    const execute = opts.runProcessImpl || runProcess;
+    const guarded = await withCodexLbCliLaunchRecovery({
+        root: opts.cwd || process.cwd(),
+        env: effectiveEnv,
+        cliArgs: command.args.slice(0, -1),
+        ...(typeof opts.recoveryFetch === 'function' ? { fetchImpl: opts.recoveryFetch } : {}),
+        ...(opts.recoveryTimeoutMs === undefined ? {} : { timeoutMs: opts.recoveryTimeoutMs })
+    }, () => execute(opts.codexBin || 'codex', command.args, { cwd: opts.cwd || process.cwd(), env: { ...(opts.env || {}), ...proxyEnv, ...fastModeEnv(fastPolicy), ...workerEnv }, timeoutMs: opts.timeoutMs || 30 * 60 * 1000, maxOutputBytes: 256 * 1024, stdoutFile, stderrFile }));
+    const result = guarded.launched
+        ? guarded.value
+        : codexLbRecoveryBlockedProcessResult(guarded.toolOutputRecovery);
     const report = await writeCodexProcessReport(opts.agentRoot || opts.cwd || process.cwd(), agent, {
+        project_hash: opts.projectHash || agent.project_hash || agent.root_hash || null,
         command: [opts.codexBin || 'codex', ...command.args],
         profile: opts.profile || null,
         result_file: command.resultFile,
@@ -97,6 +111,7 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
         stderr_bytes: result.stderrBytes,
         truncated: result.truncated,
         timed_out: result.timedOut,
+        codex_lb_tool_output_recovery: guarded.toolOutputRecovery,
         dry_run: false
     });
     if (result.code === 0) {
@@ -121,7 +136,7 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
             return { ...validated, status: 'blocked', blockers: [...validated.blockers, 'codex_exec_result_schema_invalid'] };
         }
     }
-    return validateAgentWorkerResult({ mission_id: opts.missionId || opts.mission_id || '', agent_id: agent.id, session_id: agent.session_id, persona_id: agent.persona_id || agent.id, task_slice_id: slice?.id || '', status: result.code === 0 ? 'done' : 'failed', backend: 'codex-exec', summary: result.stdout.slice(-1000) || result.stderr.slice(-1000), artifacts: [command.resultFile, report], blockers: result.code === 0 ? ['codex_exec_output_last_message_missing_or_invalid'] : ['codex_exec_exit_' + result.code], confidence: 'verified_partial', unverified: result.code === 0 ? ['codex-exec stdout fallback; resultFile JSON missing or invalid'] : [], writes: [], source_intelligence_refs: agent.source_intelligence_refs || null, goal_mode_ref: agent.goal_mode_ref || null, verification: { status: result.code === 0 ? 'partial' : 'failed', checks: ['codex-exec-exit-code', 'codex-exec-process-report', 'codex-exec-output-last-message'] } });
+    return validateAgentWorkerResult({ mission_id: opts.missionId || opts.mission_id || '', agent_id: agent.id, session_id: agent.session_id, persona_id: agent.persona_id || agent.id, task_slice_id: slice?.id || '', status: result.code === 0 ? 'done' : 'failed', backend: 'codex-exec', summary: result.stdout.slice(-1000) || result.stderr.slice(-1000), artifacts: [command.resultFile, report], blockers: result.code === 0 ? ['codex_exec_output_last_message_missing_or_invalid'] : [...(guarded.launched ? [] : guarded.toolOutputRecovery.blockers), 'codex_exec_exit_' + result.code], confidence: 'verified_partial', unverified: result.code === 0 ? ['codex-exec stdout fallback; resultFile JSON missing or invalid'] : [], writes: [], source_intelligence_refs: agent.source_intelligence_refs || null, goal_mode_ref: agent.goal_mode_ref || null, codex_child_report: { tool_output_recovery: guarded.toolOutputRecovery }, verification: { status: result.code === 0 ? 'partial' : 'failed', checks: ['codex-exec-exit-code', 'codex-exec-process-report', 'codex-exec-output-last-message'] } });
 }
 function workerNoMcpDefault(agent, opts = {}, sandbox = 'read-only') {
     if (opts.noMcp !== undefined)

package/dist/core/agents/agent-runner-process.js

@@ -48,6 +48,7 @@ export async function runProcessAgent(agent, slice, opts = {}) {
     }
     const result = await runProcess(opts.command[0], opts.command.slice(1), { cwd: opts.cwd || process.cwd(), env: { ...(opts.env || {}), ...fastModeEnv(fastPolicy) }, timeoutMs: opts.timeoutMs || 30000, maxOutputBytes: 128 * 1024 });
     const report = await writeAgentProcessReport(opts.agentRoot || opts.cwd || process.cwd(), agent, 'process', {
+        project_hash: opts.projectHash || agent.project_hash || agent.root_hash || null,
         command: opts.command,
         service_tier: fastPolicy.service_tier,
         fast_mode: fastPolicy.fast_mode,

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

@@ -1,3 +1,4 @@
+export { DEFAULT_NARUTO_MAX_THREADS, DEFAULT_NARUTO_REQUESTED_SUBAGENTS, HARD_NARUTO_MAX_THREADS } from '../subagents/thread-budget.js';
 export const AGENT_KERNEL_SCHEMA = 'sks.native-agent-kernel.v1';
 export const AGENT_RESULT_SCHEMA = 'sks.agent-result.v1';
 export const AGENT_LEDGER_EVENT_SCHEMA = 'sks.agent-ledger-event.v1';
@@ -9,9 +10,9 @@ export const AGENT_COUNT = DEFAULT_AGENT_COUNT;
 export const AGENT_INTAKE_STAGE_ID = 'native_agent_intake';
 export const MAX_AGENT_COUNT = 20;
 export const DEFAULT_AGENT_CONCURRENCY = 4;
-// Naruto may queue a large roster, but active workers are governed separately and
-// remain bounded by live CPU, memory, load, and I/O pressure.
+/** @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. */
 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/agents/fast-mode-policy.js

@@ -18,17 +18,15 @@ export function resolveFastModePolicy(input = {}) {
             ? 'standard'
             : preference?.mode === 'standard'
                 ? 'standard'
-                : explicitFast || explicitTier === 'fast' || preference?.mode === 'fast'
-                    ? 'fast'
-                    : 'standard';
+                : 'fast';
     return {
         schema: FAST_MODE_POLICY_SCHEMA,
         generated_at: nowIso(),
         fast_mode: serviceTier === 'fast',
         service_tier: serviceTier,
         codex_desktop_service_tier: codexDesktopServiceTier(serviceTier),
-        default_fast_mode: false,
-        disabled_by: explicitNoFast ? 'no-fast' : explicitTier === 'standard' ? 'service-tier-standard' : preference?.mode === 'standard' ? 'preference-standard' : serviceTier === 'standard' ? 'default-standard' : 'none',
+        default_fast_mode: true,
+        disabled_by: explicitNoFast ? 'no-fast' : explicitTier === 'standard' ? 'service-tier-standard' : preference?.mode === 'standard' ? 'preference-standard' : 'none',
         explicit_fast: explicitFast,
         explicit_no_fast: explicitNoFast,
         explicit_service_tier: explicitTier,

package/dist/core/agents/native-cli-session-swarm.js

@@ -435,7 +435,7 @@ class NativeCliSessionSwarmRecorder {
                         headless_by_design_viewport_ui: process.env.SKS_ZELLIJ_LEGACY_WORKER_PANES === '1' ? 0 : this.input.targetActiveSlots
                     },
                     active_workers: this.input.targetActiveSlots,
-                    visible_panes: Number(process.env.SKS_ZELLIJ_VIEWPORTS || 4),
+                    visible_panes: Number(process.env.SKS_ZELLIJ_VIEWPORTS || 1),
                     headless_workers: process.env.SKS_ZELLIJ_LEGACY_WORKER_PANES === '1' ? Math.max(0, this.input.targetActiveSlots - this.zellijVisiblePaneCap(input.ctx.opts)) : this.input.targetActiveSlots,
                     queue_depth: Math.max(0, this.input.requestedAgents - this.input.targetActiveSlots),
                     local_llm: { tps: 0, queue: 0 },

package/dist/core/agents/native-worker-backend-router.js

@@ -12,6 +12,7 @@ import { CODEX_AGENT_WORKER_RESULT_SCHEMA_ID, codexAgentWorkerResultSchema } fro
 import { leanEngineeringCompactText, leanPolicyReference } from '../lean-engineering-policy.js';
 import { readCodexLbModelCatalog, readLbHealth } from '../codex-lb/codex-lb-env.js';
 import { categoryForWorkerRole, isNarutoGpt56Model, modelRouteReason, routeModel } from '../provider/model-router.js';
+import { codexTimeoutClassForRoute } from '../codex-control/codex-reliability-shield.js';
 export const NATIVE_WORKER_BACKEND_ROUTER_SCHEMA = 'sks.native-worker-backend-router.v1';
 export async function runNativeWorkerBackendRouter(input) {
     const root = path.resolve(input.agentRoot);
@@ -147,7 +148,7 @@ export async function runNativeWorkerBackendRouter(input) {
                 zellijPaneId: await readZellijPaneId(root, input.workerDirRel),
                 reliabilityPolicy: {
                     maxEmptyResultRetries: 1,
-                    timeoutClass: 'standard'
+                    timeoutClass: codexTimeoutClassForRoute(input.intake.route, 'standard')
                 }
             });
             outputLastMessagePath = sdkTask.workerResultPath;

package/dist/core/agents/work-partition/repo-inventory.js

@@ -1,9 +1,50 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-const IGNORE = new Set(['.git', 'node_modules', 'dist', 'target', '.sneakoscope', '.codex', '.agents', '.next', '.turbo']);
+const IGNORE = new Set([
+    '.agents', '.cache', '.claude', '.codex', '.git', '.git-worktrees', '.hg', '.mypy_cache', '.next', '.npm', '.nuxt',
+    '.nyc_output', '.parcel-cache', '.pnpm-store', '.pytest_cache', '.ruff_cache', '.sneakoscope', '.svelte-kit', '.svn',
+    '.tmp', '.turbo', '.venv', '.worktrees', '.yarn', '__pycache__', 'build', 'coverage', 'dist', 'logs', 'node_modules',
+    'out', 'target', 'temp', 'tmp', 'venv'
+]);
+const PRIORITY_DIRS = ['src', 'test', 'docs', 'schemas', 'scripts', 'crates', 'bin'];
+const REPRESENTATIVE_DIRS = ['src', 'test', 'docs'];
+const CORE_FILES = ['package.json', 'package-lock.json', 'README.md', 'CHANGELOG.md', 'LICENSE', 'tsconfig.json', 'release-gates.v2.json', 'runtime-required-scripts.json', 'AGENTS.md'];
 export async function collectRepoInventory(root, opts = {}) {
     const files = [];
-    await walk(root, root, files, opts.maxFiles || Number(process.env.SKS_AGENT_REPO_INVENTORY_MAX_FILES || 10000));
+    const seen = new Set();
+    const requestedMax = Number(opts.maxFiles ?? process.env.SKS_AGENT_REPO_INVENTORY_MAX_FILES ?? 10000);
+    const maxFiles = Number.isFinite(requestedMax) ? Math.max(1, Math.floor(requestedMax)) : 10000;
+    const add = (file) => {
+        if (files.length >= maxFiles || seen.has(file))
+            return;
+        seen.add(file);
+        files.push(file);
+    };
+    // Seed representative source/test/docs entries before any large tree can
+    // exhaust the cap, then expand the priority roots in a stable order.
+    for (const name of REPRESENTATIVE_DIRS) {
+        const representative = await firstFile(root, path.join(root, name));
+        if (representative)
+            add(representative);
+    }
+    for (const name of CORE_FILES) {
+        const full = path.join(root, name);
+        if ((await fs.stat(full).catch(() => null))?.isFile())
+            add(name);
+    }
+    for (const name of PRIORITY_DIRS)
+        await walk(root, path.join(root, name), files, seen, maxFiles);
+    for (const entry of await sortedEntries(root)) {
+        if (files.length >= maxFiles)
+            break;
+        if (IGNORE.has(entry.name) || PRIORITY_DIRS.includes(entry.name) || CORE_FILES.includes(entry.name))
+            continue;
+        const full = path.join(root, entry.name);
+        if (entry.isDirectory())
+            await walk(root, full, files, seen, maxFiles);
+        else if (entry.isFile())
+            add(entry.name);
+    }
     const classify = (re) => files.filter((file) => re.test(file));
     return {
         schema: 'sks.agent-repo-inventory.v1',
@@ -19,11 +60,10 @@ export async function collectRepoInventory(root, opts = {}) {
         files
     };
 }
-async function walk(root, dir, out, maxFiles) {
+async function walk(root, dir, out, seen, maxFiles) {
     if (out.length >= maxFiles)
         return;
-    const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
-    for (const entry of entries) {
+    for (const entry of await sortedEntries(dir)) {
         if (out.length >= maxFiles)
             return;
         if (IGNORE.has(entry.name))
@@ -31,9 +71,30 @@ async function walk(root, dir, out, maxFiles) {
         const full = path.join(dir, entry.name);
         const rel = path.relative(root, full).replace(/\\/g, '/');
         if (entry.isDirectory())
-            await walk(root, full, out, maxFiles);
-        else if (entry.isFile())
+            await walk(root, full, out, seen, maxFiles);
+        else if (entry.isFile() && !seen.has(rel)) {
+            seen.add(rel);
             out.push(rel);
+        }
     }
 }
+async function firstFile(root, dir) {
+    for (const entry of await sortedEntries(dir)) {
+        if (IGNORE.has(entry.name))
+            continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isFile())
+            return path.relative(root, full).replace(/\\/g, '/');
+        if (entry.isDirectory()) {
+            const nested = await firstFile(root, full);
+            if (nested)
+                return nested;
+        }
+    }
+    return null;
+}
+async function sortedEntries(dir) {
+    return (await fs.readdir(dir, { withFileTypes: true }).catch(() => []))
+        .sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+}
 //# sourceMappingURL=repo-inventory.js.map

package/dist/core/agents/zellij-right-lane-cockpit.js

@@ -36,9 +36,9 @@ export function buildZellijRightLaneCockpit(input = {}) {
         visible_lane_count: Math.min(lanes.length, maxVisible),
         page_count: pageCount,
         actual_pane_ids: lanes.map((lane) => lane.pane_id).filter(Boolean),
-        attach_command: input.sessionName ? `zellij attach ${input.sessionName}` : 'sks team open-zellij latest',
+        attach_command: input.sessionName ? `zellij attach ${input.sessionName}` : 'sks zellij status',
         keyboard_hint: 'Use the Zellij pane controls to move between lanes; detach with the configured Zellij detach binding.',
-        cleanup_command_hint: 'sks team cleanup-zellij latest',
+        cleanup_command_hint: 'Use native Zellij session controls; legacy Team mutation commands are removed.',
         ok: lanes.length > 0
     };
     const laneManifest = {

package/dist/core/code-structure.js

@@ -194,10 +194,11 @@ async function collectChangedScope(root, opts) {
 async function listSourceFiles(root, dir = root, out = []) {
     const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
-        if (entry.name.startsWith('.') && !['.agents'].includes(entry.name)) {
-            if (SKIP_DIRS.has(entry.name))
-                continue;
-        }
+        // Hidden runtime/worktree directories can contain complete repository copies.
+        // Only .agents is a source-bearing project directory; all other hidden trees
+        // are state, caches, or external workspaces and must stay outside this scan.
+        if (entry.name.startsWith('.') && entry.name !== '.agents')
+            continue;
         const full = path.join(dir, entry.name);
         if (entry.isDirectory()) {
             if (!SKIP_DIRS.has(entry.name))

package/dist/core/codex/agent-config-file-repair.js

@@ -1,227 +1,128 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { ensureDir, nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
-import { managedAgentRoleConfigForFile, managedAgentRoleConfigForRole } from '../agents/agent-role-config.js';
-import { isUnmanagedProjectCodexConfig, writeCodexConfigGuarded } from './codex-config-guard.js';
+import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { backupInvalidToml, inspectOfficialSubagentToml, mergeOfficialSubagentConfig, officialSubagentConfigOwnershipProof, officialSubagentConfigWarnings, readInheritedOfficialSubagentConfigText } from '../subagents/official-subagent-config.js';
+import { writeCodexConfigGuarded } from './codex-config-guard.js';
+/**
+ * Compatibility entrypoint retained for doctor callers. It repairs the
+ * official project [agents] settings and removes only exact legacy SKS child
+ * tables after ownership has been proven. User-authored child tables remain.
+ */
 export async function repairAgentConfigFileReferences(input) {
     const root = path.resolve(input.root);
     const configPath = path.join(root, '.codex', 'config.toml');
     const configExists = await fs.stat(configPath).then((stat) => stat.isFile()).catch(() => false);
-    const original = configExists ? await fs.readFile(configPath, 'utf8').catch(() => '') : minimalManagedConfigToml();
-    if (input.apply && configExists && isUnmanagedProjectCodexConfig(root, configPath, original)) {
-        const report = {
+    const original = configExists ? await fs.readFile(configPath, 'utf8').catch(() => '') : '';
+    const manifest = await readJson(path.join(root, '.sneakoscope', 'manifest.json'), null);
+    const migrationReceipt = await readJson(path.join(root, '.sneakoscope', 'update', 'migration-receipt.json'), null);
+    const ownershipProof = officialSubagentConfigOwnershipProof({
+        text: original,
+        manifest,
+        migrationReceipt
+    });
+    const originalValidation = inspectOfficialSubagentToml(original);
+    if (configExists && !originalValidation.ok) {
+        const backupPath = input.apply
+            ? await backupInvalidToml(configPath, original, 'doctor-project-config-invalid')
+            : null;
+        return writeReport(input.reportPath, root, {
             schema: 'sks.agent-config-file-repair.v1',
             generated_at: nowIso(),
             ok: false,
-            apply: true,
+            apply: input.apply === true,
             config_path: configPath,
+            backup_path: backupPath,
             repaired_paths: [],
             created_files: [],
             removed_unsupported_fields: [],
             skipped_unmanaged_paths: [],
             manual_required: true,
-            blockers: ['user_owned_file_without_sks_marker']
-        };
-        if (input.reportPath !== null)
-            await writeJsonAtomic(input.reportPath || path.join(root, '.sneakoscope', 'reports', 'agent-config-file-repair.json'), report).catch(() => undefined);
-        return report;
-    }
-    const createdFiles = [];
-    const repairedPaths = [];
-    const removedUnsupportedFields = [];
-    const skippedUnmanagedPaths = [];
-    const edits = [];
-    let text = original;
-    for (const block of tomlBlocks(original)) {
-        const managed = managedBlockTarget(root, block);
-        const currentConfigFile = stringValue(block.text, 'config_file');
-        if (!managed) {
-            if (currentConfigFile && !path.isAbsolute(currentConfigFile))
-                skippedUnmanagedPaths.push(currentConfigFile);
-            continue;
-        }
-        const target = path.join(root, '.codex', 'agents', managed.file);
-        let replacement = removeKey(block.text, 'message_role_prefix', removedUnsupportedFields);
-        replacement = replaceOrInsertKey(replacement, 'config_file', `"${escapeToml(target)}"`);
-        if (replacement !== block.text) {
-            edits.push({ start: block.start, end: block.end, replacement });
-            repairedPaths.push(target);
-        }
-        if (input.apply) {
-            const exists = await fs.stat(target).then((stat) => stat.isFile()).catch(() => false);
-            if (!exists) {
-                await ensureDir(path.dirname(target));
-                await writeTextAtomic(target, managed.content);
-                createdFiles.push(target);
-            }
-        }
+            blockers: [
+                'project_official_subagent_config_toml_parse_failed',
+                ...(!ownershipProof.owned ? ['user_owned_file_without_sks_marker'] : [])
+            ],
+            warnings: [],
+            ownership_proof: ownershipProof
+        });
     }
-    if (edits.length)
-        text = applyEdits(original, edits);
-    if (input.apply && !configExists) {
-        await ensureDir(path.dirname(configPath));
-        await writeCodexConfigGuarded({
-            root,
-            configPath,
-            before: '',
-            cause: 'agent-config-file-repair',
-            mutate: () => text.replace(/\n{3,}/g, '\n\n').replace(/\s*$/, '\n')
+    if (input.apply && configExists && !ownershipProof.owned) {
+        return writeReport(input.reportPath, root, {
+            schema: 'sks.agent-config-file-repair.v1',
+            generated_at: nowIso(),
+            ok: false,
+            apply: true,
+            config_path: configPath,
+            backup_path: null,
+            repaired_paths: [],
+            created_files: [],
+            removed_unsupported_fields: [],
+            skipped_unmanaged_paths: [],
+            manual_required: true,
+            blockers: ['user_owned_file_without_sks_marker'],
+            warnings: [],
+            ownership_proof: ownershipProof
         });
-        createdFiles.push(configPath);
     }
-    else if (input.apply && text !== original) {
-        await writeCodexConfigGuarded({
+    const inheritedText = await readInheritedOfficialSubagentConfigText(configPath, {
+        ...(input.home ? { home: input.home } : {}),
+        ...(input.codexHome ? { codexHome: input.codexHome } : {})
+    });
+    const merged = mergeOfficialSubagentConfig(original, {
+        sksOwned: ownershipProof.owned,
+        inheritedText
+    });
+    const validation = inspectOfficialSubagentToml(merged);
+    const warnings = officialSubagentConfigWarnings(merged, inheritedText);
+    const blockers = [];
+    let changed = merged !== original;
+    let writeSucceeded = input.apply !== true;
+    let backupPath = null;
+    if (input.apply) {
+        const guarded = await writeCodexConfigGuarded({
             root,
             configPath,
             before: original,
-            cause: 'agent-config-file-repair',
-            mutate: () => text.replace(/\n{3,}/g, '\n\n').replace(/\s*$/, '\n')
+            cause: 'official-subagent-config-repair',
+            ownershipVerified: ownershipProof.owned,
+            mutate: () => merged
         });
+        writeSucceeded = guarded.ok;
+        changed = guarded.ok && guarded.changed;
+        backupPath = guarded.backup_path;
+        if (!guarded.ok)
+            blockers.push(`config_write_guard:${guarded.status}`);
+    }
+    else if (!validation.ok) {
+        blockers.push('project_official_subagent_config_toml_parse_failed');
     }
-    const effectiveText = input.apply ? await fs.readFile(configPath, 'utf8').catch(() => text) : text;
-    const missing = await missingAgentConfigFiles(effectiveText);
-    const unsupportedManagedFields = managedAgentBlocks(effectiveText)
-        .flatMap((block) => block.text.split(/\r?\n/).filter((line) => /^\s*message_role_prefix\s*=/.test(line)));
     const report = {
         schema: 'sks.agent-config-file-repair.v1',
         generated_at: nowIso(),
-        ok: missing.length === 0 && !/^\s*message_role_prefix\s*=/m.test(text),
+        ok: blockers.length === 0,
         apply: input.apply === true,
         config_path: configPath,
-        repaired_paths: repairedPaths,
-        created_files: createdFiles,
-        removed_unsupported_fields: removedUnsupportedFields,
-        skipped_unmanaged_paths: skippedUnmanagedPaths,
-        manual_required: skippedUnmanagedPaths.length > 0,
-        blockers: [
-            ...missing.map((file) => `missing_agent_config_file:${file}`),
-            ...unsupportedManagedFields.map(() => 'unsupported_message_role_prefix_field')
-        ]
+        backup_path: backupPath,
+        repaired_paths: changed && writeSucceeded ? [configPath] : [],
+        created_files: input.apply === true && !configExists && changed && writeSucceeded ? [configPath] : [],
+        removed_unsupported_fields: [],
+        skipped_unmanaged_paths: [],
+        manual_required: blockers.length > 0,
+        blockers,
+        warnings,
+        ownership_proof: ownershipProof
     };
-    report.ok = report.blockers.length === 0;
-    if (input.reportPath !== null)
-        await writeJsonAtomic(input.reportPath || path.join(root, '.sneakoscope', 'reports', 'agent-config-file-repair.json'), report).catch(() => undefined);
-    return report;
+    return writeReport(input.reportPath, root, report);
 }
-export async function missingAgentConfigFiles(text) {
-    const rows = managedAgentBlocks(text)
-        .map((block) => stringValue(block.text, 'config_file'))
-        .filter((file) => Boolean(file));
-    const missing = [];
-    for (const file of rows) {
-        if (!path.isAbsolute(file)) {
-            missing.push(file);
-            continue;
-        }
-        const ok = await fs.stat(file).then((stat) => stat.isFile()).catch(() => false);
-        if (!ok)
-            missing.push(file);
-    }
-    return missing;
+// Retained for compatibility with the startup postcheck API. Official custom
+// agents are discovered from .codex/agents and do not require config_file
+// references; legacy references are intentionally ignored and preserved.
+export async function missingAgentConfigFiles(_text) {
+    return [];
 }
-function tomlBlocks(text) {
-    const source = String(text || '');
-    const matches = [...source.matchAll(/(^|\n)\s*\[([^\]]+)\]\s*(?:#.*)?(?:\n|$)/g)];
-    return matches.map((match, index) => {
-        const start = Number(match.index || 0) + (match[1] ? 1 : 0);
-        const next = matches[index + 1];
-        const end = next ? Number(next.index || 0) + (next[1] ? 1 : 0) : source.length;
-        return {
-            header: String(match[2] || '').trim(),
-            start,
-            end,
-            text: source.slice(start, end)
-        };
-    });
-}
-function managedAgentBlocks(text) {
-    return tomlBlocks(text).filter((block) => Boolean(managedBlockTarget(process.cwd(), block)));
-}
-function managedBlockTarget(root, block) {
-    if (!block.header.startsWith('agents.'))
-        return null;
-    const role = block.header.slice('agents.'.length);
-    const byRole = managedAgentRoleConfigForRole(role);
-    if (byRole)
-        return byRole;
-    const configFile = stringValue(block.text, 'config_file');
-    if (configFile) {
-        const content = managedAgentRoleConfigForFile(configFile);
-        if (content)
-            return { file: path.basename(configFile), content };
+async function writeReport(reportPath, root, report) {
+    if (reportPath !== null) {
+        await writeJsonAtomic(reportPath || path.join(root, '.sneakoscope', 'reports', 'agent-config-file-repair.json'), report).catch(() => undefined);
     }
-    if (/SKS managed|sks_/i.test(block.text)) {
-        const fallback = managedAgentRoleConfigForRole(role);
-        if (fallback)
-            return fallback;
-    }
-    void root;
-    return null;
-}
-function stringValue(text, key) {
-    const match = text.match(new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"([^"]*)"`, 'm'));
-    return match && typeof match[1] === 'string' ? match[1] : null;
-}
-function removeKey(text, key, removed) {
-    return text.split(/\r?\n/).filter((line) => {
-        const match = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`).test(line);
-        if (match)
-            removed.push(line.trim());
-        return !match;
-    }).join('\n');
-}
-function replaceOrInsertKey(text, key, encodedValue) {
-    const lines = text.replace(/\s*$/, '').split('\n');
-    const re = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`);
-    const index = lines.findIndex((line) => re.test(line));
-    if (index >= 0)
-        lines[index] = `${key} = ${encodedValue}`;
-    else
-        lines.push(`${key} = ${encodedValue}`);
-    return `${lines.join('\n')}\n`;
-}
-function applyEdits(text, edits) {
-    return [...edits]
-        .sort((a, b) => b.start - a.start)
-        .reduce((current, edit) => `${current.slice(0, edit.start)}${edit.replacement}${current.slice(edit.end)}`, text);
-}
-function escapeToml(value) {
-    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function minimalManagedConfigToml() {
-    return [
-        'service_tier = "fast"',
-        '',
-        '[features]',
-        'hooks = true',
-        'multi_agent = true',
-        'fast_mode = true',
-        'apps = true',
-        '',
-        '[mcp_servers.context7]',
-        'url = "https://mcp.context7.com/mcp"',
-        '',
-        agentConfigBlock('native_agent', 'SKS native agent with bounded write capability.', './agents/native-agent-intake.toml', ['Analysis', 'Mapper']),
-        '',
-        agentConfigBlock('team_consensus', 'SKS planning/debate agent with bounded write capability.', './agents/team-consensus.toml', ['Consensus', 'Atlas']),
-        '',
-        agentConfigBlock('implementation_worker', 'SKS bounded implementation worker.', './agents/implementation-worker.toml', ['Builder', 'Mason']),
-        '',
-        agentConfigBlock('db_safety_reviewer', 'DB safety reviewer with bounded write capability.', './agents/db-safety-reviewer.toml', ['Sentinel', 'Ledger']),
-        '',
-        agentConfigBlock('qa_reviewer', 'QA reviewer with bounded write capability.', './agents/qa-reviewer.toml', ['Verifier', 'Reviewer']),
-        ''
-    ].join('\n');
-}
-function agentConfigBlock(table, description, configFile, nicknames = []) {
-    return [
-        `[agents.${table}]`,
-        `description = "${description}"`,
-        `config_file = "${configFile}"`,
-        `nickname_candidates = [${nicknames.map((name) => `"${name}"`).join(', ')}]`
-    ].join('\n');
+    return report;
 }
 //# sourceMappingURL=agent-config-file-repair.js.map