sneakoscope 6.1.2 → 6.2.0

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

@@ -2,7 +2,10 @@ import path from 'node:path';
 import { ui as cliUi } from '../../cli/cli-theme.js';
 import { projectRoot } from '../fsx.js';
 import { inspectSksMenuBarStatus, installSksMenuBar, restartSksMenuBar, uninstallSksMenuBar } from '../codex-app/sks-menubar.js';
+import { addCodexMcpServer, listCodexMcpServers, removeCodexMcpServer, setCodexMcpServerEnabled } from '../codex-app/mcp-manager.js';
 export async function menubarCommand(subcommand = 'status', args = []) {
+    if (String(subcommand || '').toLowerCase() === 'mcp')
+        return menubarMcpCommand(args);
     const action = normalizeAction(subcommand);
     const root = path.resolve(String(readOption(args, '--root', '') || await projectRoot()));
     const home = stringOption(args, '--home');
@@ -79,6 +82,38 @@ export async function menubarCommand(subcommand = 'status', args = []) {
     printUsage();
     process.exitCode = 2;
 }
+async function menubarMcpCommand(args = []) {
+    const action = String(args[0] || 'list').toLowerCase();
+    const rest = args.slice(1);
+    const home = stringOption(rest, '--home');
+    const options = home ? { home } : {};
+    let result;
+    if (['list', 'status', 'refresh'].includes(action)) {
+        result = await listCodexMcpServers(options);
+    }
+    else if (action === 'add') {
+        const payload = flag(rest, '--stdin-json') ? await readStdinJson() : null;
+        result = await addCodexMcpServer(payload, options);
+    }
+    else if (action === 'remove') {
+        result = await removeCodexMcpServer(stringOption(rest, '--name') || positional(rest), options);
+    }
+    else if (action === 'enable' || action === 'disable') {
+        result = await setCodexMcpServerEnabled(stringOption(rest, '--name') || positional(rest), action === 'enable', options);
+    }
+    else {
+        printMcpUsage();
+        process.exitCode = 2;
+        return;
+    }
+    if (flag(rest, '--json') || flag(args, '--json'))
+        printJson(result);
+    else
+        printMcpResult(result);
+    if (result?.ok !== true)
+        process.exitCode = 1;
+    return result;
+}
 function normalizeAction(value) {
     const text = String(value || 'status').toLowerCase();
     if (['status', 'inspect', 'doctor'].includes(text))
@@ -124,8 +159,67 @@ Usage:
   sks menubar install [--no-launch] [--json]
   sks menubar restart [--json]
   sks menubar uninstall [--json]
+  sks menubar mcp list [--json]
+  sks menubar mcp add --stdin-json [--json]
+  sks menubar mcp enable|disable|remove <name> [--json]
+`);
+}
+function printMcpUsage() {
+    console.log(`SKS Menu Bar MCP Manager
+
+Usage:
+  sks menubar mcp list [--json]
+  sks menubar mcp add --stdin-json [--json]
+  sks menubar mcp enable <name> [--json]
+  sks menubar mcp disable <name> [--json]
+  sks menubar mcp remove <name> [--json]
 `);
 }
+function printMcpResult(result) {
+    if (result?.schema === 'sks.menubar-mcp-list.v1') {
+        console.log(`Codex MCP servers (${result.server_count || 0})`);
+        for (const server of result.servers || [])
+            console.log(`- ${server.enabled ? 'on ' : 'off'} ${server.name}: ${server.summary}`);
+        return;
+    }
+    console.log(`Codex MCP ${result?.action || 'mutation'}: ${result?.ok ? 'ok' : 'failed'}`);
+    for (const blocker of result?.blockers || [])
+        console.log(`blocker: ${blocker}`);
+}
+async function readStdinJson() {
+    if (process.stdin.isTTY)
+        return null;
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of process.stdin) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += buffer.length;
+        if (bytes > 1024 * 1024)
+            throw new Error('menubar_mcp_stdin_payload_too_large');
+        chunks.push(buffer);
+    }
+    const text = Buffer.concat(chunks).toString('utf8').trim();
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function positional(args) {
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = String(args[index] || '');
+        if (arg === '--home' || arg === '--name') {
+            index += 1;
+            continue;
+        }
+        if (!arg.startsWith('--'))
+            return arg;
+    }
+    return null;
+}
 function printJson(value) {
     console.log(JSON.stringify(value, null, 2));
 }

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

@@ -196,7 +196,8 @@ async function narutoRunTransaction(parsed, root, appSession, sessionKey) {
         parentSummary: effectiveParentSummary,
         blockers,
         appSession,
-        sessionKey
+        sessionKey,
+        suggestedAgents: Array.isArray(completedPlan?.suggested_agents) ? completedPlan.suggested_agents : []
     });
     await writeJsonAtomic(path.join(dir, NARUTO_SUMMARY_FILENAME), summary);
     await writeNarutoGate(dir, { missionId: id, workflowRunId, evidence, passed, blockers });
@@ -364,6 +365,7 @@ async function narutoProof(parsed) {
 function narutoHelp(parsed) {
     const result = buildNarutoHelpResult();
     return emit(parsed, result, () => {
+        cliUi.ok('official subagent workflow help available');
         console.log('$Naruto — Codex official subagent workflow');
         for (const line of result.usage)
             console.log(`  ${line}`);

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

@@ -22,6 +22,7 @@ import { recordImageWrongnessFromValidation } from '../triwiki-wrongness/image-w
 import { publishSharedMemory, rebuildSharedIndexes, sharedMemorySummary, validateSharedMemory } from '../git-hygiene/shared-memory-publish.js';
 import { scanCodebaseIndex } from '../triwiki/code-index-scanner.js';
 import { buildCodePack, validateCodePack, writeCodePackAtomic } from '../triwiki/code-pack.js';
+import { inspectCodePackHeadFreshness } from '../triwiki/code-pack-head-freshness.js';
 import { sealTriWikiContextPack, validateTriWikiContextPackProvenance } from '../triwiki-provenance.js';
 import { flag, positionalArgs, readFlagValue, readOption, resolveMissionId } from './command-utils.js';
 export async function wikiCommand(sub, args = []) {
@@ -251,8 +252,10 @@ async function wikiRefreshCode(args = []) {
         console.log(`- ${issue}`);
 }
 /** Cheap freshness check: compares the code pack's recorded git HEAD sha (at
- * generation time) against the current HEAD. Any uncertainty (no pack, no git,
- * spawn failure) resolves to 'stale' rather than 'fresh', never overclaiming. */
+ * generation time) against the current HEAD. A commit containing only the two
+ * tracked code-pack metadata files is equivalent to the generating HEAD, which
+ * avoids an impossible self-referential commit hash. Any other uncertainty
+ * resolves to 'stale' rather than 'fresh', never overclaiming. */
 /** Active-wrongness counts per TriWiki module id (from wrongness records' module_ids),
  * so attention can hydrate frequently-wrong modules' code entries first. */
 async function buildWrongnessByModule(root) {
@@ -276,9 +279,12 @@ async function codePackFreshness(root) {
     const packSha = pack?.git_head_sha || null;
     if (!packSha)
         return { status: 'missing', git_head_sha: null, pack_sha: null };
-    const head = await runProcess('git', ['rev-parse', 'HEAD'], { cwd: root, timeoutMs: 5000 }).catch(() => null);
-    const currentSha = head && head.code === 0 ? head.stdout.trim() : null;
-    return { status: currentSha && currentSha === packSha ? 'fresh' : 'stale', git_head_sha: currentSha, pack_sha: packSha };
+    const freshness = await inspectCodePackHeadFreshness(root, packSha, { timeoutMs: 5_000 });
+    return {
+        status: freshness.fresh ? 'fresh' : 'stale',
+        git_head_sha: freshness.current_sha,
+        pack_sha: freshness.pack_sha
+    };
 }
 function wikiRefreshFailureAnalysis(validationResult, gate = {}) {
     if (validationResult?.ok) {

package/dist/core/fsx.js

@@ -11,6 +11,7 @@ import { PACKAGE_VERSION } from './version.js';
 export { PACKAGE_VERSION };
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
+export const SKS_TEMP_LEASE_FILE = '.sks-temp-lease.json';
 const gunzipAsync = promisify(gunzipCallback);
 export function nowIso() {
     return new Date().toISOString();

package/dist/core/hooks-runtime/code-pack-freshness-preflight.js

@@ -1,17 +1,21 @@
 import path from 'node:path';
-import { exists, readJson, runProcess } from '../fsx.js';
+import { exists, readJson } from '../fsx.js';
+import { inspectCodePackHeadFreshness } from '../triwiki/code-pack-head-freshness.js';
 /** Bounded, non-blocking code-pack staleness nudge for the user-prompt-submit hook.
  *
  * Returns a one-line context note when a published code pack
  * (.sneakoscope/wiki/code-pack.json) exists but was generated against a different
  * git HEAD than the current one — i.e. the codebase moved and the LLM-facing code
- * summaries are now out of date. Returns null (silent) when there is no pack at all
+ * summaries are now out of date. A follow-up commit that changes only the two
+ * tracked code-pack metadata files remains fresh; otherwise committing the generated
+ * pack would make itself stale forever. Returns null (silent) when there is no pack at all
  * (repos that never opted into `sks wiki refresh --code` must not be nagged) or when
  * the check can't complete cheaply. It NEVER regenerates the pack and NEVER blocks:
- * the whole check is one JSON read plus one `git rev-parse HEAD`, wrapped in a hard
- * timeout so it cannot blow the hook latency budget. Any failure resolves to null. */
+ * the common path is one JSON read plus one bounded `git log` history check,
+ * wrapped in a hard timeout so it cannot blow the hook latency budget. Any
+ * failure resolves to null. */
 export async function codePackFreshnessNote(root, opts = {}) {
-    const budgetMs = Math.max(1, opts.budgetMs ?? 250);
+    const budgetMs = Math.max(1, opts.budgetMs ?? 750);
     const gitTimeoutMs = Math.max(1, budgetMs - 50);
     return raceWithTimeout(computeNote(root, gitTimeoutMs), budgetMs).catch(() => null);
 }
@@ -25,9 +29,11 @@ async function computeNote(root, gitTimeoutMs) {
     // rather than nag with a comparison we can't actually make.
     if (!packSha)
         return null;
-    const head = await runProcess('git', ['rev-parse', 'HEAD'], { cwd: root, timeoutMs: gitTimeoutMs }).catch(() => null);
-    const currentSha = head && head.code === 0 ? String(head.stdout || '').trim() : null;
-    if (!currentSha || currentSha === packSha)
+    const freshness = await inspectCodePackHeadFreshness(root, packSha, {
+        timeoutMs: gitTimeoutMs,
+        advisoryCache: true,
+    });
+    if (!freshness.conclusive || !freshness.current_sha || freshness.fresh)
         return null;
     return 'SKS note: the codebase code pack is stale (HEAD moved since it was built). Run `sks wiki refresh --code` to refresh source-cited code context.';
 }

package/dist/core/hooks-runtime/naruto-decision-gate.js

@@ -0,0 +1,184 @@
+import path from 'node:path';
+import { appendJsonlBounded, nowIso, sha256 } from '../fsx.js';
+import { codexHookEventName } from '../codex-compat/codex-hook-events.js';
+import { narutoDecisionForRoute, routeByDollarCommand, routeById, routePrompt, stripVisibleDecisionAnswerBlocks } from '../routes.js';
+import { classifyTaskProfile, isTaskProfile } from '../runtime/task-profile.js';
+export const HOOK_NARUTO_DECISION_LOG = 'hook-naruto-decision-gate.jsonl';
+const HOOK_NARUTO_DECISION_LOG_MAX_BYTES = 256 * 1024;
+export function hookNarutoDecisionLogPath(root) {
+    return path.join(root, '.sneakoscope', 'state', HOOK_NARUTO_DECISION_LOG);
+}
+export async function evaluateHookNarutoDecisionGate(input) {
+    const decision = decideHookNaruto(input);
+    const prompt = decision.event === 'UserPromptSubmit'
+        ? stripVisibleDecisionAnswerBlocks(extractPrompt(input.payload))
+        : '';
+    const row = {
+        ts: nowIso(),
+        schema: decision.schema,
+        event: decision.event,
+        mode: decision.mode,
+        required: decision.required,
+        action: decision.action,
+        route_id: decision.route_id,
+        task_profile: decision.task_profile,
+        reason: decision.reason,
+        source: decision.source,
+        trivial: decision.trivial,
+        default_parallel: decision.default_parallel,
+        session_hash: shortHash(input.sessionKey),
+        turn_hash: shortHash(input.payload?.turn_id || input.payload?.turnId || ''),
+        prompt_hash: prompt ? shortHash(prompt) : null
+    };
+    let recorded = true;
+    try {
+        await appendJsonlBounded(hookNarutoDecisionLogPath(input.root), row, HOOK_NARUTO_DECISION_LOG_MAX_BYTES);
+    }
+    catch {
+        recorded = false;
+    }
+    return { ...decision, recorded };
+}
+export function decideHookNaruto(input) {
+    const event = codexHookEventName(input.name) || String(input.name || 'unknown');
+    const state = input.state || {};
+    if (event !== 'UserPromptSubmit') {
+        return decisionFromState(event, state);
+    }
+    const prompt = stripVisibleDecisionAnswerBlocks(extractPrompt(input.payload));
+    const profile = classifyTaskProfile(prompt);
+    if (input.parentLaunchMissionId) {
+        return decision({
+            event,
+            mode: 'generic_naruto',
+            required: true,
+            action: 'prepare_naruto',
+            routeId: 'Naruto',
+            profile,
+            reason: 'attached_parent_naruto_launch',
+            source: 'parent_launch',
+            trivial: false
+        });
+    }
+    if (input.noQuestion || shouldInheritActiveRoute(prompt, state)) {
+        return decisionFromState(event, state);
+    }
+    const route = routePrompt(prompt);
+    const routeDecision = narutoDecisionForRoute(route, prompt, profile);
+    return decision({
+        event,
+        mode: routeDecision.mode,
+        required: routeDecision.required,
+        action: routeDecision.mode === 'generic_naruto'
+            ? 'prepare_naruto'
+            : routeDecision.mode === 'route_owned'
+                ? 'route_owned'
+                : 'bypass',
+        routeId: routeDecision.route_id,
+        profile: routeDecision.task_profile,
+        reason: routeDecision.reason,
+        source: 'user_prompt',
+        trivial: routeDecision.trivial
+    });
+}
+export function looksLikeActiveContinuationPrompt(prompt = '') {
+    const text = stripVisibleDecisionAnswerBlocks(String(prompt || ''))
+        .trim()
+        .replace(/[.!?。！？…,:;]+$/u, '')
+        .trim();
+    if (!text)
+        return false;
+    return /^(?:(?:please\s+)?(?:keep\s+going|continue|resume|go\s+on|proceed|carry\s+on)(?:\s+please)?|계속(?:\s*진행)?(?:\s*해\s*줘|\s*해주세요|\s*해)?|이어\s*서(?:\s*해\s*줘|\s*해주세요|\s*진행해)?|이어서(?:\s*해\s*줘|\s*해주세요|\s*진행해)?|진행(?:\s*해\s*줘|\s*해주세요|\s*해)?|마저\s*해(?:\s*줘|\s*주세요)?|다음|next)$/i.test(text);
+}
+function decisionFromState(event, state) {
+    const route = routeFromState(state);
+    const routePolicy = narutoDecisionForRoute(route, '', 'passthrough');
+    if (state?.route_closed !== true && routePolicy.mode === 'route_owned') {
+        return decision({
+            event,
+            mode: 'route_owned',
+            required: false,
+            action: 'route_owned',
+            routeId: state?.route_command || state?.route || state?.mode || routePolicy.route_id,
+            profile: isTaskProfile(state?.task_profile) ? state.task_profile : routePolicy.task_profile,
+            reason: routePolicy.reason,
+            source: state?.mission_id ? 'active_route' : 'no_task_context',
+            trivial: false
+        });
+    }
+    const required = state?.route_closed === true
+        ? false
+        : state?.subagents_required === true
+            || (/^(?:NARUTO|TEAM)$/i.test(String(state?.mode || state?.route || '')) && state?.subagents_required !== false);
+    const profile = isTaskProfile(state?.task_profile)
+        ? state.task_profile
+        : required
+            ? 'bounded-work'
+            : 'passthrough';
+    return decision({
+        event,
+        mode: required ? 'generic_naruto' : 'none',
+        required,
+        action: required ? 'observe_required' : 'observe_bypass',
+        routeId: state?.route_command || state?.route || state?.mode || null,
+        profile,
+        reason: state?.route_closed === true
+            ? 'active_route_closed'
+            : required
+                ? 'active_route_requires_official_subagents'
+                : 'no_active_naruto_requirement',
+        source: state?.mission_id ? 'active_route' : 'no_task_context',
+        trivial: !required
+    });
+}
+function routeFromState(state) {
+    for (const candidate of [state?.route, state?.mode, state?.route_command]) {
+        const route = routeById(candidate) || routeByDollarCommand(candidate);
+        if (route)
+            return route;
+    }
+    return null;
+}
+function shouldInheritActiveRoute(prompt, state) {
+    if (!state?.mission_id || state?.route_closed === true)
+        return false;
+    if (looksLikeActiveContinuationPrompt(prompt))
+        return true;
+    const phase = String(state?.phase || '');
+    const clarificationAwaiting = phase.includes('CLARIFICATION_AWAITING_ANSWERS')
+        || String(state?.stop_gate || '') === 'clarification-gate';
+    return clarificationAwaiting
+        && state?.ambiguity_gate_required === true
+        && state?.ambiguity_gate_passed !== true;
+}
+function decision(input) {
+    return {
+        schema: 'sks.hook-naruto-decision.v1',
+        event: input.event,
+        mode: input.mode,
+        required: input.required,
+        action: input.action,
+        route_id: input.routeId,
+        task_profile: input.profile,
+        reason: input.reason,
+        source: input.source,
+        trivial: input.trivial,
+        default_parallel: input.required,
+        recorded: false
+    };
+}
+function extractPrompt(payload = {}) {
+    return String(payload.prompt
+        || payload.user_prompt
+        || payload.userPrompt
+        || payload.message
+        || payload.input?.prompt
+        || payload.input?.message
+        || payload.raw
+        || '');
+}
+function shortHash(value) {
+    const text = String(value || '').trim();
+    return text ? sha256(text).slice(0, 16) : null;
+}
+//# sourceMappingURL=naruto-decision-gate.js.map

package/dist/core/hooks-runtime/stop-repeat-guard.js

@@ -0,0 +1,89 @@
+import path from 'node:path';
+import { nowIso, readJson, sha256, writeJsonAtomic } from '../fsx.js';
+import { appendMissionStatus } from '../recallpulse.js';
+import { conversationId } from './payload-signals.js';
+const STOP_REPEAT_GUARD_ARTIFACT = 'stop-hook-repeat-guard.json';
+const STOP_REPEAT_GUARD_WINDOW_MS = 10 * 60 * 1000;
+const STOP_REPEAT_GUARD_MAX_ENTRIES = 25;
+const DEFAULT_STOP_REPEAT_GUARD_LIMIT = 2;
+export async function finalizationRepeatDecision(root, state = {}, payload = {}, reason = '', kind = 'finalization') {
+    const now = nowIso();
+    const guardPath = path.join(root, '.sneakoscope', 'state', STOP_REPEAT_GUARD_ARTIFACT);
+    const previous = await readJson(guardPath, {}).catch(() => ({}));
+    const limit = stopRepeatGuardLimit();
+    const entries = pruneStopRepeatEntries(previous.entries || {}, now);
+    const key = stopRepeatKey(state, payload, reason, kind);
+    const prior = entries[key] || {};
+    const repeatCount = stopRepeatInWindow(prior, now)
+        ? Number(prior.repeat_count || 0) + 1
+        : 1;
+    const record = {
+        schema_version: 1,
+        updated_at: now,
+        window_ms: STOP_REPEAT_GUARD_WINDOW_MS,
+        limit,
+        entries: {
+            ...entries,
+            [key]: {
+                kind,
+                route: state.route_command || state.route || state.mode || null,
+                mission_id: state.mission_id || null,
+                conversation_id: conversationId(payload),
+                first_seen: stopRepeatInWindow(prior, now) ? (prior.first_seen || now) : now,
+                last_seen: now,
+                repeat_count: repeatCount,
+                tripped: repeatCount >= limit,
+                reason
+            }
+        }
+    };
+    await writeJsonAtomic(guardPath, record).catch(() => null);
+    if (state.mission_id) {
+        await appendMissionStatus(root, state.mission_id, {
+            category: repeatCount >= limit ? 'warning' : 'blocker',
+            audience: ['user', 'route', 'final-summary'],
+            stage_id: 'before_final',
+            message: repeatCount >= limit
+                ? `Repeated ${kind} stop prompt was suppressed; route completion is still unclaimed until evidence passes.`
+                : reason,
+            dedupe_key: key,
+            evidence: [STOP_REPEAT_GUARD_ARTIFACT]
+        }).catch(() => null);
+    }
+    if (repeatCount < limit)
+        return null;
+    return {
+        continue: true,
+        systemMessage: `SKS stop hook repeat guard suppressed repeated ${kind} prompt after ${repeatCount} identical block(s). No completion success is claimed by the hook.`
+    };
+}
+function stopRepeatKey(state = {}, payload = {}, reason = '', kind = '') {
+    return sha256(JSON.stringify({
+        kind,
+        reason,
+        conversation_id: conversationId(payload),
+        mission_id: state.mission_id || null,
+        route: state.route_command || state.route || state.mode || null,
+        gate: state.stop_gate || null
+    })).slice(0, 24);
+}
+function stopRepeatGuardLimit() {
+    const raw = Number.parseInt(process.env.SKS_STOP_REPEAT_GUARD_LIMIT || '', 10);
+    if (!Number.isFinite(raw))
+        return DEFAULT_STOP_REPEAT_GUARD_LIMIT;
+    return Math.max(1, Math.min(20, raw));
+}
+function stopRepeatInWindow(entry = {}, now = nowIso()) {
+    const last = Date.parse(entry.last_seen || '');
+    const current = Date.parse(now);
+    if (!Number.isFinite(last) || !Number.isFinite(current))
+        return false;
+    return current - last <= STOP_REPEAT_GUARD_WINDOW_MS;
+}
+function pruneStopRepeatEntries(entries = {}, now = nowIso()) {
+    return Object.fromEntries(Object.entries(entries)
+        .filter(([, entry]) => stopRepeatInWindow(entry, now))
+        .sort((a, b) => Date.parse(b[1]?.last_seen || '') - Date.parse(a[1]?.last_seen || ''))
+        .slice(0, STOP_REPEAT_GUARD_MAX_ENTRIES));
+}
+//# sourceMappingURL=stop-repeat-guard.js.map