sneakoscope 6.0.3 → 6.1.2

package/dist/core/hooks-runtime/hook-invocation-dedupe.js

@@ -0,0 +1,147 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { sha256 } from '../fsx.js';
+const DEDUPE_EVENTS = new Set([
+    'user-prompt-submit',
+    'post-tool',
+    'stop',
+    'session-start',
+    'pre-compact',
+    'post-compact',
+    'subagent-start',
+    'subagent-stop'
+]);
+const DEFAULT_WINDOW_MS = 3_000;
+const DEFAULT_MAX_MARKERS = 64;
+export async function claimHookInvocation(root, name, payload = {}) {
+    const event = String(name || '').trim();
+    if (!DEDUPE_EVENTS.has(event))
+        return { duplicate: false, claimed: false, reason: 'event_not_deduped' };
+    const identity = hookInvocationIdentity(event, payload);
+    if (!identity)
+        return { duplicate: false, claimed: false, reason: 'stable_host_identity_missing' };
+    const windowMs = hookDedupeWindowMs();
+    const dir = await prepareDedupeDir(root);
+    const digest = sha256(JSON.stringify(identity)).slice(0, 32);
+    const marker = path.join(dir, `${digest}.json`);
+    const claimed = await createMarker(marker, windowMs);
+    await pruneMarkers(dir, windowMs).catch(() => null);
+    return {
+        duplicate: !claimed,
+        claimed,
+        reason: claimed ? 'invocation_claimed' : 'duplicate_host_invocation',
+        digest
+    };
+}
+function hookInvocationIdentity(event, payload) {
+    const turnId = firstText(payload.turn_id, payload.turnId, payload.request_id, payload.requestId);
+    const toolUseId = firstText(payload.tool_use_id, payload.toolUseId, payload.item_id, payload.itemId);
+    const agentId = firstText(payload.agent_id, payload.agentId);
+    if (!turnId && !toolUseId && !agentId)
+        return null;
+    const sessionId = firstText(payload.session_id, payload.sessionId, payload.conversation_id, payload.thread_id, payload.threadId, payload.chat_id);
+    const content = event === 'user-prompt-submit'
+        ? firstText(payload.prompt, payload.user_prompt, payload.userPrompt, payload.message, payload.input?.prompt, payload.input?.message)
+        : event === 'stop'
+            ? firstText(payload.last_assistant_message, payload.assistant_message, payload.message, payload.response)
+            : '';
+    return {
+        event,
+        session_id: sessionId || null,
+        turn_id: turnId || null,
+        tool_use_id: toolUseId || null,
+        agent_id: agentId || null,
+        content_hash: content ? sha256(content).slice(0, 16) : null
+    };
+}
+async function createMarker(marker, windowMs) {
+    try {
+        const handle = await fsp.open(marker, 'wx');
+        try {
+            await handle.writeFile(JSON.stringify({ created_at_ms: Date.now() }));
+        }
+        finally {
+            await handle.close();
+        }
+        return true;
+    }
+    catch (error) {
+        if (error?.code !== 'EEXIST')
+            throw error;
+    }
+    const stat = await fsp.stat(marker).catch(() => null);
+    if (stat && Date.now() - stat.mtimeMs <= windowMs)
+        return false;
+    await fsp.rm(marker, { force: true }).catch(() => null);
+    try {
+        const handle = await fsp.open(marker, 'wx');
+        try {
+            await handle.writeFile(JSON.stringify({ created_at_ms: Date.now() }));
+        }
+        finally {
+            await handle.close();
+        }
+        return true;
+    }
+    catch (error) {
+        if (error?.code === 'EEXIST')
+            return false;
+        throw error;
+    }
+}
+async function pruneMarkers(dir, windowMs) {
+    const directoryNames = await fsp.readdir(dir).catch(() => []);
+    const names = directoryNames.filter((name) => /^[0-9a-f]{32}\.json$/.test(name));
+    if (names.length <= DEFAULT_MAX_MARKERS)
+        return;
+    const cutoff = Date.now() - Math.max(windowMs * 4, 12_000);
+    const rows = await Promise.all(names.map(async (name) => {
+        const file = path.join(dir, name);
+        const stat = await fsp.lstat(file).catch(() => null);
+        return { file, mtimeMs: stat?.isFile() && !stat.isSymbolicLink() ? stat.mtimeMs : 0, removable: Boolean(stat?.isFile() && !stat.isSymbolicLink()) };
+    }));
+    const stale = rows
+        .filter((row) => row.removable && row.mtimeMs < cutoff && path.dirname(row.file) === dir)
+        .sort((a, b) => a.mtimeMs - b.mtimeMs);
+    const overflow = Math.max(0, rows.length - DEFAULT_MAX_MARKERS);
+    for (const row of stale.slice(0, Math.max(overflow, stale.length))) {
+        await fsp.rm(row.file, { force: true }).catch(() => null);
+    }
+}
+async function prepareDedupeDir(root) {
+    const sksDir = path.resolve(root, '.sneakoscope');
+    const stateDir = path.join(sksDir, 'state');
+    const dir = path.join(stateDir, 'hook-invocation-dedupe');
+    await fsp.mkdir(sksDir, { recursive: true });
+    await assertRealDirectoryWithin(root, sksDir, path.resolve(root));
+    await fsp.mkdir(stateDir, { recursive: true });
+    await assertRealDirectoryWithin(root, stateDir, sksDir);
+    await fsp.mkdir(dir, { recursive: true });
+    await assertRealDirectoryWithin(root, dir, stateDir);
+    return dir;
+}
+async function assertRealDirectoryWithin(root, candidate, parent) {
+    const stat = await fsp.lstat(candidate);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new Error(`unsafe_hook_dedupe_directory:${path.relative(root, candidate)}`);
+    const [realCandidate, realParent] = await Promise.all([fsp.realpath(candidate), fsp.realpath(parent)]);
+    const relative = path.relative(realParent, realCandidate);
+    if (relative.startsWith('..') || path.isAbsolute(relative))
+        throw new Error(`hook_dedupe_directory_outside_root:${path.relative(root, candidate)}`);
+}
+function hookDedupeWindowMs() {
+    const configured = Number(process.env.SKS_HOOK_DEDUPE_WINDOW_MS || DEFAULT_WINDOW_MS);
+    if (!Number.isFinite(configured))
+        return DEFAULT_WINDOW_MS;
+    return Math.max(250, Math.min(30_000, Math.floor(configured)));
+}
+function firstText(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+        if (typeof value === 'number' && Number.isFinite(value))
+            return String(value);
+    }
+    return '';
+}
+//# sourceMappingURL=hook-invocation-dedupe.js.map

