sneakoscope 2.0.14 → 2.0.16

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

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { createMission, findLatestMission, loadMission } from '../mission.js';
+import { createMission, findLatestMission, loadMission, setCurrent } from '../mission.js';
 import { nowIso, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
 import { classifyOllamaWorkerSlice } from '../agents/agent-runner-ollama.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';
@@ -235,7 +237,66 @@ async function narutoRun(parsed) {
         placeholderGuard,
         gitWorktreeCapability
     });
+    await writeJsonAtomic(path.join(mission.dir, 'naruto-gate.json'), {
+        schema: 'sks.naruto-gate.v1',
+        passed: false,
+        mission_id: mission.id,
+        clone_roster_built: true,
+        clone_count: roster.agent_count,
+        work_graph_ready: workGraph.ok === true,
+        role_distribution_ready: roleDistribution.ok === true,
+        allocation_ready: allocationPolicy.ok === true,
+        rebalance_ready: rebalancePolicy.ok === true,
+        concurrency_governor_ready: true,
+        active_pool_simulated: activePool.ok === true,
+        verification_dag_ready: true,
+        gpt_final_pack_ready: true,
+        zellij_dashboard_ready: zellijDashboard.ok === true,
+        native_agent_proof: false,
+        final_arbiter_accepted: false,
+        session_cleanup: false,
+        blockers: [],
+        updated_at: nowIso()
+    });
+    await setCurrent(root, {
+        mission_id: mission.id,
+        route: 'Naruto',
+        route_command: '$Naruto',
+        mode: 'NARUTO',
+        phase: 'NARUTO_NATIVE_AGENT_INTAKE',
+        questions_allowed: false,
+        implementation_allowed: true,
+        context7_required: false,
+        context7_verified: parsed.mock,
+        subagents_required: true,
+        subagents_verified: false,
+        native_sessions_required: true,
+        native_sessions_verified: false,
+        reflection_required: true,
+        visible_progress_required: true,
+        required_skills: ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
+        stop_gate: 'naruto-gate.json',
+        clone_count: roster.agent_count,
+        target_active_slots: activeSlots,
+        work_graph_ready: workGraph.ok === true,
+        naruto_gate_file: 'naruto-gate.json',
+        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,
@@ -311,6 +372,45 @@ 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,
+        mission_id: mission.id,
+        clone_roster_built: true,
+        clone_count: roster.agent_count,
+        work_graph_ready: workGraph.ok === true,
+        role_distribution_ready: roleDistribution.ok === true,
+        allocation_ready: allocationPolicy.ok === true,
+        rebalance_ready: rebalancePolicy.ok === true,
+        concurrency_governor_ready: true,
+        active_pool_simulated: activePool.ok === true,
+        verification_dag_ready: true,
+        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 || []), ...(parallelRuntimeOk ? [] : ['naruto_parallel_runtime_proof_below_gate'])],
+        updated_at: nowIso()
+    });
+    await setCurrent(root, {
+        mission_id: mission.id,
+        route: 'Naruto',
+        route_command: '$Naruto',
+        mode: 'NARUTO',
+        phase: result.ok === true ? 'NARUTO_COMPLETE_OR_REVIEW' : 'NARUTO_BLOCKED',
+        native_sessions_verified: nativeProofOk,
+        subagents_verified: nativeProofOk,
+        naruto_gate_file: 'naruto-gate.json',
+        stop_gate: 'naruto-gate.json',
+        prompt: parsed.prompt
+    });
     const clones = result.roster?.agent_count ?? roster.agent_count;
     const localWorkerSummary = summarizeNarutoLocalWorkerResult(localWorker, result);
     const summary = {
@@ -362,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),
@@ -375,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)
@@ -636,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/research-command.js

