sneakoscope 6.1.0 → 6.2.0

package/dist/core/hooks-runtime/payload-signals.js

@@ -0,0 +1,270 @@
+import { stripVisibleDecisionAnswerBlocks } from '../routes.js';
+export function extractLastMessage(payload = {}) {
+    return payload.last_assistant_message || payload.assistant_message || payload.message || payload.response || payload.raw || '';
+}
+export function extractUserPrompt(payload = {}) {
+    return payload.prompt
+        || payload.user_prompt
+        || payload.userPrompt
+        || payload.message
+        || payload.input?.prompt
+        || payload.input?.message
+        || payload.raw
+        || '';
+}
+export function conversationId(payload = {}) {
+    return String(payload.conversation_id || payload.thread_id || payload.session_id || payload.chat_id || payload.cwd || 'default');
+}
+export function explicitConversationId(payload = {}) {
+    return payload.conversation_id || payload.thread_id || payload.session_id || payload.chat_id || null;
+}
+export function hookTurnId(payload = {}) {
+    return String(payload.turn_id || payload.turnId || payload.metadata?.turn_id || payload.metadata?.turnId || '');
+}
+export function extractCommand(payload = {}) {
+    return payload.command || payload.tool_input?.command || payload.toolInput?.command || payload.input?.command || payload.tool?.input?.command || '';
+}
+export function codexGitActionMetadataText(payload = {}) {
+    const seen = new Set();
+    const out = [];
+    const interesting = new Set([
+        'action',
+        'intent',
+        'operation',
+        'permission',
+        'description',
+        'kind',
+        'type',
+        'feature',
+        'tool_name',
+        'toolName',
+        'name',
+        'label',
+        'title',
+        'source',
+        'event',
+        'hook',
+        'hook_name',
+        'hookName',
+        'hook_event_name',
+        'hookEventName',
+        'id',
+        'command'
+    ]);
+    const noisy = new Set([
+        'prompt',
+        'user_prompt',
+        'userPrompt',
+        'message',
+        'assistant_message',
+        'last_assistant_message',
+        'response',
+        'raw',
+        'stdout',
+        'stderr'
+    ]);
+    function walk(value, depth = 0, parentKey = '') {
+        if (!value || typeof value !== 'object' || depth > 5 || seen.has(value))
+            return;
+        seen.add(value);
+        for (const [key, candidate] of Object.entries(value)) {
+            if (noisy.has(key))
+                continue;
+            if (typeof candidate === 'string') {
+                if (interesting.has(key) || /\b(?:codex[_\s-]*app|git[_\s-]*actions?|codex_git_|gitCommit|gitPush|pull\s+request)\b/i.test(candidate)) {
+                    out.push(`${key}:${candidate}`);
+                }
+                continue;
+            }
+            if (candidate && typeof candidate === 'object') {
+                const allowedContainer = interesting.has(key)
+                    || /^(?:input|metadata|context|client|thread|session|request|payload|tool|tool_input|toolInput|permission_request|permissionRequest)$/i.test(key)
+                    || parentKey;
+                if (allowedContainer)
+                    walk(candidate, depth + 1, key);
+            }
+        }
+    }
+    walk(payload);
+    return out.join(' ');
+}
+export function codexGitActionMetadataSignal(text = '') {
+    const s = String(text || '');
+    if (!s)
+        return false;
+    const action = String(s)
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/[_-]+/g, ' ');
+    if (/\bcodex\s*app\b[\s\S]{0,120}\bgit\b[\s\S]{0,120}\b(?:action|actions|commit|push|pr|pull request)\b/i.test(action))
+        return true;
+    if (/\bgit\s*actions?\b[\s\S]{0,120}\b(?:commit|push|pr|pull request|commit\s*(?:and|&)\s*push)\b/i.test(action))
+        return true;
+    if (/\bcodex\s*git\s*(?:commit|push|pr|pull request|commit\s*(?:and|&)\s*push)\b/i.test(action))
+        return true;
+    if (/\b(?:git\s*)?(?:commit|push|commit\s*(?:and|&)\s*push|create\s+(?:a\s+)?pull\s+request|pull\s+request|pr)\b/i.test(action)) {
+        return /\b(?:action|intent|operation|permission|feature|tool\s*name|source|event|hook|name|label|title|type|kind|id)\s*:/i.test(action);
+    }
+    return false;
+}
+export function toolFailed(payload = {}) {
+    const candidates = [
+        payload.exit_code,
+        payload.exitCode,
+        payload.tool_response?.exit_code,
+        payload.toolResponse?.exitCode,
+        payload.result?.exit_code,
+        payload.result?.exitCode
+    ];
+    for (const candidate of candidates) {
+        if (candidate === undefined || candidate === null || candidate === '')
+            continue;
+        const n = Number(candidate);
+        if (Number.isFinite(n))
+            return n !== 0;
+    }
+    if (payload.isError === true || payload.tool_response?.isError === true || payload.toolResponse?.isError === true || payload.result?.isError === true)
+        return true;
+    if (payload.success === false || payload.tool_response?.success === false || payload.toolResponse?.success === false || payload.result?.success === false)
+        return true;
+    if (payload.executed === false)
+        return true;
+    return false;
+}
+export function compactAnswerContext(prompt = '') {
+    return [
+        'SKS answer-only pipeline active (light turn).',
+        'Answer the user directly. Do not create or continue a mission, prepare a route, reconcile project skills, load active route context, read TriWiki/code-pack preflight state, or open a subagent workflow for this turn.',
+        'Use tools only when the answer itself needs current repository facts, official documentation, web evidence, or another source explicitly requested by the user.',
+        `Question: ${String(prompt || '').trim()}`
+    ].join('\n');
+}
+export function looksLikeMadSksConfirmationPrompt(prompt = '') {
+    return /^(yes|y|no|n|confirm|confirmed|approve|approved|proceed|continue|ok|okay|stop|abort|cancel|deny|denied|네|예|응|아니|아니요|허용|승인|진행|계속|중단|취소|거부|삭제\s*허용|테이블\s*삭제\s*허용)(?=$|\s|[.!?。！？,，])/i.test(String(prompt || '').trim());
+}
+export function observedParentModel(payload = {}) {
+    const value = payload.parent_model
+        || payload.parentModel
+        || payload.model
+        || payload.metadata?.parent_model
+        || payload.metadata?.model
+        || payload.session?.model
+        || null;
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+export function observedParentModelMismatch(model, expectedModel) {
+    const value = String(model || '').trim();
+    if (!value)
+        return false;
+    return value.toLowerCase() !== expectedModel && !/gpt[-_. ]?5\.6[-_. ]?sol|\bsol(?:\s+max)?\b/i.test(value);
+}
+export function looksLikeCodexUiSettingsEvent(payload = {}) {
+    const prompt = stripVisibleDecisionAnswerBlocks(extractUserPrompt(payload));
+    const haystack = [
+        payload.action,
+        payload.intent,
+        payload.operation,
+        payload.permission,
+        payload.description,
+        payload.kind,
+        payload.type,
+        payload.feature,
+        payload.source,
+        payload.event,
+        payload.hook,
+        payload.hook_name,
+        payload.metadata?.action,
+        payload.metadata?.intent,
+        payload.metadata?.operation,
+        payload.metadata?.feature,
+        payload.metadata?.source,
+        payload.context?.surface,
+        payload.session?.surface
+    ].filter(Boolean).join(' ');
+    return !prompt && /\b(?:settings|preferences|profile|speed|fast[_\s-]*mode|reasoning|model[_\s-]*select|codex[_\s-]*app)\b/i.test(haystack);
+}
+export function looksLikeCodexGitAction(payload = {}) {
+    const prompt = stripVisibleDecisionAnswerBlocks(extractUserPrompt(payload));
+    const metadataText = codexGitActionMetadataText(payload);
+    const haystack = [
+        metadataText,
+        payload.action,
+        payload.intent,
+        payload.operation,
+        payload.permission,
+        payload.description,
+        payload.kind,
+        payload.type,
+        payload.feature,
+        payload.tool_name,
+        payload.toolName,
+        payload.source,
+        payload.event,
+        payload.hook,
+        payload.hook_name,
+        payload.input?.action,
+        payload.input?.intent,
+        payload.input?.operation,
+        payload.input?.feature,
+        payload.input?.source,
+        payload.metadata?.action,
+        payload.metadata?.intent,
+        payload.metadata?.operation,
+        payload.metadata?.feature,
+        payload.metadata?.source
+    ].filter(Boolean).join(' ');
+    const codexAppGitSignal = /\bcodex[_\s-]*app\b[\s\S]{0,80}\bgit\b[\s\S]{0,80}\b(?:action|actions|commit|push|pr)\b/i.test(haystack);
+    const gitActionSignal = /\bgit[_\s-]*actions?\b[\s\S]{0,80}\b(?:commit|push|commit[\s_-]*(?:and|&)?[\s_-]*push)\b/i.test(haystack);
+    const appSignal = codexGitActionMetadataSignal(metadataText)
+        || codexAppGitSignal
+        || gitActionSignal
+        || /\b(?:codex[_\s-]*(?:app[_\s-]*)?)?(?:git[_\s-]*)?(?:commit[_\s-]*message|git[_\s-]*commit|git[_\s-]*push|git[_\s-]*pr|codex_git_commit|codex_git_push|codex_git_pr)\b/i.test(haystack)
+        || /커밋\s*메시지\s*생성/i.test(haystack);
+    const promptSignal = /\bgenerate(?:\s+a)?(?:\s+git)?\s+commit\s+message\b/i.test(prompt)
+        || /\bcommit\s+message\b[\s\S]{0,80}\b(?:staged|diff|changes?|git)\b/i.test(prompt)
+        || looksLikeStockCodexGitActionPrompt(prompt)
+        || /커밋\s*메시지\s*생성/i.test(prompt);
+    if (!appSignal && !promptSignal)
+        return false;
+    if (looksLikeStockCodexGitActionPrompt(prompt))
+        return true;
+    if (appSignal)
+        return true;
+    return !looksLikeUserImplementationRequest(prompt);
+}
+export function looksLikeStockCodexGitActionPrompt(prompt = '') {
+    const text = String(prompt || '').trim();
+    if (!text || text.length > 120)
+        return false;
+    return /^(?:generate\s+(?:a\s+)?git\s+commit\s+message(?:\s+for\s+(?:the\s+)?(?:staged\s+)?diff)?|commit\s+changes|commit\s+and\s+push\s+changes|push\s+changes|create\s+(?:a\s+)?commit|create\s+(?:a\s+)?pull\s+request)\.?$/i.test(text);
+}
+export function looksLikeCodexGitActionStopCompletion(last = '', payload = {}) {
+    const text = String(last || '').trim();
+    const metadataText = codexGitActionMetadataText(payload);
+    const haystack = [
+        metadataText,
+        payload.action,
+        payload.intent,
+        payload.operation,
+        payload.kind,
+        payload.type,
+        payload.feature,
+        payload.source,
+        payload.event,
+        payload.metadata?.action,
+        payload.metadata?.intent,
+        payload.metadata?.operation,
+        payload.metadata?.feature,
+        payload.metadata?.source
+    ].filter(Boolean).join(' ');
+    if (codexGitActionMetadataSignal(metadataText))
+        return true;
+    if (/\bcodex[_\s-]*app\b[\s\S]{0,80}\bgit\b[\s\S]{0,80}\b(?:action|commit|push|pr)\b/i.test(haystack))
+        return true;
+    if (!text || text.length > 180)
+        return false;
+    return /^(?:commit(?:ted)?(?:\s+and\s+pushed)?(?:\s+changes)?(?:\s+complete[.!]?)?|push(?:ed)?(?:\s+changes)?(?:\s+complete[.!]?)?|created\s+(?:a\s+)?pull\s+request[.!]?)$/i.test(text);
+}
+function looksLikeUserImplementationRequest(text = '') {
+    return /(fix|bug|broken|error|issue|implement|change|update|repair|수정|버그|오류|에러|문제|고쳐|고치|해결|변경|수리|패치|안생기|안\s*생기)/i.test(String(text || ''));
+}
+//# sourceMappingURL=payload-signals.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

package/dist/core/hooks-runtime/team-digest.js

@@ -30,7 +30,6 @@ export async function teamLiveDigest(root, state = {}) {
     const lines = events.map(formatTeamDigestEvent);
     const context = boundText([
         `SKS Team live digest: mission ${id}, phase ${phase}, source ${source}.`,
-        `Open Zellij multi-view with: sks team open-zellij ${id}`,
         `Open live view with: sks team watch ${id}`,
         'Recent events:',
         ...lines.map((line) => `- ${line}`)

package/dist/core/hooks-runtime/tool-output-quarantine.js

@@ -0,0 +1,93 @@
+import path from 'node:path';
+import { nowIso, readJson, sha256, writeJsonAtomic } from '../fsx.js';
+export const TOOL_OUTPUT_QUARANTINE_SCHEMA = 'sks.tool-output-quarantine.v1';
+export function missingToolOutputCallId(text) {
+    return String(text || '').match(/\[No tool output found for (?:custom\s+)?tool call\s+([^\].\s]+)\.?\]/i)?.[1] || null;
+}
+export function missingToolOutputCallIdFromPayload(payload = {}) {
+    const candidates = [
+        payload.prompt,
+        payload.user_prompt,
+        payload.userPrompt,
+        payload.last_assistant_message,
+        payload.assistant_message,
+        payload.previous_assistant_message,
+        payload.prior_assistant_message,
+        payload.response,
+        payload.raw,
+        payload.error,
+        payload.error_message,
+        payload.errorMessage,
+        payload.last_error,
+        payload.raw_error,
+        payload.rawError,
+        payload.result
+    ];
+    const seen = new Set();
+    let visited = 0;
+    const scan = (value, depth = 0) => {
+        if (visited >= 128 || depth > 4 || value === null || value === undefined)
+            return null;
+        visited += 1;
+        if (typeof value === 'string' || typeof value === 'number')
+            return missingToolOutputCallId(value);
+        if (typeof value !== 'object' || seen.has(value))
+            return null;
+        seen.add(value);
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                const found = scan(item, depth + 1);
+                if (found)
+                    return found;
+            }
+            return null;
+        }
+        for (const nested of Object.values(value)) {
+            const found = scan(nested, depth + 1);
+            if (found)
+                return found;
+        }
+        return null;
+    };
+    for (const candidate of candidates) {
+        const found = scan(candidate);
+        if (found)
+            return found;
+    }
+    return null;
+}
+export function toolOutputQuarantinePath(root, sessionKey) {
+    return path.join(root, '.sneakoscope', 'state', 'tool-output-quarantine', `${sha256(String(sessionKey || 'default')).slice(0, 32)}.json`);
+}
+export async function readToolOutputQuarantine(root, sessionKey) {
+    const record = await readJson(toolOutputQuarantinePath(root, sessionKey), null).catch(() => null);
+    return record?.schema === TOOL_OUTPUT_QUARANTINE_SCHEMA && record.active === true ? record : null;
+}
+export async function quarantineMissingToolOutput(input) {
+    const previous = await readToolOutputQuarantine(input.root, input.sessionKey);
+    const now = nowIso();
+    const record = {
+        schema: TOOL_OUTPUT_QUARANTINE_SCHEMA,
+        active: true,
+        session_key_hash: sha256(String(input.sessionKey || 'default')).slice(0, 24),
+        call_id: String(input.callId || previous?.call_id || 'unknown'),
+        mission_id: String(input.missionId || previous?.mission_id || '').trim() || null,
+        turn_id: String(input.turnId || '').trim() || previous?.turn_id || null,
+        first_seen_at: previous?.first_seen_at || now,
+        updated_at: now,
+        recovery: 'fresh_thread_required'
+    };
+    await writeJsonAtomic(toolOutputQuarantinePath(input.root, input.sessionKey), record);
+    return record;
+}
+export function interruptedToolOutputRecoveryBlockReason(input = {}) {
+    const callId = String(input.callId || 'unknown');
+    const missionId = String(input.missionId || '').trim() || 'none';
+    return [
+        `SKS blocked same-thread continuation because custom tool call ${callId} has no correlated output (active mission: ${missionId}).`,
+        'The current Codex conversation state may be structurally invalid, so additional context cannot repair the pending Responses request.',
+        'Treat the call result as unknown and do not replay a possibly mutating action.',
+        'Upgrade the selected codex-lb to 1.21.0-beta.3 or later, or explicitly switch with `sks codex-lb use-oauth`, then open a fresh Codex thread and continue the persisted mission after inspecting side effects.'
+    ].join(' ');
+}
+//# sourceMappingURL=tool-output-quarantine.js.map