package/dist/core/hooks-runtime/hook-io.js

@@ -19,7 +19,15 @@ export async function loadHookPayload() {
 export function normalizeHookResult(name, result = {}) {
     const eventName = codexHookEventName(name);
     const out = { ...result };
-    const systemMessage = out.systemMessage || visibleHookMessage(name, out.reason || out.additionalContext || '');
+    // Project and legacy user-level SKS hooks can briefly coexist during an
+    // upgrade. The runtime owner performs the work once; duplicate invocations
+    // must be silent so Codex does not inject the same route or Stop feedback
+    // twice into one turn.
+    if (out.suppressedDuplicate === true)
+        return { continue: true };
+    const systemMessage = out.silent === true
+        ? undefined
+        : out.systemMessage || visibleHookMessage(name, out.reason || out.additionalContext || '');
     const reason = out.reason || 'SKS guard denied this action.';
     if (eventName === 'UserPromptSubmit' || eventName === 'PostToolUse') {
         if (eventName === 'UserPromptSubmit') {
@@ -96,8 +104,10 @@ export function visibleHookMessage(name, text = '') {
             return 'SKS: native Computer Use lane injected; defer TriWiki/Honest Mode to final closeout.';
         if (body.includes('MANDATORY ambiguity-removal gate') || body.includes('VISIBLE RESPONSE CONTRACT') || body.includes('Required questions still pending'))
             return 'SKS: stale clarification gate detected; continue from inferred route contract.';
+        if (body.includes('$Naruto route prepared') || body.includes('Codex subagent workflow'))
+            return 'SKS: Naruto Codex subagent delegation context injected.';
         if (body.includes('$Team route prepared') || body.includes('Team route'))
-            return 'SKS: Team route, live transcript, and native multi-session plan injected.';
+            return 'SKS: Team compatibility route redirected to the Naruto Codex subagent workflow.';
         if (body.includes('$Research route prepared'))
             return 'SKS: Research route, xhigh Eureka agent council, source/debate ledgers, paper output, and falsification gate injected.';
         if (body.includes('$AutoResearch route prepared'))
@@ -112,8 +122,8 @@ export function visibleHookMessage(name, text = '') {
             return 'SKS: GX visual context route injected.';
         if (body.includes('$QA-LOOP route prepared'))
             return 'SKS: QA-LOOP route and safety checklist injected.';
-        if (body.includes('Native multi-session policy: REQUIRED'))
-            return 'SKS: route context injected; native multi-session gate is active.';
+        if (body.includes('Codex subagent workflow: required'))
+            return 'SKS: route context injected; official subagent evidence gate is active.';
         return 'SKS: skill-first route context injected.';
     }
     if (name === 'post-tool')

package/dist/core/hooks-runtime/light-turn.js

@@ -0,0 +1,70 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { nowIso, readJson, sha256, writeJsonAtomic } from '../fsx.js';
+export async function armLightTurnStopBypass(root, input) {
+    const sessionKeyHash = lightTurnSessionHash(input.sessionKey);
+    const createdAt = nowIso();
+    const ttlMs = Math.max(1_000, Math.min(10 * 60_000, Math.floor(Number(input.ttlMs) || 0)));
+    const receipt = {
+        schema: 'sks.light-turn.v1',
+        session_key_hash: sessionKeyHash,
+        turn_id_hash: sha256(String(input.turnId || '')).slice(0, 32),
+        prompt_hash: sha256(String(input.prompt || '')).slice(0, 32),
+        profile: input.profile,
+        created_at: createdAt,
+        expires_at: new Date(Date.parse(createdAt) + ttlMs).toISOString(),
+        consumed: false
+    };
+    await writeJsonAtomic(lightTurnReceiptPath(root, sessionKeyHash), receipt);
+    return receipt;
+}
+export async function consumeLightTurnStopBypass(root, input) {
+    const sessionKeyHash = lightTurnSessionHash(input.sessionKey);
+    const file = lightTurnReceiptPath(root, sessionKeyHash);
+    const receipt = await readJson(file, null).catch(() => null);
+    if (!receipt)
+        return { accepted: false, receipt: null, reason: 'receipt_missing' };
+    // A light receipt is single-use. Remove it before evaluating stale route
+    // state so it can never become durable completion evidence or be replayed.
+    await fsp.rm(file, { force: true }).catch(() => null);
+    if (receipt.schema !== 'sks.light-turn.v1')
+        return { accepted: false, receipt, reason: 'schema_mismatch' };
+    if (receipt.session_key_hash !== sessionKeyHash)
+        return { accepted: false, receipt, reason: 'session_mismatch' };
+    if (receipt.turn_id_hash !== sha256(String(input.turnId || '')).slice(0, 32))
+        return { accepted: false, receipt, reason: 'turn_mismatch' };
+    if (receipt.consumed === true)
+        return { accepted: false, receipt, reason: 'already_consumed' };
+    const expiresAt = Date.parse(receipt.expires_at);
+    if (!Number.isFinite(expiresAt) || expiresAt < Date.now())
+        return { accepted: false, receipt, reason: 'expired' };
+    return { accepted: true, receipt: { ...receipt, consumed: true }, reason: 'accepted' };
+}
+export async function hasMatchingLightTurnStopBypass(root, input) {
+    const turnId = String(input.turnId || '').trim();
+    if (!turnId)
+        return false;
+    const sessionKeyHash = lightTurnSessionHash(input.sessionKey);
+    const receipt = await readJson(lightTurnReceiptPath(root, sessionKeyHash), null).catch(() => null);
+    if (!receipt || receipt.schema !== 'sks.light-turn.v1' || receipt.consumed === true)
+        return false;
+    if (receipt.session_key_hash !== sessionKeyHash)
+        return false;
+    if (receipt.turn_id_hash !== sha256(turnId).slice(0, 32))
+        return false;
+    const expiresAt = Date.parse(receipt.expires_at);
+    return Number.isFinite(expiresAt) && expiresAt >= Date.now();
+}
+export async function clearLightTurnStopBypass(root, input) {
+    await fsp.rm(lightTurnReceiptPath(root, input.sessionKey), { force: true }).catch(() => undefined);
+}
+export function lightTurnReceiptPath(root, sessionKeyOrHash) {
+    const hash = /^[0-9a-f]{32}$/.test(String(sessionKeyOrHash || ''))
+        ? String(sessionKeyOrHash)
+        : lightTurnSessionHash(sessionKeyOrHash);
+    return path.join(root, '.sneakoscope', 'state', 'light-turn', `${hash}.json`);
+}
+function lightTurnSessionHash(sessionKey) {
+    return sha256(String(sessionKey || 'default')).slice(0, 32);
+}
+//# sourceMappingURL=light-turn.js.map

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/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