sneakoscope 7.0.0 → 7.0.3

package/dist/core/mission.js

@@ -21,11 +21,81 @@ export function sessionStateKey(sessionKey = 'default') {
 export function stateFileForSession(root, sessionKey) {
     return path.join(stateSessionsDir(root), `${sessionStateKey(sessionKey)}.json`);
 }
-export async function createMission(root, { mode, prompt, sessionKey }) {
-    return withStateLock(root, () => createMissionUnlocked(root, { mode, prompt, sessionKey }));
+export function validateExternallyReservedMissionId(rawId) {
+    const id = String(rawId ?? '');
+    if (!id.startsWith('M-'))
+        return { ok: false, reason: 'missing_m_prefix' };
+    if (id.length < 3 || id.length > 160)
+        return { ok: false, reason: 'length' };
+    if (id.trim() !== id)
+        return { ok: false, reason: 'normalization' };
+    if (id.includes('/') || id.includes('\\') || id.includes('\0') || /\s/.test(id) || id.includes('..')) {
+        return { ok: false, reason: 'path' };
+    }
+    if (!/^[A-Za-z0-9._-]+$/.test(id))
+        return { ok: false, reason: 'charset' };
+    return { ok: true, id };
+}
+export async function createMission(root, { mode, prompt, sessionKey, requestedId }) {
+    return withStateLock(root, () => createMissionUnlocked(root, { mode, prompt, sessionKey, requestedId }));
+}
+export async function getOrCreateExplicitNarutoMission(root, input) {
+    const validated = validateExternallyReservedMissionId(input.requestedId);
+    if (!validated.ok) {
+        return { ok: false, blockers: [`naruto_mission_id_invalid:${validated.reason}`] };
+    }
+    const normalizedPrompt = String(input.prompt || '').trim();
+    return withStateLock(root, async () => {
+        let loaded = await loadMission(root, validated.id).catch(() => null);
+        if (!loaded) {
+            try {
+                const created = await createMissionUnlocked(root, {
+                    mode: 'naruto',
+                    prompt: normalizedPrompt,
+                    sessionKey: input.sessionKey,
+                    requestedId: validated.id
+                });
+                return { ok: true, id: String(created.id), dir: String(created.dir) };
+            }
+            catch (error) {
+                if (error?.code !== 'mission_already_exists')
+                    throw error;
+                loaded = await loadMission(root, validated.id).catch(() => null);
+                if (!loaded) {
+                    return { ok: false, blockers: [`naruto_mission_not_found:${validated.id}`] };
+                }
+            }
+        }
+        if (String(loaded.mission?.mode || '') !== 'naruto') {
+            return { ok: false, blockers: ['naruto_mission_identity_conflict:mission_mode'] };
+        }
+        if (String(loaded.mission?.prompt || '').trim() !== normalizedPrompt) {
+            return { ok: false, blockers: ['naruto_mission_identity_conflict:mission_prompt'] };
+        }
+        return { ok: true, id: String(loaded.id), dir: String(loaded.dir) };
+    });
 }
-async function createMissionUnlocked(root, { mode, prompt, sessionKey }) {
-    const id = missionId();
+async function createMissionUnlocked(root, { mode, prompt, sessionKey, requestedId }) {
+    let id;
+    if (requestedId != null && String(requestedId).length > 0) {
+        const validated = validateExternallyReservedMissionId(requestedId);
+        if (!validated.ok) {
+            const err = new Error(`invalid_mission_id:${validated.reason}`);
+            err.code = 'invalid_mission_id';
+            err.reason = validated.reason;
+            throw err;
+        }
+        id = validated.id;
+        if (await exists(path.join(missionDir(root, id), 'mission.json'))) {
+            const err = new Error('mission_already_exists');
+            err.code = 'mission_already_exists';
+            err.id = id;
+            throw err;
+        }
+    }
+    else {
+        id = missionId();
+    }
     const dir = missionDir(root, id);
     await ensureDir(dir);
     await ensureDir(path.join(dir, 'bus'));
@@ -137,8 +207,6 @@ export async function findLatestMission(root, opts = {}) {
         const mission = await readJson(path.join(dirPath, 'mission.json'), {}).catch(() => ({}));
         if (mode && mission.mode !== mode)
             return null;
-        // Route scoping is indirect: mission.json never carries a route field, so the
-        // caller must name the route-specific gate artifact to probe for.
         if (route && gateFile) {
             const gate = await readJson(path.join(dirPath, gateFile), null).catch(() => null);
             if (!gate)

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

@@ -141,7 +141,6 @@ async function nextCollectableWorkers(active, hardTimeoutMs = 10 * 60 * 1000) {
         ;
         handle.exit.then(() => settled.add(handle), () => settled.add(handle));
     }
-    /* intentional: only racing for settlement timing here — actual outcomes are captured via the .then() handlers above, this catch just prevents an unhandled-rejection warning on the raced promises */
     await Promise.race([
         ...handlesWithExit.map((handle) => handle.exit.catch(() => undefined)),
         delay(1000)
@@ -178,7 +177,6 @@ async function forceCollectTimedOutWorker(handle) {
     };
 }
 function sendSignal(pid, signal) {
-    /* intentional: the pid/process-group may already be dead (ESRCH) by the time this fires — that's the expected common case, not an error */
     if (process.platform !== 'win32') {
         try {
             process.kill(-pid, signal);

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

@@ -36,7 +36,6 @@ export function decideNarutoConcurrency(input = {}) {
     const pressure = monitorNarutoResourcePressure(hardware, { activeWorkers: rawSafe, zellijVisiblePaneCap });
     const backpressure = applyNarutoBackpressure(rawSafe, pressure);
     const currentSafeActiveWorkers = Math.max(1, Math.min(rawSafe, backpressure.adjusted_active_workers));
-    // Every mode respects live backpressure. Modes only lower the bounded cap.
     const modeCap = parallelismMode === 'safe'
         ? Math.max(1, Math.ceil(rawSafe * 0.5))
         : parallelismMode === 'balanced'

package/dist/core/naruto/naruto-real-write-proof.js

@@ -1,8 +1,4 @@
 export const NARUTO_REAL_WRITE_PROOF_SCHEMA = 'sks.naruto-real-write-proof.v1';
-// Exact blocker values that legitimately record "work could not be safely
-// split across ≥2 workers" — matched by strict equality only. A substring
-// match here would let any unrelated blocker text mentioning this word
-// silently waive the worker-diversity requirement.
 const UNSPLITTABLE_BLOCKER_VALUES = new Set([
     'native_session_unsplittable_evidence_recorded',
     'unsplittable_write_scope_explicit'

package/dist/core/naruto/naruto-write-e2e.js

@@ -476,7 +476,6 @@ function readPositiveIntEnv(name, fallback) {
     return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
 }
 function parseJsonObjectFromStdout(stdout) {
-    /* intentional: best-effort JSON extraction from mixed stdout — each parse attempt below is expected to fail on non-JSON lines, falling through to the next strategy, with null as the final honest outcome */
     const text = String(stdout || '').trim();
     const first = text.indexOf('{');
     const last = text.lastIndexOf('}');

package/dist/core/perf/perf-budget.js

@@ -61,11 +61,6 @@ export async function writePerfBudgetReport(root, budgets, opts = {}) {
     await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'perf-budget.json'), report);
     return report;
 }
-// p50_ms/p95_ms are the numbers the budget is judged against, and they must
-// be the user-experienced raw wall time. This used to subtract a measured
-// node startup baseline, which let a real 171ms command report as 3ms
-// (20차 P0-11) — that deduction is gone; these are plain percentiles of the
-// measured process wall-clock durations, nothing else.
 async function measureCommand(root, budget, measuredRuns, timeoutMs) {
     const durations = [];
     const exitCodes = [];

package/dist/core/permission-gates.js

@@ -106,8 +106,6 @@ export function madSksCatastrophicSqlExplicitlyRequested({ classification, userI
     const requirements = madSksCatastrophicSqlLiteralRequirements(classification || {});
     if (!requirements.length)
         return { required: false, ok: true, missing: [] };
-    // The SQL text can be generated by the agent. Only the user's literal request
-    // or CLI statement counts as explicit catastrophic authorization.
     const haystack = String(userIntent || '');
     const missing = requirements.filter((entry) => !entry.pattern.test(haystack)).map((entry) => entry.reason);
     return {

package/dist/core/pipeline-internals/runtime-core.js

@@ -25,7 +25,7 @@ import { prepareMadSksSqlPlaneMission } from '../mad-sks/sql-plane/coordinator.j
 import { MAD_SKS_SQL_PLANE_CAPABILITY_FILE, madSksSqlPlaneRelativePath } from '../mad-sks/sql-plane/paths.js';
 import { OFFICIAL_SUBAGENT_EXECUTION_STAGE_ID } from '../agents/agent-schema.js';
 import { normalizeOfficialSubagentPolicy, officialSubagentPipelineStage } from '../agents/agent-plan.js';
-import { CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_COMPUTER_USE_EVIDENCE_SOURCE, CODEX_COMPUTER_USE_ONLY_POLICY, CODEX_IMAGEGEN_REQUIRED_POLICY, CODEX_WEB_VERIFICATION_POLICY, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS, chatCaptureIntakeText, context7RequirementText, dollarCommand, evidenceMentionsForbiddenBrowserAutomation, hasFromChatImgSignal, hasMadSksSignal, imageUxReviewPipelinePolicyText, pptPipelineAllowlistPolicyText, reflectionRequiredForRoute, reasoningInstruction, routeNeedsContext7, routePrompt, routeReasoning, routeRequiresSubagents, stripDollarCommand, stripMadSksSignal, stripVisibleDecisionAnswerBlocks, subagentExecutionPolicyText, stackCurrentDocsPolicyText, triwikiContextTracking } from '../routes.js';
+import { CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_COMPUTER_USE_EVIDENCE_SOURCE, CODEX_COMPUTER_USE_ONLY_POLICY, CODEX_IMAGEGEN_REQUIRED_POLICY, CODEX_WEB_VERIFICATION_POLICY, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS, chatCaptureIntakeText, context7RequirementText, dollarCommand, evidenceMentionsForbiddenBrowserAutomation, explicitManagedSkillNames, hasFromChatImgSignal, hasMadSksSignal, imageUxReviewPipelinePolicyText, managedSkillNamesForPrompt, pptPipelineAllowlistPolicyText, reflectionRequiredForRoute, reasoningInstruction, routeNeedsContext7, routePrompt, routeReasoning, routeRequiresSubagents, stripDollarCommand, stripMadSksSignal, stripVisibleDecisionAnswerBlocks, subagentExecutionPolicyText, stackCurrentDocsPolicyText, triwikiContextTracking } from '../routes.js';
 import { coreEngineeringDirectiveReferenceText } from '../lean-engineering-policy.js';
 import { classifyTaskProfile, gateProfileForTask } from '../runtime/task-profile.js';
 import { chooseVerificationBudget } from '../runtime/verification-budget.js';
@@ -665,7 +665,12 @@ export function goalNativeOnlyContext(prompt, route = routePrompt(prompt)) {
 }
 export async function prepareRoute(root, prompt, state = {}, opts = {}) {
     const cleanPrompt = stripVisibleDecisionAnswerBlocks(prompt);
-    const route = routePrompt(cleanPrompt);
+    const selectedRoute = routePrompt(cleanPrompt);
+    const explicitlyInvokedSkills = explicitManagedSkillNames(cleanPrompt);
+    const route = selectedRoute ? {
+        ...selectedRoute,
+        requiredSkills: managedSkillNamesForPrompt(selectedRoute, cleanPrompt)
+    } : null;
     const codexThreadId = String(process.env.CODEX_THREAD_ID || '').trim();
     const sessionKey = opts.sessionKey || codexThreadId || state?._session_key || null;
     const madSksAuthorization = hasMadSksSignal(cleanPrompt);
@@ -702,7 +707,7 @@ export async function prepareRoute(root, prompt, state = {}, opts = {}) {
     if (route.id === 'Naruto' && subagentsRequired)
         return finish(await prepareNaruto(root, route, task, required, { madSksAuthorization, sessionKey, parentModel: opts.parentModel || null }));
     if (route.id === 'Naruto')
-        return finish(await prepareLightRoute(root, parentOwnedProfileRoute(route), task, required, { sessionKey }));
+        return finish(await prepareLightRoute(root, parentOwnedProfileRoute(route, explicitlyInvokedSkills), task, required, { sessionKey }));
     if (route.id === 'Research')
         return finish(await prepareResearch(root, route, task, required, { sessionKey }));
     if (route.id === 'AutoResearch')
@@ -718,7 +723,7 @@ export async function prepareRoute(root, prompt, state = {}, opts = {}) {
         additionalContext: `${promptPipelineContext(prompt, route)}\n\nReasoning: ${reasoning.effort} (${reasoning.reason}); temporary profile ${reasoning.profile}.\nRequired skills: ${route.requiredSkills.join(', ')}.\nOfficial subagents required: ${subagentsRequired ? 'yes' : 'no'}.`
     });
 }
-function parentOwnedProfileRoute(route) {
+function parentOwnedProfileRoute(route, explicitlyInvokedSkills = []) {
     return {
         ...route,
         id: 'SKS',
@@ -726,7 +731,12 @@ function parentOwnedProfileRoute(route) {
         mode: 'SKS',
         route: 'profiled parent-owned execution',
         description: 'Parent-owned bounded execution selected by the task profile; no subagent workflow is required.',
-        requiredSkills: ['sks-pipeline-runner', 'sks-prompt-pipeline', 'sks-honest-mode'],
+        requiredSkills: Array.from(new Set([
+            'sks-pipeline-runner',
+            'sks-prompt-pipeline',
+            'sks-honest-mode',
+            ...explicitlyInvokedSkills
+        ])),
         lifecycle: ['task_profile', 'ownership', 'focused_implementation', 'listed_verification', 'honest_summary'],
         stopGate: 'honest_mode',
         coverage_required: false,

package/dist/core/pipeline-internals/runtime-gates.js

@@ -71,13 +71,6 @@ async function reflectionGateStatus(root, state = {}, jsonCache) {
     }
     return { ok, missing };
 }
-// The single choke point every route's stop decision passes through
-// (hookStop -> evaluateStop). A work-order-ledger.json here means SOME
-// code already committed to tracking this mission's work items; once that
-// commitment exists, stop must not be allowed while items remain
-// unresolved (neither verified nor honestly blocked), or an omission can
-// reach "done" silently. Missions with no ledger are unaffected (routes
-// that haven't adopted per-item tracking yet, or non-work routes).
 async function workOrderCoverageGateStatus(root, state = {}) {
     const id = state?.mission_id;
     if (!id)
@@ -184,10 +177,6 @@ export async function projectGateStatus(root, state = {}) {
     };
 }
 export async function evaluateStop(root, state, payload, opts = {}) {
-    // `sks route close` is the explicit terminal control for abandoning or
-    // superseding a route. Once it has closed the route, stale requirements
-    // from that route must not re-open native-agent, reflection, or proof gates
-    // on the next Stop hook invocation.
     if (state?.route_closed === true) {
         return {
             continue: true,
@@ -266,7 +255,6 @@ export async function evaluateStop(root, state, payload, opts = {}) {
         return complianceBlock(root, state, `SKS no-question run is not done. Continue autonomously, fix failing checks, update ${gate.file || 'the active gate file'}, and do not ask the user.${missing}`, { gate: gate.file || 'active-gate', missing: gate.missing });
     }
     if (state?.mission_id && state?.stop_gate && !['none', 'honest_mode', 'clarification-gate'].includes(state.stop_gate)) {
-        // 4.0.9: Use canonical stop-gate resolver first for NARUTO/GLM_NARUTO routes.
         const modeUpper = String(state?.mode || '').toUpperCase();
         const routeUpper = String(state?.route || state?.route_command || '').replace(/^\$/, '').toUpperCase();
         const narutoFamily = modeUpper === 'NARUTO' || routeUpper === 'NARUTO' || routeUpper === 'GLM_NARUTO';

package/dist/core/preflight/parallel-preflight-engine.js

@@ -31,23 +31,12 @@ export async function runParallelPreflight(checks) {
 export async function runCodexLaunchPreflight(rootInput = process.cwd(), opts = {}) {
     const root = path.resolve(rootInput || process.cwd());
     const reportPath = opts.reportPath || path.join(root, '.sneakoscope', 'reports', 'mad-launch-preflight.json');
-    // On the interactive launch path the real codex profile is exercised the moment the
-    // Zellij session opens, so spawning `codex exec` here (up to ~20s, and again inside
-    // the repair re-inspections) is redundant. launchFast skips ONLY the live-codex probe;
-    // all filesystem/permission/symlink/ACL/EPERM readability + repair checks still run, so
-    // the EPERM/tcc_possible/EACCES blockers still fire for unreadable configs
-    // (codex_cli_config_eperm is probe-only and intentionally not exercised on this path).
     const probeCodex = opts.launchFast === true ? false : opts.actualCodex !== false;
     const readonly = await runParallelPreflight([
         { id: 'codex_config_readability', run: () => inspectCodexConfigReadability(root, { ...opts, codexProbe: probeCodex, actualCodex: probeCodex, writeReport: false }) },
         { id: 'codex_project_config_policy', run: () => splitCodexProjectConfigPolicy(root, { ...opts, writeReport: false }) },
         { id: 'codex_lb_tool_output_recovery', run: () => inspectCodexLbToolOutputRecoveryForLaunch(opts) }
     ]);
-    // A failed read-only preflight must not invoke the full repair inspector unless
-    // the operator explicitly requested repair. The repair path re-runs readability
-    // before and after its work; on macOS ACL/TCC failures those repeated 5s probes
-    // used to compound into minute-scale `sks --mad` startup delays even though no
-    // mutation was authorized. Keep the blocker from the first pass and fail fast.
     const repair = opts.fix === true
         ? await repairCodexConfigEperm(root, { ...opts, codexProbe: probeCodex, actualCodex: probeCodex, fix: true, writeReport: false })
         : null;

package/dist/core/proof/evidence-collector.js

@@ -4,7 +4,6 @@ import { codexLbMetrics, readCodexLbCircuit } from '../codex-lb-circuit.js';
 import { imageVoxelSummary } from '../wiki-image/image-voxel-ledger.js';
 import { wrongnessProofEvidence } from '../triwiki-wrongness/wrongness-proof-linker.js';
 export async function collectProofEvidence(root = packageRoot()) {
-    /* intentional: each field below is optional supplementary evidence for the proof report — a missing/unreadable source just omits that field rather than failing the whole collection */
     return {
         files: await collectGitFileChanges(root),
         image_voxels: await imageVoxelSummary(root).catch(() => null),
@@ -23,7 +22,6 @@ export async function collectProofEvidence(root = packageRoot()) {
     };
 }
 async function collectGitFileChanges(root) {
-    /* intentional: git absent or the status call failing just means no file-change evidence is available, not a collection error */
     const git = await which('git').catch(() => null);
     if (!git)
         return [];

package/dist/core/proof/route-finalizer.js

@@ -30,7 +30,6 @@ export async function finalizeRouteWithProof(root, { missionId, route, gateFile
         status: 'not_collected',
         reason: err?.message || String(err || 'unknown_error')
     }));
-    /* intentional: optional report-enrichment evidence — a read failure here degrades the report, it doesn't invalidate the route decision */
     const agentEvidence = agents === false ? null : await readAgentProofEvidence(root, missionId).catch(() => null);
     const wrongnessEvidence = lightweightEvidence ? null : await wrongnessProofEvidence(root, missionId, { route: policy.route }).catch(() => null);
     const requiresNativeComputerUseLiveEvidence = ['$Computer-Use', '$CU'].includes(String(policy.route || ''));

package/dist/core/proof/selftest-proof-fixtures.js

@@ -26,11 +26,6 @@ export async function writeSelftestRouteProof(root, { missionId, route = '$Narut
     return writeRouteCompletionProof(root, {
         missionId,
         route,
-        // This fixture writes into a scratch temp directory (see selftestCommand's
-        // `tmpdir('sks-selftest-')`) that is discarded after the call returns, so trust
-        // artifacts and post-route retention are pointless here. The production
-        // post-route path now skips global temp sweeping, but this mock fixture still
-        // avoids unnecessary trust/retention work before its caller removes the root.
         lightweightEvidence: true,
         status: 'mock_only',
         executionClass: 'mock_fixture',

package/dist/core/providers/glm/bench/glm-benchmark-runner.js

@@ -38,7 +38,6 @@ export async function runGlmBenchmark(root, args = [], deps = {}) {
     await fsp.mkdir(benchDir, { recursive: true });
     const sharedFixture = await createGlmBenchFixture();
     const cases = [];
-    // Direct GLM case — does NOT call runGlmNarutoMission
     const directFixture = await cloneFixture(sharedFixture, 'direct');
     const directCaseDir = path.join(benchDir, 'cases', 'direct-glm-speed');
     const directCase = await runGlmDirectBenchCase({
@@ -52,7 +51,6 @@ export async function runGlmBenchmark(root, args = [], deps = {}) {
     }, deps.runDirect ? { runDirect: deps.runDirect } : {});
     cases.push(directCase);
     await cleanupFixture(directFixture);
-    // Naruto cases — each calls runGlmNarutoMission with different worker counts
     for (const workers of NARUTO_WORKER_COUNTS) {
         const narutoFixture = await cloneFixture(sharedFixture, `naruto-${workers}`);
         const caseDir = path.join(benchDir, 'cases', `glm-naruto-${workers}`);

package/dist/core/providers/glm/glm-request-cache.js

@@ -8,16 +8,13 @@ export function encodeGlmRequestWithCache(input, cache = defaultEncodedRequestCa
     const stringify = 'request' in input && input.stringify ? input.stringify : JSON.stringify;
     const key = 'request' in input && input.cacheKeyParts ? digestRequestCacheKeyParts(input.cacheKeyParts) : digestRequestForCache(request);
     const hit = cache.get(key);
-    // Fix 18.2: On cache hit, return stored body without JSON.stringify
     if (hit) {
         if (hit.bodyStored) {
             return { body: hit.body, entry: hit, cacheHit: true };
         }
-        // Even for non-stored bodies, skip re-stringifying by computing from request
         const body = stringify(request);
         return { body, entry: hit, cacheHit: true };
     }
-    // Cache miss: stringify once
     const body = stringify(request);
     if (containsSecretLikeContent(body)) {
         const entry = {

package/dist/core/providers/glm/naruto/glm-naruto-command.js

@@ -5,7 +5,6 @@ import { runGlmNarutoBench } from './glm-naruto-bench.js';
 import { stripGlmSlashModelArgs } from '../glm-profile-resolver.js';
 export async function glmNarutoCommand(args = []) {
     if (flag(args, '--bench')) {
-        // --compare is an alias; the benchmark always compares direct vs Naruto.
         const result = await runGlmNarutoBench(process.cwd(), args);
         if (flag(args, '--json'))
             printJson(result);

package/dist/core/providers/glm/naruto/glm-naruto-decomposer.js

@@ -138,7 +138,6 @@ export function validateWorkGraph(graph, isVerifyOnly) {
     const mutableCount = graph.mutable_shards.length;
     if (mutableCount === 0)
         return { ok: false, reason: 'glm_naruto_needs_target_path_context' };
-    // Check ratio of mutable shards to total shards (excluding verification shards from the denominator)
     const totalWorkShards = graph.shards.filter(s => s.mutable || s.kind !== 'verification').length;
     const ratio = totalWorkShards > 0 ? mutableCount / totalWorkShards : 0;
     if (ratio < GLM_NARUTO_DEFAULTS.patch_worker_ratio) {

package/dist/core/providers/glm/naruto/glm-naruto-orchestrator.js

@@ -96,7 +96,6 @@ export async function runGlmNarutoMission(input) {
     }
     const healthTracker = createProviderHealthTracker();
     let traceState = createMissionTrace(missionId);
-    // Wave 1: parallel patch candidate generation
     const poolResult = await runPatchWorkerPool({
         apiKey: key.key,
         missionId,
@@ -130,7 +129,6 @@ export async function runGlmNarutoMission(input) {
     let schedulerSummary = poolResult.schedulerSummary;
     const stageMetrics = [...poolResult.stageMetrics];
     const stageEvents = [...poolResult.stageEvents];
-    // Repair wave if needed
     if (failedShardIds.length > 0 && repairWaves < GLM_NARUTO_LIMITS.max_repair_waves) {
         const repairPlan = planRepairWave({
             failedEnvelopes: envelopes.filter((e) => e.status === 'gate_failed'),
@@ -168,7 +166,6 @@ export async function runGlmNarutoMission(input) {
             failedShardIds = [...failedShardIds, ...repairPool.failedShardIds];
         }
     }
-    // 4.0.9: Verifier wave — run parallel verifier workers over gate-passed candidates.
     let passedEnvelopes = envelopes.filter((e) => e.status === 'gate_passed');
     let verifierWaveRun = false;
     if (passedEnvelopes.length > 0 && !input.skipVerifier) {
@@ -222,7 +219,6 @@ export async function runGlmNarutoMission(input) {
     envelopes = envelopes.map((env) => enrichGlmNarutoCandidateRequirementCoverage({ envelope: env, ledger: requirementLedger }));
     passedEnvelopes = envelopes.filter((e) => e.status === 'gate_passed');
     const verifierWarnings = input.skipVerifier && passedEnvelopes.length > 0 ? ['verifier_skipped_by_flag'] : [];
-    // Build conflict graph and merge plan
     const conflictMergeStartedMs = Date.now();
     const nodes = passedEnvelopes.map((env) => ({
         patch_id: env.worker_id,
@@ -267,7 +263,6 @@ export async function runGlmNarutoMission(input) {
         selectedPatchIds: preliminarySelectedPatchIds
     });
     const selectedPatchIds = requirementCoverageSummary.passed ? preliminarySelectedPatchIds : [];
-    // Apply winning merge plan
     let appliedPatches = 0;
     let applyResult = null;
     let applyTransaction = null;
@@ -413,7 +408,6 @@ export async function runGlmNarutoMission(input) {
         parallelismWarnings: parallelismSummary.blockers
     });
     await writeGlmNarutoCriticalPathArtifacts({ root: cwd, missionId, metrics: criticalPath }).catch(() => undefined);
-    // 4.0.9: Write canonical stop-gate artifacts for hook resolution.
     await writeFinalStopGate({
         root: cwd,
         missionId,

package/dist/core/providers/glm/naruto/glm-naruto-trace.js

@@ -52,7 +52,6 @@ export async function writeMissionArtifacts(input) {
         await writeJsonAtomic(path.join(dir, 'verification-summary.json'), sanitizeArtifact(input.verificationSummary));
     if (input.missionResult)
         await writeJsonAtomic(path.join(dir, 'mission-result.json'), sanitizeArtifact(input.missionResult));
-    // 4.0.9: Write per-worker patch envelope / request-summary / stream-trace / gate-result artifacts.
     if (input.envelopes && input.envelopes.length > 0) {
         const workersDir = path.join(dir, 'workers');
         await ensureDir(workersDir);

package/dist/core/providers/glm/naruto/glm-naruto-worker-pool.js

@@ -78,7 +78,6 @@ export async function runPatchWorkerPool(input) {
             failedShardIds.push(result.value.trace.shard_id);
         }
         else {
-            // rejected promise
             failedShardIds.push('unknown');
         }
     }

package/dist/core/providers/glm/naruto/glm-naruto-worktree.js

@@ -12,7 +12,6 @@ export async function removeWorktree(repoRoot, worktree) {
         await runGit(repoRoot, ['branch', '-D', worktree.branch]);
     }
     catch {
-        // best-effort cleanup
     }
 }
 export async function applyPatchToWorktree(worktreePath, patch) {

package/dist/core/providers/openrouter/openrouter-secret-store.js

@@ -115,7 +115,6 @@ export async function promptForOpenRouterKeyHidden() {
     const { stdin, stdout } = await import('node:process');
     const rl = readline.createInterface({ input: stdin, output: stdout, terminal: true });
     try {
-        // Use muted input for hidden key entry
         let key = '';
         const escaped = stdout.isTTY
             ? await new Promise((resolve) => {

package/dist/core/providers/openrouter/openrouter-stream.js

@@ -35,12 +35,10 @@ export async function sendOpenRouterChatCompletionStream(input) {
             const text = await response.text();
             return { ok: false, error: normalizeOpenRouterError(response.status, text) };
         }
-        // Real streaming via ReadableStream reader
         if (response.body && typeof response.body.getReader === 'function') {
             const value = await readRealStream(response.body, started, input.idleTimeoutMs);
             return { ok: true, value: { ...value, request_cache_hit: encoded.cacheHit, request_body_sha256: encoded.entry.bodySha256 } };
         }
-        // Fallback: non-streaming response
         const text = await response.text();
         const value = parseOpenRouterStreamText(text, started, false);
         return { ok: true, value: { ...value, request_cache_hit: encoded.cacheHit, request_body_sha256: encoded.entry.bodySha256 } };

package/dist/core/questions.js

@@ -220,7 +220,7 @@ export function inferAnswersForPrompt(prompt, explicitAnswers = {}) {
         .replace(/\s+/g, ' ')
         .trim();
     const version = String(text || '').match(/\bv?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)\b/)?.[1] || null;
-    const versionWork = /\b(?:versioning\s+bump|version\s+bump|bump\s+(?:the\s+)?version|publish:dry|npm\s+pack)\b/.test(lower)
+    const versionWork = /\b(?:versioning\s+bump|version\s+bump|bump\s+(?:the\s+)?version|npm\s+publish\s+--dry-run|npm\s+pack)\b/.test(lower)
         || /(?:버전|version)[^\n]{0,48}(?:올려|올리|상향|증가|bump|upgrade|publish|배포|출시)/.test(lower)
         || /(?:올려|올리|상향|증가|bump|upgrade|publish|배포|출시)[^\n]{0,48}(?:버전|version)/.test(lower)
         || /(?:릴리스|release)[^\n]{0,48}(?:준비|prepare|cut|ship|publish)/.test(lower)
@@ -269,7 +269,7 @@ export function inferAnswersForPrompt(prompt, explicitAnswers = {}) {
         install: 'SKS 최초 설치와 bootstrap을 한 번에 준비 상태까지 연결한다'
     };
     const criteria = {
-        version: [version ? `version refs are ${version}` : 'version refs advance consistently', 'publish:dry gate passes', 'npm publish is not run'],
+        version: [version ? `version refs are ${version}` : 'version refs advance consistently', 'npm publish --dry-run gate passes', 'npm publish is not run'],
         chat_capture: ['From-Chat-IMG activates chat-image intake only here', 'all visible chat requirements are listed before implementation', `${FROM_CHAT_IMG_COVERAGE_ARTIFACT} maps every customer request, screenshot region, and attachment to work-order item(s)`, `${FROM_CHAT_IMG_CHECKLIST_ARTIFACT} is updated as each request, image match, work item, scoped QA-LOOP, and verification step is completed`, `${FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT} records temporary TriWiki-backed session context with retention metadata`, `${FROM_CHAT_IMG_QA_LOOP_ARTIFACT} proves QA-LOOP ran over the exact customer-request work-order range after implementation`, 'unresolved_items is empty before Naruto completion', 'scoped_qa_loop_completed is true with zero unresolved QA findings', 'Web/browser visual inspection uses Codex Chrome Extension readiness first; native Mac/non-web visual inspection uses Codex Computer Use when available', CODEX_WEB_VERIFICATION_POLICY, CODEX_COMPUTER_USE_ONLY_POLICY, 'client requests follow normal SKS gates and verification'],
         triwiki_audit: ['TriWiki ingestion, voxel attention, and contract consumption paths are inspected against current code', 'repeat-mistake prevention gaps are fixed in the relevant code path or blocked with evidence', 'regression coverage proves fresh/high-weight mistake memory can influence future missions', 'final status separates supported behavior from anything still unverified'],
         priority: ['strong feedback raises required_weight', 'request topics are counted in wiki packs', 'future inference uses priority signals'],
@@ -308,7 +308,7 @@ export function inferAnswersForPrompt(prompt, explicitAnswers = {}) {
         addInferred(inferred, notes, 'DEPENDENCY_CHANGE_ALLOWED', 'no', 'no-new-deps');
     if (!hasAnswer(explicitAnswers.TEST_SCOPE)) {
         const releaseLike = versionWork || installWork;
-        addInferred(inferred, notes, 'TEST_SCOPE', releaseLike ? ['packcheck', 'selftest', 'sizecheck', 'publish:dry'] : ['focused relevant tests or documented justification'], 'tests');
+        addInferred(inferred, notes, 'TEST_SCOPE', releaseLike ? ['packcheck', 'selftest', 'sizecheck', 'npm publish --dry-run'] : ['focused relevant tests or documented justification'], 'tests');
     }
     if (!hasAnswer(explicitAnswers.MID_RUN_UNKNOWN_POLICY)) {
         addInferred(inferred, notes, 'MID_RUN_UNKNOWN_POLICY', ['preserve_existing_behavior', 'smallest_reversible_change', 'defer_optional_scope', 'block_only_if_no_safe_path'], 'ladder');

package/dist/core/release/gate-manifest.js

@@ -9,7 +9,6 @@ export const FORBIDDEN_RECURSIVE_GATES = new Set([
     'publish:npm',
     'prepublishOnly'
 ]);
-// Gates that always run on a release check regardless of which files changed.
 export const ALWAYS_ON_GATES = new Set([
     'release:metadata',
     'release:readiness',
@@ -40,7 +39,6 @@ export const ALWAYS_ON_GATES = new Set([
     'release:provenance',
     'changelog:check'
 ]);
-// Gates that must never be skipped when planning for publish.
 export const REQUIRED_FOR_PUBLISH = new Set([
     'release:metadata',
     'architecture:guard',
@@ -86,7 +84,6 @@ function costFor(id) {
     }
     return 'hermetic';
 }
-/** Heuristic mapping from a gate id to the source globs that affect it. */
 export function affectedGlobsFor(id) {
     const prefix = id.split(':')[0];
     switch (prefix) {
@@ -163,7 +160,6 @@ export function buildGateManifest(gateIds) {
     gates.sort((a, b) => a.id.localeCompare(b.id));
     return { schema: GATE_MANIFEST_SCHEMA, gates };
 }
-/** Parity between the manifest and the actual release-gate set. */
 export function validateManifestParity(manifestGateIds, releaseGateIds) {
     const manifest = new Set(manifestGateIds);
     const release = new Set(releaseGateIds);
@@ -186,7 +182,6 @@ export function gateMatchesChange(entry, changedFiles) {
     const regexes = entry.affected_by.map(globToRegExp);
     return changedFiles.some((file) => regexes.some((re) => re.test(file)));
 }
-/** Select which gates to run given changed files. Always-on gates are always selected. */
 export function selectGates(gates, changedFiles, opts = {}) {
     const selected = [];
     const skipped = [];

package/dist/core/release/package-size-budget.js

@@ -1,2 +1,2 @@
-export const DEFAULT_MAX_PACK_BYTES = 2464 * 1024;
+export const DEFAULT_MAX_PACK_BYTES = 2488 * 1024;
 export const DEFAULT_MAX_UNPACKED_BYTES = 11_141_120;

package/dist/core/release/release-gate-batch-runner.js

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 import path from 'node:path';
+import { performance } from 'node:perf_hooks';
 import { cleanupReleaseGateHermeticEnv, createReleaseGateHermeticEnv } from './release-gate-hermetic-env.js';
 import { writeReleaseGateJson } from './release-gate-report.js';
 import { guardedProcessKill, guardContextForRoute } from '../safety/mutation-guard.js';
@@ -53,7 +54,7 @@ export async function runReleaseGateBatch(root, gates, input = {}) {
     };
 }
 function runOne(root, runId, reportRoot, gate) {
-    const started = Date.now();
+    const started = performance.now();
     const hermetic = createReleaseGateHermeticEnv({ root, runId, gate, reportRoot });
     return new Promise((resolve) => {
         const child = spawn(gate.command, { cwd: root, shell: true, env: hermetic.env, stdio: ['ignore', 'ignore', 'ignore'], detached: process.platform !== 'win32' });
@@ -70,7 +71,15 @@ function runOne(root, runId, reportRoot, gate) {
                 if (timeoutCleanup)
                     await timeoutCleanup;
                 const exitCode = timedOut ? 124 : code;
-                const result = { id: gate.id, ok: exitCode === 0, exit_code: exitCode, signal, timed_out: timedOut, duration_ms: Date.now() - started, report_dir: hermetic.report_dir };
+                const result = {
+                    id: gate.id,
+                    ok: exitCode === 0,
+                    exit_code: exitCode,
+                    signal,
+                    timed_out: timedOut,
+                    duration_ms: Math.max(1, Math.round(performance.now() - started)),
+                    report_dir: hermetic.report_dir
+                };
                 cleanupReleaseGateHermeticEnv(hermetic);
                 resolve(result);
             })();

package/dist/core/release/release-gate-cache-v2.js

@@ -13,8 +13,6 @@ export function releaseGateCacheFile(root) {
 export function releaseGateProofBankFile(root) {
     return path.join(root, '.sneakoscope', 'proof-bank', 'gates', 'cache-v2.json');
 }
-// Keep behavior gates reusable across pure version bumps; proof/version gates remain uncached.
-// Set SKS_RELEASE_CACHE_VERSION_SENSITIVE=1 to restore version-sensitive hashing.
 const VERSION_NEUTRAL_CACHE_FILES = new Set([
     'package.json',
     'package-lock.json',
@@ -39,8 +37,6 @@ export function releaseGateCacheKey(root, gate) {
     hash.update(JSON.stringify(gate.preset || []));
     hashFileIfPresent(hash, path.join(root, 'release-gates.v2.json'));
     if (versionSensitive || !gate.cache.inputs.length) {
-        // No declared inputs (or explicitly version-sensitive mode): fall back to
-        // the conservative global digests so such a gate cannot cache-hit forever.
         hashFileIfPresent(hash, path.join(root, 'package.json'));
         hashFileIfPresent(hash, path.join(root, 'dist', 'build-manifest.json'));
     }

package/dist/core/release/release-gate-hermetic-env.js

@@ -26,14 +26,9 @@ export function createReleaseGateHermeticEnv(input) {
         XDG_CACHE_HOME: cacheHome,
         SKS_DISABLE_REAL_MODEL_CALLS: input.gate.preset.includes('real-check') ? process.env.SKS_DISABLE_REAL_MODEL_CALLS || '0' : '1',
         SKS_DISABLE_GLOBAL_CONFIG_MUTATION: '1',
-        // Gates must never spawn a real GUI menu bar status item into the user's
-        // live session. Belt to the temp-path launch guard in installSksMenuBar.
         SKS_SKIP_SKS_MENUBAR_LAUNCH: '1'
     };
     if (input.gate.id === 'migration:current-surface-e2e') {
-        // This gate exercises the migration path itself. An ambient disable flag
-        // from the parent Codex/SKS process must not turn the fixture into a false
-        // successful skip.
         delete gateEnv.SKS_UPDATE_MIGRATION_GATE_DISABLED;
     }
     else {

package/dist/core/release-parallel-full-coverage.js

@@ -1,8 +1,6 @@
 import { nowIso } from './fsx.js';
 import { RELEASE_GATE_CONTRACT_IDS, releaseGateContractSnapshot } from './release/release-gate-contract.js';
 export const RELEASE_PARALLEL_FULL_COVERAGE_SCHEMA = 'sks.release-parallel-full-coverage.v2';
-// Compatibility export: the independent, versioned contract is now the full
-// release preset, not a self-authorizing critical subset.
 export const RELEASE_DAG_CRITICAL_GATES = RELEASE_GATE_CONTRACT_IDS;
 export function evaluateReleaseParallelFullCoverage(currentGateIds) {
     const raw = currentGateIds.map(String).filter(Boolean);