@@ -277,8 +277,10 @@ async function researchRun(args) {
 }
 function printResearchCompletion(id, root, dir, plan, gate) {
     const metrics = gate?.metrics || {};
+    const synthesis = metrics.synthesis || {};
     const rel = (artifact) => path.relative(root, path.join(dir, artifact));
     console.log(`Research done: ${id}`);
+    console.log(`Synthesis: ${synthesis.writer || 'missing'}`);
     console.log(`Report: ${rel('research-report.md')}`);
     console.log(`Paper: ${rel(researchPaperArtifactForPlan(plan))}`);
     console.log(`Implementation blueprint: ${rel('implementation-blueprint.json')}`);
@@ -286,7 +288,8 @@ function printResearchCompletion(id, root, dir, plan, gate) {
     console.log(`Experiment plan: ${rel('experiment-plan.json')}`);
     console.log(`Replication pack: ${rel('replication-pack.json')}`);
     console.log(`Gate: ${gate?.passed ? 'passed' : 'blocked'}`);
-    console.log(`Quality: ${metrics.source_entries_total_with_counterevidence ?? metrics.source_entries ?? 0} sources / ${metrics.source_layers_covered ?? 0} layers / ${metrics.key_claims ?? 0} key claims / ${metrics.falsification_cases ?? 0} falsification cases`);
+    console.log(`Quality: ${metrics.report_word_count ?? 0} words / ${metrics.source_entries_total_with_counterevidence ?? metrics.source_entries ?? 0} sources / ${metrics.key_claims ?? 0} key claims / repetition ${synthesis.repetition_ratio ?? metrics.report_repetition?.repeated_paragraph_ratio ?? 'n/a'}`);
+    console.log(`Final review: static ${metrics.final_review_blockers?.length ? 'block' : 'pass'} / codex ${synthesis.codex_final_review_verdict || 'missing'}`);
     console.log(`Handoff: ${rel('team-handoff-goal.md')}`);
 }
 async function researchStatus(args) {
@@ -320,6 +323,7 @@ async function researchStatus(args) {
     const experimentPlan = await readExperimentPlan(dir);
     const replicationPack = await readReplicationPack(dir);
     const finalReview = await readResearchFinalReview(dir);
+    const synthesisOutput = await readJson(path.join(dir, 'research-synthesis-output.json'), null);
     const blueprintValidation = validateImplementationBlueprint(implementationBlueprint, qualityContract);
     const experimentValidation = validateExperimentPlan(experimentPlan, qualityContract);
     const replicationValidation = validateReplicationPack(replicationPack);
@@ -356,6 +360,14 @@ async function researchStatus(args) {
         research_quality: {
             contract: qualityContract,
             report_word_count: gate?.metrics?.report_word_count ?? null,
+            synthesis: {
+                writer: gate?.metrics?.synthesis?.writer ?? (synthesisOutput ? 'evidence-bound writer artifact present' : null),
+                repetition_ratio: gate?.metrics?.synthesis?.repetition_ratio ?? gate?.metrics?.report_repetition?.repeated_paragraph_ratio ?? null,
+                source_density_per_1000_words: gate?.metrics?.synthesis?.source_density_per_1000_words ?? gate?.metrics?.source_density_per_1000_words ?? null,
+                claim_density_per_1000_words: gate?.metrics?.synthesis?.claim_density_per_1000_words ?? gate?.metrics?.claim_density_per_1000_words ?? null,
+                template_phrase_hits: gate?.metrics?.synthesis?.template_phrase_hits ?? gate?.metrics?.template_phrase_hits ?? [],
+                codex_final_review_verdict: finalReview?.codex_review?.verdict || null
+            },
             claim_evidence_matrix_present: claimMatrix.present,
             key_claims: claimMatrix.key_claim_ids.length,
             triangulated_claims: claimMatrix.triangulated_claim_count,

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

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { appendJsonlBounded, exists, nowIso, readJson, sksRoot, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 import { initProject } from '../init.js';
-import { createMission, loadMission, setCurrent } from '../mission.js';
+import { createMission, findLatestMission, loadMission, setCurrent } from '../mission.js';
 import { buildQuestionSchema, writeQuestions } from '../questions.js';
 import { CODEX_COMPUTER_USE_ONLY_POLICY, CODEX_WEB_VERIFICATION_POLICY, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_SOURCE_INVENTORY_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_VISUAL_MAP_ARTIFACT, FROM_CHAT_IMG_WORK_ORDER_ARTIFACT, ROUTES, hasFromChatImgSignal, routePrompt, routeReasoning, triwikiContextTracking } from '../routes.js';
 import { TEAM_DECOMPOSITION_ARTIFACT, TEAM_GRAPH_ARTIFACT, TEAM_INBOX_DIR, TEAM_RUNTIME_TASKS_ARTIFACT, teamRuntimePlanMetadata, teamRuntimeRequiredArtifacts, writeTeamRuntimeArtifacts } from '../team-dag.js';
@@ -18,187 +18,35 @@ import { attachZellijSessionInteractive, launchTeamZellijView } from '../zellij/
 import { maybeFinalizeRoute } from '../proof/auto-finalize.js';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
 import { ambientGoalContinuation, flag, readBoundedIntegerFlag, readFlagValue } from './command-utils.js';
+import { narutoCommand } from './naruto-command.js';
 const TEAM_SESSION_CLEANUP_ARTIFACT = 'team-session-cleanup.json';
 export async function team(args = []) {
     const teamSubcommands = new Set(['log', 'tail', 'watch', 'lane', 'status', 'dashboard', 'event', 'message', 'open-zellij', 'attach-zellij', 'cleanup-zellij', 'open-tmux', 'attach-tmux', 'cleanup-tmux']);
     if (teamSubcommands.has(args[0]))
         return teamCommand(args[0], args.slice(1));
-    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;
-    }
+    return redirectTeamCreateToNaruto(args);
+}
+async function redirectTeamCreateToNaruto(args = []) {
     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 });
-        }
+    const list = (args || []).map((arg) => String(arg));
+    const narutoArgs = list[0] === 'run' ? list : ['run', ...list];
+    console.warn('SKS Team is deprecated for new execution missions; redirecting to $Naruto.');
+    const result = await narutoCommand(narutoArgs);
+    const missionId = result?.mission_id || await findLatestMission(root);
+    if (missionId) {
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'missions', missionId, 'team-alias-to-naruto.json'), {
+            schema: 'sks.team-alias-to-naruto.v1',
+            ok: true,
+            mission_id: missionId,
+            source_command: 'sks team',
+            redirected_to: 'sks naruto run',
+            route_command: '$Naruto',
+            deprecated_route: '$Team',
+            created_at: nowIso(),
+            args: list
+        });
     }
-    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}`);
+    return result;
 }
 export function parseTeamCreateArgs(args) {
     const spec = parseTeamSpecArgs(args);

package/dist/core/db-safety.js

@@ -1,7 +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 { 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',
@@ -504,6 +507,57 @@ export async function checkDbOperation(root, state, payload, { duringNoQuestion
     const policy = await loadDbSafetyPolicy(root);
     const contract = await loadMissionContract(root, state);
     const classification = classifyToolPayload(payload);
+    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',
+            reasons: madDb.reasons,
+            classification,
+            effective: { mode: 'mad-db-break-glass', env: 'operator_authorized_one_cycle', destructive: true, migrationApply: 'yes' },
+            mad_db: {
+                active: true,
+                priority: 'highest',
+                one_cycle_only: true,
+                cycle_id: madDbDecision.cycle_id,
+                capability_file: 'mad-db-capability.json',
+                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, 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;
+    }
     const madSks = await madSksOverrideState(root, state);
     const decision = evaluateDbSafety({ classification, policy, contract, duringNoQuestion, madSks });
     if (decision.action === 'confirm')

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.14';
+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'