sneakoscope 2.0.15 → 2.0.16

package/dist/core/commands/naruto-command.js

@@ -165,10 +165,12 @@ async function narutoRun(parsed) {
         requestedClones: roster.agent_count,
         totalWorkItems: workGraph.total_work_items,
         pendingWorkQueueSize: workGraph.total_work_items,
-        backend: schedulerBackend
+        backend: schedulerBackend,
+        parallelismMode: parsed.parallelism
     });
     const backendMinimum = schedulerBackend === 'fake' ? roster.agent_count : Math.min(roster.agent_count, 2);
-    const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || Math.max(governor.safe_active_workers, backendMinimum), safe.cap));
+    const activeCap = parsed.parallelism === 'safe' ? safe.cap : MAX_NARUTO_AGENT_COUNT;
+    const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || Math.max(governor.safe_active_workers, backendMinimum), activeCap));
     const zellijVisiblePanes = Math.max(1, Math.min(activeSlots, governor.safe_zellij_visible_panes));
     const activePool = await runNarutoActivePool({ graph: workGraph, governor: { ...governor, safe_active_workers: activeSlots } });
     const runPreRunSmoke = parsed.smoke === true || process.env.SKS_NARUTO_PRE_RUN_SMOKE === '1';
@@ -281,6 +283,20 @@ async function narutoRun(parsed) {
         prompt: parsed.prompt
     });
     let liveZellij = null;
