sneakoscope 4.8.4 → 4.8.6

package/dist/core/agents/worker-pane-communication-contract.js

@@ -45,9 +45,8 @@ async function checkRecord(root, record) {
     const pane = await readJson(panePath, null);
     const codexControlProof = await readJson(codexControlProofPath, null);
     const patchPath = record.patch_envelope_path ? path.join(root, String(record.patch_envelope_path)) : path.join(root, workerDir, 'worker-patch-envelope.json');
-    const noPatchPath = path.join(root, workerDir, 'worker-no-patch-reason.json');
     const intakeExists = await exists(intakePath);
-    const patchOrNoPatchExists = await exists(patchPath) || await exists(noPatchPath);
+    const patchOrNoPatchExists = await exists(patchPath) || Boolean(result?.no_patch_reason);
     const events = eventsText.trim().split(/\r?\n/).filter(Boolean).map((line) => {
         try {
             return JSON.parse(line);
@@ -60,7 +59,6 @@ async function checkRecord(root, record) {
     const resultObserved = eventTypes.includes('result_written');
     const paneClosedObserved = eventTypes.includes('pane_closed');
     const blockers = [
-        ...(!intakeExists ? ['worker_pane_contract_intake_missing'] : []),
         ...(!result ? ['worker_pane_contract_result_missing'] : []),
         ...(!heartbeatText.trim() ? ['worker_pane_contract_heartbeat_missing'] : []),
         ...(!processReport ? ['worker_pane_contract_process_report_missing'] : []),
@@ -77,6 +75,7 @@ async function checkRecord(root, record) {
         slot_id: record.slot_id || null,
         generation_index: record.generation_index || null,
         worker_artifact_dir: workerDir,
+        intake_present: intakeExists,
         result_path: resultPath,
         heartbeat_path: heartbeatPath,
         process_report_path: processReportPath,

package/dist/core/codex/codex-cli-syntax-builder.js

@@ -22,6 +22,8 @@ export function buildCodexExecArgs(opts) {
         args.push('--ephemeral');
     if (opts.skipGitRepoCheck)
         args.push('--skip-git-repo-check');
+    if (opts.noMcp)
+        args.push('--no-mcp');
     if (opts.profile)
         args.push(...buildCodexProfileArgs(opts.profile, opts.profileAlias));
     else if (opts.ignoreUserConfig)

package/dist/core/codex-app/codex-init-deep.js

@@ -28,7 +28,8 @@ export async function runCodexInitDeep(input = {}) {
                     }
                     if (existing.trim()) {
                         const beforeHash = hashText(existing);
-                        const backup = `${agentsPath}.sks-backup-${Date.now()}-${beforeHash.slice(0, 12)}`;
+                        const backup = initDeepBackupPath(root, agentsPath, beforeHash);
+                        await ensureDir(path.dirname(backup));
                         await fs.copyFile(agentsPath, backup);
                         directoryLocalAgents.backup_paths.push(path.relative(root, backup));
                         directoryLocalAgents.backups_created += 1;
@@ -81,8 +82,8 @@ function mergeManagedBlockPreview(current, markerName, content) {
 async function pruneBackups(root, agentsPath, keep) {
     if (keep < 1)
         return [];
-    const dir = path.dirname(agentsPath);
-    const base = path.basename(agentsPath);
+    const dir = path.join(root, '.sneakoscope', 'backups', 'agents');
+    const base = backupBaseName(root, agentsPath);
     const backupPattern = new RegExp(`^${escapeRegExp(base)}\\.sks-backup-\\d{13}-[0-9a-f]{8,12}$`);
     const rows = await fs.readdir(dir).catch(() => []);
     const backups = rows
@@ -100,6 +101,12 @@ async function pruneBackups(root, agentsPath, keep) {
         await guardedRm(guard, file, { force: true }).catch(() => undefined);
     return remove;
 }
+function initDeepBackupPath(root, agentsPath, beforeHash) {
+    return path.join(root, '.sneakoscope', 'backups', 'agents', `${backupBaseName(root, agentsPath)}.sks-backup-${Date.now()}-${beforeHash.slice(0, 12)}`);
+}
+function backupBaseName(root, agentsPath) {
+    return path.relative(root, agentsPath).replace(/[\\/]+/g, '__');
+}
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }

package/dist/core/codex-control/codex-reliability-shield.js

@@ -15,8 +15,9 @@ export async function runWithCodexReliabilityShield(input, runAttempt) {
     const attempts = [];
     let selected = null;
     let selectedAttempt = 0;
+    const controls = {};
     for (let attempt = 1; attempt <= policy.maxEmptyResultRetries + 1; attempt += 1) {
-        const raw = await runAttempt(attempt);
+        const raw = await runAttempt(attempt, controls);
         const repaired = repairToolCallSequence(Array.isArray(raw.events) ? raw.events : []);
         const heartbeats = buildKeepaliveHeartbeats(repaired.events);
         const evaluation = evaluateCodexReliabilityAttempt(raw, repaired.events, policy, attempt);
@@ -30,9 +31,11 @@ export async function runWithCodexReliabilityShield(input, runAttempt) {
             ...raw,
             events: repaired.events,
             reliabilityHeartbeats: heartbeats,
-            blockers: [...(raw.blockers || []), ...report.blockers]
+            blockers: report.mcp_auth_error ? report.blockers : [...(raw.blockers || []), ...report.blockers]
         };
         selectedAttempt = attempt;
+        if (report.retryable && report.mcp_auth_error)
+            controls.noMcp = true;
         if (!report.retryable || attempt > policy.maxEmptyResultRetries)
             break;
     }
@@ -65,7 +68,8 @@ export async function runWithCodexReliabilityShield(input, runAttempt) {
 export function evaluateCodexReliabilityAttempt(result, events, policy, attempt) {
     const meaningful = events.filter(isMeaningfulEvent);
     const modelCapacity = isCodexModelCapacityError(result, events);
-    const fatal = !modelCapacity && hasFatalError(result, events);
+    const mcpAuth = isMcpAuthError(result, events);
+    const fatal = !modelCapacity && !mcpAuth && hasFatalError(result, events);
     const idle = hasIdleTimeout(events, policy.idleTimeoutMs);
     const empty = events.length === 0 || (!String(result.finalResponse || '').trim() && meaningful.length === 0);
     const partial = meaningful.length > 0 && !result.structuredOutput;
@@ -74,13 +78,19 @@ export function evaluateCodexReliabilityAttempt(result, events, policy, attempt)
     let retryReason = null;
     if (modelCapacity)
         blockers.push('codex_model_capacity_unavailable');
+    if (mcpAuth)
+        blockers.push('codex_reliability_mcp_auth_error');
     if (!modelCapacity && idle && partial)
         blockers.push('codex_reliability_idle_after_partial_output');
     if (!modelCapacity && partial && !idle)
         blockers.push('codex_reliability_partial_output_without_structured_result');
     if (fatal)
         blockers.push('codex_reliability_fatal_error_no_retry');
-    if (!modelCapacity && !fatal && idle && meaningful.length === 0) {
+    if (mcpAuth) {
+        retryable = true;
+        retryReason = 'mcp_auth_error_retry_no_mcp';
+    }
+    else if (!modelCapacity && !fatal && idle && meaningful.length === 0) {
         retryable = true;
         retryReason = 'stream_idle_before_meaningful_event';
     }
@@ -98,6 +108,7 @@ export function evaluateCodexReliabilityAttempt(result, events, policy, attempt)
         retry_reason: retryReason,
         idle_timeout: idle,
         fatal_error: fatal,
+        mcp_auth_error: mcpAuth,
         model_capacity_error: modelCapacity,
         capacity_fallback_hint: null,
         repaired_tool_result_count: 0,
@@ -106,16 +117,7 @@ export function evaluateCodexReliabilityAttempt(result, events, policy, attempt)
     };
 }
 export function isCodexModelCapacityError(result, events) {
-    const text = [
-        String(result.finalResponse || ''),
-        ...(Array.isArray(result.blockers) ? result.blockers : []),
-        ...events.map((event) => [
-            event?.error?.message,
-            event?.message,
-            event?.item?.text,
-            event?.raw?.failed_event?.error?.message
-        ].filter(Boolean).join('\n'))
-    ].join('\n');
+    const text = collectText(result, events);
     return /selected model is at capacity|model(?:\s+[\w.-]+)?\s+is\s+at\s+capacity|try a different model|capacity(?:\s+is)?\s+exhausted|temporarily at capacity/i.test(text);
 }
 export function repairToolCallSequence(events) {
@@ -166,11 +168,28 @@ function isMeaningfulEvent(event) {
         || itemType === 'mcp_tool_call';
 }
 function hasFatalError(result, events) {
-    const text = [
+    if (isMcpAuthError(result, events))
+        return false;
+    const text = collectText(result, events);
+    return /\b(?:4\d\d|fatal|unauthorized|forbidden|authrequired|invalid oauth|side-effect applied|partial patch applied)\b/i.test(text);
+}
+function isMcpAuthError(result, events) {
+    const text = collectText(result, events);
+    return /\b(?:authrequired|oauth)\b/i.test(text)
+        && /transport channel closed|rmcp/i.test(text)
+        && !/side-effect applied|partial patch applied/i.test(text);
+}
+function collectText(result, events) {
+    return [
+        String(result.finalResponse || ''),
         ...(Array.isArray(result.blockers) ? result.blockers : []),
-        ...events.map((event) => event?.error?.message || event?.message || '')
+        ...events.map((event) => [
+            event?.error?.message,
+            event?.message,
+            event?.item?.text,
+            event?.raw?.failed_event?.error?.message
+        ].filter(Boolean).join('\n'))
     ].join('\n');
-    return /\b(?:4\d\d|fatal|unauthorized|forbidden|authrequired|invalid oauth|side-effect applied|partial patch applied)\b/i.test(text);
 }
 function hasIdleTimeout(events, idleTimeoutMs) {
     const stamps = events.map(eventTimeMs).filter((value) => Number.isFinite(value));

package/dist/core/codex-control/codex-sdk-adapter.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { appendJsonl } from '../fsx.js';
+import { appendJsonlBounded } from '../fsx.js';
 import { buildCodexExecutionPolicy, buildCodexSdkConfig } from './codex-sdk-config-policy.js';
 import { buildCodexSdkEnv } from './codex-sdk-env-policy.js';
 import { translateCodexSdkEvent } from './codex-event-translator.js';
@@ -41,7 +41,7 @@ export async function runRealCodexSdkTask(input, policy) {
     for await (const event of streamed.events) {
         events.push(event);
         if (liveEventPath) {
-            await appendJsonl(liveEventPath, translateCodexSdkEvent(event));
+            await appendJsonlBounded(liveEventPath, translateCodexSdkEvent(event), 5 * 1024 * 1024);
             liveEventsWritten = true;
         }
         if (event?.type === 'item.completed' && event?.item?.type === 'agent_message')

package/dist/core/codex-control/codex-sdk-config-policy.js

@@ -13,6 +13,10 @@ export function buildCodexSdkConfig(input) {
             generation_index: Number(input.generationIndex || 0)
         }
     };
+    if (input.requestedScopeContract?.no_mcp === true) {
+        config.mcp_servers = {};
+        config.sks = { ...config.sks, no_mcp: true };
+    }
     const codexLbApiKey = String(process.env.CODEX_LB_API_KEY || '').trim();
     const codexLbBaseUrl = normalizeCodexLbBaseUrl(process.env.CODEX_LB_BASE_URL);
     if (codexLbApiKey && codexLbBaseUrl) {

package/dist/core/codex-control/codex-task-runner.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { appendJsonl, ensureDir, nowIso, packageRoot, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { appendJsonlBounded, ensureDir, nowIso, packageRoot, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 import { validateJsonSchemaRecursive } from '../json-schema-validator.js';
 import { resolveCodexOutputSchema } from './codex-output-schemas.js';
 import { detectCodexSdkCapability } from './codex-sdk-capability.js';
@@ -56,11 +56,14 @@ export async function runCodexTask(input) {
             generationIndex: task.generationIndex ?? null,
             sessionId: task.sessionId || null,
             backend: 'codex-sdk'
-        }, () => runWithCodexReliabilityShield(task, async () => {
+        }, () => runWithCodexReliabilityShield(task, async (_attempt, controls) => {
             try {
+                const attemptTask = controls?.noMcp
+                    ? { ...task, requestedScopeContract: { ...task.requestedScopeContract, no_mcp: true } }
+                    : task;
                 return fakeAllowed
-                    ? await runFakeCodexSdkTask(task)
-                    : await runRealCodexSdkTask(task, { sandboxMode: sandbox.sandboxMode, env: runtime.env.env, config: runtime.config });
+                    ? await runFakeCodexSdkTask(attemptTask)
+                    : await runRealCodexSdkTask(attemptTask, { sandboxMode: sandbox.sandboxMode, env: runtime.env.env, config: { ...runtime.config, mcp_servers: {} } });
             }
             catch (err) {
                 return {
@@ -79,17 +82,26 @@ export async function runCodexTask(input) {
     const translatedEvents = translateCodexSdkEvents(events);
     if (adapterResult?.liveEventsWritten !== true) {
         for (const event of translatedEvents)
-            await appendJsonl(path.join(root, 'codex-sdk-events.jsonl'), event);
+            await appendJsonlBounded(path.join(root, 'codex-sdk-events.jsonl'), event, 5 * 1024 * 1024);
     }
     if (adapterResult?.reliabilityShield)
         await writeJsonAtomic(path.join(root, 'codex-reliability-shield.json'), adapterResult.reliabilityShield);
     const structuredOutput = adapterResult?.structuredOutput;
     const validation = structuredOutput ? validateJsonSchemaRecursive(structuredOutput, schema) : { ok: false, issues: ['structured_output_missing'] };
-    const finalBlockers = [
+    const primaryBlockers = [
         ...blockers,
-        ...(adapterResult?.blockers || []),
-        ...(events.length > 0 ? [] : ['codex_sdk_event_stream_missing']),
-        ...(validation.ok ? [] : ['codex_sdk_structured_output_invalid', ...validation.issues.map((issue) => `schema:${issue}`)])
+        ...(adapterResult?.blockers || [])
+    ];
+    const runFailed = primaryBlockers.some((blocker) => {
+        const text = String(blocker || '');
+        return text.startsWith('codex_sdk_run_failed')
+            || text === 'codex_reliability_fatal_error_no_retry'
+            || text === 'codex_reliability_mcp_auth_error';
+    });
+    const finalBlockers = [
+        ...primaryBlockers,
+        ...(!runFailed && events.length === 0 ? ['codex_sdk_event_stream_missing'] : []),
+        ...(!runFailed && !validation.ok ? ['codex_sdk_structured_output_invalid', ...validation.issues.map((issue) => `schema:${issue}`)] : [])
     ];
     const workerResult = normalizeWorkerResult(structuredOutput, task, finalBlockers, validation.ok);
     const workerResultPath = path.join(root, 'codex-sdk-worker-result.json');
@@ -183,7 +195,7 @@ async function runPythonControlTask(root, task, schema, routerDecision) {
     const events = Array.isArray(adapterResult.events) ? adapterResult.events : [];
     const translatedEvents = Array.isArray(adapterResult.translatedEvents) ? adapterResult.translatedEvents : [];
     for (const event of translatedEvents)
-        await appendJsonl(path.join(root, 'python-codex-sdk-events.jsonl'), event);
+        await appendJsonlBounded(path.join(root, 'python-codex-sdk-events.jsonl'), event, 5 * 1024 * 1024);
     const structuredOutput = parseStructuredOutput(adapterResult.finalResponse || '');
     const validation = structuredOutput ? validateJsonSchemaRecursive(structuredOutput, schema) : { ok: false, issues: ['structured_output_missing'] };
     const finalBlockers = [
@@ -287,7 +299,7 @@ async function runLocalControlTask(root, task, schema, routerDecision) {
         backend: 'local-llm'
     }, () => runLocalLlmTask(task, { config, outputSchema: schema }));
     for (const event of adapterResult.events || [])
-        await appendJsonl(path.join(root, 'local-llm-events.jsonl'), event);
+        await appendJsonlBounded(path.join(root, 'local-llm-events.jsonl'), event, 5 * 1024 * 1024);
     const structuredOutput = adapterResult.structuredOutput;
     const validation = structuredOutput ? validateJsonSchemaRecursive(structuredOutput, schema) : { ok: false, issues: ['structured_output_missing'] };
     const finalBlockers = [

package/dist/core/codex-native/core-skill-manifest.js

@@ -30,8 +30,9 @@ const CORE_SKILL_DEFINITIONS = [
         canonical_name: 'qa-loop',
         display_name: 'qa-loop',
         route: '$QA-LOOP',
-        purpose: 'dogfood UI/API behavior with safety gates and QA reports.',
+        purpose: 'dogfood UI/API behavior with safety gates, Codex Chrome Extension-first web UI evidence, and QA reports.',
         when: 'Use when route completion needs human-proxy verification, rechecks, and QA ledgers.',
+        workflow: 'Infer the QA scope, dogfood real UI/API flows, and for web/browser/webapp UI evidence use the Codex Chrome Extension readiness gate first. If the extension is missing or disabled, rapidly halt and ask the user to set it up before resuming. Computer Use is reserved for native Mac/non-web surfaces and must not satisfy web UI evidence.',
         evidence: 'qa-ledger.json, dated QA report, qa-gate.json, and post-fix verification.',
         fallback: 'Mark unverified browser/native surfaces explicitly; never substitute fake visual evidence.'
     },

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

@@ -0,0 +1,58 @@
+import { spawnSync } from 'node:child_process';
+import { flag } from '../../cli/args.js';
+import { printJson } from '../../cli/output.js';
+import { projectRoot } from '../fsx.js';
+export async function gatesCommand(args = []) {
+    const root = await projectRoot();
+    const sub = args[0] && !args[0].startsWith('-') ? args[0] : 'run';
+    const json = flag(args, '--json');
+    if (sub !== 'run') {
+        const result = { schema: 'sks.gates-command.v1', ok: false, error: `Unknown subcommand: ${sub}` };
+        if (json)
+            return printJson(result);
+        console.error('Usage: sks gates run <gate-id|preset> [--full] [--json]');
+        process.exitCode = 1;
+        return result;
+    }
+    const target = args[1] && !args[1].startsWith('-') ? args[1] : readArg(args, '--preset', 'affected');
+    const isPreset = ['release', 'affected', 'fast', 'harness'].includes(target) || flag(args, '--preset');
+    const runnerArgs = ['dist/scripts/release-gate-dag-runner.js'];
+    if (isPreset)
+        runnerArgs.push('--preset', target);
+    else
+        runnerArgs.push('--gate', target);
+    if (flag(args, '--full'))
+        runnerArgs.push('--full');
+    const result = spawnSync(process.execPath, runnerArgs, {
+        cwd: root,
+        encoding: 'utf8',
+        maxBuffer: 1024 * 1024 * 20,
+        env: { ...process.env, CI: process.env.CI || 'true' }
+    });
+    const report = {
+        schema: 'sks.gates-command.v1',
+        ok: result.status === 0,
+        target,
+        mode: isPreset ? 'preset' : 'gate',
+        status: result.status,
+        stdout_tail: tail(String(result.stdout || '')),
+        stderr_tail: tail(String(result.stderr || ''))
+    };
+    if (json)
+        return printJson(report);
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    if (!report.ok)
+        process.exitCode = result.status || 1;
+    return report;
+}
+function readArg(args, name, fallback) {
+    const index = args.indexOf(name);
+    return index >= 0 && args[index + 1] ? String(args[index + 1]) : fallback;
+}
+function tail(value, limit = 4000) {
+    return value.length > limit ? value.slice(-limit) : value;
+}
+//# sourceMappingURL=gates-command.js.map

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

@@ -12,7 +12,7 @@ export async function releaseCommand(args = []) {
         process.exitCode = 1;
         return null;
     }
-    const result = spawnSync('npm', ['run', command, '--silent'], {
+    const result = spawnSync(process.execPath, command.args, {
         cwd: root,
         encoding: 'utf8',
         maxBuffer: 1024 * 1024 * 20,
@@ -22,7 +22,7 @@ export async function releaseCommand(args = []) {
         schema: 'sks.release-command.v1',
         ok: result.status === 0,
         subcommand: sub,
-        script: command,
+        command: [process.execPath, ...command.args],
         status: result.status,
         stdout_tail: tail(String(result.stdout || '')),
         stderr_tail: tail(String(result.stderr || ''))
@@ -39,11 +39,11 @@ export async function releaseCommand(args = []) {
 }
 function commandForSubcommand(sub) {
     if (sub === 'affected')
-        return 'release:check:affected';
+        return { args: ['dist/scripts/release-gate-dag-runner.js', '--preset', 'affected', '--changed-since', 'auto', '--sla', '5m'] };
     if (sub === 'full')
-        return 'release:check:full';
+        return { args: ['dist/scripts/release-gate-dag-runner.js', '--preset', 'release', '--full'] };
     if (sub === 'background')
-        return 'release:check:full';
+        return { args: ['dist/scripts/release-gate-dag-runner.js', '--preset', 'release', '--full'] };
     return null;
 }
 function tail(value, limit = 4000) {

package/dist/core/commands/stop-gate-command.js

@@ -49,7 +49,7 @@ export async function stopGateCommand(command, args) {
             console.log(`Selected gate: ${result.diagnostics.selected_gate_path}`);
         }
     }
-    if (result.action === 'continue')
+    if (result.action !== 'allow_stop')
         process.exitCode = 1;
     return result;
 }

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '4.8.4';
+export const PACKAGE_VERSION = '4.8.6';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

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

@@ -0,0 +1,86 @@
+import path from 'node:path';
+import { readJson, readText } from '../fsx.js';
+import { missionDir } from '../mission.js';
+const TEAM_DIGEST_MAX_EVENTS = 4;
+const TEAM_DIGEST_MESSAGE_CHARS = 180;
+const TEAM_DIGEST_CONTEXT_CHARS = 1600;
+const TEAM_DIGEST_SYSTEM_CHARS = 260;
+export async function teamLiveDigest(root, state = {}) {
+    if (!isTeamState(state) || !state.mission_id)
+        return null;
+    const id = String(state.mission_id);
+    const dir = missionDir(root, id);
+    const dashboard = await readJson(path.join(dir, 'team-dashboard.json'), null).catch(() => null);
+    const transcript = await readText(path.join(dir, 'team-transcript.jsonl'), '').catch(() => '');
+    let events = transcript.split(/\n/).filter(Boolean).slice(-TEAM_DIGEST_MAX_EVENTS * 3).map(parseTeamTranscriptLine).filter(Boolean);
+    let source = 'team-transcript.jsonl';
+    if (!events.length) {
+        const live = await readText(path.join(dir, 'team-live.md'), '').catch(() => '');
+        events = live.split(/\n/).filter((line) => /^- \d{4}-\d{2}-\d{2}T/.test(line.trim())).slice(-TEAM_DIGEST_MAX_EVENTS).map(parseTeamLiveLine).filter(Boolean);
+        source = 'team-live.md';
+    }
+    if (!events.length) {
+        events = dashboard?.latest_messages || [];
+        source = 'team-dashboard.json';
+    }
+    events = normalizeTeamEvents(events).slice(-TEAM_DIGEST_MAX_EVENTS);
+    if (!events.length)
+        return null;
+    const phase = oneLine(state.phase || dashboard?.phase || 'TEAM', 48);
+    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}`)
+    ].join('\n'), TEAM_DIGEST_CONTEXT_CHARS);
+    const system = boundText(`SKS Team live: ${lines.at(-1) || `${id} ${phase}`}`, TEAM_DIGEST_SYSTEM_CHARS);
+    return { context, system };
+}
+function isTeamState(state = {}) {
+    const values = [state.mode, state.route, state.route_command, state.stop_gate].map((value) => String(value || '').toLowerCase());
+    return values.some((value) => value === 'team' || value === '$team' || value.includes('team-gate'));
+}
+function normalizeTeamEvents(events = []) {
+    return events.map((event) => ({
+        ts: String(event?.ts || ''),
+        agent: oneLine(event?.agent || 'unknown', 40),
+        phase: oneLine(event?.phase || 'general', 48),
+        message: oneLine(event?.message || '', TEAM_DIGEST_MESSAGE_CHARS)
+    })).filter((event) => event.message);
+}
+function parseTeamTranscriptLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
+function parseTeamLiveLine(line) {
+    const match = String(line || '').trim().match(/^-\s+(\S+)\s+\[([^\]]+)\]\s+([^:]+):\s*(.*)$/);
+    if (!match)
+        return null;
+    return { ts: match[1], phase: match[2], agent: match[3], message: match[4] };
+}
+function formatTeamDigestEvent(event) {
+    const ts = shortIsoTime(event.ts);
+    return `${ts} [${event.phase}] ${event.agent}: ${event.message}`;
+}
+function shortIsoTime(ts) {
+    return String(ts || '').replace(/^\d{4}-\d{2}-\d{2}T/, '').replace(/\.\d{3}Z$/, 'Z') || 'recent';
+}
+function oneLine(value, limit) {
+    return boundText(String(value || '').replace(/\s+/g, ' ').trim(), limit);
+}
+function boundText(value, limit) {
+    const text = String(value || '');
+    if (text.length <= limit)
+        return text;
+    return `${text.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
+}
+export function joinSystemMessages(...parts) {
+    return boundText(parts.filter(Boolean).join(' | '), 420);
+}
+//# sourceMappingURL=team-digest.js.map

package/dist/core/hooks-runtime.js

@@ -17,10 +17,7 @@ import { appendMissionStatus } from './recallpulse.js';
 import { scanAgentTextForRecursion } from './agents/agent-recursion-guard.js';
 import { evaluateLoopContinuation } from './loops/loop-continuation-enforcer.js';
 import { buildCompactContinue, buildPermissionRequestAllow, buildPermissionRequestDeny, buildPostToolUseBlock, buildPostToolUseContinue, buildPreToolUseContinue, buildPreToolUseDeny, buildSessionStartContinue, buildStopBlock, buildStopContinue, buildSubagentStartContinue, buildSubagentStopBlock, buildSubagentStopContinue, buildUserPromptSubmitBlock, buildUserPromptSubmitContinue } from './codex-compat/codex-hook-output-builders.js';
-const TEAM_DIGEST_MAX_EVENTS = 4;
-const TEAM_DIGEST_MESSAGE_CHARS = 180;
-const TEAM_DIGEST_CONTEXT_CHARS = 1600;
-const TEAM_DIGEST_SYSTEM_CHARS = 260;
+import { joinSystemMessages, teamLiveDigest } from './hooks-runtime/team-digest.js';
 const STOP_REPEAT_GUARD_ARTIFACT = 'stop-hook-repeat-guard.json';
 const LIGHT_ROUTE_STOP_ARTIFACT = 'light-route-stop.json';
 const CODEX_GIT_ACTION_STOP_ARTIFACT = 'codex-git-action-stop-bypass.json';
@@ -1017,84 +1014,6 @@ async function resolveHonestModeLoopback(root, state = {}) {
         questions_allowed: true
     });
 }
-async function teamLiveDigest(root, state = {}) {
-    if (!isTeamState(state) || !state.mission_id)
-        return null;
-    const id = String(state.mission_id);
-    const dir = missionDir(root, id);
-    const dashboard = await readJson(path.join(dir, 'team-dashboard.json'), null).catch(() => null);
-    const transcript = await readText(path.join(dir, 'team-transcript.jsonl'), '').catch(() => '');
-    let events = transcript.split(/\n/).filter(Boolean).slice(-TEAM_DIGEST_MAX_EVENTS * 3).map(parseTeamTranscriptLine).filter(Boolean);
-    let source = 'team-transcript.jsonl';
-    if (!events.length) {
-        const live = await readText(path.join(dir, 'team-live.md'), '').catch(() => '');
-        events = live.split(/\n/).filter((line) => /^- \d{4}-\d{2}-\d{2}T/.test(line.trim())).slice(-TEAM_DIGEST_MAX_EVENTS).map(parseTeamLiveLine).filter(Boolean);
-        source = 'team-live.md';
-    }
-    if (!events.length) {
-        events = dashboard?.latest_messages || [];
-        source = 'team-dashboard.json';
-    }
-    events = normalizeTeamEvents(events).slice(-TEAM_DIGEST_MAX_EVENTS);
-    if (!events.length)
-        return null;
-    const phase = oneLine(state.phase || dashboard?.phase || 'TEAM', 48);
-    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}`)
-    ].join('\n'), TEAM_DIGEST_CONTEXT_CHARS);
-    const system = boundText(`SKS Team live: ${lines.at(-1) || `${id} ${phase}`}`, TEAM_DIGEST_SYSTEM_CHARS);
-    return { context, system };
-}
-function isTeamState(state = {}) {
-    const values = [state.mode, state.route, state.route_command, state.stop_gate].map((value) => String(value || '').toLowerCase());
-    return values.some((value) => value === 'team' || value === '$team' || value.includes('team-gate'));
-}
-function normalizeTeamEvents(events = []) {
-    return events.map((event) => ({
-        ts: String(event?.ts || ''),
-        agent: oneLine(event?.agent || 'unknown', 40),
-        phase: oneLine(event?.phase || 'general', 48),
-        message: oneLine(event?.message || '', TEAM_DIGEST_MESSAGE_CHARS)
-    })).filter((event) => event.message);
-}
-function parseTeamTranscriptLine(line) {
-    try {
-        return JSON.parse(line);
-    }
-    catch {
-        return null;
-    }
-}
-function parseTeamLiveLine(line) {
-    const match = String(line || '').trim().match(/^-\s+(\S+)\s+\[([^\]]+)\]\s+([^:]+):\s*(.*)$/);
-    if (!match)
-        return null;
-    return { ts: match[1], phase: match[2], agent: match[3], message: match[4] };
-}
-function formatTeamDigestEvent(event) {
-    const ts = shortIsoTime(event.ts);
-    return `${ts} [${event.phase}] ${event.agent}: ${event.message}`;
-}
-function shortIsoTime(ts) {
-    return String(ts || '').replace(/^\d{4}-\d{2}-\d{2}T/, '').replace(/\.\d{3}Z$/, 'Z') || 'recent';
-}
-function oneLine(value, limit) {
-    return boundText(String(value || '').replace(/\s+/g, ' ').trim(), limit);
-}
-function boundText(value, limit) {
-    const text = String(value || '');
-    if (text.length <= limit)
-        return text;
-    return `${text.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
-}
-function joinSystemMessages(...parts) {
-    return boundText(parts.filter(Boolean).join(' | '), 420);
-}
 export async function emitHook(name) {
     const result = await hookMain(name);
     process.stdout.write(`${JSON.stringify(normalizeHookResult(name, result))}\n`);