sneakoscope 2.0.13 → 2.0.15

package/dist/core/codex-control/gpt-final-review-schema.js

@@ -1,5 +1,25 @@
 export const GPT_FINAL_ARBITER_RESULT_SCHEMA_ID = 'sks.gpt-final-arbiter-result.v1';
 export const GPT_FINAL_ARBITER_INPUT_SCHEMA = 'sks.gpt-final-arbiter-input.v1';
+const reviewItemSchema = {
+    type: 'object',
+    required: ['id', 'severity', 'summary'],
+    properties: {
+        id: { type: 'string' },
+        severity: { type: 'string', enum: ['low', 'medium', 'high'] },
+        summary: { type: 'string' }
+    },
+    additionalProperties: false
+};
+const patchDecisionSchema = {
+    type: 'object',
+    required: ['id', 'summary', 'patch_envelope_json'],
+    properties: {
+        id: { type: 'string' },
+        summary: { type: 'string' },
+        patch_envelope_json: { type: 'string' }
+    },
+    additionalProperties: false
+};
 export const gptFinalArbiterResultSchema = {
     type: 'object',
     required: [
@@ -17,20 +37,20 @@ export const gptFinalArbiterResultSchema = {
         'confidence'
     ],
     properties: {
-        schema: { const: GPT_FINAL_ARBITER_RESULT_SCHEMA_ID },
+        schema: { type: 'string', enum: [GPT_FINAL_ARBITER_RESULT_SCHEMA_ID] },
         status: { enum: ['approved', 'modified', 'rejected', 'needs_more_work'] },
         summary: { type: 'string' },
-        gpt_review_findings: { type: 'array', items: { type: 'object' } },
-        accepted_patch_envelopes: { type: 'array', items: { type: 'object' } },
-        modified_patch_envelopes: { type: 'array', items: { type: 'object' } },
-        rejected_patch_envelopes: { type: 'array', items: { type: 'object' } },
-        required_followup_work: { type: 'array', items: { type: 'object' } },
+        gpt_review_findings: { type: 'array', items: reviewItemSchema },
+        accepted_patch_envelopes: { type: 'array', items: patchDecisionSchema },
+        modified_patch_envelopes: { type: 'array', items: patchDecisionSchema },
+        rejected_patch_envelopes: { type: 'array', items: patchDecisionSchema },
+        required_followup_work: { type: 'array', items: reviewItemSchema },
         verification_plan: { type: 'array', items: { type: 'string' } },
         rollback_notes: { type: 'array', items: { type: 'string' } },
         blockers: { type: 'array', items: { type: 'string' } },
         confidence: { enum: ['low', 'medium', 'high'] }
     },
-    additionalProperties: true
+    additionalProperties: false
 };
 export function normalizeGptFinalArbiterResult(value) {
     const status = normalizeStatus(value?.status);
@@ -38,11 +58,11 @@ export function normalizeGptFinalArbiterResult(value) {
         schema: GPT_FINAL_ARBITER_RESULT_SCHEMA_ID,
         status,
         summary: String(value?.summary || defaultSummary(status)),
-        gpt_review_findings: array(value?.gpt_review_findings),
-        accepted_patch_envelopes: array(value?.accepted_patch_envelopes),
-        modified_patch_envelopes: array(value?.modified_patch_envelopes),
-        rejected_patch_envelopes: array(value?.rejected_patch_envelopes),
-        required_followup_work: array(value?.required_followup_work),
+        gpt_review_findings: reviewItems(value?.gpt_review_findings),
+        accepted_patch_envelopes: patchDecisionItems(value?.accepted_patch_envelopes),
+        modified_patch_envelopes: patchDecisionItems(value?.modified_patch_envelopes),
+        rejected_patch_envelopes: patchDecisionItems(value?.rejected_patch_envelopes),
+        required_followup_work: reviewItems(value?.required_followup_work),
         verification_plan: stringArray(value?.verification_plan),
         rollback_notes: stringArray(value?.rollback_notes),
         blockers: stringArray(value?.blockers),
@@ -57,12 +77,39 @@ function normalizeStatus(value) {
 function normalizeConfidence(value) {
     return value === 'low' || value === 'medium' || value === 'high' ? value : 'medium';
 }
-function array(value) {
-    return Array.isArray(value) ? value : [];
+function reviewItems(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((entry, index) => {
+        const raw = typeof entry === 'object' && entry !== null ? entry : { summary: entry };
+        return {
+            id: String(raw.id || raw.blocker || raw.reason || `item-${index + 1}`),
+            severity: normalizeSeverity(raw.severity),
+            summary: String(raw.summary || raw.message || raw.blocker || raw.reason || entry || '').trim()
+        };
+    }).filter((entry) => entry.summary);
+}
+function patchDecisionItems(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((entry, index) => {
+        const raw = typeof entry === 'object' && entry !== null ? entry : { summary: entry };
+        const patch = typeof raw.patch_envelope_json === 'string'
+            ? raw.patch_envelope_json
+            : JSON.stringify(entry ?? {});
+        return {
+            id: String(raw.id || raw.schema || raw.reason || `patch-${index + 1}`),
+            summary: String(raw.summary || raw.reason || raw.rationale || raw.schema || entry || '').trim() || `Patch decision ${index + 1}`,
+            patch_envelope_json: patch
+        };
+    });
 }
 function stringArray(value) {
     return Array.isArray(value) ? value.map((entry) => String(entry || '').trim()).filter(Boolean) : [];
 }
+function normalizeSeverity(value) {
+    return value === 'low' || value === 'medium' || value === 'high' ? value : 'medium';
+}
 function defaultSummary(status) {
     return status === 'approved' || status === 'modified'
         ? 'GPT final arbiter accepted the candidate result.'

package/dist/core/commands/basic-cli.js

@@ -101,7 +101,7 @@ export function quickstartCommand() {
   sks dollar-commands
   sks all-features selftest --mock --execute-fixtures --strict-artifacts --json
 
-For implementation work, use Codex App prompt routes such as $Team, $Goal, $QA-LOOP, $Image-UX-Review, and $Computer-Use.`);
+For implementation work, use Codex App prompt routes such as $Naruto, $Goal, $QA-LOOP, $Image-UX-Review, and $Computer-Use.`);
 }
 export async function updateCheckCommand(args = []) {
     const result = await runSksUpdateCheck();

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

@@ -1,7 +1,7 @@
 export const COMMAND_SUGGESTIONS_SCHEMA = 'sks.command-suggestions.v1';
 export function suggestSksCommands(input) {
     const query = String(input || '').toLowerCase();
-    const commands = ['$Team', '$Goal', '$DFix', '$QA-LOOP', '$Research', '$PPT', '$Image-UX-Review', '$Computer-Use'];
+    const commands = ['$Naruto', '$Goal', '$DFix', '$QA-LOOP', '$Research', '$PPT', '$Image-UX-Review', '$Computer-Use'];
     const suggestions = commands.filter((command) => command.toLowerCase().includes(query.replace(/^\$/, ''))).slice(0, 8);
     return {
         schema: COMMAND_SUGGESTIONS_SCHEMA,

package/dist/core/commands/mad-db-command.js

@@ -0,0 +1,106 @@
+import { initProject } from '../init.js';
+import { createMission, findLatestMission, setCurrent } from '../mission.js';
+import { exists, sksRoot } from '../fsx.js';
+import path from 'node:path';
+import { createMadDbCapability, isMadDbCapabilityActive, MAD_DB_ACK, readMadDbCapability, resolveMadDbMissionId, revokeMadDbCapability } from '../mad-db/mad-db-capability.js';
+export async function madDbCommand(args = []) {
+    const action = String(args[0] && !String(args[0]).startsWith('--') ? args[0] : 'status');
+    const rest = action === args[0] ? args.slice(1) : args;
+    const root = await sksRoot();
+    if (!(await exists(path.join(root, '.sneakoscope'))))
+        await initProject(root, {});
+    if (action === 'enable')
+        return enableMadDb(root, rest);
+    if (action === 'revoke')
+        return revokeMadDb(root, rest);
+    if (action === 'status')
+        return statusMadDb(root, rest);
+    console.error('Usage: sks mad-db enable --ack "I AUTHORIZE ONE-CYCLE DB BREAK-GLASS" [--mission latest|new|M-...] | status | revoke');
+    process.exitCode = 1;
+}
+async function enableMadDb(root, args) {
+    const json = hasFlag(args, '--json');
+    const ack = readOption(args, '--ack', '');
+    if (ack !== MAD_DB_ACK) {
+        const result = { schema: 'sks.mad-db-command.v1', ok: false, action: 'enable', reason: 'ack_phrase_required', required_ack: MAD_DB_ACK };
+        if (json)
+            return console.log(JSON.stringify(result, null, 2));
+        console.error(`Mad-DB enable blocked. Required --ack ${JSON.stringify(MAD_DB_ACK)}`);
+        process.exitCode = 2;
+        return result;
+    }
+    const requestedMission = readOption(args, '--mission', 'latest');
+    let missionId = requestedMission === 'new' ? null : await resolveMadDbMissionId(root, {}, requestedMission);
+    if (!missionId) {
+        const created = await createMission(root, { mode: 'mad-db', prompt: 'sks mad-db enable one-cycle DB break-glass' });
+        missionId = created.id;
+    }
+    const capability = await createMadDbCapability(root, {
+        missionId,
+        ack,
+        cwd: process.cwd(),
+        ttlMs: Number(readOption(args, '--ttl-ms', String(2 * 60 * 60 * 1000)))
+    });
+    await setCurrent(root, {
+        mission_id: missionId,
+        route: 'MadDB',
+        route_command: '$MAD-DB',
+        mode: 'MADDB',
+        phase: 'MADDB_ONE_CYCLE_CAPABILITY_ACTIVE',
+        mad_db_active: true,
+        mad_db_cycle_id: capability.cycle_id,
+        mad_db_capability_file: 'mad-db-capability.json',
+        mad_db_ack_phrase: 'accepted',
+        stop_gate: 'mad-db-capability.json'
+    });
+    const result = { schema: 'sks.mad-db-command.v1', ok: true, action: 'enable', mission_id: missionId, capability };
+    if (json)
+        return console.log(JSON.stringify(result, null, 2));
+    console.log(`Mad-DB one-cycle capability active for ${missionId}; expires ${capability.expires_at}.`);
+    return result;
+}
+async function statusMadDb(root, args) {
+    const json = hasFlag(args, '--json');
+    const missionId = await resolveMadDbMissionId(root, {}, readOption(args, '--mission', 'latest'));
+    const capability = missionId ? await readMadDbCapability(root, missionId) : null;
+    const result = {
+        schema: 'sks.mad-db-command.v1',
+        ok: true,
+        action: 'status',
+        mission_id: missionId,
+        active: isMadDbCapabilityActive(capability),
+        capability
+    };
+    if (json)
+        return console.log(JSON.stringify(result, null, 2));
+    if (!missionId || !capability)
+        console.log('Mad-DB: no capability found.');
+    else
+        console.log(`Mad-DB: ${result.active ? 'active' : 'inactive'} for ${missionId}; consumed=${capability.consumed}; expires=${capability.expires_at}.`);
+    return result;
+}
+async function revokeMadDb(root, args) {
+    const json = hasFlag(args, '--json');
+    const missionId = await resolveMadDbMissionId(root, {}, readOption(args, '--mission', 'latest')) || await findLatestMission(root);
+    const revoked = missionId ? await revokeMadDbCapability(root, missionId, readOption(args, '--reason', 'operator_revoked')) : null;
+    await setCurrent(root, { mad_db_active: false, phase: 'MADDB_REVOKED' });
+    const result = { schema: 'sks.mad-db-command.v1', ok: Boolean(revoked), action: 'revoke', mission_id: missionId, capability: revoked };
+    if (json)
+        return console.log(JSON.stringify(result, null, 2));
+    if (!revoked)
+        console.log('Mad-DB: no capability to revoke.');
+    else
+        console.log(`Mad-DB capability revoked for ${missionId}.`);
+    return result;
+}
+function hasFlag(args, flag) {
+    return args.includes(flag);
+}
+function readOption(args, name, fallback) {
+    const index = args.indexOf(name);
+    if (index >= 0 && args[index + 1] && !String(args[index + 1]).startsWith('--'))
+        return String(args[index + 1]);
+    const prefixed = args.find((arg) => String(arg).startsWith(name + '='));
+    return prefixed ? prefixed.slice(name.length + 1) : fallback;
+}
+//# sourceMappingURL=mad-db-command.js.map

package/dist/core/commands/mad-sks-command.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import fs from 'node:fs';
 import { spawn } from 'node:child_process';
-import { appendJsonlBounded, exists, nowIso, packageRoot, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
+import { PACKAGE_VERSION, appendJsonlBounded, exists, nowIso, packageRoot, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { initProject } from '../init.js';
 import { createMission, setCurrent } from '../mission.js';
 import { buildMadHighLaunchProfileNoWrite, madHighProfileName } from '../auto-review.js';
@@ -18,6 +18,8 @@ import { applyMadSksRollbackPlan } from '../mad-sks/rollback-apply.js';
 import { repairCodexConfigEperm } from '../codex/codex-config-eperm-repair.js';
 import { runCodexLaunchPreflight } from '../preflight/parallel-preflight-engine.js';
 import { diffCodexAppUiSnapshots, writeCodexAppUiSnapshot } from '../codex-app/codex-app-ui-state-snapshot.js';
+import { checkSksUpdateNotice } from '../update/update-notice.js';
+import { createMadDbCapability, MAD_DB_ACK } from '../mad-db/mad-db-capability.js';
 export async function madHighCommand(args = [], deps = {}) {
     const subcommand = firstSubcommand(args);
     if (subcommand)
@@ -27,16 +29,7 @@ export async function madHighCommand(args = [], deps = {}) {
         const profile = buildMadHighLaunchProfileNoWrite();
         return console.log(JSON.stringify(profile, null, 2));
     }
-    const update = deps.maybePromptSksUpdateForLaunch ? await deps.maybePromptSksUpdateForLaunch(args, { label: 'MAD launch' }) : { status: 'skipped' };
-    if (update.status === 'updated') {
-        console.log(`SKS updated from ${deps.packageVersion} to ${update.latest}. Rerun: sks --mad`);
-        return;
-    }
-    if (update.status === 'failed') {
-        console.error(`SKS update failed: ${update.error}`);
-        process.exitCode = 1;
-        return;
-    }
+    const update = { status: 'notice_only', non_blocking: true };
     const codexUpdate = deps.maybePromptCodexUpdateForLaunch ? await deps.maybePromptCodexUpdateForLaunch(args, { label: 'MAD launch' }) : { status: 'skipped' };
     if (codexUpdate.status === 'failed' || codexUpdate.status === 'updated_not_reflected') {
         console.error(`Codex CLI update failed: ${codexUpdate.error || 'updated version was not visible on PATH'}`);
@@ -68,6 +61,13 @@ export async function madHighCommand(args = [], deps = {}) {
     // readability + repair checks still run. SKS_LAUNCH_FULL_CODEX_PROBE=1 restores the
     // old behavior.
     const rawArgs = (args || []).map((arg) => String(arg));
+    const madDbRequested = rawArgs.includes('--mad-db');
+    const madDbAck = readOption(rawArgs, '--ack', '');
+    if (madDbRequested && madDbAck !== MAD_DB_ACK) {
+        console.error(`SKS MAD-DB launch blocked. Required --ack ${JSON.stringify(MAD_DB_ACK)}`);
+        process.exitCode = 2;
+        return { ok: false, status: 'blocked', reason: 'mad_db_ack_phrase_required', required_ack: MAD_DB_ACK };
+    }
     const allowMadRepair = rawArgs.includes('--repair-config') || rawArgs.includes('--fix') || rawArgs.includes('--yes-repair');
     const launchPreflight = await runCodexLaunchPreflight(launchRoot, { fix: allowMadRepair, launchFast: process.env.SKS_LAUNCH_FULL_CODEX_PROBE !== '1', profile: profile.profile_name, sandbox: 'danger-full-access', serviceTier: 'fast' });
     const afterPreflightUi = beforeUi ? await writeCodexAppUiSnapshot(launchRoot, `mad-after-preflight-${uiSnapshotId}`).catch(() => null) : null;
@@ -88,7 +88,41 @@ export async function madHighCommand(args = [], deps = {}) {
         return launchPreflight;
     }
     const madLaunch = await activateMadZellijPermissionState(process.cwd(), args);
+    const madDbCapability = madDbRequested
+        ? await createMadDbCapability(madLaunch.root, { missionId: madLaunch.mission_id, ack: madDbAck, cwd: process.cwd() })
+        : null;
+    if (madDbCapability) {
+        await setCurrent(madLaunch.root, {
+            mission_id: madLaunch.mission_id,
+            mad_db_active: true,
+            mad_db_cycle_id: madDbCapability.cycle_id,
+            mad_db_capability_file: 'mad-db-capability.json',
+            mad_db_break_glass: true
+        });
+        await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_db.capability_created', cycle_id: madDbCapability.cycle_id, expires_at: madDbCapability.expires_at });
+    }
+    const updateNotice = await checkSksUpdateNotice({
+        packageName: deps.packageName || 'sneakoscope',
+        currentVersion: deps.packageVersion || PACKAGE_VERSION,
+        missionDir: madLaunch.dir
+    }).catch((err) => ({
+        schema: 'sks.update-notice.v1',
+        checked_at: nowIso(),
+        package_name: deps.packageName || 'sneakoscope',
+        current_version: deps.packageVersion || PACKAGE_VERSION,
+        latest_version: null,
+        update_available: false,
+        source: 'error',
+        cache_ttl_ms: 0,
+        message: 'SKS update notice check failed; MAD launch continues.',
+        error: err?.message || String(err)
+    }));
+    await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.update_notice_checked', non_blocking: true, update_available: updateNotice.update_available === true, source: updateNotice.source });
     console.log(`SKS MAD ready: ${madHighProfileName()} | gate ${madLaunch.mission_id}`);
+    if (madDbCapability)
+        console.log(`MAD-DB one-cycle capability active; expires ${madDbCapability.expires_at}.`);
+    if (updateNotice.update_available === true)
+        console.log(`SKS update notice: ${updateNotice.latest_version} available (non-blocking).`);
     console.log('Scoped high-power maintenance authority active; add explicit --allow-* flags for packages, services, network, browser/Computer Use, generated assets, file permissions, DB writes, or system/admin scopes. Catastrophic guards remain.');
     const launchLb = lb.status === 'present' ? { ...lb, status: 'configured' } : lb;
     const madSksEnv = {
@@ -445,6 +479,7 @@ function madLaunchOnlyFlags() {
         '--allow-file-permissions',
         '--allow-chmod',
         '--allow-delete',
+        '--mad-db',
         '--confirm-delete',
         '--confirm-destructive-delete',
         '--no-swarm',
@@ -460,7 +495,8 @@ function madLaunchOnlyFlags() {
         '--yes',
         '-y',
         '--dry-run',
-        '--plan-only'
+        '--plan-only',
+        '--ack'
     ]);
 }
 function madLaunchValueFlags() {
@@ -469,7 +505,8 @@ function madLaunchValueFlags() {
         '--mad-swarm-agents',
         '--mad-swarm-work-items',
         '--mad-swarm-backend',
-        '--mad-swarm-prompt'
+        '--mad-swarm-prompt',
+        '--ack'
     ]);
 }
 export function defaultMadSwarmBackend(args = [], opts = {}) {

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';
@@ -235,6 +235,51 @@ 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 && !parsed.mock && !parsed.noOpenZellij) {
         liveZellij = await launchZellijLayout({
@@ -311,6 +356,41 @@ async function narutoRun(parsed) {
         narutoRebalancePolicy: rebalancePolicy,
         json: parsed.json
     });
+    const nativeProofOk = result.proof?.ok === true || result.proof?.status === 'passed';
+    const finalAccepted = result.proof?.status === 'passed' || result.proof?.gpt_final_status === 'approved';
+    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,
+        final_arbiter_accepted: finalAccepted,
+        session_cleanup: result.proof?.all_sessions_closed === true || nativeProofOk,
+        blockers: result.proof?.blockers || [],
+        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 = {
@@ -444,6 +524,7 @@ async function runNarutoControlPlaneSmoke(input) {
             item,
             placement,
             backend: 'fake',
+            parentPrompt: input.prompt,
             worktreePolicy: smokeWorktreePolicy,
             zellijSessionName: `sks-${input.missionId}`,
             visiblePaneCap: input.zellijVisiblePanes

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

@@ -145,25 +145,67 @@ async function researchRun(args) {
     const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: flag(args, '--autoresearch') ? '$AutoResearch' : '$Research', prompt: mission.prompt || plan.prompt || 'Research run', backend: mock ? 'fake' : 'codex-sdk', mock, agents: requestedAgents, targetActiveSlots, desiredWorkItemCount: Math.max(desiredWorkItemCount, graphWorkItemCount), minimumWorkItems: Math.max(minimumWorkItems, Math.min(graphWorkItemCount, targetActiveSlots)), maxQueueExpansion, concurrency: Math.min(requestedAgents, 5), readonly: true, profile, writeMode: writeMode, applyPatches: false, dryRunPatches, maxWriteAgents, roster: plan.native_agent_plan, routeCommand: 'sks research run', routeBlackboxKind: 'actual_research_command', narutoWorkGraph: researchWorkGraph });
     await writeJsonAtomic(path.join(dir, 'research-native-agent-run.json'), nativeAgentRun);
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.native_agents.completed', backend: nativeAgentRun.backend, ok: nativeAgentRun.ok, proof: nativeAgentRun.proof?.status });
-    if (mock) {
-        let gate = await writeMockResearchResult(dir, plan);
-        const nativeGate = { ...(gate.gate || gate), native_agent_proof: nativeAgentRun.proof?.ok === true, agent_central_ledger: true };
-        await writeJsonAtomic(path.join(dir, 'research-gate.json'), nativeGate);
-        gate = { ...gate, gate: nativeGate, passed: nativeGate.passed };
-        const proof = await maybeFinalizeRoute(root, { missionId: id, route: '$Research', gateFile: 'research-gate.json', gate: gate.gate || gate, artifacts: ['agents/agent-proof-evidence.json', 'research-native-agent-run.json', 'research-gate.json', 'research-report.md', researchPaperArtifactForPlan(plan), 'source-ledger.json', 'agent-ledger.json', 'debate-ledger.json', 'completion-proof.json'], mock, command: { cmd: `sks research run ${id} --mock`, status: 0 } });
-        await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: gate.passed ? 'RESEARCH_DONE' : 'RESEARCH_PAUSED', questions_allowed: true, implementation_allowed: false });
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify({ schema: flag(args, '--autoresearch') ? 'sks.autoresearch-run.v1' : 'sks.research-run.v1', ok: proof.ok, mission_id: id, gate, quality_metrics: gate.metrics || null, proof: proof.validation, native_agent_run: nativeAgentRun, research_work_graph: researchWorkGraph, agent_batches: plan.agent_batches, autoresearch_cycle_policy: plan.autoresearch_cycle_policy }, null, 2));
-        console.log(`Mock research done: ${id}`);
-        console.log(`Gate: ${gate.passed ? 'passed' : 'blocked'}`);
-        return;
-    }
     if (!nativeAgentRun.ok) {
         await maybeFinalizeRoute(root, { missionId: id, route: '$Research', gateFile: 'research-gate.json', gate: await readJson(path.join(dir, 'research-gate.json'), null), artifacts: ['agents/agent-proof-evidence.json', 'research-native-agent-run.json', 'completion-proof.json'], statusHint: 'blocked', blockers: nativeAgentRun.proof?.blockers || ['native_agent_backend_blocked'], command: { cmd: `sks research run ${id}`, status: 2 } });
         await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: 'RESEARCH_BLOCKED_NATIVE_AGENTS', questions_allowed: true, implementation_allowed: false, blocker: 'agents/agent-proof-evidence.json' });
         process.exitCode = 2;
         return;
     }
+    const legacyResearchCycle = flag(args, '--legacy-research-cycle') || process.env.SKS_RESEARCH_LEGACY_CYCLE === '1';
+    const sourceMutationBaseline = await researchCodeMutationSnapshot(root, id);
+    if (!legacyResearchCycle) {
+        const cycleResult = await runResearchCycle({
+            root,
+            dir,
+            plan,
+            graph: researchWorkGraph,
+            cycle: 1,
+            backend: mock ? 'mock' : 'codex-sdk',
+            timeoutMs: cycleTimeoutMs,
+            maxParallelStages: readBoundedIntegerFlag(args, '--research-stage-parallelism', 4, 1, 16),
+            mock
+        });
+        const mutation = await researchCodeMutationDelta(root, sourceMutationBaseline, id);
+        if (mutation.blocked) {
+            const blocker = {
+                schema_version: 1,
+                mission_id: id,
+                ts: nowIso(),
+                phase: 'RESEARCH_BLOCKED_CODE_MUTATION',
+                reason: 'Research mode must not modify repository source files. Only route-local mission artifacts are allowed.',
+                changed_paths: mutation.changed_paths,
+                allowed_prefixes: mutation.allowed_prefixes,
+                implementation_allowed: false
+            };
+            await writeJsonAtomic(path.join(dir, 'research-code-mutation-blocker.json'), blocker);
+            await maybeFinalizeRoute(root, { missionId: id, route: '$Research', gateFile: 'research-gate.json', gate: await readJson(path.join(dir, 'research-gate.json'), null), artifacts: ['research-code-mutation-blocker.json', 'completion-proof.json'], statusHint: 'blocked', blockers: ['research_code_mutation_detected'], command: { cmd: `sks research run ${id}`, status: 2 } });
+            await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: 'RESEARCH_BLOCKED_CODE_MUTATION', questions_allowed: true, implementation_allowed: false, blocker: 'research-code-mutation-blocker.json' });
+            process.exitCode = 2;
+            return;
+        }
+        const gate = await evaluateResearchGate(dir);
+        const passed = cycleResult.status === 'passed' && gate.passed === true;
+        const proof = await maybeFinalizeRoute(root, {
+            missionId: id,
+            route: '$Research',
+            gateFile: 'research-gate.json',
+            gate: gate.gate || gate,
+            artifacts: ['agents/agent-proof-evidence.json', 'research-native-agent-run.json', 'research-cycle-runner.json', 'research-gate.json', 'research-report.md', researchPaperArtifactForPlan(plan), 'source-ledger.json', 'claim-evidence-matrix.json', 'implementation-blueprint.json', 'team-handoff-goal.md', 'completion-proof.json'],
+            statusHint: passed ? undefined : 'blocked',
+            blockers: passed ? [] : [...(cycleResult.blockers || []), ...(gate.reasons || [])],
+            mock,
+            command: { cmd: `sks research run ${id}${mock ? ' --mock' : ''}`, status: passed ? 0 : 2 }
+        });
+        await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: passed ? 'RESEARCH_DONE' : 'RESEARCH_BLOCKED_STAGE_CYCLE', questions_allowed: true, implementation_allowed: false });
+        await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: passed ? 'research.done' : 'research.stage_cycle.blocked', cycle: 1, cycle_status: cycleResult.status });
+        await enforceRetention(root).catch(() => { });
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify({ schema: flag(args, '--autoresearch') ? 'sks.autoresearch-run.v1' : 'sks.research-run.v1', ok: proof.ok && passed, mission_id: id, gate, quality_metrics: gate.metrics || null, proof: proof.validation, native_agent_run: nativeAgentRun, research_work_graph: researchWorkGraph, research_cycle: cycleResult, agent_batches: plan.agent_batches, autoresearch_cycle_policy: plan.autoresearch_cycle_policy }, null, 2));
+        printResearchCompletion(id, root, dir, plan, gate);
+        if (!passed)
+            process.exitCode = 2;
+        return;
+    }
     const codex = await getCodexInfo();
     if (!codex.bin) {
         const blocker = {
@@ -185,12 +227,10 @@ async function researchRun(args) {
     }
     let last = '';
     const researchCodexArgs = ['-c', 'service_tier="fast"', '-c', 'model_reasoning_effort="xhigh"'];
-    const sourceMutationBaseline = await researchCodeMutationSnapshot(root, id);
     for (let cycle = 1; cycle <= maxCycles; cycle += 1) {
         const cycleDir = path.join(dir, 'research', `cycle-${cycle}`);
         const outputFile = path.join(cycleDir, 'final.md');
-        await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.cycle.start', cycle, timeoutMinutes: cycleTimeoutMinutes, profile, enforced_reasoning_effort: 'xhigh' });
-        await runResearchCycle(dir, researchWorkGraph, { cycle, status: 'codex_research_cycle_started' });
+        await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.legacy_cycle.start', cycle, timeoutMinutes: cycleTimeoutMinutes, profile, enforced_reasoning_effort: 'xhigh', legacy_final_md_loop: true });
         const prompt = buildResearchPrompt({ id, mission, plan, cycle, previous: last });
         const result = await runCodexExec({ root, prompt, outputFile, json: true, profile, extraArgs: researchCodexArgs, logDir: cycleDir, timeoutMs: cycleTimeoutMs });
         await writeJsonAtomic(path.join(cycleDir, 'process.json'), { code: result.code, stdout_tail: result.stdout, stderr_tail: result.stderr, stdout_bytes: result.stdoutBytes, stderr_bytes: result.stderrBytes, truncated: result.truncated, timed_out: result.timedOut });
@@ -226,7 +266,7 @@ async function researchRun(args) {
             await enforceRetention(root).catch(() => { });
             if (flag(args, '--json'))
                 return console.log(JSON.stringify({ schema: flag(args, '--autoresearch') ? 'sks.autoresearch-run.v1' : 'sks.research-run.v1', ok: proof.ok, mission_id: id, gate, quality_metrics: gate.metrics || null, proof: proof.validation, research_work_graph: researchWorkGraph, agent_batches: plan.agent_batches, autoresearch_cycle_policy: plan.autoresearch_cycle_policy }, null, 2));
-            console.log(`Research done: ${id}`);
+            printResearchCompletion(id, root, dir, plan, gate);
             return;
         }
     }
@@ -235,6 +275,23 @@ async function researchRun(args) {
     await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: 'RESEARCH_PAUSED_MAX_CYCLES', questions_allowed: true, implementation_allowed: false });
     console.log(`Research paused after max cycles without unanimous agent consensus: ${id}`);
 }
+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')}`);
+    console.log(`Claim-evidence matrix: ${rel('claim-evidence-matrix.json')}`);
+    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.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) {
     const root = await sksRoot();
     const id = await resolveMissionId(root, args[0]);
@@ -266,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);
@@ -302,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,