+    if (!parsed.json) {
+        console.log('$Naruto starting:');
+        console.log('  clones requested: ' + roster.agent_count);
+        console.log('  work items: ' + workGraph.total_work_items);
+        console.log('  target active workers: ' + activeSlots);
+        console.log('  visible panes: ' + zellijVisiblePanes);
+        console.log('  headless workers: ' + Math.max(0, activeSlots - zellijVisiblePanes));
+        console.log('  backend: ' + schedulerBackend);
+        console.log('  parallelism mode: ' + parsed.parallelism);
+        if (activeSlots < roster.agent_count)
+            console.log('  cap reasons: ' + (governor.reasons.join(', ') || 'host safety cap'));
+        if (parsed.parallelism !== 'safe' && activeSlots < 10)
+            console.log('  warning: active workers below 10 in non-safe mode');
+    }
     if (!parsed.json && !parsed.mock && !parsed.noOpenZellij) {
         liveZellij = await launchZellijLayout({
             root,
@@ -356,8 +372,11 @@ async function narutoRun(parsed) {
         narutoRebalancePolicy: rebalancePolicy,
         json: parsed.json
     });
+    const parallelRuntime = result.parallel_runtime_proof || null;
     const nativeProofOk = result.proof?.ok === true || result.proof?.status === 'passed';
     const finalAccepted = result.proof?.status === 'passed' || result.proof?.gpt_final_status === 'approved';
+    const parallelRuntimeOk = !parsed.mock || roster.agent_count < 16 || (parallelRuntime?.passed === true
+        && Number(parallelRuntime.max_observed_active_workers || 0) >= Math.min(16, activeSlots));
     await writeJsonAtomic(path.join(mission.dir, 'naruto-gate.json'), {
         schema: 'sks.naruto-gate.v1',
         passed: result.ok === true && nativeProofOk && finalAccepted,
@@ -374,9 +393,10 @@ async function narutoRun(parsed) {
         gpt_final_pack_ready: true,
         zellij_dashboard_ready: zellijDashboard.ok === true,
         native_agent_proof: nativeProofOk,
+        parallel_runtime_proof: parallelRuntimeOk,
         final_arbiter_accepted: finalAccepted,
         session_cleanup: result.proof?.all_sessions_closed === true || nativeProofOk,
-        blockers: result.proof?.blockers || [],
+        blockers: [...(result.proof?.blockers || []), ...(parallelRuntimeOk ? [] : ['naruto_parallel_runtime_proof_below_gate'])],
         updated_at: nowIso()
     });
     await setCurrent(root, {
@@ -442,6 +462,15 @@ async function narutoRun(parsed) {
                 worker_lifecycle_sample: realActivePoolSmoke.worker_lifecycle.slice(0, 5)
             }
         },
+        parallel_runtime: parallelRuntime ? {
+            proof_path: path.join(result.ledger_root || '', 'parallel-runtime-proof.json'),
+            max_observed_active_workers: parallelRuntime.max_observed_active_workers,
+            unique_worker_pids: parallelRuntime.unique_worker_pids,
+            speedup_ratio: parallelRuntime.speedup_ratio,
+            visible_panes: parallelRuntime.visible_panes,
+            headless_workers: parallelRuntime.headless_workers,
+            passed: parallelRuntime.passed
+        } : null,
         local_worker: localWorkerSummary,
         proof: result.proof?.status || 'missing',
         run: compactNarutoRunResult(result),
@@ -455,6 +484,13 @@ async function narutoRun(parsed) {
         console.log('Backend: ' + result.backend);
         console.log('Roles: ' + roleDistribution.entries.map((entry) => `${entry.role}:${entry.count}`).join(', '));
         console.log('Proof: ' + summary.proof);
+        if (summary.parallel_runtime) {
+            console.log('$Naruto parallel proof:');
+            console.log('  max active workers: ' + summary.parallel_runtime.max_observed_active_workers);
+            console.log('  unique PIDs: ' + summary.parallel_runtime.unique_worker_pids);
+            console.log('  speedup: ' + summary.parallel_runtime.speedup_ratio + 'x');
+            console.log('  result: ' + (summary.parallel_runtime.passed ? 'passed' : 'blocked'));
+        }
         if (summary.zellij?.ok && summary.zellij.capability?.status === 'ok')
             console.log('Zellij: prepared ' + zellijVisiblePanes + ' visible active clone lane(s) in ' + summary.zellij.session_name + '; dashboard tracks ' + Math.max(0, activeSlots - zellijVisiblePanes) + ' headless active worker(s)');
         else if (summary.zellij?.ok)
@@ -716,9 +752,16 @@ function parseNarutoArgs(args = []) {
     const noOpenZellij = hasFlag(args, '--no-open-zellij') || hasFlag(args, '--no-zellij');
     const attach = hasFlag(args, '--attach');
     const smoke = hasFlag(args, '--smoke');
-    const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url']);
+    const parallelism = normalizeParallelism(readOption(args, '--parallelism', 'extreme'));
+    const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url', '--parallelism']);
     const prompt = positionalArgs(rest, valueFlags).join(' ').trim() || 'Naruto shadow clone swarm run';
-    return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach, smoke };
+    return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach, smoke, parallelism };
+}
+function normalizeParallelism(value) {
+    const text = String(value || 'extreme').toLowerCase();
+    if (text === 'safe' || text === 'balanced' || text === 'extreme')
+        return text;
+    return 'extreme';
 }
 async function writeNarutoArtifacts(ledgerRoot, artifacts) {
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-work-graph.json'), artifacts.workGraph);

package/dist/core/commands/team-command.js

@@ -25,182 +25,6 @@ export async function team(args = []) {
     if (teamSubcommands.has(args[0]))
         return teamCommand(args[0], args.slice(1));
     return redirectTeamCreateToNaruto(args);
-    const jsonOutput = flag(args, '--json');
-    const mock = flag(args, '--mock');
-    const openZellij = !mock && !jsonOutput && !flag(args, '--no-open-zellij') && !flag(args, '--no-zellij');
-    const useOllama = flag(args, '--ollama') || flag(args, '--local-model');
-    const noOllama = flag(args, '--no-ollama') || flag(args, '--no-local-model');
-    const ollamaModel = readFlagValue(args, '--ollama-model', readFlagValue(args, '--local-model-model', '')) || null;
-    const ollamaBaseUrl = readFlagValue(args, '--ollama-base-url', readFlagValue(args, '--local-model-base-url', '')) || null;
-    const cleanCreateArgs = stripTeamCreateControlArgs(args);
-    const opts = parseTeamCreateArgs(cleanCreateArgs);
-    const { prompt, agentSessions, roleCounts, roster } = opts;
-    const targetActiveSlots = readBoundedIntegerFlag(args, '--target-active-slots', roster.bundle_size, 1, 20);
-    const visualLaneCount = roster.bundle_size;
-    const desiredWorkItemCount = readBoundedIntegerFlag(args, '--work-items', targetActiveSlots, 1, 200);
-    const minimumWorkItems = readBoundedIntegerFlag(args, '--minimum-work-items', targetActiveSlots, 1, 200);
-    const maxQueueExpansion = readBoundedIntegerFlag(args, '--max-queue-expansion', 10, 0, 200);
-    const profile = readFlagValue(args, '--profile', '') || null;
-    const writeMode = readFlagValue(args, '--write-mode', flag(args, '--parallel-write') ? 'parallel' : 'off');
-    const applyPatches = flag(args, '--apply-patches');
-    const dryRunPatches = flag(args, '--dry-run-patches') || flag(args, '--dryrun-patches');
-    const maxWriteAgents = readBoundedIntegerFlag(args, '--max-write-agents', Math.min(roster.bundle_size, 5), 1, 20);
-    if (!prompt) {
-        console.error('Usage: sks team "task" [20:agents] [executor:5 reviewer:6 user:1] [--agents N] [--work-items N] [--target-active-slots N] [--profile NAME] [--write-mode off|proof-safe|parallel|serial] [--apply-patches] [--ollama|--no-ollama] [--no-open-zellij] [--json] [--mock]');
-        process.exitCode = 1;
-        return;
-    }
-    const root = await sksRoot();
-    if (!(await exists(path.join(root, '.sneakoscope'))))
-        await initProject(root, {});
-    const { id, dir } = await createMission(root, { mode: 'team', prompt });
-    const schema = buildQuestionSchema(prompt);
-    await writeQuestions(dir, schema);
-    const plan = buildTeamPlan(id, prompt, { agentSessions, roleCounts, roster, targetActiveSlots });
-    await writeJsonAtomic(path.join(dir, 'team-plan.json'), plan);
-    await writeJsonAtomic(path.join(dir, SSOT_GUARD_ARTIFACT), plan.ssot_guard);
-    await writeTextAtomic(path.join(dir, 'team-workflow.md'), teamWorkflowMarkdown(plan));
-    const liveFiles = await initTeamLive(id, dir, prompt, { agentSessions, roleCounts, roster });
-    await writeJsonAtomic(path.join(dir, 'team-roster.json'), { schema_version: 1, mission_id: id, role_counts: roleCounts, agent_sessions: agentSessions, bundle_size: roster.bundle_size, roster, confirmed: true, source: 'default_or_prompt_team_spec' });
-    const fromChatImgRequired = hasFromChatImgSignal(prompt);
-    const teamReasoning = teamReasoningPolicy(prompt, roster);
-    const promptEffort = teamReasoning.prompt_policy?.effort || 'medium';
-    const runtime = await writeTeamRuntimeArtifacts(dir, plan, {});
-    const effortDecision = await writeEffortDecision(dir, {
-        mission_id: id,
-        task_id: 'TEAM-INTAKE',
-        route: fromChatImgRequired ? 'from-chat-img' : 'team',
-        prompt,
-        tool_use: promptEffort === 'medium',
-        multi_step_decision: promptEffort !== 'low',
-        spans_many_files: promptEffort === 'high' || promptEffort === 'xhigh',
-        is_deterministic: promptEffort === 'low',
-        has_verified_skill: true,
-        high_risk: promptEffort === 'high' || promptEffort === 'xhigh',
-        risk_scores: {
-            security: /security|auth|permission|database|supabase|sql|보안|권한|데이터베이스/i.test(prompt) ? 0.8 : 0.1,
-            destructive_action: /delete|drop|reset|remove|삭제|초기화/i.test(prompt) ? 0.8 : 0.1,
-            user_impact: /release|publish|deploy|commit|push|production|배포|커밋|푸쉬|운영/i.test(prompt) ? 0.8 : 0.3
-        }
-    });
-    const workOrder = createWorkOrderLedger({ missionId: id, route: fromChatImgRequired ? 'from-chat-img' : 'team', sourcesComplete: !fromChatImgRequired, requests: [{ verbatim: prompt, normalized_requirement: prompt, implementation_tasks: ['TASK-001'], status: 'pending' }] });
-    await writeWorkOrderLedger(dir, workOrder);
-    if (fromChatImgRequired)
-        await writeFromChatImgArtifacts(dir, { missionId: id, requests: [{ verbatim: prompt }], ambiguities: ['image source inventory must be completed before implementation'] });
-    let liveZellij = null;
-    if (!mock && openZellij) {
-        liveZellij = await launchTeamZellijView({ root, missionId: id, ledgerRoot: path.join(dir, 'agents'), slotCount: visualLaneCount, dryRun: false, attach: false });
-        if (liveZellij?.ok && liveZellij.capability?.status === 'ok')
-            console.log(`Zellij: prepared ${visualLaneCount} native agent lane(s) in ${liveZellij.session_name}. Attach with: ${liveZellij.attach_command_with_env || liveZellij.attach_command}`);
-        else if (liveZellij?.ok)
-            console.log(`Zellij: optional live panes unavailable (${(liveZellij.warnings || []).join('; ') || liveZellij.capability?.status || 'unknown'}).`);
-        else
-            console.log(`Zellij: blocked (${Array.from(new Set(liveZellij?.blockers || [])).join('; ')})`);
-    }
-    const nativeAgentRun = await runNativeAgentOrchestrator({
-        root,
-        missionId: id,
-        route: '$Team',
-        prompt,
-        backend: mock ? 'fake' : 'codex-sdk',
-        mock,
-        agents: roster.bundle_size,
-        targetActiveSlots,
-        visualLaneCount,
-        desiredWorkItemCount,
-        minimumWorkItems,
-        maxQueueExpansion,
-        concurrency: Math.min(agentSessions, roster.bundle_size),
-        readonly: !applyPatches && writeMode === 'off',
-        profile,
-        writeMode: writeMode,
-        applyPatches,
-        dryRunPatches,
-        maxWriteAgents,
-        ollamaEnabled: useOllama && !noOllama,
-        noOllama,
-        ollamaModel,
-        ollamaBaseUrl,
-        routeCommand: 'sks team',
-        routeBlackboxKind: 'actual_team_command'
-    });
-    await appendTeamEvent(dir, {
-        agent: 'native_agent_orchestrator',
-        phase: 'native_agent_intake',
-        type: nativeAgentRun.ok ? 'complete' : 'blocked',
-        artifact: 'agents/agent-proof-evidence.json',
-        message: 'Native agent orchestrator completed with ' + nativeAgentRun.backend + ' backend; proof ' + (nativeAgentRun.proof?.status || 'unknown') + '.'
-    });
-    let dashboardState = await writeTeamDashboardState(dir, { missionId: id, mission: { id, mode: 'team' }, effort: effortDecision.selected_effort, phase: 'intake', next_action: fromChatImgRequired ? 'complete visual source inventory and work-order mapping' : 'run Team native agent intake agents' });
-    await writeJsonAtomic(path.join(dir, 'team-gate.json'), { passed: false, team_roster_confirmed: true, native_agent_proof: nativeAgentRun.proof?.ok === true, agent_central_ledger: true, analysis_artifact: false, triwiki_refreshed: false, triwiki_validated: false, ssot_guard: false, consensus_artifact: false, ...runtime.gate_fields, implementation_team_fresh: false, review_artifact: false, integration_evidence: false, session_cleanup: false, context7_evidence: false, ...(fromChatImgRequired ? { from_chat_img_required: true, from_chat_img_request_coverage: false } : {}) });
-    dashboardState = await writeTeamDashboardState(dir, { missionId: id, mission: { id, mode: 'team' }, effort: effortDecision.selected_effort, phase: 'intake', next_action: fromChatImgRequired ? 'complete visual source inventory and work-order mapping' : 'run Team native agent intake agents' });
-    const route = routePrompt(`$Team ${prompt}`) || ROUTES.find((candidate) => candidate.id === 'Team');
-    const routeReason = routeReasoning(route, prompt);
-    const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task: prompt, required: false, ambiguity: { required: false, status: 'team_cli_direct' } });
-    await setCurrent(root, { mission_id: id, route: 'Team', route_command: '$Team', mode: 'TEAM', phase: mock ? 'TEAM_FIXTURE_DONE' : 'TEAM_NATIVE_AGENT_INTAKE', questions_allowed: false, implementation_allowed: true, context7_required: false, context7_verified: mock, subagents_required: false, subagents_verified: true, native_sessions_required: true, native_sessions_verified: nativeAgentRun.proof?.ok === true, reflection_required: true, visible_progress_required: true, context_tracking: 'triwiki', required_skills: route?.requiredSkills || ['team'], stop_gate: 'team-gate.json', reasoning_effort: routeReason.effort, reasoning_profile: routeReason.profile, reasoning_temporary: true, team_agent_reasoning_policy: teamReasoning, goal_continuation: pipelinePlan.goal_continuation, agent_sessions: agentSessions, target_active_slots: targetActiveSlots, role_counts: roleCounts, team_roster_confirmed: true, team_graph_ready: runtime.ok, team_live_ready: true, from_chat_img_required: fromChatImgRequired, pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok, pipeline_plan_path: PIPELINE_PLAN_ARTIFACT, native_agent_backend: nativeAgentRun.backend, native_agent_proof: 'agents/agent-proof-evidence.json', prompt });
-    const result = {
-        mission_id: id,
-        mission_dir: dir,
-        plan: path.join(dir, 'team-plan.json'),
-        workflow: path.join(dir, 'team-workflow.md'),
-        team_graph: path.join(dir, TEAM_GRAPH_ARTIFACT),
-        runtime_tasks: path.join(dir, TEAM_RUNTIME_TASKS_ARTIFACT),
-        decomposition_report: path.join(dir, TEAM_DECOMPOSITION_ARTIFACT),
-        worker_inbox_dir: path.join(dir, TEAM_INBOX_DIR),
-        live: liveFiles.live,
-        transcript: liveFiles.transcript,
-        dashboard: liveFiles.dashboard,
-        dashboard_state: path.join(dir, ARTIFACT_FILES.team_dashboard_state),
-        effort_decision: path.join(dir, ARTIFACT_FILES.effort_decision),
-        work_order_ledger: path.join(dir, ARTIFACT_FILES.work_order_ledger),
-        pipeline_plan: path.join(dir, PIPELINE_PLAN_ARTIFACT),
-        dashboard_state_valid: dashboardState.ok,
-        context_pack: path.join(root, '.sneakoscope', 'wiki', 'context-pack.json'),
-        agent_sessions: agentSessions,
-        bundle_size: roster.bundle_size,
-        target_active_slots: targetActiveSlots,
-        visual_lane_count: visualLaneCount,
-        desired_work_items: desiredWorkItemCount,
-        minimum_work_items: minimumWorkItems,
-        max_queue_expansion: maxQueueExpansion,
-        role_counts: roleCounts,
-        questions: path.join(dir, 'questions.md'),
-        native_agent_run: nativeAgentRun,
-        codex_agents: ['native_agent_orchestrator', 'agent_central_ledger', 'agent_proof_evidence', 'agent_review_lane', 'agent_integration_lane']
-    };
-    if (mock) {
-        await writeTextAtomic(path.join(dir, 'team-analysis.md'), `# Team Native Agent Analysis\n\nMock Team fixture completed native agent intake for ${id}.\n`);
-        await writeTextAtomic(path.join(dir, 'team-consensus.md'), `# Team Consensus\n\nMock Team fixture consensus reached for ${id}.\n`);
-        await writeTextAtomic(path.join(dir, 'team-review.md'), `# Team Review\n\nMock Team fixture review completed with ${MIN_TEAM_REVIEWER_LANES} validation lanes for ${id}.\n`);
-        await writeTextAtomic(path.join(dir, 'context7-evidence.jsonl'), `${JSON.stringify({ schema: 'sks.context7-evidence.v1', mission_id: id, route: '$Team', status: 'mock_not_required', generated_at: nowIso() })}\n`);
-        const cleanup = { schema_version: 1, mission_id: id, status: 'clean', passed: true, all_sessions_closed: true, outstanding_sessions: 0, live_transcript_finalized: true, mock: true, generated_at: nowIso() };
-        await writeJsonAtomic(path.join(dir, TEAM_SESSION_CLEANUP_ARTIFACT), cleanup);
-        const gate = { passed: true, team_roster_confirmed: true, native_agent_proof: nativeAgentRun.proof?.ok === true, agent_central_ledger: true, analysis_artifact: true, triwiki_refreshed: true, triwiki_validated: true, ssot_guard: true, consensus_artifact: true, ...runtime.gate_fields, implementation_team_fresh: true, review_artifact: true, review_lanes: MIN_TEAM_REVIEWER_LANES, integration_evidence: true, session_cleanup: true, context7_evidence: true, mock: true };
-        await writeJsonAtomic(path.join(dir, 'team-gate.json'), gate);
-        const proof = await maybeFinalizeRoute(root, { missionId: id, route: '$Team', gateFile: 'team-gate.json', gate, mock: true, statusHint: 'verified_partial', artifacts: ['agents/agent-proof-evidence.json', SSOT_GUARD_ARTIFACT, 'team-gate.json', TEAM_SESSION_CLEANUP_ARTIFACT, 'team-plan.json', 'team-runtime-tasks.json', 'completion-proof.json'], claims: [{ id: 'team-fixture-complete', status: 'verified_partial' }], command: { cmd: `sks team "${prompt}" --mock`, status: 0 } });
-        result.mock = true;
-        result.proof = proof.validation;
-    }
-    else {
-        result.zellij = liveZellij || await launchTeamZellijView({ root, missionId: id, ledgerRoot: path.join(dir, 'agents'), slotCount: visualLaneCount, dryRun: jsonOutput || !openZellij, attach: false });
-        if (openZellij && result.zellij?.ok && result.zellij.capability?.status === 'ok' && shouldAutoAttachTeamZellij(args)) {
-            attachZellijSessionInteractive(result.zellij.session_name, { cwd: root, configPath: result.zellij.clipboard_config_path });
-        }
-    }
-    if (jsonOutput)
-        return console.log(JSON.stringify(result, null, 2));
-    console.log(`Team mission created: ${id}`);
-    console.log(`Agent sessions: ${agentSessions}`);
-    console.log(`Role counts: ${formatRoleCounts(roleCounts)}`);
-    console.log(`Review policy: minimum ${MIN_TEAM_REVIEWER_LANES} reviewer/QA validation lanes`);
-    if (result.zellij?.ok && result.zellij.capability?.status === 'ok')
-        console.log(`Zellij: prepared ${visualLaneCount} native agent lane(s) in ${result.zellij.session_name}`);
-    else if (result.zellij?.ok)
-        console.log(`Zellij: optional live panes unavailable (${(result.zellij.warnings || []).join('; ') || result.zellij.capability?.status || 'unknown'})`);
-    else if (!mock)
-        console.log(`Zellij: blocked (${Array.from(new Set(result.zellij?.blockers || [])).join('; ')})`);
-    console.log(`Watch: sks team watch ${id}`);
-    console.log(`Artifacts: .sneakoscope/missions/${id}`);
 }
 async function redirectTeamCreateToNaruto(args = []) {
     const root = await sksRoot();

package/dist/core/db-safety.js

@@ -1,10 +1,10 @@
 import path from 'node:path';
-import { exists, readJson, writeJsonAtomic, readText, nowIso, appendJsonlBounded } from './fsx.js';
+import { exists, readJson, writeJsonAtomic, readText, nowIso, appendJsonlBounded, sha256 } from './fsx.js';
 import { missionDir, setCurrent } from './mission.js';
 import { evaluateMadSksPermissionGate, isMadSksRouteState } from './permission-gates.js';
 import { resolveMadDbMutationPolicy } from './mad-db/mad-db-policy-resolver.js';
-import { consumeMadDbCapability } from './mad-db/mad-db-capability.js';
-import { appendMadDbLedgerEvent } from './mad-db/mad-db-ledger.js';
+import { recordMadDbOperation } from './mad-db/mad-db-capability.js';
+import { appendMadDbLedgerEvent, appendMadDbOperationLifecycle } from './mad-db/mad-db-ledger.js';
 export const DEFAULT_DB_SAFETY_POLICY = Object.freeze({
     schema_version: 1,
     mode: 'read_only_default',
@@ -510,6 +510,16 @@ export async function checkDbOperation(root, state, payload, { duringNoQuestion
     const madDb = await resolveMadDbMutationPolicy(root, state, classification);
     if (madDb.allowed === true && state?.mission_id) {
         const madDbDecision = madDb;
+        const operationId = `mad-db-op-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+        const sqlHash = classification.sql?.statements?.length ? sha256(String(classification.sql.statements.join('\n'))) : null;
+        await appendMadDbOperationLifecycle(root, state.mission_id, {
+            type: 'db_operation.started',
+            operationId,
+            cycleId: madDbDecision.cycle_id,
+            toolName: classification.toolName || null,
+            sqlHash,
+            destructive: classification.level === 'destructive'
+        });
         const decision = {
             allowed: true,
             action: 'allow',
@@ -522,11 +532,29 @@ export async function checkDbOperation(root, state, payload, { duringNoQuestion
                 one_cycle_only: true,
                 cycle_id: madDbDecision.cycle_id,
                 capability_file: 'mad-db-capability.json',
-                consumed: true
+                consumed: false,
+                operation_id: operationId,
+                operation_count: Number(madDbDecision.operation_count || 0) + 1,
+                max_operations: madDbDecision.max_operations || 20
             }
         };
-        await appendMadDbLedgerEvent(root, state.mission_id, { type: 'db_mutation.allowed', cycle_id: madDbDecision.cycle_id, mode: madDbDecision.mode, classification });
-        await consumeMadDbCapability(root, state.mission_id, { consumedBy: 'db-safety-checkDbOperation', reason: 'db_mutation_allowed' });
+        await appendMadDbLedgerEvent(root, state.mission_id, { type: 'db_mutation.allowed', cycle_id: madDbDecision.cycle_id, mode: madDbDecision.mode, classification, operation_id: operationId });
+        await appendMadDbOperationLifecycle(root, state.mission_id, {
+            type: 'db_operation.allowed',
+            operationId,
+            cycleId: madDbDecision.cycle_id,
+            toolName: classification.toolName || null,
+            sqlHash,
+            destructive: classification.level === 'destructive',
+            resultStatus: 'unknown_pending_tool_result'
+        });
+        const updatedCapability = await recordMadDbOperation(root, state.mission_id, {
+            operationId,
+            ...(classification.toolName ? { toolName: classification.toolName } : {}),
+            ...(sqlHash ? { sqlHash } : {})
+        });
+        decision.mad_db.consumed = updatedCapability?.consumed === true;
+        decision.mad_db.operation_count = updatedCapability?.operation_count ?? decision.mad_db.operation_count;
         await appendJsonlBounded(path.join(missionDir(root, state.mission_id), 'db-safety.jsonl'), { ts: nowIso(), decision });
         return decision;
     }

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '2.0.15';
+export const PACKAGE_VERSION = '2.0.16';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

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

@@ -4,6 +4,7 @@ import { gitBlocker, runGitCommand } from './git-worktree-runner.js';
 import { resolveGitWorktreeRoot } from './git-worktree-root.js';
 export async function evaluateGitWorktreeCapability(input = {}) {
     const requireGitWorktree = input.requireGitWorktree === true || process.env.SKS_REQUIRE_GIT_WORKTREE === '1';
+    const disabledByEnv = process.env.SKS_DISABLE_GIT_WORKTREE === '1';
     const detection = await detectGitRepo(input.root || process.cwd());
     const blockers = [...detection.blockers];
     const gitAvailable = Boolean(detection.git_binary);
@@ -24,6 +25,23 @@ export async function evaluateGitWorktreeCapability(input = {}) {
             blockers
         };
     }
+    if (disabledByEnv) {
+        if (requireGitWorktree)
+            blockers.push('git_worktree_disabled_by_env');
+        return {
+            schema: 'sks.git-worktree-capability.v1',
+            ok: blockers.length === 0,
+            mode: 'patch-envelope-only',
+            require_git_worktree: requireGitWorktree,
+            git_available: gitAvailable,
+            is_git_repo: true,
+            worktree_supported: false,
+            worktree_probe_attempted: false,
+            detection,
+            root_resolution: null,
+            blockers: [...new Set(blockers)]
+        };
+    }
     const rootResolution = resolveGitWorktreeRoot({
         repoRoot: detection.root,
         missionId: input.missionId || 'capability'

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

@@ -4,7 +4,21 @@ import { ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { evaluateGitWorktreeCapability } from './git-worktree-capability.js';
 import { gitBlocker, gitOutputLine, runGitCommand } from './git-worktree-runner.js';
 import { sanitizePathPart } from './git-worktree-root.js';
+import { appendParallelRuntimeEvent } from '../agents/parallel-runtime-proof.js';
 export async function allocateWorkerWorktree(input) {
+    const eventRoot = input.repoRoot || process.cwd();
+    const writeProofEvents = await shouldWriteWorktreeAllocationProof(eventRoot, input.missionId);
+    if (writeProofEvents)
+        await appendParallelRuntimeEvent(eventRoot, input.missionId, {
+            event_type: 'worktree_allocation_started',
+            slot_id: input.slotId || input.workerId || null,
+            generation_index: input.generationIndex || 1,
+            session_id: null,
+            pid: null,
+            backend: 'git-worktree',
+            placement: 'unknown',
+            worktree_id: input.workerId || null
+        }).catch(() => undefined);
     const capability = await evaluateGitWorktreeCapability({
         root: input.repoRoot || process.cwd(),
         missionId: input.missionId,
@@ -64,8 +78,63 @@ export async function allocateWorkerWorktree(input) {
         blockers: [...new Set(blockers)]
     };
     await appendWorktreeManifest(allocation);
+    if (writeProofEvents)
+        await appendParallelRuntimeEvent(eventRoot, input.missionId, {
+            event_type: 'worktree_allocation_completed',
+            slot_id: allocation.slot_id,
+            generation_index: allocation.generation_index,
+            session_id: null,
+            pid: null,
+            backend: 'git-worktree',
+            placement: 'unknown',
+            worktree_id: `${allocation.slot_id}-gen-${allocation.generation_index}`,
+            meta: {
+                ok: allocation.ok,
+                worktree_path: allocation.worktree_path,
+                branch: allocation.branch,
+                blockers: allocation.blockers
+            }
+        }).catch(() => undefined);
     return allocation;
 }
+export async function allocateWorkerWorktreesBatch(input) {
+    const maxParallel = Math.max(1, Math.floor(Number(input.maxParallel || 1)));
+    const queue = uniqueWorktreeAllocationInputs(input.workers);
+    const allocations = [];
+    const workers = Array.from({ length: Math.min(maxParallel, queue.length) }, async () => {
+        while (queue.length) {
+            const next = queue.shift();
+            if (!next)
+                continue;
+            allocations.push(await allocateWorkerWorktree({
+                repoRoot: input.root,
+                missionId: input.missionId,
+                workerId: next.workerId,
+                ...(next.slotId === undefined ? {} : { slotId: next.slotId }),
+                ...(next.generationIndex === undefined ? {} : { generationIndex: next.generationIndex }),
+                ...(next.baseRef === undefined ? {} : { baseRef: next.baseRef }),
+                ...(next.branchPrefix === undefined ? {} : { branchPrefix: next.branchPrefix })
+            }));
+        }
+    });
+    await Promise.all(workers);
+    return allocations;
+}
+function uniqueWorktreeAllocationInputs(workers = []) {
+    const seen = new Set();
+    const unique = [];
+    for (const worker of workers) {
+        const workerId = sanitizePathPart(worker.workerId || 'worker');
+        const slotId = sanitizePathPart(worker.slotId || workerId);
+        const generationIndex = Math.max(1, Math.floor(Number(worker.generationIndex || 1)));
+        const key = `${workerId}:${slotId}:${generationIndex}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push({ ...worker, workerId, slotId, generationIndex });
+    }
+    return unique;
+}
 async function appendWorktreeManifest(allocation) {
     const current = await readJson(allocation.manifest_path, null).catch(() => null);
     const allocations = Array.isArray(current?.allocations) ? current.allocations : [];
@@ -84,6 +153,17 @@ async function appendWorktreeManifest(allocation) {
     };
     await writeJsonAtomic(allocation.manifest_path, manifest);
 }
+async function shouldWriteWorktreeAllocationProof(root, missionId) {
+    if (process.env.SKS_GIT_WORKTREE_ALLOCATION_PROOF === '0')
+        return false;
+    try {
+        const stat = await fsp.stat(path.join(root, '.sneakoscope', 'missions', missionId, 'agents'));
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
 function sanitizeBranchPart(value) {
     return sanitizePathPart(value).replace(/\./g, '-').slice(0, 48) || 'item';
 }

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

@@ -1,4 +1,5 @@
 import { nowIso } from '../fsx.js';
+import { allocateWorkerWorktreesBatch as allocateBatch } from './git-worktree-manager.js';
 export function planGitWorktreePool(input) {
     const reusable = [...(input.reusableWorktrees || [])];
     const assignments = input.workerIds.map((workerId) => {
@@ -20,4 +21,7 @@ export function planGitWorktreePool(input) {
         blockers: []
     };
 }
+export async function allocateWorkerWorktreesBatch(input) {
+    return allocateBatch(input);
+}
 //# sourceMappingURL=git-worktree-pool.js.map

package/dist/core/mad-db/mad-db-capability.js

@@ -27,7 +27,9 @@ export async function createMadDbCapability(root, input) {
         },
         consumed: false,
         consumed_at: null,
-        consumed_by: null
+        consumed_by: null,
+        max_operations: Math.max(1, Math.floor(Number(process.env.SKS_MAD_DB_MAX_OPERATIONS || 20))),
+        operation_count: 0
     };
     const dir = missionDir(root, input.missionId);
     await writeJsonAtomic(path.join(dir, MAD_DB_CAPABILITY_FILE), capability);
@@ -52,9 +54,39 @@ export function isMadDbCapabilityActive(capability, nowMs = Date.now()) {
     return capability.enabled === true
         && capability.consumed !== true
         && capability.one_cycle_only === true
+        && Number(capability.operation_count || 0) < Number(capability.max_operations || 20)
         && Number.isFinite(expires)
         && expires > nowMs;
 }
+export async function recordMadDbOperation(root, missionId, input = {}) {
+    const capability = await readMadDbCapability(root, missionId);
+    if (!isMadDbCapabilityActive(capability))
+        return capability;
+    const operationCount = Number(capability.operation_count || 0) + 1;
+    const maxOperations = Math.max(1, Number(capability.max_operations || 20));
+    const updated = {
+        ...capability,
+        operation_count: operationCount,
+        max_operations: maxOperations
+    };
+    const dir = missionDir(root, missionId);
+    await writeJsonAtomic(path.join(dir, MAD_DB_CAPABILITY_FILE), updated);
+    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), {
+        ts: nowIso(),
+        type: 'db_operation.counted',
+        mission_id: missionId,
+        cycle_id: updated.cycle_id,
+        operation_id: input.operationId || null,
+        tool_name: input.toolName || null,
+        sql_hash: input.sqlHash || null,
+        operation_count: operationCount,
+        max_operations: maxOperations
+    });
+    if (operationCount >= maxOperations) {
+        return consumeMadDbCapability(root, missionId, { consumedBy: 'db-safety-checkDbOperation', reason: 'mad_db_max_operations_reached' });
+    }
+    return updated;
+}
 export async function consumeMadDbCapability(root, missionId, input = {}) {
     const capability = await readMadDbCapability(root, missionId);
     if (!isMadDbCapabilityActive(capability))

package/dist/core/mad-db/mad-db-ledger.js

@@ -14,4 +14,18 @@ export async function appendMadDbLedgerEvent(root, missionId, event) {
     await writeJsonAtomic(path.join(dir, 'mad-db-ledger.latest.json'), row).catch(() => undefined);
     return row;
 }
+export async function appendMadDbOperationLifecycle(root, missionId, input) {
+    return appendMadDbLedgerEvent(root, missionId, {
+        type: input.type,
+        operation_id: input.operationId,
+        cycle_id: input.cycleId || null,
+        mcp_server: input.mcpServer || null,
+        tool_name: input.toolName || null,
+        sql_hash: input.sqlHash || null,
+        destructive: input.destructive === true,
+        result_status: input.resultStatus || 'unknown_pending_tool_result',
+        row_count: input.rowCount ?? null,
+        error: input.error || null
+    });
+}
 //# sourceMappingURL=mad-db-ledger.js.map

package/dist/core/mad-db/mad-db-policy-resolver.js

@@ -20,6 +20,8 @@ export async function resolveMadDbMutationPolicy(root, state = {}, classificatio
         audit_required: true,
         mission_id: missionId,
         cycle_id: capability.cycle_id,
+        operation_count: capability.operation_count || 0,
+        max_operations: capability.max_operations || 20,
         capability
     };
 }

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

@@ -9,6 +9,7 @@ export function decideNarutoConcurrency(input = {}) {
     const hardware = probeHardwareCapacity(input.hardware || {});
     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 parallelismMode = normalizeParallelismMode(input.parallelismMode);
     const freeGb = hardware.free_memory_bytes / (1024 * 1024 * 1024);
     const totalGb = hardware.total_memory_bytes / (1024 * 1024 * 1024);
     const reclaimableFloorGb = totalGb >= 32 ? 16 : totalGb >= 16 ? 8 : totalGb >= 8 ? 4 : Math.max(1, freeGb);
@@ -33,7 +34,12 @@ export function decideNarutoConcurrency(input = {}) {
     const rawSafe = Math.max(1, Math.min(requestedClones, totalWorkItems, memoryCap, fdCap, cpuCap + ioCap, gitWorktreeCap + processCap, backendBudget, queueCap, leaseCap, 100));
     const pressure = monitorNarutoResourcePressure(hardware, { activeWorkers: rawSafe, zellijVisiblePaneCap });
     const backpressure = applyNarutoBackpressure(rawSafe, pressure);
-    const safeActiveWorkers = Math.max(1, Math.min(rawSafe, backpressure.adjusted_active_workers));
+    const currentSafeActiveWorkers = Math.max(1, Math.min(rawSafe, backpressure.adjusted_active_workers));
+    const safeActiveWorkers = parallelismMode === 'extreme'
+        ? rawSafe
+        : parallelismMode === 'balanced'
+            ? Math.max(1, Math.min(rawSafe, Math.max(16, Math.floor(rawSafe * 0.75))))
+            : currentSafeActiveWorkers;
     const safeVisible = Math.min(safeActiveWorkers, zellijVisiblePaneCap);
     const reasons = [
         ...(memoryCap < requestedClones ? ['memory_cap'] : []),
@@ -60,11 +66,18 @@ export function decideNarutoConcurrency(input = {}) {
         git_worktree_parallel: gitWorktreeCap,
         cpu_io_parallel: cpuCap + ioCap,
         verification_parallel: Math.max(1, Math.min(hardware.cpu_core_count * 2, safeActiveWorkers, 16)),
+        parallelism_mode: parallelismMode,
         reasons: [...new Set(reasons)],
         backpressure: backpressure.backpressure,
         hardware
     };
 }
+function normalizeParallelismMode(value) {
+    const text = String(value || process.env.SKS_NARUTO_PARALLELISM || 'extreme').toLowerCase();
+    if (text === 'safe' || text === 'balanced' || text === 'extreme')
+        return text;
+    return 'extreme';
+}
 function normalizePositiveInt(value, fallback) {
     const parsed = Number(value);
     if (!Number.isFinite(parsed) || parsed < 1)

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '2.0.15';
+export const PACKAGE_VERSION = '2.0.16';
 //# sourceMappingURL=version.js.map