sneakoscope 2.0.13 → 2.0.15

package/dist/core/routes.js

@@ -355,11 +355,15 @@ export const ROUTES = [
         id: 'Team',
         command: '$Team',
         mode: 'TEAM',
-        route: 'multi-agent team orchestration',
-        description: 'Run substantial work through Team only when the proof cone is broad enough: native agents, TriWiki, debate, runtime task graph, fresh executors, review, cleanup, reflection, and Honest Mode.',
+        route: 'deprecated alias to Naruto',
+        description: 'Deprecated compatibility alias. New substantial work is routed to $Naruto, the native shadow-clone swarm SSOT.',
         requiredSkills: ['team', 'pipeline-runner', 'context7-docs', 'prompt-pipeline', REFLECTION_SKILL_NAME, 'honest-mode'],
         dollarAliases: ['$From-Chat-IMG'],
         appSkillAliases: ['from-chat-img'],
+        deprecated: true,
+        hidden: true,
+        aliasTo: '$Naruto',
+        deprecationMessage: '$Team is deprecated and redirects new execution missions to $Naruto. Existing Team observation commands remain available for old missions.',
         lifecycle: ['native_agent_intake', 'triwiki_refresh', 'planning_debate', 'live_transcript', 'consensus_artifact', 'fresh_implementation_team', 'review_artifact', 'integration_evidence', 'session_cleanup', 'post_route_reflection', 'honest_mode'],
         context7Policy: 'optional',
         reasoningPolicy: 'high',
@@ -373,13 +377,13 @@ export const ROUTES = [
         mode: 'NARUTO',
         route: 'hardware-safe massive parallel work swarm',
         description: '$Naruto mode launches a hardware-safe massive parallel work swarm. Clones may implement, modify, verify, test, research, document, and resolve conflicts according to role and lease policy; write-capable output is accepted only through patch envelopes, verification DAG, mutation guard, and GPT final arbiter.',
-        requiredSkills: ['team', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
+        requiredSkills: ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
         dollarAliases: ['$ShadowClone', '$Kagebunshin'],
         appSkillAliases: ['shadow-clone', 'kage-bunshin'],
         lifecycle: ['clone_roster_build', 'massive_work_graph', 'hardware_safe_governor', 'dynamic_active_pool', 'lease_based_write_swarm', 'parallel_verification_dag', 'gpt_final_arbiter_pack', 'per_clone_proof', 'session_cleanup', 'honest_mode'],
         context7Policy: 'optional',
         reasoningPolicy: 'high',
-        stopGate: 'team-gate.json',
+        stopGate: 'naruto-gate.json',
         cliEntrypoint: 'sks naruto run "task" [--clones N] [--backend codex-sdk|fake|ollama] [--parallel-write] | sks naruto status',
         examples: ['$Naruto run sweep the codebase for TODO comments with 50 clones', '$ShadowClone --clones 100 fan out and draft tests for every module']
     },
@@ -598,7 +602,7 @@ export const ROUTES = [
         examples: ['$Help show available SKS commands']
     }
 ];
-export const DOLLAR_COMMANDS = ROUTES.flatMap(({ command, route, description, dollarAliases = [] }) => [
+export const DOLLAR_COMMANDS = ROUTES.filter((route) => route.hidden !== true).flatMap(({ command, route, description, dollarAliases = [] }) => [
     { command, route, description },
     ...dollarAliases.map((alias) => ({ command: alias, route, description }))
 ]);
@@ -632,11 +636,11 @@ export const COMMAND_CATALOG = [
     { name: 'auth', usage: 'sks auth status|health|repair|setup --host <domain> --api-key <key>', description: 'Shortcut for codex-lb provider auth status, health, repair, and setup commands.' },
     { name: 'openclaw', usage: 'sks openclaw install|path|print [--dir path] [--force] [--json]', description: 'Generate an OpenClaw skill package so OpenClaw agents can discover and use local SKS workflows.' },
     { name: 'hermes', usage: 'sks hermes install|status|path|print [--dir path] [--force] [--json]', description: 'Generate a Hermes Agent skill package so Hermes agents can discover and use local SKS workflows.' },
-    { name: 'zellij', usage: 'sks zellij status|repair [--json] | sks team open-zellij latest | sks --mad', description: 'Inspect Zellij runtime status, explain repair (no auto-install), and open the SKS Zellij runtime used by MAD and Team lane UI.' },
+    { name: 'zellij', usage: 'sks zellij status|repair [--json] | sks naruto dashboard latest | sks --mad', description: 'Inspect Zellij runtime status, explain repair (no auto-install), and open the SKS Zellij runtime used by MAD and Naruto lane UI.' },
     { name: 'tmux', usage: 'sks tmux [--json]', description: 'Show the removed-runtime migration notice and point operators to Zellij.' },
     { name: 'mad', usage: 'sks --mad [--high]', description: 'Open a one-shot Zellij Codex CLI workspace with the SKS MAD full-access auto-review profile.' },
     { name: 'auto-review', usage: 'sks auto-review status|enable|start [--high] | sks --Auto-review --high', description: 'Enable Codex automatic approval review and launch SKS Zellij with the auto-review profile.' },
-    { name: 'dollar-commands', usage: 'sks dollar-commands [--json]', description: 'List Codex App $ commands such as $DFix and $Team.' },
+    { name: 'dollar-commands', usage: 'sks dollar-commands [--json]', description: 'List Codex App $ commands such as $DFix and $Naruto.' },
     { name: 'fast-mode', usage: 'sks fast-mode on|off|status|clear [--json]', description: 'Toggle the project-local Fast mode default used by $Fast-On, $Fast-Off, and native-agent routes.' },
     { name: 'with-local-llm', usage: 'sks with-local-llm on|off|status|set-model [--json]', description: 'Toggle the optional local Ollama worker backend used by $with-local-llm-on/$with-local-llm-off and eligible simple worker slices.' },
     { name: 'commit', usage: 'sks commit [--message "msg"] [--json]', description: 'Stage current changes, summarize them, and create a simple git commit without the full SKS pipeline.' },
@@ -681,7 +685,7 @@ export const COMMAND_CATALOG = [
     { name: 'wiki', usage: 'sks wiki coords|pack|refresh|publish|rebuild-index|validate|validate-shared|wrongness ...', description: 'Build, refresh, publish shared shards, rebuild ignored indexes, validate, and attach wrongness-memory context to RGBA/trig LLM Wiki packs with attention.use_first and attention.hydrate_first for compact recall plus source hydration.' },
     { name: 'hproof', usage: 'sks hproof check [mission-id|latest]', description: 'Evaluate the H-Proof done gate for a mission.' },
     { name: 'agent', usage: 'sks agent run|status|close|cleanup <mission-id|latest> [--agents N] [--work-items N] [--target-active-slots N] [--mock] [--apply|--dry-run] [--drain] [--stale-ms N] [--json] | sks agent rollback-patches [mission-id|latest] [--patch-entry-id id] [--dry-run|--apply] [--json]', description: 'Run, inspect, close, clean, or rollback native multi-session agent missions with agents as target active slots, work items as the route queue size, cleanup executor proof for stale runtime resources, and patch rollback proof for applied patch entries.' },
-    { name: 'team', usage: 'sks team "task" [executor:5 reviewer:6 user:1] [--work-items N] [--target-active-slots N]|log|tail|watch|lane|status|dashboard|event|message|open-zellij|attach-zellij|cleanup-zellij ...', description: 'Create and observe a native-agent-first Team mission with at least five reviewer/QA validation lanes, current-session managed Zellij lanes when available, transcript messages, and cleanup-aware follow panes.' },
+    { name: 'team', usage: 'sks team \"task\" | sks team log|tail|watch|lane|status|dashboard|event|message|open-zellij|attach-zellij|cleanup-zellij ...', description: 'Deprecated compatibility command: new tasks redirect to Naruto; observation subcommands remain for old Team missions.' },
     { name: 'reasoning', usage: 'sks reasoning ["prompt"] [--json]', description: 'Show SKS temporary reasoning-effort routing: medium for simple tasks, high for logic, xhigh for research.' },
     { name: 'gx', usage: 'sks gx init|render|validate|drift|snapshot [name]', description: 'Create and verify deterministic SVG/HTML visual context cartridges.' },
     { name: 'profile', usage: 'sks profile show|set <model>', description: 'Inspect or set the current SKS model profile metadata.' },
@@ -819,14 +823,14 @@ export function routePrompt(prompt) {
             if (looksLikeAnswerOnlyRequest(afterModifier))
                 return routeById('Answer');
             if (looksLikeCodeChangingWork(afterModifier) || looksLikeDirectWorkRequest(afterModifier))
-                return routeById('Team');
+                return routeById('Naruto');
             return routeById('MadSKS');
         }
         const route = routeByDollarCommand(command) || routeById('SKS');
         if (route?.id === 'SKS' && looksLikeTeamDefaultWork(stripDollarCommand(text)))
-            return routeById('Team');
-        if (route?.id === 'Team')
-            return route;
+            return routeById('Naruto');
+        if (route?.id === 'Team' && command === 'TEAM')
+            return routeById('Naruto');
         return route;
     }
     if (hasFromChatImgSignal(text))
@@ -843,13 +847,13 @@ export function routePrompt(prompt) {
     if (looksLikeTinyDirectFix(text))
         return routeById('DFix');
     if (looksLikeQuestionShapedDirective(text))
-        return routeById('Team');
+        return routeById('Naruto');
     if (looksLikeAnswerOnlyRequest(text))
         return routeById('Answer');
     if (/\b(SQL|Supabase|Postgres|migration|RLS|Prisma|Drizzle|Knex|database|DB|execute_sql)\b/i.test(text))
         return routeById('DB');
     if (/\b(team|multi-agent|subagent|parallel agents|agent team)\b|병렬|팀/i.test(text))
-        return routeById('Team');
+        return routeById('Naruto');
     if (looksLikeChatCaptureRequest(text) && !looksLikeAnswerOnlyRequest(text))
         return routeById('Team');
     if (/\b(qa[-\s]?loop|qaloop|e2e\s+qa|qa\s+e2e)\b/i.test(text))
@@ -863,7 +867,7 @@ export function routePrompt(prompt) {
     if (/\b(GX|vgraph|visual context|render cartridge|wiki coordinate|rgba|trig|llm wiki)\b/i.test(text))
         return routeById('GX');
     if (looksLikeTeamDefaultWork(text))
-        return routeById('Team');
+        return routeById('Naruto');
     return routeById('SKS');
 }
 export function looksLikeComputerUseFastLane(prompt = '') {
@@ -941,7 +945,7 @@ export function routeNeedsContext7(route, prompt = '') {
 export function routeRequiresSubagents(route, prompt = '') {
     if (!route)
         return false;
-    if (route.id === 'Team')
+    if (route.id === 'Team' || route.id === 'Naruto')
         return true;
     if (route.id === 'SKS')
         return looksLikeTeamDefaultWork(prompt);
@@ -983,7 +987,7 @@ export function simpleGitOnlyRouteId(prompt = '') {
 }
 export function reflectionRequiredForRoute(route) {
     const id = String(route?.id || route?.mode || route?.route || route || '').replace(/^\$/, '');
-    return /^(team|qaloop|qa-loop|ppt|imageuxreview|image-ux-review|research|autoresearch|db|database|madsks|mad-sks|gx)$/i.test(id);
+    return /^(team|naruto|shadowclone|shadow-clone|kagebunshin|kage-bunshin|qaloop|qa-loop|ppt|imageuxreview|image-ux-review|research|autoresearch|db|database|madsks|mad-sks|gx)$/i.test(id);
 }
 export function looksLikeCodeChangingWork(prompt = '') {
     const text = String(prompt || '');
@@ -1012,7 +1016,7 @@ export function subagentExecutionPolicyText(route, prompt = '') {
     }
     return [
         'Native multi-session policy: REQUIRED for code-changing or execution work in this route.',
-        'The selected SKS route itself authorizes route-owned worker/reviewer native sessions; the user does not need to separately ask for helper sessions when the default Team pipeline is active.',
+        'The selected SKS route itself authorizes route-owned worker/reviewer native sessions; the user does not need to separately ask for helper sessions when the default Naruto pipeline is active.',
         'Before editing, the parent orchestrator must visibly state the SKS route, split independent write scopes, and run worker/reviewer native sessions whenever the route can be split safely.',
         'Run workers in parallel only with disjoint ownership. The parent owns integration, verification, and final evidence.',
         'If native sessions are unavailable or the work cannot be safely split, record explicit unavailable/unsplittable native-session evidence before editing.',
@@ -1027,7 +1031,7 @@ export function routeReasoning(route, prompt = '') {
         return reasoning('xhigh', 'from_chat_img_image_work_order_analysis');
     if (/(?:^|\s)sks\s+--mad\b|(?:^|\s)--mad\b|\$MAD-SKS\b|\bmad-sks\b|\bmadsks\b/i.test(text))
         return reasoning('xhigh', 'mad_sks_or_mad_launch_default');
-    if (route?.id === 'Team')
+    if (route?.id === 'Team' || route?.id === 'Naruto')
         return teamRouteReasoning(text);
     if (route?.id === 'Research' || route?.id === 'AutoResearch')
         return reasoning('xhigh', 'research_or_experiment_route');

package/dist/core/update/update-notice.js

@@ -0,0 +1,120 @@
+import https from 'node:https';
+import os from 'node:os';
+import path from 'node:path';
+import { ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+export const SKS_UPDATE_NOTICE_SCHEMA = 'sks.update-notice.v1';
+export async function checkSksUpdateNotice(input = {}) {
+    const env = input.env || process.env;
+    const packageName = input.packageName || env.SKS_UPDATE_NOTICE_PACKAGE || 'sneakoscope';
+    const currentVersion = input.currentVersion || env.SKS_PACKAGE_VERSION || '0.0.0';
+    const ttlMs = normalizePositiveInt(env.SKS_UPDATE_NOTICE_TTL_MS, 6 * 60 * 60 * 1000);
+    const cachePath = path.join(os.homedir(), '.sneakoscope', 'cache', 'update-notice.json');
+    if (env.SKS_DISABLE_UPDATE_NOTICE === '1' || env.SKS_UPDATE_NOTICE_DISABLE === '1' || env.SKS_UPDATE_NOTICE === '0') {
+        return persistNotice(input.missionDir, {
+            schema: SKS_UPDATE_NOTICE_SCHEMA,
+            checked_at: nowIso(),
+            package_name: packageName,
+            current_version: currentVersion,
+            latest_version: null,
+            update_available: false,
+            source: 'disabled',
+            cache_ttl_ms: ttlMs,
+            message: 'SKS update notice disabled by environment.'
+        });
+    }
+    const cached = await readJson(cachePath, null);
+    if (cached?.schema === SKS_UPDATE_NOTICE_SCHEMA && Date.now() - Date.parse(cached.checked_at || '') < ttlMs) {
+        return persistNotice(input.missionDir, { ...cached, source: 'cache', cache_ttl_ms: ttlMs });
+    }
+    try {
+        const latest = await npmLatest(packageName, input.timeoutMs || normalizePositiveInt(env.SKS_UPDATE_NOTICE_TIMEOUT_MS, 1500));
+        const updateAvailable = compareVersions(latest, currentVersion) > 0;
+        const notice = {
+            schema: SKS_UPDATE_NOTICE_SCHEMA,
+            checked_at: nowIso(),
+            package_name: packageName,
+            current_version: currentVersion,
+            latest_version: latest,
+            update_available: updateAvailable,
+            source: 'npm-registry',
+            cache_ttl_ms: ttlMs,
+            message: updateAvailable
+                ? `SKS ${latest} is available; current ${currentVersion}. This notice is informational and does not block launch or release gates.`
+                : `SKS ${currentVersion} is current enough; update notice is informational.`
+        };
+        await ensureDir(path.dirname(cachePath));
+        await writeJsonAtomic(cachePath, notice).catch(() => undefined);
+        return persistNotice(input.missionDir, notice);
+    }
+    catch (err) {
+        const notice = {
+            schema: SKS_UPDATE_NOTICE_SCHEMA,
+            checked_at: nowIso(),
+            package_name: packageName,
+            current_version: currentVersion,
+            latest_version: cached?.latest_version || null,
+            update_available: false,
+            source: 'error',
+            cache_ttl_ms: ttlMs,
+            message: 'SKS update notice could not reach npm; launch continues without blocking.',
+            error: err?.message || String(err)
+        };
+        return persistNotice(input.missionDir, notice);
+    }
+}
+async function persistNotice(missionDir, notice) {
+    if (missionDir)
+        await writeJsonAtomic(path.join(missionDir, 'update-notice.json'), notice).catch(() => undefined);
+    return notice;
+}
+function npmLatest(packageName, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const req = https.request({
+            hostname: 'registry.npmjs.org',
+            path: `/${encodeURIComponent(packageName).replace(/^%40/, '@')}/latest`,
+            method: 'GET',
+            timeout: timeoutMs,
+            headers: { Accept: 'application/json' }
+        }, (res) => {
+            let body = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => {
+                try {
+                    if ((res.statusCode || 0) < 200 || (res.statusCode || 0) >= 300)
+                        throw new Error(`npm_status_${res.statusCode}`);
+                    const parsed = JSON.parse(body);
+                    if (!parsed?.version)
+                        throw new Error('npm_latest_version_missing');
+                    resolve(String(parsed.version));
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+        req.on('timeout', () => {
+            req.destroy(new Error('update_notice_timeout'));
+        });
+        req.on('error', reject);
+        req.end();
+    });
+}
+function compareVersions(left, right) {
+    const a = parseVersion(left);
+    const b = parseVersion(right);
+    for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+        const delta = (a[i] || 0) - (b[i] || 0);
+        if (delta !== 0)
+            return delta;
+    }
+    return 0;
+}
+function parseVersion(value) {
+    return String(value || '').split(/[.-]/).map((part) => Number(part)).map((part) => Number.isFinite(part) ? part : 0);
+}
+function normalizePositiveInt(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+//# sourceMappingURL=update-notice.js.map

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '2.0.13';
+export const PACKAGE_VERSION = '2.0.15';
 //# sourceMappingURL=version.js.map

package/dist/core/zellij/zellij-dashboard-renderer.js

@@ -20,6 +20,7 @@ export function buildZellijDashboardSnapshot(input) {
         local_llm: input.local_llm || { tps: 0, queue: 0 },
         gpt_final_status: input.gpt_final_status || 'not_started',
         gate_progress: input.gate_progress || 'not_release',
+        update_notice: input.update_notice || null,
         patch_verify: input.patch_verify || {
             patches: 0,
             gpt_approved: 0,
@@ -48,6 +49,7 @@ export function renderZellijDashboardText(snapshot) {
         `Local LLM TPS / queue: ${snapshot.local_llm.tps}/${snapshot.local_llm.queue}`,
         `GPT final status: ${snapshot.gpt_final_status}`,
         `Gate progress: ${snapshot.gate_progress}`,
+        `Update notice: ${snapshot.update_notice?.update_available ? `${snapshot.update_notice.latest_version || 'available'} available` : (snapshot.update_notice ? `none (${snapshot.update_notice.source})` : 'not checked')}`,
         `Patch / verify: patches ${snapshot.patch_verify.patches} · approved ${snapshot.patch_verify.gpt_approved} · conflicts ${snapshot.patch_verify.conflicts} · verify ${snapshot.patch_verify.verification_running}/${snapshot.patch_verify.verification_passed}/${snapshot.patch_verify.verification_failed}`,
         'Workers:',
         ...(snapshot.workers.length ? snapshot.workers.slice(0, 12).map((worker) => `${worker.slot_id} gen-${worker.generation_index} ${worker.role} ${worker.backend}/${worker.provider}/${worker.service_tier} WT:${worker.worktree_id || '-'} ${worker.status} ${worker.current_file || ''} ${worker.latest_heartbeat || ''}`) : ['none']),

package/dist/core/zellij/zellij-slot-column-anchor.js

@@ -1,11 +1,18 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { readZellijSlotTelemetrySnapshot } from './zellij-slot-telemetry.js';
 export function renderZellijSlotColumnAnchor(input = {}) {
     const active = nonNegativeInt(input.activeWorkers, 0);
     const visible = Math.max(1, nonNegativeInt(input.visiblePaneCap, active || 1));
     const headless = nonNegativeInt(input.headlessWorkers, 0);
     const queue = nonNegativeInt(input.queueDepth, 0);
-    const header = `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}`;
+    const done = nonNegativeInt(input.completedWorkers, 0);
+    const fail = nonNegativeInt(input.failedWorkers, 0);
+    const update = input.updateAvailableVersion ? ` · update ${trimInline(input.updateAvailableVersion, 18)} available` : '';
+    const madDb = input.madDbActive ? ' · MAD-DB ACTIVE' : '';
+    const header = done || fail
+        ? `SLOTS active ${active} · headless ${headless} · done ${done} · fail ${fail} · q ${queue}${update}${madDb}`
+        : `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}${update}${madDb}`;
     const workers = Array.isArray(input.workerRows) ? input.workerRows : [];
     if (!workers.length)
         return `${header}\nvisible slot panes stack below this anchor`;
@@ -23,6 +30,12 @@ export function renderZellijSlotColumnAnchor(input = {}) {
 export async function renderZellijSlotColumnAnchorFromArtifacts(input) {
     const root = path.resolve(input.artifactRoot);
     const missionDir = inferMissionDir(root, input.missionId);
+    const telemetry = await readZellijSlotTelemetrySnapshot(root, input.missionId).catch(() => null);
+    const updateNotice = await readJson(path.join(missionDir, 'update-notice.json'));
+    const madDb = await readJson(path.join(missionDir, 'mad-db-capability.json'));
+    if (telemetry && Object.keys(telemetry.slots || {}).length) {
+        return renderTelemetryAnchor(telemetry, updateNotice, madDb);
+    }
     const snapshot = await readJson(path.join(missionDir, 'zellij-dashboard-snapshot.json'));
     const rightColumn = await readJson(path.join(missionDir, 'zellij-right-column-state.json'));
     const swarm = await readJson(path.join(root, 'agent-native-cli-session-swarm.json'))
@@ -33,10 +46,31 @@ export async function renderZellijSlotColumnAnchorFromArtifacts(input) {
     const headlessWorkers = Number(snapshot?.headless_workers ?? workerRows.filter((row) => row.placement === 'headless' && (!row.status || row.status === 'running')).length ?? 0);
     const queueDepth = Number(snapshot?.queue_depth ?? 0);
     const anchorInput = { activeWorkers, visiblePaneCap, headlessWorkers, queueDepth, workerRows };
+    if (updateNotice?.update_available && updateNotice.latest_version)
+        anchorInput.updateAvailableVersion = String(updateNotice.latest_version);
+    if (isMadDbActive(madDb))
+        anchorInput.madDbActive = true;
     if (input.mode !== undefined)
         anchorInput.mode = input.mode;
     return renderZellijSlotColumnAnchor(anchorInput);
 }
+function renderTelemetryAnchor(snapshot, updateNotice = null, madDbCapability = null) {
+    const updatedAt = Date.parse(snapshot.updated_at || '');
+    const staleSeconds = Number.isFinite(updatedAt) ? Math.max(0, Math.round((Date.now() - updatedAt) / 1000)) : null;
+    const counts = snapshot.counts || {};
+    const active = Number(counts.running || 0) + Number(counts.verifying || 0);
+    const update = updateNotice?.update_available && updateNotice?.latest_version ? ` · update ${trimInline(String(updateNotice.latest_version), 18)} available` : '';
+    const madDb = isMadDbActive(madDbCapability) ? ' · MAD-DB ACTIVE' : '';
+    if (staleSeconds != null && staleSeconds > 10)
+        return `SLOTS telemetry stale ${staleSeconds}s · active ?${update}${madDb}`;
+    return `SLOTS active ${active} · headless ${Number(counts.headless || 0)} · done ${Number(counts.completed || 0)} · fail ${Number(counts.failed || 0)} · q ${Number(counts.queued || 0)}${update}${madDb}`;
+}
+function isMadDbActive(capability) {
+    if (!capability || capability.enabled !== true || capability.consumed === true)
+        return false;
+    const expires = Date.parse(capability.expires_at || '');
+    return Number.isFinite(expires) && expires > Date.now();
+}
 export function buildZellijSlotColumnAnchorCommand(input) {
     const args = [
         input.cliPath,

package/dist/core/zellij/zellij-slot-pane-renderer.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { readZellijSlotTelemetrySnapshot } from './zellij-slot-telemetry.js';
 export function renderZellijSlotPane(input) {
     const mode = input.mode || 'compact-slots';
     const maxLines = mode === 'compact-slots' ? 17 : mode === 'dashboard-plus-slots' ? 20 : 32;
@@ -30,6 +31,21 @@ export function renderZellijSlotPane(input) {
     return frameSlotPane(`LIVE SLOT ${input.slotId}`, rows.slice(0, Math.max(1, maxLines - 2)));
 }
 export async function renderZellijSlotPaneFromArtifacts(input) {
+    if (input.missionId && input.missionId !== 'latest') {
+        const telemetry = await tryRenderTelemetrySlotPane({
+            artifactRoot: input.artifactRoot || input.artifactDir,
+            missionId: input.missionId,
+            slotId: input.slotId,
+            generationIndex: input.generationIndex
+        });
+        if (telemetry)
+            return telemetry;
+        return [
+            `${input.slotId} gen-${Math.max(1, Math.floor(Number(input.generationIndex) || 1))}`,
+            'waiting for telemetry...',
+            `mission ${input.missionId}`
+        ].join('\n');
+    }
     const artifactDir = path.resolve(input.artifactDir);
     const result = await readJson(path.join(artifactDir, 'worker-result.json'));
     const intake = await readJson(path.join(artifactDir, 'worker-intake.json'));
@@ -128,6 +144,7 @@ export function buildZellijSlotPaneCommand(input) {
         '--slot', input.slotId,
         '--generation', String(Math.max(1, Math.floor(Number(input.generationIndex) || 1))),
         '--artifact-dir', input.artifactDir,
+        '--artifact-root', input.artifactRoot || input.artifactDir,
         '--mode', input.mode || 'compact-slots',
         ...(input.backend ? ['--backend', input.backend] : []),
         ...(input.role ? ['--role', input.role] : []),
@@ -135,6 +152,46 @@ export function buildZellijSlotPaneCommand(input) {
     ];
     return [input.nodePath || process.execPath, ...args].map(shellQuote).join(' ');
 }
+async function tryRenderTelemetrySlotPane(input) {
+    const snapshot = await readZellijSlotTelemetrySnapshot(path.resolve(input.artifactRoot), input.missionId).catch(() => null);
+    if (!snapshot || !Object.keys(snapshot.slots || {}).length)
+        return null;
+    const slot = findTelemetrySlot(snapshot, input.slotId, input.generationIndex);
+    if (!slot)
+        return null;
+    if (slot.status === 'failed') {
+        return [
+            `${slot.slot_id} gen-${slot.generation_index} · FAILED`,
+            `blocker: ${trimInline(slot.blockers[0] || 'worker_failed', 78)}`,
+            `artifact: ${trimInline(slot.artifact_paths[slot.artifact_paths.length - 1] || '-', 78)}`
+        ].join('\n');
+    }
+    if (slot.status === 'completed' || slot.status === 'drained') {
+        return [
+            `${slot.slot_id} gen-${slot.generation_index} · done`,
+            `artifacts ${slot.artifact_paths.length} · ${slot.latest_event_type === 'verification_passed' ? 'verify passed' : 'verify queued'}`,
+            'closing in 3s'
+        ].join('\n');
+    }
+    const backend = [slot.backend, slot.service_tier, slot.worktree_id].filter((value) => value && value !== 'unknown').join(' · ') || 'worker';
+    const heartbeat = slot.latest_ts ? `${Math.max(0, Math.round((Date.now() - Date.parse(slot.latest_ts)) / 1000))}s` : '?';
+    return [
+        `${slot.slot_id} gen-${slot.generation_index} · ${trimInline(slot.role || 'worker', 28)}`,
+        trimInline(backend, 78),
+        `${slot.status}: ${trimInline(slot.task_title || 'worker task', 68)}`,
+        `${formatTelemetryProgress(slot.progress)} · latest ${slot.latest_event_type} ${heartbeat}`,
+        `${slot.latest_event_type === 'patch_candidate' ? 'patch candidate' : 'patch'}: ${slot.latest_event_type === 'patch_candidate' ? 'queued' : trimInline(slot.current_file || '-', 42)}`
+    ].join('\n');
+}
+function findTelemetrySlot(snapshot, slotId, generationIndex) {
+    const generation = Math.max(1, Math.floor(Number(generationIndex) || 1));
+    return Object.values(snapshot.slots || {}).find((row) => row.slot_id === slotId && Number(row.generation_index) === generation) || null;
+}
+function formatTelemetryProgress(progress) {
+    if (!progress)
+        return 'progress ?';
+    return `progress ${progress.done}/${progress.total}${progress.label ? ` ${trimInline(progress.label, 24)}` : ''}`;
+}
 async function readJson(file) {
     try {
         return JSON.parse(await fs.promises.readFile(file, 'utf8'));

package/dist/core/zellij/zellij-slot-telemetry.js

@@ -0,0 +1,182 @@
+import path from 'node:path';
+import { appendJsonlBounded, ensureDir, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
+export const ZELLIJ_SLOT_TELEMETRY_EVENT_SCHEMA = 'sks.zellij-slot-telemetry-event.v1';
+export const ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA = 'sks.zellij-slot-telemetry-snapshot.v1';
+export function slotTelemetryEventPath(root, missionId) {
+    return path.join(inferMissionDir(root, missionId), 'zellij', 'slot-telemetry.events.jsonl');
+}
+export function slotTelemetrySnapshotPath(root, missionId) {
+    return path.join(inferMissionDir(root, missionId), 'zellij', 'slot-telemetry.snapshot.json');
+}
+export async function appendZellijSlotTelemetry(root, event) {
+    const missionId = String(event?.mission_id || '').trim();
+    if (!missionId)
+        throw new Error('mission_id required for Zellij slot telemetry');
+    const normalized = normalizeTelemetryEvent(event);
+    const file = slotTelemetryEventPath(root, missionId);
+    await ensureDir(path.dirname(file));
+    await appendJsonlBounded(file, normalized);
+    await rebuildZellijSlotTelemetrySnapshot(root, missionId);
+}
+export async function readZellijSlotTelemetrySnapshot(root, missionId) {
+    const existing = await readJson(slotTelemetrySnapshotPath(root, missionId), null);
+    if (existing?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA)
+        return existing;
+    return rebuildZellijSlotTelemetrySnapshot(root, missionId);
+}
+export async function rebuildZellijSlotTelemetrySnapshot(root, missionId) {
+    const eventsPath = slotTelemetryEventPath(root, missionId);
+    const rows = await readTelemetryEvents(eventsPath);
+    const slots = {};
+    for (const row of rows) {
+        if (row.mission_id !== missionId)
+            continue;
+        const key = slotTelemetryKey(row.slot_id || row.worker_id, row.generation_index);
+        const previous = slots[key];
+        slots[key] = mergeSlotTelemetry(previous, row);
+    }
+    const snapshot = {
+        schema: ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA,
+        mission_id: missionId,
+        updated_at: nowIso(),
+        slots,
+        counts: countSlotTelemetry(slots)
+    };
+    await writeJsonAtomic(slotTelemetrySnapshotPath(root, missionId), snapshot);
+    return snapshot;
+}
+async function readTelemetryEvents(file) {
+    const text = await readText(file, '');
+    return String(text)
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return normalizeTelemetryEvent(JSON.parse(line));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((row) => Boolean(row));
+}
+function normalizeTelemetryEvent(event) {
+    const status = normalizeStatus(event.status);
+    return {
+        schema: ZELLIJ_SLOT_TELEMETRY_EVENT_SCHEMA,
+        ts: event.ts || nowIso(),
+        mission_id: String(event.mission_id || ''),
+        slot_id: String(event.slot_id || event.worker_id || 'slot-001'),
+        generation_index: Math.max(1, Math.floor(Number(event.generation_index) || 1)),
+        worker_id: String(event.worker_id || event.slot_id || 'worker'),
+        event_type: normalizeEventType(event.event_type),
+        status,
+        ...(event.role ? { role: String(event.role) } : {}),
+        ...(event.backend ? { backend: String(event.backend) } : {}),
+        ...(event.provider ? { provider: String(event.provider) } : {}),
+        ...(event.service_tier ? { service_tier: String(event.service_tier) } : {}),
+        worktree_id: event.worktree_id == null ? null : String(event.worktree_id),
+        worktree_path: event.worktree_path == null ? null : String(event.worktree_path),
+        ...(event.task_title ? { task_title: String(event.task_title) } : {}),
+        current_file: event.current_file == null ? null : String(event.current_file),
+        ...(event.progress ? { progress: normalizeProgress(event.progress) } : {}),
+        ...(Array.isArray(event.artifact_paths) ? { artifact_paths: event.artifact_paths.map(String).filter(Boolean) } : {}),
+        ...(event.log_tail ? { log_tail: tail(event.log_tail, 1200) } : {}),
+        ...(Array.isArray(event.blockers) ? { blockers: event.blockers.map(String).filter(Boolean) } : {})
+    };
+}
+function mergeSlotTelemetry(previous, event) {
+    return {
+        slot_id: event.slot_id,
+        generation_index: event.generation_index,
+        worker_id: event.worker_id,
+        status: event.status,
+        role: event.role || previous?.role || 'worker',
+        backend: event.backend || previous?.backend || 'unknown',
+        provider: event.provider || previous?.provider || 'unknown',
+        service_tier: event.service_tier || previous?.service_tier || 'unknown',
+        worktree_id: event.worktree_id ?? previous?.worktree_id ?? null,
+        worktree_path: event.worktree_path ?? previous?.worktree_path ?? null,
+        task_title: event.task_title || previous?.task_title || 'waiting for task',
+        current_file: event.current_file ?? previous?.current_file ?? null,
+        latest_event_type: event.event_type,
+        latest_ts: event.ts,
+        progress: event.progress || previous?.progress || null,
+        artifact_paths: unique([...(previous?.artifact_paths || []), ...(event.artifact_paths || [])]),
+        blockers: unique([...(previous?.blockers || []), ...(event.blockers || [])]),
+        log_tail: event.log_tail || previous?.log_tail || ''
+    };
+}
+function countSlotTelemetry(slots) {
+    const counts = { queued: 0, running: 0, verifying: 0, completed: 0, failed: 0, headless: 0 };
+    for (const row of Object.values(slots)) {
+        const status = normalizeStatus(row.status);
+        if (status === 'queued' || status === 'launching')
+            counts.queued += 1;
+        else if (status === 'running')
+            counts.running += 1;
+        else if (status === 'verifying')
+            counts.verifying += 1;
+        else if (status === 'completed' || status === 'drained')
+            counts.completed += 1;
+        else if (status === 'failed')
+            counts.failed += 1;
+        else if (status === 'headless')
+            counts.headless += 1;
+    }
+    return counts;
+}
+function normalizeStatus(value) {
+    const text = String(value || '').toLowerCase();
+    if (text === 'closed' || text === 'done' || text === 'passed')
+        return 'completed';
+    if (text === 'blocked' || text === 'error')
+        return 'failed';
+    if (text === 'coding')
+        return 'running';
+    if (['queued', 'launching', 'running', 'verifying', 'completed', 'failed', 'headless', 'drained'].includes(text))
+        return text;
+    return 'running';
+}
+function normalizeEventType(value) {
+    const text = String(value || '');
+    const allowed = new Set([
+        'slot_reserved', 'worker_spawned', 'heartbeat', 'task_started', 'task_progress',
+        'artifact_written', 'patch_candidate', 'verification_started', 'verification_passed',
+        'verification_failed', 'worker_completed', 'worker_failed', 'headless_overflow'
+    ]);
+    return allowed.has(text) ? text : 'heartbeat';
+}
+function normalizeProgress(value) {
+    return {
+        done: Math.max(0, Math.floor(Number(value?.done) || 0)),
+        total: Math.max(0, Math.floor(Number(value?.total) || 0)),
+        label: String(value?.label || 'progress')
+    };
+}
+function unique(values) {
+    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
+}
+function slotTelemetryKey(slotId, generationIndex) {
+    const slot = String(slotId || 'slot-001').trim() || 'slot-001';
+    const generation = Math.max(1, Math.floor(Number(generationIndex) || 1));
+    return `${slot}:g${generation}`;
+}
+function tail(value, max) {
+    const text = String(value || '').replace(/\s+$/g, '');
+    return text.length > max ? text.slice(-max) : text;
+}
+function inferMissionDir(root, missionId) {
+    const resolved = path.resolve(root);
+    if (path.basename(resolved) === 'agents' && path.basename(path.dirname(resolved)) === missionId)
+        return path.dirname(resolved);
+    if (path.basename(resolved) === missionId && path.basename(path.dirname(resolved)) === 'missions')
+        return resolved;
+    const marker = `${path.sep}.sneakoscope${path.sep}missions${path.sep}${missionId}${path.sep}`;
+    const index = resolved.indexOf(marker);
+    if (index >= 0)
+        return resolved.slice(0, index + marker.length - 1);
+    return path.join(resolved, '.sneakoscope', 'missions', missionId);
+}
+//# sourceMappingURL=zellij-slot-telemetry.js.map

package/dist/scripts/release-gate-dag-runner.js

@@ -6,15 +6,20 @@ const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '.
 const args = process.argv.slice(2);
 const presetIndex = args.indexOf('--preset');
 const preset = presetIndex >= 0 ? args[presetIndex + 1] : 'release';
+const changedSinceIndex = args.indexOf('--changed-since');
+const changedSince = changedSinceIndex >= 0 ? (args[changedSinceIndex + 1] || null) : null;
 const result = await runReleaseGateDag({
     root,
     ...(preset === undefined ? {} : { preset }),
+    changedSince,
+    full: args.includes('--full'),
     explain: args.includes('--explain'),
     noCache: args.includes('--no-cache'),
     failFast: args.includes('--fail-fast')
 });
 console.log(`SKS Release DAG
   gates: ${result.total_gates} total, ${result.selected_gates} selected, ${result.cached} cached
+  affected: ${result.affected_selection?.mode || 'full'} selected=${result.selected_gate_ids.length} skipped=${result.skipped_by_affected.length}
   concurrency: ${result.budget_summary}
   peak_running: ${result.peak_running}
   completed: ${result.completed} pass, ${result.failed} fail