sneakoscope 2.0.9 → 2.0.11

package/dist/core/git/git-worktree-checkpoint.js

@@ -0,0 +1,52 @@
+import { nowIso } from '../fsx.js';
+import { gitBlocker, gitOutputLine, runGitCommand } from './git-worktree-runner.js';
+export async function checkpointWorkerWorktree(input) {
+    const status = await runGitCommand(input.worktreePath, ['status', '--porcelain=v1', '--untracked-files=all']);
+    const names = await runGitCommand(input.worktreePath, ['diff', '--name-only', 'HEAD']);
+    const untracked = await runGitCommand(input.worktreePath, ['ls-files', '--others', '--exclude-standard']);
+    const changedFiles = [...new Set([...lines(names.stdout), ...lines(untracked.stdout), ...statusFiles(status.stdout)])];
+    const blockers = [...(status.ok ? [] : [gitBlocker('git_worktree_status_failed', status)])];
+    const requested = input.mode || 'auto';
+    const commitMode = requested === 'checkpoint-commit' || (requested === 'auto' && changedFiles.length > 1);
+    if (!changedFiles.length || blockers.length) {
+        return report(input, requested, 'noop', null, changedFiles, blockers);
+    }
+    if (!commitMode)
+        return report(input, requested, 'diff-envelope', null, changedFiles, blockers);
+    const add = await runGitCommand(input.worktreePath, ['add', '-A'], { timeoutMs: 30000 });
+    if (!add.ok)
+        blockers.push(gitBlocker('git_worktree_checkpoint_add_failed', add));
+    const commit = blockers.length ? null : await runGitCommand(input.worktreePath, ['commit', '--no-verify', '-m', `sks(worker): checkpoint ${input.workerId}/${input.taskId}`], { timeoutMs: 120000 });
+    if (commit && !commit.ok)
+        blockers.push(gitBlocker('git_worktree_checkpoint_commit_failed', commit));
+    const head = blockers.length ? null : await runGitCommand(input.worktreePath, ['rev-parse', 'HEAD']);
+    const hash = head?.ok ? gitOutputLine(head) : null;
+    return report(input, requested, blockers.length ? 'noop' : 'checkpoint-commit', hash, changedFiles, blockers);
+}
+function report(input, mode, applied, commitHash, changedFiles, blockers) {
+    return {
+        schema: 'sks.git-worktree-checkpoint.v1',
+        ok: blockers.length === 0,
+        generated_at: nowIso(),
+        worktree_path: input.worktreePath,
+        repo_root: input.repoRoot,
+        worker_id: input.workerId,
+        task_id: input.taskId,
+        mode_requested: mode,
+        mode_applied: applied,
+        commit_hash: commitHash,
+        changed_files: changedFiles,
+        blockers
+    };
+}
+function lines(text) {
+    return String(text || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+function statusFiles(text) {
+    return lines(text).map((line) => {
+        const match = line.match(/^.{2}\s+(.*)$/) || line.match(/^\S+\s+(.*)$/);
+        const file = (match?.[1] || line).trim();
+        return file.includes(' -> ') ? file.split(' -> ').pop()?.trim() || file : file;
+    }).filter(Boolean);
+}
+//# sourceMappingURL=git-worktree-checkpoint.js.map

package/dist/core/git/git-worktree-cross-rebase.js

@@ -0,0 +1,54 @@
+import { nowIso } from '../fsx.js';
+import { gitBlocker, gitOutputLine, runGitCommand } from './git-worktree-runner.js';
+export async function crossRebaseIdleWorktrees(input) {
+    const records = [];
+    for (const worker of input.workers) {
+        const before = await runGitCommand(worker.worktree_path, ['rev-parse', 'HEAD']);
+        const beforeHead = before.ok ? gitOutputLine(before) : null;
+        if (!['idle', 'done', 'failed', 'unknown'].includes(worker.state)) {
+            records.push(record(worker, 'skipped', 'worker_not_idle', beforeHead, beforeHead, []));
+            continue;
+        }
+        const status = await runGitCommand(worker.worktree_path, ['status', '--porcelain=v1', '--untracked-files=all']);
+        if (!status.ok) {
+            records.push(record(worker, 'failed', 'status_failed', beforeHead, beforeHead, [gitBlocker('git_worktree_cross_rebase_status_failed', status)]));
+            continue;
+        }
+        if (status.stdout.trim()) {
+            records.push(record(worker, 'skipped', 'dirty_worktree_skipped', beforeHead, beforeHead, []));
+            continue;
+        }
+        const rebase = await runGitCommand(worker.worktree_path, ['rebase', input.integrationHead], { timeoutMs: 120000 });
+        if (!rebase.ok) {
+            await runGitCommand(worker.worktree_path, ['rebase', '--abort'], { timeoutMs: 30000 }).catch(() => null);
+            records.push(record(worker, 'failed', 'rebase_failed', beforeHead, beforeHead, [gitBlocker('git_worktree_cross_rebase_failed', rebase)]));
+            continue;
+        }
+        const after = await runGitCommand(worker.worktree_path, ['rev-parse', 'HEAD']);
+        records.push(record(worker, 'applied', 'rebased_to_integration_head', beforeHead, after.ok ? gitOutputLine(after) : null, []));
+    }
+    const blockers = records.flatMap((row) => row.blockers);
+    return {
+        schema: 'sks.git-worktree-cross-rebase.v1',
+        ok: blockers.length === 0,
+        generated_at: nowIso(),
+        integration_head: input.integrationHead,
+        applied_count: records.filter((row) => row.status === 'applied').length,
+        skipped_count: records.filter((row) => row.status === 'skipped').length,
+        records,
+        blockers
+    };
+}
+function record(worker, status, reason, beforeHead, afterHead, blockers) {
+    return {
+        worker_id: worker.worker_id,
+        worktree_path: worker.worktree_path,
+        state: worker.state,
+        status,
+        reason,
+        before_head: beforeHead,
+        after_head: afterHead,
+        blockers
+    };
+}
+//# sourceMappingURL=git-worktree-cross-rebase.js.map

package/dist/core/git/git-worktree-merge-queue.js

@@ -3,10 +3,35 @@ import { runGitCommand } from './git-worktree-runner.js';
 import { summarizeGitWorktreeConflict } from './git-worktree-conflict-resolver.js';
 export async function applyGitWorktreeMergeQueue(input) {
     const conflicts = [];
+    const strategyResults = [];
     const changedFiles = new Set();
     let appliedCount = 0;
     let skippedCleanCount = 0;
+    let checkpointCommitCount = 0;
+    for (const checkpoint of input.checkpoints || []) {
+        for (const file of checkpoint.changed_files || [])
+            changedFiles.add(file);
+        if (checkpoint.mode_applied !== 'checkpoint-commit' || !checkpoint.commit_hash)
+            continue;
+        checkpointCommitCount += 1;
+        const merged = await applyCheckpointCommit(input.integrationWorktreePath, checkpoint);
+        strategyResults.push(merged);
+        if (merged.ok)
+            appliedCount += 1;
+        else
+            conflicts.push({
+                worker_id: checkpoint.worker_id,
+                changed_files: checkpoint.changed_files,
+                strategy: 'checkpoint-commit',
+                blockers: merged.blockers,
+                conflict_files: merged.conflict_files
+            });
+    }
     for (const diff of input.diffs) {
+        if ((input.checkpoints || []).some((checkpoint) => checkpoint.worker_id === diff.worker_id && checkpoint.mode_applied === 'checkpoint-commit' && checkpoint.commit_hash)) {
+            skippedCleanCount += 1;
+            continue;
+        }
         for (const file of diff.changed_files)
             changedFiles.add(file);
         if (diff.clean || !diff.diff.trim()) {
@@ -46,10 +71,54 @@ export async function applyGitWorktreeMergeQueue(input) {
         generated_at: nowIso(),
         integration_worktree_path: input.integrationWorktreePath,
         applied_count: appliedCount,
+        checkpoint_commit_count: checkpointCommitCount,
         skipped_clean_count: skippedCleanCount,
         conflicts,
+        strategy_results: strategyResults,
         changed_files: [...changedFiles],
         blockers
     };
 }
+async function applyCheckpointCommit(integrationWorktreePath, checkpoint) {
+    const merge = await runGitCommand(integrationWorktreePath, ['merge', '--no-ff', '--no-edit', checkpoint.commit_hash || ''], {
+        timeoutMs: 120000
+    });
+    if (merge.ok) {
+        return {
+            ok: true,
+            worker_id: checkpoint.worker_id,
+            strategy: 'merge',
+            commit_hash: checkpoint.commit_hash,
+            conflict_files: [],
+            blockers: []
+        };
+    }
+    await runGitCommand(integrationWorktreePath, ['merge', '--abort'], { timeoutMs: 30000 }).catch(() => null);
+    const cherryPick = await runGitCommand(integrationWorktreePath, ['cherry-pick', checkpoint.commit_hash || ''], {
+        timeoutMs: 120000
+    });
+    if (cherryPick.ok) {
+        return {
+            ok: true,
+            worker_id: checkpoint.worker_id,
+            strategy: 'cherry-pick',
+            commit_hash: checkpoint.commit_hash,
+            conflict_files: [],
+            blockers: []
+        };
+    }
+    const conflictFiles = await runGitCommand(integrationWorktreePath, ['diff', '--name-only', '--diff-filter=U'], { timeoutMs: 30000 }).catch(() => null);
+    await runGitCommand(integrationWorktreePath, ['cherry-pick', '--abort'], { timeoutMs: 30000 }).catch(() => null);
+    return {
+        ok: false,
+        worker_id: checkpoint.worker_id,
+        strategy: 'merge_then_cherry-pick',
+        commit_hash: checkpoint.commit_hash,
+        conflict_files: String(conflictFiles?.stdout || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean),
+        blockers: [
+            `git_worktree_checkpoint_merge_failed:${merge.stderr_tail || merge.stdout_tail}`,
+            `git_worktree_checkpoint_cherry_pick_failed:${cherryPick.stderr_tail || cherryPick.stdout_tail}`
+        ]
+    };
+}
 //# sourceMappingURL=git-worktree-merge-queue.js.map

package/dist/core/git/git-worktree-patch-envelope.js

@@ -18,7 +18,14 @@ export function buildGitWorktreePatchEnvelope(input) {
             base_head: input.diff.base_head,
             worktree_head: input.diff.worktree_head,
             changed_files: changedFiles,
-            diff_bytes: input.diff.diff_bytes
+            diff_bytes: input.diff.diff_bytes,
+            checkpoint: input.checkpoint ? {
+                schema: input.checkpoint.schema,
+                mode_applied: input.checkpoint.mode_applied,
+                commit_hash: input.checkpoint.commit_hash,
+                changed_files: input.checkpoint.changed_files,
+                blockers: input.checkpoint.blockers
+            } : null
         },
         operations: [{
                 op: 'git_apply_patch',

package/dist/core/hooks-runtime.js

@@ -25,6 +25,10 @@ const STOP_REPEAT_GUARD_WINDOW_MS = 10 * 60 * 1000;
 const STOP_REPEAT_GUARD_MAX_ENTRIES = 25;
 const DEFAULT_STOP_REPEAT_GUARD_LIMIT = 2;
 const CODEX_GIT_ACTION_STOP_TTL_MS = 15 * 60 * 1000;
+const UPDATE_CHECK_HOOK_INVOCATION_POLICY = 'function-only:no-runSksUpdateCheck-call-in-hooks';
+// Update checks stay function-only in hooks: the policy marker above is checked
+// by release readiness so ordinary Codex hook flow cannot grow a hidden update
+// prompt path.
 async function loadHookPayload() {
     const raw = await readStdin();
     try {

package/dist/core/init.js

@@ -237,7 +237,7 @@ function isSksManagedHook(hook) {
     const command = String(hook.command || '');
     return hook.type === 'command' && /\bhook\s+(?:session-start|user-prompt-submit|pre-tool|post-tool|permission-request|pre-compact|post-compact|subagent-start|subagent-stop|stop)\b/.test(command) && /\b(?:sks|sneakoscope|sks\.js)\b/.test(command);
 }
-const AGENTS_BLOCK = "\n# Sneakoscope Codex Managed Rules\n\nThis repository uses Sneakoscope Codex.\n\n## Core Rules\n\n- Codex native `/goal` workflows are the persisted continuation surface; Ralph is removed from the user-facing SKS surface.\n- Keep runtime state bounded: raw logs go to files, prompts get tails/summaries, and `sks gc` may prune stale artifacts.\n- Codex App hooks do not force SKS update prompts during ordinary work. CLI update surfaces (`sks update-check`, `sks update check`, and launch notices) show latest-version guidance, and `sks doctor --fix` runs the guarded global SKS update path.\n- Versioning is explicit: use `sks versioning bump` when preparing release metadata. SKS must not install Git pre-commit hooks.\n- Installed harness files are immutable to LLM edits: `.codex/*`, `.agents/skills/`, `.codex/agents/`, `.sneakoscope/*policy*.json`, `AGENTS.md`, and `node_modules/sneakoscope`. The Sneakoscope engine source repo is the only automatic exception.\n- OMX/DCodex conflicts block setup/doctor. Show `sks conflicts prompt`; cleanup requires explicit human approval.\n- Do not stop at a plan when implementation was requested. Finish, verify, or report the hard blocker.\n- Do not create unrequested fallback implementation code. If the requested path is impossible, block with evidence instead of inventing substitute behavior.\n\n## Routes\n\n- General execution/code-changing prompts default to `$Team`: native agent intake agents, TriWiki refresh/validate, read-only debate, consensus, concrete runtime task graph/inboxes, fresh executor team, minimum five-lane Team review, integration, Honest Mode.\n- `$Computer-Use` / `$CU` is the maximum-speed Codex Computer Use lane for native macOS, desktop-app, OS-settings, and non-web visual tasks only. Web, browser, localhost, website, webapp, and web-based app verification must use the Codex Chrome Extension path first and halt rapidly if the extension is not installed/enabled.\n- `$Goal` is a fast bridge/overlay for Codex native `/goal` create/pause/resume/clear persistence controls; implementation continues through the selected SKS execution route.\n- TriWiki recall must stay bounded. Use `sks wiki sweep` to record demote, soft-forget, archive, delete, promote-to-skill, and promote-to-rule candidates instead of injecting every old claim.\n- Team missions must keep schema-backed evidence current: `work-order-ledger.json`, `effort-decision.json`, `team-dashboard-state.json`, and route-specific visual/dogfood artifacts where applicable. Team completion requires at least five independent reviewer/QA validation lanes before integration or final, even when a prompt requests fewer reviewers. Use `sks validate-artifacts latest` before claiming those artifacts pass.\n- `$DFix` is Direct Fix: only tiny copy/config/docs/labels/spacing/translation/simple mechanical edits, bypassing the main pipeline, Team, TriWiki/TriFix/reflection recording, and persistent route state; it still uses a one-line DFix-specific Honest check before final. Broad implementation stays on `$Team`, while UI design specifics follow the relevant design/UI route rules. `$PPT` is the restrained, information-first HTML/PDF presentation route and must seal delivery context, audience profile, STP, decision context, and 3+ pain-point/solution/aha mappings before design/render work. It must avoid over-designed visuals, carry detail through hierarchy, spacing, alignment, thin rules, source clarity, and subtle accents, preserve editable source HTML under `source-html/`, record `ppt-parallel-report.json`, and clean PPT-only temporary build files before completion. `$Image-UX-Review` / `$UX-Review` is the imagegen/gpt-image-2 UI/UX review route: source screenshots must become generated annotated review images, those generated images must be extracted into issue ledgers, and text-only critique cannot pass the route gate. `$Answer`, `$Help`, and `$Wiki` stay lightweight.\n- For code work, surface route/guard/write scopes first, split independent worker scopes when available, and keep parent-owned integration and verification.\n- Design work reads `design.md` as the only design decision SSOT. If missing, create it through `design-system-builder` from `docs/Design-Sys-Prompt.md`; getdesign.md, getdesign-reference, and curated DESIGN.md examples from https://github.com/VoltAgent/awesome-design-md are source inputs to fuse into that SSOT or route-local style tokens, not parallel design authorities. Image/logo/raster assets use `imagegen`, which must prefer official Codex App built-in image generation via `$imagegen` / `gpt-image-2`; for newest-model image requests prompt explicitly for ChatGPT Images 2.0 / GPT Image 2.0 with `gpt-image-2`. Do not replace required raster evidence with placeholder SVG/HTML/CSS, prose-only reviews, or fabricated files.\n- Research, AutoResearch, performance, token, accuracy, SEO/GEO, or workflow-improvement claims need experiment/eval evidence. Do not claim live model accuracy without a scored dataset.\n- Treat handwritten files above 3000 lines as split-review risks. Run `sks code-structure scan` and prefer extraction before adding substantial logic.\n- Skill dreaming stays lightweight: route use records JSON counters in `.sneakoscope/skills/dream-state.json`, and full skill inventory/recommendation runs only after the configured 10-route-event threshold and cooldown. Reports are recommendation-only; deleting or merging skills needs explicit user approval.\n\n## Evidence And Context\n\n- Context7 is required for external libraries, APIs, MCPs, package managers, SDKs, and generated docs: resolve-library-id then query-docs.\n- When tech stack, framework, package, runtime, or deployment-platform versions change, use Context7 or official vendor web docs, record current syntax/security/limit guidance as high-priority TriWiki claims, then refresh and validate before coding.\n- TriWiki is the context-tracking SSOT for long-running missions, Team handoffs, and context-pressure recovery. Read `.sneakoscope/wiki/context-pack.json` before each stage, use `attention.use_first` for compact high-trust recall, hydrate `attention.hydrate_first` from source before risky or lower-trust decisions, refresh after findings or artifact changes, and validate before handoffs/final claims.\n- Source priority: current code/tests/config, decision contract, vgraph, beta, GX render/snapshot metadata, LLM Wiki coordinate index, then model knowledge only if allowed.\n- Final response before stop: summarize what was done, what changed for the user/repo, what was verified, and what remains unverified or blocked; then run Honest Mode. Say what passed and what was not verified.\n- `$From-Chat-IMG` uses forensic visual effort, not ordinary Team effort. Completion is blocked until source inventory, visual mapping, work-order coverage, scoped dogfood/QA, and post-fix verification artifacts are present and valid.\n\n## Safety\n\n- Database access is high risk. Use read-only inspection by default; live data mutation is out of scope unless a sealed contract allows local or branch-only migration files.\n- MAD and MAD-SKS widen only explicit scoped permissions; they still do not authorize unrequested fallback implementation code.\n- Task completion requires relevant tests or justification, zero unsupported critical claims, accepted visual/wiki drift, and final evidence.\n\n## Codex App\n\nUse `.codex/SNEAKOSCOPE.md`, generated `.agents/skills`, `.codex/hooks.json`, and SKS dollar commands (`$sks`, `$team`, `$computer-use`, `$cu`, `$ppt`, `$image-ux-review`, `$ux-review`, `$goal`, `$dfix`, `$qa-loop`, etc.) as the app control surface.\n";
+const AGENTS_BLOCK = "\n# Sneakoscope Codex Managed Rules\n\nThis repository uses Sneakoscope Codex.\n\n## Core Rules\n\n- Codex native `/goal` workflows are the persisted continuation surface; Ralph is removed from the user-facing SKS surface.\n- Keep runtime state bounded: raw logs go to files, prompts get tails/summaries, and `sks gc` may prune stale artifacts.\n- Codex App hooks, launch paths, and `sks doctor --fix` do not force SKS update prompts during ordinary work. Manual CLI update surfaces (`sks update-check`, `sks update check`, and `sks update now`) remain available when the operator explicitly asks for them.\n- Versioning is explicit: use `sks versioning bump` when preparing release metadata. SKS must not install Git pre-commit hooks.\n- Installed harness files are immutable to LLM edits: `.codex/*`, `.agents/skills/`, `.codex/agents/`, `.sneakoscope/*policy*.json`, `AGENTS.md`, and `node_modules/sneakoscope`. The Sneakoscope engine source repo is the only automatic exception.\n- OMX/DCodex conflicts block setup/doctor. Show `sks conflicts prompt`; cleanup requires explicit human approval.\n- Do not stop at a plan when implementation was requested. Finish, verify, or report the hard blocker.\n- Do not create unrequested fallback implementation code. If the requested path is impossible, block with evidence instead of inventing substitute behavior.\n\n## Routes\n\n- General execution/code-changing prompts default to `$Team`: native agent intake agents, TriWiki refresh/validate, read-only debate, consensus, concrete runtime task graph/inboxes, fresh executor team, minimum five-lane Team review, integration, Honest Mode.\n- `$Computer-Use` / `$CU` is the maximum-speed Codex Computer Use lane for native macOS, desktop-app, OS-settings, and non-web visual tasks only. Web, browser, localhost, website, webapp, and web-based app verification must use the Codex Chrome Extension path first and halt rapidly if the extension is not installed/enabled.\n- `$Goal` is a fast bridge/overlay for Codex native `/goal` create/pause/resume/clear persistence controls; implementation continues through the selected SKS execution route.\n- TriWiki recall must stay bounded. Use `sks wiki sweep` to record demote, soft-forget, archive, delete, promote-to-skill, and promote-to-rule candidates instead of injecting every old claim.\n- Team missions must keep schema-backed evidence current: `work-order-ledger.json`, `effort-decision.json`, `team-dashboard-state.json`, and route-specific visual/dogfood artifacts where applicable. Team completion requires at least five independent reviewer/QA validation lanes before integration or final, even when a prompt requests fewer reviewers. Use `sks validate-artifacts latest` before claiming those artifacts pass.\n- `$DFix` is Direct Fix: only tiny copy/config/docs/labels/spacing/translation/simple mechanical edits, bypassing the main pipeline, Team, TriWiki/TriFix/reflection recording, and persistent route state; it still uses a one-line DFix-specific Honest check before final. Broad implementation stays on `$Team`, while UI design specifics follow the relevant design/UI route rules. `$PPT` is the restrained, information-first HTML/PDF presentation route and must seal delivery context, audience profile, STP, decision context, and 3+ pain-point/solution/aha mappings before design/render work. It must avoid over-designed visuals, carry detail through hierarchy, spacing, alignment, thin rules, source clarity, and subtle accents, preserve editable source HTML under `source-html/`, record `ppt-parallel-report.json`, and clean PPT-only temporary build files before completion. `$Image-UX-Review` / `$UX-Review` is the imagegen/gpt-image-2 UI/UX review route: source screenshots must become generated annotated review images, those generated images must be extracted into issue ledgers, and text-only critique cannot pass the route gate. `$Answer`, `$Help`, and `$Wiki` stay lightweight.\n- For code work, surface route/guard/write scopes first, split independent worker scopes when available, and keep parent-owned integration and verification.\n- Design work reads `design.md` as the only design decision SSOT. If missing, create it through `design-system-builder` from `docs/Design-Sys-Prompt.md`; getdesign.md, getdesign-reference, and curated DESIGN.md examples from https://github.com/VoltAgent/awesome-design-md are source inputs to fuse into that SSOT or route-local style tokens, not parallel design authorities. Image/logo/raster assets use `imagegen`, which must prefer official Codex App built-in image generation via `$imagegen` / `gpt-image-2`; for newest-model image requests prompt explicitly for ChatGPT Images 2.0 / GPT Image 2.0 with `gpt-image-2`. Do not replace required raster evidence with placeholder SVG/HTML/CSS, prose-only reviews, or fabricated files.\n- Research, AutoResearch, performance, token, accuracy, SEO/GEO, or workflow-improvement claims need experiment/eval evidence. Do not claim live model accuracy without a scored dataset.\n- Treat handwritten files above 3000 lines as split-review risks. Run `sks code-structure scan` and prefer extraction before adding substantial logic.\n- Skill dreaming stays lightweight: route use records JSON counters in `.sneakoscope/skills/dream-state.json`, and full skill inventory/recommendation runs only after the configured 10-route-event threshold and cooldown. Reports are recommendation-only; deleting or merging skills needs explicit user approval.\n\n## Evidence And Context\n\n- Context7 is required for external libraries, APIs, MCPs, package managers, SDKs, and generated docs: resolve-library-id then query-docs.\n- When tech stack, framework, package, runtime, or deployment-platform versions change, use Context7 or official vendor web docs, record current syntax/security/limit guidance as high-priority TriWiki claims, then refresh and validate before coding.\n- TriWiki is the context-tracking SSOT for long-running missions, Team handoffs, and context-pressure recovery. Read `.sneakoscope/wiki/context-pack.json` before each stage, use `attention.use_first` for compact high-trust recall, hydrate `attention.hydrate_first` from source before risky or lower-trust decisions, refresh after findings or artifact changes, and validate before handoffs/final claims.\n- Source priority: current code/tests/config, decision contract, vgraph, beta, GX render/snapshot metadata, LLM Wiki coordinate index, then model knowledge only if allowed.\n- Final response before stop: summarize what was done, what changed for the user/repo, what was verified, and what remains unverified or blocked; then run Honest Mode. Say what passed and what was not verified.\n- `$From-Chat-IMG` uses forensic visual effort, not ordinary Team effort. Completion is blocked until source inventory, visual mapping, work-order coverage, scoped dogfood/QA, and post-fix verification artifacts are present and valid.\n\n## Safety\n\n- Database access is high risk. Use read-only inspection by default; live data mutation is out of scope unless a sealed contract allows local or branch-only migration files.\n- MAD and MAD-SKS widen only explicit scoped permissions; they still do not authorize unrequested fallback implementation code.\n- Task completion requires relevant tests or justification, zero unsupported critical claims, accepted visual/wiki drift, and final evidence.\n\n## Codex App\n\nUse `.codex/SNEAKOSCOPE.md`, generated `.agents/skills`, `.codex/hooks.json`, and SKS dollar commands (`$sks`, `$team`, `$computer-use`, `$cu`, `$ppt`, `$image-ux-review`, `$ux-review`, `$goal`, `$dfix`, `$qa-loop`, etc.) as the app control surface.\n";
 function agentsBlockText() {
     return AGENTS_BLOCK;
 }
@@ -1011,7 +1011,7 @@ function codexAppQuickReference(scope, commandPrefix) {
         stackCurrentDocsPolicyText(commandPrefix),
         `Team review: ${MIN_TEAM_REVIEW_POLICY_TEXT}`,
         `Team Zellij view: ${commandPrefix} team "task" prepares live watch/lane commands and reconciles managed Team panes inside the current SKS-owned Zellij session when available; add --no-open-zellij for artifact-only creation. Existing hook-created Team missions can be opened later with ${commandPrefix} team open-zellij latest. The view keeps the main Codex pane alive, adds an overview watch pane plus color-coded split per-agent lanes, and closes only SKS-managed Team panes as agent lanes finish or cleanup is requested; ${commandPrefix} team lane latest --agent native_agent_1 --follow shows one agent's status, assigned runtime tasks, recent agent events, direct messages, and fallback global tail; ${commandPrefix} team message latest --from native_agent_1 --to executor_1 --message "handoff note" mirrors bounded agent communication into transcript/lane panes; ${commandPrefix} team cleanup-zellij latest marks the SKS session record complete and asks managed panes/follow loops to close or show a cleanup summary.`,
-        `Runtime: open Codex App once, then run ${commandPrefix} bootstrap and ${commandPrefix} deps check. Zellij is the interactive lane runtime for ${commandPrefix} --mad and Team lane UI; ${commandPrefix} bootstrap --yes, ${commandPrefix} deps check --yes, and ${commandPrefix} --mad --yes can install or repair Codex CLI/Zellij on macOS/Homebrew. npm postinstall reports missing CLI tools but does not mutate Homebrew/npm globals unless SKS_POSTINSTALL_AUTO_INSTALL_CLI_TOOLS=1 is set. Before launch SKS prints non-blocking latest-version notices for sneakoscope and checks npm @openai/codex@latest, prompting Y/n only when the installed Codex CLI is missing or outdated. ${commandPrefix} doctor --fix runs the guarded global SKS update path before repair. ${commandPrefix} codex-app remote-control wraps the Codex CLI 0.130.0+ headless remote-control entrypoint. ${commandPrefix} team open-zellij latest is the explicit Team lane view command.`,
+        `Runtime: open Codex App once, then run ${commandPrefix} bootstrap and ${commandPrefix} deps check. Zellij is the interactive lane runtime for ${commandPrefix} --mad and Team lane UI; ${commandPrefix} bootstrap --yes, ${commandPrefix} deps check --yes, and ${commandPrefix} --mad --yes can install or repair Codex CLI/Zellij on macOS/Homebrew. npm postinstall reports missing CLI tools but does not mutate Homebrew/npm globals unless SKS_POSTINSTALL_AUTO_INSTALL_CLI_TOOLS=1 is set. Launch paths do not run sneakoscope npm update checks; use ${commandPrefix} update-check or ${commandPrefix} update now explicitly when you want that. Codex CLI latest checks remain dependency-readiness guidance and prompt Y/n only when the installed Codex CLI is missing or outdated. ${commandPrefix} doctor --fix repairs the local SKS/Codex setup without running a global SKS package update. ${commandPrefix} codex-app remote-control wraps the Codex CLI 0.130.0+ headless remote-control entrypoint. ${commandPrefix} team open-zellij latest is the explicit Team lane view command.`,
         `Guard: generated harness files are immutable outside the engine source repo; check ${commandPrefix} guard check; conflicts use ${commandPrefix} conflicts prompt with human approval.`
     ].join('\n') + '\n';
 }
@@ -1257,6 +1257,7 @@ async function removeDirIfEmpty(dir) {
 }
 async function installCodexAgents(root) {
     const agents = {
+        'analysis-scout.toml': `name = "analysis_scout"\ndescription = "Read-only SKS analysis scout retained for stale Codex agent-role config repair."\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "medium"\nsandbox_mode = "read-only"\ndeveloper_instructions = """\nYou are an SKS read-only analysis scout.\nDo not edit files.\nInspect only the assigned source paths and return concise source-backed findings.\n"""\n`,
         'native-agent-intake.toml': `name = "native_agent"\ndescription = "Read-only Team native agent. Maps one independent repo/docs/tests/API/risk/user-friction slice and returns TriWiki-ready source-backed findings before debate starts."\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "medium"\nsandbox_mode = "read-only"\ndeveloper_instructions = """\nYou are an SKS Team native agent.\nDo not edit files.\nOwn exactly one investigation slice assigned by the parent orchestrator.\nUse the mission roster or worker inbox reasoning_effort when the host exposes it; simple bounded work can use low, tool-heavy runtime work medium, and knowledge/research/safety/release work high or xhigh. Default to medium only when no assignment is visible.\nMap relevant source files, docs, tests, APIs, DB or safety risks, UX friction, and likely implementation boundaries.\nReturn concise source-backed claims suitable for team-analysis.md and TriWiki ingestion: claim, source path, evidence hash or quoted anchor, risk, confidence, and recommended implementation slice.\nDo not debate the final plan and do not implement code.\nAlso return a concise LIVE_EVENT line that the parent can record with sks team event.\n"""\n`,
         'team-consensus.toml': `name = "team_consensus"\ndescription = "Planning and debate specialist for SKS Team mode. Maps options, constraints, role-persona risks, and proposes the agreed objective before implementation starts."\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "high"\nsandbox_mode = "read-only"\ndeveloper_instructions = """\nYou are the SKS Team consensus specialist.\nDo not edit files.\nUse the mission roster reasoning_effort when the host exposes it; planning has a medium minimum, with high or xhigh for knowledge, safety, release, research, or recovery work.\nMap the affected code paths, viable approaches, constraints, risks, and acceptance criteria.\nRun the debate as role-persona synthesis: final users are low-context, self-interested, stubborn, and inconvenience-averse; executors are capable developers; reviewers are strict.\nArgue for the smallest coherent objective that can be handed to a fresh executor_N development team.\nPlan for at least ${MIN_TEAM_REVIEWER_LANES} independent reviewer/QA validation lanes before integration or final.\nReturn: recommended objective, rejected alternatives, implementation slices, required reviewers, user-friction risks, and unresolved risks.\nAlso return a concise LIVE_EVENT line that the parent can record with sks team event.\n"""\n`,
         'implementation-worker.toml': `name = "implementation_worker"\ndescription = "Implementation specialist for SKS Team mode. Owns one bounded write set and coordinates with other executor_N workers."\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "medium"\nsandbox_mode = "workspace-write"\ndeveloper_instructions = """\nYou are an SKS Team executor/developer in the fresh development bundle.\nYou are not alone in the codebase. Other executor_N workers may be editing disjoint files.\nUse the mission roster or worker inbox reasoning_effort when the host exposes it; simple bounded changes can use low, tool-heavy implementation medium, and safety/release/DB work high.\nOnly edit the files or module slice assigned to you.\nDo not revert or overwrite edits made by others.\nRead local patterns first, make the smallest correct change, avoid adding user friction, run focused verification for your slice, and report changed paths plus evidence.\nDo not create fallback implementation code, substitute behavior, mock behavior, or compatibility shims unless the user or sealed decision contract explicitly requested them.\nRespect all SKS hooks, DB safety rules, no-question run rules, and H-Proof completion gates.\nAlso return concise LIVE_EVENT lines for started, blocked, changed files, verification, and final result so the parent can record them.\n"""\n`,

package/dist/core/naruto/naruto-active-pool.js

@@ -29,7 +29,7 @@ export async function runNarutoRealActivePool(input) {
                 visibleRunning += 1;
             const handle = await input.spawnWorker(item, placement);
             active.set(handle.id, handle);
-            lifecycle.push({ work_item_id: item.id, placement: placement.placement, started_at: handle.started_at, completed_at: null, ok: null });
+            lifecycle.push({ work_item_id: item.id, placement: placement.placement, pid: handle.pid || null, worker_artifact_dir: handle.worker_artifact_dir || null, started_at: handle.started_at, completed_at: null, ok: null });
             launched += 1;
             await input.updateDashboard({ event_type: 'worker_spawned', work_item_id: item.id, active_workers: active.size, pending_workers: pending.length, completed_workers: completed.size, placement });
         }
@@ -40,7 +40,7 @@ export async function runNarutoRealActivePool(input) {
         }
         maxObserved = Math.max(maxObserved, active.size);
         timeline.push({ tick, active: active.size, pending: pending.length, completed: completed.size, event: launched ? 'refill' : 'wait' });
-        const done = [...active.values()].slice(0, Math.max(1, Math.ceil(active.size / 2)));
+        const done = await nextCollectableWorkers(active);
         if (!done.length)
             break;
         for (const handle of done) {
@@ -53,6 +53,8 @@ export async function runNarutoRealActivePool(input) {
             if (row) {
                 row.completed_at = result.completed_at;
                 row.ok = result.ok;
+                row.pid = result.pid || row.pid || null;
+                row.worker_artifact_dir = result.worker_artifact_dir || row.worker_artifact_dir || null;
             }
             await input.updateDashboard({ event_type: 'worker_completed', work_item_id: result.item.id, active_workers: active.size, pending_workers: pending.length, completed_workers: completed.size, placement: result.placement });
             if (result.item.verification_required) {
@@ -66,16 +68,32 @@ export async function runNarutoRealActivePool(input) {
     }
     await input.updateDashboard({ event_type: 'pool_drained', active_workers: active.size, pending_workers: pending.length, completed_workers: completed.size });
     const failedCount = [...completed.values()].filter((result) => !result.ok).length;
+    const activeSamples = timeline.map((row) => row.active);
+    const averageActiveWorkers = activeSamples.length
+        ? activeSamples.reduce((sum, value) => sum + value, 0) / activeSamples.length
+        : 0;
+    const saturatedSamples = timeline
+        .filter((row) => row.pending + row.active >= safeActiveWorkers)
+        .map((row) => row.active);
+    const averageSaturatedActiveWorkers = saturatedSamples.length
+        ? saturatedSamples.reduce((sum, value) => sum + value, 0) / saturatedSamples.length
+        : averageActiveWorkers;
+    const utilizationDenominator = Math.max(1, safeActiveWorkers);
+    const activePoolUtilization = Math.min(1, averageSaturatedActiveWorkers / utilizationDenominator);
+    const enoughWorkForUtilization = input.graph.total_work_items >= safeActiveWorkers * 2;
     const blockers = [
         ...(pending.length ? ['naruto_real_active_pool_pending_not_drained'] : []),
         ...(active.size ? ['naruto_real_active_pool_active_not_drained'] : []),
         ...(maxObserved > safeActiveWorkers ? ['naruto_real_active_pool_exceeded_safe_workers'] : []),
+        ...(enoughWorkForUtilization && maxObserved < Math.ceil(safeActiveWorkers * 0.8) ? ['naruto_real_active_pool_underutilized'] : []),
+        ...(enoughWorkForUtilization && activePoolUtilization < 0.8 ? ['naruto_real_active_pool_low_sustained_utilization'] : []),
         ...[...completed.values()].flatMap((result) => result.blockers || [])
     ];
     return {
         schema: 'sks.naruto-active-pool.v1',
         ok: blockers.length === 0,
         runtime_mode: 'real-worker-lifecycle',
+        active_cap: safeActiveWorkers,
         safe_active_workers: safeActiveWorkers,
         total_work_items: input.graph.total_work_items,
         completed_count: completed.size,
@@ -85,12 +103,27 @@ export async function runNarutoRealActivePool(input) {
         duplicate_execution_count: 0,
         conflict_items_enqueued: 0,
         max_observed_write_lease_conflicts: 0,
+        average_active_workers: Number(averageSaturatedActiveWorkers.toFixed(4)),
+        active_pool_utilization: Number(activePoolUtilization.toFixed(4)),
+        visible_workers: lifecycle.filter((row) => row.placement === 'zellij-pane').length,
+        headless_workers: lifecycle.filter((row) => row.placement === 'headless').length,
         refill_latency_ms_p95: percentile(refillLatencies, 0.95),
         worker_lifecycle: lifecycle,
         timeline,
         blockers
     };
 }
+async function nextCollectableWorkers(active) {
+    const handles = [...active.values()];
+    const handlesWithExit = handles.filter((handle) => typeof handle.exit?.then === 'function');
+    if (!handlesWithExit.length)
+        return handles.slice(0, Math.max(1, Math.ceil(active.size / 2)));
+    const completed = await Promise.race(handlesWithExit.map(async (handle) => {
+        await handle.exit.catch(() => undefined);
+        return handle;
+    }));
+    return completed ? [completed] : [];
+}
 export async function runNarutoActivePool(input) {
     const base = simulateNarutoActivePool(input);
     const allocations = [];

package/dist/core/naruto/naruto-allocation-policy.js

@@ -0,0 +1,99 @@
+import { extractNarutoTaskHints, pathPrefix } from './naruto-task-hints.js';
+export function chooseNarutoTaskOwner(task, workers, currentAssignments = [], leaseState = {}) {
+    if (!workers.length)
+        throw new Error('at least one Naruto worker is required');
+    const hints = extractNarutoTaskHints(task);
+    const activeWritePaths = new Set((leaseState.active_write_paths || []).map(String));
+    const completedTaskIds = new Set((leaseState.completed_task_ids || []).map(String));
+    const writeConflict = hints.writePaths.some((file) => activeWritePaths.has(file));
+    const dependencyIncomplete = task.dependencies.some((dep) => !completedTaskIds.has(dep));
+    const ranked = workers.map((worker, index) => {
+        const assigned = currentAssignments.filter((row) => row.owner === worker.id);
+        const assignedHints = assigned.map((row) => ({
+            role: row.role || null,
+            paths: row.paths || [],
+            domains: row.domains || [],
+            writePaths: row.write_paths || []
+        }));
+        const primaryRole = worker.primary_role || worker.role || null;
+        const declaredRoles = new Set([worker.role, ...(worker.declared_roles || [])].filter(Boolean).map(String));
+        const primaryRoleMatches = Boolean(hints.role && primaryRole === hints.role);
+        const declaredRoleMatches = Boolean(hints.role && declaredRoles.has(hints.role));
+        const assignmentRoleMatches = Boolean(hints.role && assigned.some((row) => row.role === hints.role));
+        const sameLane = samePathLane(hints.paths, assignedHints.flatMap((row) => row.paths));
+        const overlap = overlapCount(hints.paths, assignedHints.flatMap((row) => row.paths))
+            + overlapCount(hints.domains, assignedHints.flatMap((row) => row.domains));
+        const laneMatches = Boolean(worker.lane && hints.paths.some((file) => pathLaneMatches(file, String(worker.lane))));
+        const score = dependencyIncomplete
+            ? Number.NEGATIVE_INFINITY
+            : (primaryRoleMatches ? 18 : 0)
+                + (declaredRoleMatches ? 12 : 0)
+                + (sameLane || laneMatches ? 12 : 0)
+                + (overlap * 4)
+                - (assigned.length * 4)
+                - (writeConflict ? 20 : 0);
+        return { worker, index, assigned, score, overlap, primaryRoleMatches, declaredRoleMatches, assignmentRoleMatches, sameLane: sameLane || laneMatches, writeConflict, dependencyIncomplete };
+    }).sort((left, right) => {
+        if (right.score !== left.score)
+            return right.score - left.score;
+        if (right.overlap !== left.overlap)
+            return right.overlap - left.overlap;
+        if (left.assigned.length !== right.assigned.length)
+            return left.assigned.length - right.assigned.length;
+        return left.index - right.index;
+    });
+    const selected = ranked[0];
+    const reasons = [
+        selected.primaryRoleMatches ? 'same primary role' : null,
+        selected.declaredRoleMatches ? 'same declared role' : null,
+        selected.assignmentRoleMatches ? 'same assigned role history' : null,
+        selected.sameLane ? 'same path/domain lane' : null,
+        selected.overlap ? `overlap:${selected.overlap}` : null,
+        selected.writeConflict ? 'write lease conflict penalty applied' : null,
+        selected.dependencyIncomplete ? 'dependency incomplete' : null,
+        `load:${selected.assigned.length}`
+    ].filter(Boolean);
+    return {
+        owner: selected.worker.id,
+        score: selected.score,
+        reason: reasons.join('; '),
+        hints
+    };
+}
+export function allocateNarutoTasksToWorkers(tasks, workers) {
+    const assignments = [];
+    for (const task of tasks) {
+        const decision = chooseNarutoTaskOwner(task, workers, assignments.map((row) => ({
+            task_id: row.id,
+            owner: row.owner,
+            role: row.required_role,
+            paths: row.hints.paths,
+            domains: row.hints.domains,
+            write_paths: row.hints.writePaths
+        })), {
+            active_write_paths: assignments.flatMap((row) => row.hints.writePaths)
+        });
+        assignments.push({
+            ...task,
+            owner: decision.owner,
+            allocation_reason: decision.reason,
+            allocation_score: decision.score,
+            hints: decision.hints
+        });
+    }
+    return assignments;
+}
+function samePathLane(left, right) {
+    const prefixes = new Set(right.map(pathPrefix).filter(Boolean));
+    return left.some((file) => prefixes.has(pathPrefix(file)));
+}
+function pathLaneMatches(file, lane) {
+    const normalizedLane = lane.replace(/^\.\/+/, '').replace(/\/+$/, '');
+    const normalizedFile = file.replace(/^\.\/+/, '');
+    return pathPrefix(normalizedFile) === normalizedLane || normalizedFile === normalizedLane || normalizedFile.startsWith(`${normalizedLane}/`);
+}
+function overlapCount(left, right) {
+    const rightSet = new Set(right);
+    return left.filter((item) => rightSet.has(item)).length;
+}
+//# sourceMappingURL=naruto-allocation-policy.js.map

package/dist/core/naruto/naruto-concurrency-governor.js

@@ -7,7 +7,7 @@ export function decideNarutoConcurrency(input = {}) {
     const pending = normalizeNonNegativeInt(input.pendingWorkQueueSize, totalWorkItems);
     const leaseConflicts = normalizeNonNegativeInt(input.activeLeaseConflicts, 0);
     const hardware = probeHardwareCapacity(input.hardware || {});
-    const zellijVisiblePaneCap = normalizePositiveInt(input.zellijVisiblePaneCap, Math.min(12, Math.max(4, Math.floor(hardware.terminal_rows / 3))));
+    const zellijVisiblePaneCap = normalizePositiveInt(input.zellijVisiblePaneCap, Math.min(8, Math.max(4, Math.floor(hardware.terminal_rows / 5))));
     const backend = String(input.backend || 'codex-sdk');
     const freeGb = hardware.free_memory_bytes / (1024 * 1024 * 1024);
     const totalGb = hardware.total_memory_bytes / (1024 * 1024 * 1024);

package/dist/core/naruto/naruto-real-worker-child.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { runCodexTask } from '../codex-control/codex-control-plane.js';
+import { CODEX_AGENT_WORKER_RESULT_SCHEMA_ID, codexAgentWorkerResultSchema } from '../codex-control/schemas/agent-worker-result.schema.js';
+async function main() {
+    const intakePath = process.argv[2];
+    if (!intakePath)
+        throw new Error('naruto worker intake path is required');
+    const intake = await readJson(intakePath, null);
+    if (!intake?.result_path || !intake?.heartbeat_path || !intake?.item?.id) {
+        throw new Error('naruto worker intake is invalid');
+    }
+    await fs.appendFile(intake.heartbeat_path, `${JSON.stringify({
+        schema: 'sks.naruto-actual-worker-heartbeat.v1',
+        ts: nowIso(),
+        item_id: intake.item.id,
+        status: 'running'
+    })}\n`);
+    if (intake.backend === 'fake')
+        process.env.SKS_CODEX_SDK_FAKE = '1';
+    const controlRoot = path.join(path.dirname(intake.result_path), 'codex-control');
+    await ensureDir(controlRoot);
+    try {
+        const taskResult = await runCodexTask({
+            route: '$Naruto',
+            tier: 'worker',
+            missionId: String(intake.mission_id || ''),
+            workItemId: String(intake.item.id || ''),
+            slotId: String(intake.item.id || ''),
+            generationIndex: 1,
+            sessionId: String(intake.item.id || ''),
+            cwd: String(intake.worktree_path || process.cwd()),
+            prompt: buildNarutoWorkerPrompt(intake.item),
+            outputSchemaId: CODEX_AGENT_WORKER_RESULT_SCHEMA_ID,
+            outputSchema: codexAgentWorkerResultSchema,
+            sandboxPolicy: intake.item.write_allowed === true ? 'workspace-write' : 'read-only',
+            requestedScopeContract: {
+                id: `naruto:${intake.item.id}`,
+                route: '$Naruto',
+                read_only: intake.item.write_allowed !== true,
+                allowed_paths: [...new Set([...(intake.item.target_paths || []), ...(intake.item.readonly_paths || []), ...(intake.item.write_paths || [])].map(String))],
+                write_paths: Array.isArray(intake.item.write_paths) ? intake.item.write_paths.map(String) : [],
+                user_confirmed_full_access: false,
+                mad_sks_authorized: false
+            },
+            backendPreference: backendPreference(intake.backend),
+            allowLocalLlm: intake.backend === 'ollama' || intake.backend === 'local-llm',
+            ...(intake.backend === 'ollama' || intake.backend === 'local-llm' ? { localLlmPolicy: { mode: 'local_preferred', requiresGptFinal: true } } : {}),
+            mutationLedgerRoot: controlRoot,
+            reliabilityPolicy: {
+                maxEmptyResultRetries: 1,
+                timeoutClass: 'short'
+            }
+        });
+        const workerResult = await readJson(taskResult.workerResultPath, null);
+        const blockers = [...(taskResult.blockers || []), ...(Array.isArray(workerResult?.blockers) ? workerResult.blockers : [])];
+        await writeJsonAtomic(intake.result_path, {
+            schema: 'sks.naruto-actual-worker-result.v1',
+            ok: taskResult.ok === true && blockers.length === 0,
+            generated_at: nowIso(),
+            item_id: intake.item.id,
+            placement: intake.placement,
+            backend: taskResult.backend,
+            backend_family: taskResult.backend_family,
+            worktree_path: intake.worktree_path,
+            control_plane_result: {
+                worker_result_path: taskResult.workerResultPath,
+                patch_envelope_path: taskResult.patchEnvelopePath || null,
+                stream_event_count: taskResult.streamEventCount,
+                structured_output_valid: taskResult.structuredOutputValid,
+                sdk_thread_id: taskResult.sdkThreadId,
+                sdk_run_id: taskResult.sdkRunId || null
+            },
+            changed_files: Array.isArray(workerResult?.changed_files) ? workerResult.changed_files : [],
+            blockers
+        });
+        await fs.appendFile(intake.heartbeat_path, `${JSON.stringify({
+            schema: 'sks.naruto-actual-worker-heartbeat.v1',
+            ts: nowIso(),
+            item_id: intake.item.id,
+            status: blockers.length ? 'blocked' : 'done'
+        })}\n`);
+    }
+    catch (err) {
+        await writeJsonAtomic(intake.result_path, {
+            schema: 'sks.naruto-actual-worker-result.v1',
+            ok: false,
+            generated_at: nowIso(),
+            item_id: intake.item.id,
+            placement: intake.placement,
+            backend: intake.backend,
+            worktree_path: intake.worktree_path,
+            blockers: [`naruto_actual_worker_control_plane_exception:${err?.message || String(err)}`]
+        });
+        await fs.appendFile(intake.heartbeat_path, `${JSON.stringify({
+            schema: 'sks.naruto-actual-worker-heartbeat.v1',
+            ts: nowIso(),
+            item_id: intake.item.id,
+            status: 'blocked'
+        })}\n`);
+        throw err;
+    }
+}
+function backendPreference(value) {
+    const backend = String(value || '');
+    if (backend === 'ollama' || backend === 'local-llm')
+        return ['local-llm', 'codex-sdk'];
+    return ['codex-sdk'];
+}
+function buildNarutoWorkerPrompt(item) {
+    const writeAllowed = item?.write_allowed === true;
+    return [
+        'You are a Naruto route worker. Complete only this assigned work item and return JSON matching the required schema.',
+        `Work item: ${String(item?.id || '')} ${String(item?.title || item?.kind || '')}`,
+        `Role: ${String(item?.required_role || 'worker')}`,
+        `Kind: ${String(item?.kind || 'verification')}`,
+        `Target paths: ${JSON.stringify(item?.target_paths || [])}`,
+        `Readonly paths: ${JSON.stringify(item?.readonly_paths || [])}`,
+        `Write paths: ${JSON.stringify(item?.write_paths || [])}`,
+        writeAllowed
+            ? 'If changes are needed, return model-authored patch_envelopes scoped to write paths.'
+            : 'This is read-only work. Do not mutate files and return an empty patch_envelopes array.',
+        'Include verification checks, rollback notes, blockers, findings, and changed_files.'
+    ].join('\n');
+}
+main().then(() => {
+    process.exit(0);
+}).catch((err) => {
+    console.error(err?.message || String(err));
+    process.exit(1);
+});
+//# sourceMappingURL=naruto-real-worker-child.js.map