sneakoscope 2.0.14 → 2.0.15

package/README.md

@@ -16,7 +16,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **2.0.14** is the public-ready research runtime stabilization release. It upgrades Research from a quality-contract package into a real stage-aware runtime with parallel source shards, source-ledger merge, claim matrix builder, repository-aware implementation blueprint, Codex/GPT final reviewer, and blackbox gates while preserving the 2.0.13 research artifact contract.
+SKS **2.0.15** is the ultra-stabilized Research synthesis release. It keeps the 2.0.14 stage-aware runtime, then hardens final synthesis so non-mock Research uses an evidence-bound Codex/GPT writer, rejects repeated or template-like reports, records source/claim density, and produces handoffs that Team or Naruto can consume directly.
 
 What changed:
 
@@ -44,6 +44,9 @@ What changed:
 - Zellij proof now links `pane_id`, `slot_id`, `generation_index`, `session_id`, `sdk_thread_id`, provider, and `service_tier`.
 - Production runtime scripts are TypeScript source under `src/scripts` and build to `dist/scripts`; Python remains optional diagnostics under `pytools`.
 - Release gates include `codex-control:*`, `ultra-router:*`, `codex-sdk:*`, Codex App Fast UI preservation, provider badges, Zellij spawn-on-demand, slot/pane binding, release truth, and real smoke checks.
+- Research synthesis is now evidence-bound in non-mock runs; deterministic report generation is mock/fallback only.
+- Research quality checks reject repeated paragraphs, template-like prose, low source density, low claim density, and thin implementation sections.
+- Research handoffs now include context, key claims, evidence summary, blueprint sections, parallel work items, acceptance tests, rollback, and source appendix for `$Team` or `$Naruto`.
 
 Quick checks:
 
@@ -466,7 +469,7 @@ sks code-structure scan --json
 
 `sks research` prepares a named genius-lens agent council, requires every agent to run at `xhigh`, records one literal `Eureka!` idea per agent, runs an evidence-bound debate, and creates `research-source-skill.md` as a route-local source collection skill before synthesis. Research is not a code-change route: real runs may write only their own mission artifacts under `.sneakoscope/missions/<id>/`, and source/package/docs/config mutations block the run with `research-code-mutation-blocker.json`. The required Research persona lenses are Einstein Agent, Feynman Agent, Turing Agent, von Neumann Agent, and Skeptic Agent; they are cognitive roles, not impersonations, and `agent-ledger.json` must include `display_name`, `persona`, `persona_boundary`, `reasoning_effort`, falsifiers, cheap probes, and `challenge_or_response`. Normal Research is not a fixed three-cycle flow: it repeats source gathering, Eureka ideas, debate, falsification, and synthesis pressure until every agent records final agreement, or pauses at the explicit max-cycle safety cap with an unpassed gate. `debate-ledger.json` must include `consensus_iterations`, `unanimous_consensus`, and per-agent agreements; `research-gate.json` cannot pass until unanimous consensus is true for all agents. Normal Research is intentionally allowed to take one or two hours when the problem needs it; `--mock` is only for selftests or dry harness checks, and a real run blocks with `research-blocker.json` instead of silently substituting mock output when the Codex execution path is unavailable. The source layer contract separates latest papers, official/government or leading-institution sources, standards/primary docs, current news such as BBC/CNN/GDELT-style sources, public discourse such as X/Reddit, developer/practitioner knowledge such as Stack Overflow/GitHub, traditional background sources, and counterevidence/fact-checking; `source-ledger.json` must record layer coverage, source quality, blockers, citations, and cross-layer triangulation. Context7 is optional for `$Research` and only becomes relevant when the research topic specifically depends on package, API, framework, or SDK documentation. Research runs require `research-report.md`, `research-paper.md`, `genius-opinion-summary.md`, `research-source-skill.md`, `source-ledger.json`, `agent-ledger.json`, `debate-ledger.json`, `novelty-ledger.json`, `falsification-ledger.json`, and `research-gate.json` so they stay source-backed, adversarially checked, falsifiable, paper-ready, and clear about every agent lens opinion. `research status` reports source entries, source-layer coverage, triangulation checks, counterevidence, xhigh agent count, Eureka moments, debate exchanges, consensus iterations, unanimous consensus, paper presence/sections, genius-opinion summary coverage, agent findings, and falsification cases alongside the gate.
 
-In 2.0.14, Research also writes a quality contract and handoff package: `research-quality-contract.json`, parallel `research/cycle-N/source-shards/*.json`, `source-ledger.json`, `claim-evidence-matrix.json`, `source-quality-report.json`, `implementation-blueprint.json`/`.md`, `team-handoff-goal.md`, `experiment-plan.json`/`.md`, `replication-pack.json`, `research-work-graph.json`, `research-final-review.static.json`, `research-final-review.codex.json`, and `research-final-review.json`. The default gate requires 12 total sources, 5 source layers, 2 counterevidence sources, 8 key claims, 6 triangulated claims, 8 blueprint sections, 4 falsification cases, 5 experiment steps, a 2200-word report, and approved static plus Codex/GPT final review before `research-gate.json` can pass. See `docs/research-pipeline.md`, `docs/research-artifacts.md`, and `docs/research-implementation-handoff.md`.
+In 2.0.15, Research also writes a quality contract and handoff package: `research-quality-contract.json`, parallel `research/cycle-N/source-shards/*.json`, `source-ledger.json`, `claim-evidence-matrix.json`, `source-quality-report.json`, `research-synthesis-output.json`, `implementation-blueprint.json`/`.md`, `team-handoff-goal.md`, `experiment-plan.json`/`.md`, `replication-pack.json`, `research-work-graph.json`, `research-final-review.static.json`, `research-final-review.codex.json`, and `research-final-review.json`. The default gate requires 12 total sources, 5 source layers, 2 counterevidence sources, 8 key claims, 6 triangulated claims, 8 blueprint sections, 4 falsification cases, 5 experiment steps, a 2200-word report, approved static plus Codex/GPT final review, and anti-template/source-density report quality before `research-gate.json` can pass. See `docs/research-pipeline.md`, `docs/research-artifacts.md`, and `docs/research-implementation-handoff.md`.
 
 `sks recallpulse` is the 0.8.0 report-only RecallPulse utility. It writes `recallpulse-decision.json`, `mission-status-ledger.json`, `route-proof-capsule.json`, `evidence-envelope.json`, `recallpulse-governance-report.json`, `recallpulse-task-goal-ledger.json`, and `recallpulse-eval-report.json` for the current mission. RecallPulse does not replace route gates, Honest Mode, DB safety, imagegen evidence, or TriWiki validation; it records cache hits, hydration needs, duplicate suppression, route-governance risks, and final-summary-ready durable status so later releases can promote only measured improvements. Checklist updates are sequential: every `Txxx` row is treated as a child `$Goal` checkpoint, and `sks recallpulse checklist ... --task T001 --apply` refuses out-of-order checks unless explicitly overridden.
 
@@ -756,7 +759,7 @@ npm run release:check
 npm run publish:dry
 ```
 
-`release:check` runs the current 1.21.x release-closure DAG, writes a source digest stamp under `.sneakoscope/reports/`, then refreshes release readiness so publish commands can verify the same stamp. The DAG preserves the 1.18 baseline gates and adds Codex 0.136 compatibility, inherited Codex 0.135/0.134 runner truth, patch swarm runtime truth, transaction journaling, serial conflict rebase, strict strategy-to-patch proof, rollback command proof, Native CLI Session Swarm 5/10/20-process proof, Real Worker Backend Router proof, Codex child overlap proof, model-authored patch-envelope separation, Zellij layout/pane/screen/socket-dir proof, no-subagent-scaling proof, Fast mode default/worker/Codex/MAD propagation proof, Appshots attachment provenance, MCP runtime overlap evidence, task graph expansion, schema-bound follow-up work, actual Agent/Team/Research/QA route blackboxes, scheduler proof hardening, Source Intelligence propagation, and Goal mode propagation checks. Broader live gates remain explicit scripts such as `release:real-check`; real Codex patch smoke, real Codex parallel worker proof, and real Zellij proof are optional unless their `SKS_REQUIRE_REAL_*` or `SKS_REQUIRE_ZELLIJ=1` environment variables are set. Generate the human-readable registry with `sks features inventory --write-docs`. Plain `npm publish` uses the `latest` dist-tag. npm's `prepublishOnly` verifies the fresh release stamp instead of rerunning the full gate, and `prepack` only rebuilds `dist`; publish no longer repeats the expensive release suite during packaging. `npm run publish:dry` remains the explicit dry-run helper.
+`release:check` runs the change-aware affected release gate for ordinary local checks. Publish readiness uses `release:check:full`, which runs the full release DAG and writes a source digest stamp under `.sneakoscope/reports/` so publish commands can verify the same source/dist state. The DAG preserves the 1.18 baseline gates and adds Codex 0.136 compatibility, inherited Codex 0.135/0.134 runner truth, patch swarm runtime truth, transaction journaling, serial conflict rebase, strict strategy-to-patch proof, rollback command proof, Native CLI Session Swarm 5/10/20-process proof, Real Worker Backend Router proof, Codex child overlap proof, model-authored patch-envelope separation, Zellij layout/pane/screen/socket-dir proof, no-subagent-scaling proof, Fast mode default/worker/Codex/MAD propagation proof, Appshots attachment provenance, MCP runtime overlap evidence, task graph expansion, schema-bound follow-up work, actual Agent/Team/Research/QA route blackboxes, scheduler proof hardening, Source Intelligence propagation, Goal mode propagation checks, slot telemetry, update notice, MAD-DB, and Naruto SSOT gates. Broader live gates remain explicit scripts such as `release:real-check`; real Codex patch smoke, real Codex parallel worker proof, and real Zellij proof are optional unless their `SKS_REQUIRE_REAL_*` or `SKS_REQUIRE_ZELLIJ=1` environment variables are set. Generate the human-readable registry with `sks features inventory --write-docs`. Plain `npm publish` uses the `latest` dist-tag. npm's `prepublishOnly` and `npm run publish:dry` both run `release:check:full`, verify the fresh stamp, and then run provenance/registry checks before the real or dry-run publish step.
 
 Version bumps are manual. Run `sks versioning bump` only when preparing release metadata; SKS will not create `.git/hooks/pre-commit` or auto-bump during ordinary commits.
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "2.0.14"
+version = "2.0.15"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "2.0.14"
+version = "2.0.15"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 2.0.14"),
+        Some("--version") => println!("sks-rs 2.0.15"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "2.0.14",
-  "source_digest": "e559602363886e06dc0d079905dacbaddcadccd0617447573f90240aa9b8f2f4",
-  "source_file_count": 2104,
-  "built_at_source_time": 1780852294757
+  "package_version": "2.0.15",
+  "source_digest": "18f7432c59dd0bbd8090697c2cd4e0c4681d05923e3086f4a96cdc4e0b420280",
+  "source_file_count": 2160,
+  "built_at_source_time": 1780893056447
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '2.0.14';
+const FAST_PACKAGE_VERSION = '2.0.15';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/cli/command-registry.js

@@ -109,6 +109,7 @@ export const COMMANDS = {
     zellij: entry('beta', 'Inspect Zellij runtime status and explain repair (no auto-install)', 'dist/commands/zellij.js', directCommand(() => import('../commands/zellij.js'), 'dist/commands/zellij.js')),
     mad: entry('beta', 'MAD-SKS Zellij permission launcher', 'dist/commands/mad-sks.js', directCommand(() => import('../commands/mad-sks.js'), 'dist/commands/mad-sks.js')),
     'mad-sks': entry('beta', 'MAD-SKS scoped permission modifier', 'dist/commands/mad-sks.js', directCommand(() => import('../commands/mad-sks.js'), 'dist/commands/mad-sks.js')),
+    'mad-db': entry('beta', 'Create or inspect one-cycle Mad-DB break-glass capability tokens', 'dist/commands/mad-db.js', directCommand(() => import('../commands/mad-db.js'), 'dist/commands/mad-db.js')),
     'auto-review': entry('beta', 'Manage auto-review profile', 'dist/commands/auto-review.js', directCommand(() => import('../commands/auto-review.js'), 'dist/commands/auto-review.js')),
     autoreview: entry('beta', 'Alias for auto-review', 'dist/commands/auto-review.js', directCommand(() => import('../commands/auto-review.js'), 'dist/commands/auto-review.js')),
     'dollar-commands': entry('stable', 'List Codex App dollar commands', 'dist/core/commands/basic-cli.js', basicArgs('dollarCommandsCommand')),

package/dist/commands/mad-db.js

@@ -0,0 +1,5 @@
+import { madDbCommand } from '../core/commands/mad-db-command.js';
+export async function run(_command = 'mad-db', args = []) {
+    return madDbCommand(args);
+}
+//# sourceMappingURL=mad-db.js.map

package/dist/commands/zellij-slot-pane.js

@@ -1,6 +1,8 @@
 import { renderZellijSlotPaneFromArtifacts } from '../core/zellij/zellij-slot-pane-renderer.js';
 export async function run(_command = 'zellij-slot-pane', args = []) {
     const artifactDir = readOption(args, '--artifact-dir', process.cwd()) || process.cwd();
+    const artifactRoot = readOption(args, '--artifact-root', artifactDir) || artifactDir;
+    const missionId = readOption(args, '--mission', '') || '';
     const slotId = readOption(args, '--slot', 'slot-001') || 'slot-001';
     const generationIndex = Number(readOption(args, '--generation', '1') || 1);
     const backend = readOption(args, '--backend', null);
@@ -9,7 +11,7 @@ export async function run(_command = 'zellij-slot-pane', args = []) {
     const watch = hasFlag(args, '--watch');
     const intervalMs = Math.max(250, Number(readOption(args, '--interval-ms', '1000') || 1000));
     for (;;) {
-        const text = await renderZellijSlotPaneFromArtifacts({ artifactDir, slotId, generationIndex, backend, role, mode });
+        const text = await renderZellijSlotPaneFromArtifacts({ artifactDir, artifactRoot, missionId, slotId, generationIndex, backend, role, mode });
         process.stdout.write('\x1Bc' + text + '\n');
         if (!watch)
             break;

package/dist/core/agents/agent-plan.js

@@ -1,6 +1,7 @@
 import { AGENT_INTAKE_STAGE_ID, DEFAULT_AGENT_COUNT } from './agent-schema.js';
 const AGENT_REQUIRED_ROUTE_KEYS = new Set([
-    'team', '$team', 'research', '$research', 'autoresearch', '$autoresearch', 'qa-loop', '$qa-loop', 'review', '$review', 'release-review', '$release-review'
+    'team', '$team', 'naruto', '$naruto', 'shadowclone', '$shadowclone', 'shadow-clone', '$shadow-clone', 'kagebunshin', '$kagebunshin', 'kage-bunshin', '$kage-bunshin',
+    'research', '$research', 'autoresearch', '$autoresearch', 'qa-loop', '$qa-loop', 'review', '$review', 'release-review', '$release-review'
 ]);
 function routeKey(route) {
     return String(route?.id || route?.command || route?.name || route || '').trim().toLowerCase();
@@ -14,7 +15,7 @@ export function routeRequiresAgentIntake(route, input = {}) {
     if (AGENT_REQUIRED_ROUTE_KEYS.has(key))
         return true;
     const task = String(input.task || '');
-    return /\$(Team|Research|AutoResearch|QA-LOOP|Review|Release-Review)\b/i.test(task);
+    return /\$(Team|Naruto|ShadowClone|Kagebunshin|Research|AutoResearch|QA-LOOP|Review|Release-Review)\b/i.test(task);
 }
 export function normalizeAgentPolicy(route, task = '', input = {}) {
     const required = routeRequiresAgentIntake(route, { task, ...(typeof input === 'object' && input ? input : {}) });

package/dist/core/agents/native-cli-session-swarm.js

@@ -9,6 +9,7 @@ import { closeWorkerInRightColumn, recordHeadlessWorkerInRightColumn } from '../
 import { resolveProviderContext } from '../provider/provider-context.js';
 import { buildZellijSlotPaneCommand } from '../zellij/zellij-slot-pane-renderer.js';
 import { resolveZellijUiMode } from '../zellij/zellij-ui-mode.js';
+import { appendZellijSlotTelemetry } from '../zellij/zellij-slot-telemetry.js';
 export const NATIVE_CLI_SESSION_SWARM_SCHEMA = 'sks.agent-native-cli-session-swarm.v1';
 export function createNativeCliSessionSwarmRecorder(root, input) {
     return new NativeCliSessionSwarmRecorder(root, input);
@@ -112,6 +113,12 @@ class NativeCliSessionSwarmRecorder {
             ? this.reserveVisibleZellijPane(ctx.opts, String(ctx.agent.session_id || ctx.agent.id || `${Date.now()}:${Math.random()}`))
             : null;
         const useZellijPane = Boolean(zellijReservation);
+        await this.telemetry(ctx, {
+            eventType: 'slot_reserved',
+            status: placement === 'zellij-pane' && !useZellijPane ? 'headless' : 'queued',
+            artifacts: [intakeRel, heartbeatRel, resultRel],
+            logTail: `placement=${placement}`
+        });
         if (useZellijPane) {
             stdout.end();
             stderr.end();
@@ -130,6 +137,12 @@ class NativeCliSessionSwarmRecorder {
         if (placement === 'zellij-pane' && ctx.opts.zellijPaneWorker !== false && !useZellijPane) {
             record.worker_placement = 'headless';
             record.headless_reason = `visible_pane_cap:${this.zellijVisiblePaneCap(ctx.opts)}`;
+            await this.telemetry(ctx, {
+                eventType: 'headless_overflow',
+                status: 'headless',
+                artifacts: [intakeRel, heartbeatRel, resultRel],
+                logTail: record.headless_reason
+            });
             await recordHeadlessWorkerInRightColumn({
                 root: this.root,
                 projectRoot: ctx.opts.projectRoot || this.input.projectRoot || ctx.opts.cwd,
@@ -162,6 +175,12 @@ class NativeCliSessionSwarmRecorder {
         record.pid = child.pid || null;
         record.process_id = child.pid || null;
         record.status = 'running';
+        await this.telemetry(ctx, {
+            eventType: 'worker_spawned',
+            status: 'launching',
+            artifacts: [intakeRel, heartbeatRel, resultRel, stdoutRel, stderrRel],
+            logTail: `pid=${child.pid || 'unknown'}`
+        });
         if (child.pid)
             this.active.add(child.pid);
         this.maxObserved = Math.max(this.maxObserved, this.active.size);
@@ -194,6 +213,13 @@ class NativeCliSessionSwarmRecorder {
         const parsed = await readJson(path.join(this.root, resultRel), null).catch(() => null);
         if (!parsed) {
             record.blockers = ['native_cli_worker_result_missing'];
+            await this.telemetry(ctx, {
+                eventType: 'worker_failed',
+                status: 'failed',
+                artifacts: [stdoutRel, stderrRel],
+                blockers: record.blockers,
+                logTail: 'Native CLI worker result missing.'
+            });
             await this.record(record);
             return validateAgentWorkerResult({
                 mission_id: this.input.missionId,
@@ -218,6 +244,13 @@ class NativeCliSessionSwarmRecorder {
         });
         record.status = result.status === 'done' ? 'closed' : result.status;
         record.blockers = result.blockers || [];
+        await this.telemetry(ctx, {
+            eventType: result.status === 'done' ? 'worker_completed' : 'worker_failed',
+            status: result.status === 'done' ? 'completed' : 'failed',
+            artifacts: result.artifacts || [],
+            blockers: result.blockers || [],
+            logTail: result.summary || ''
+        });
         await this.record(record);
         return result;
     }
@@ -250,6 +283,12 @@ class NativeCliSessionSwarmRecorder {
             SKS_ZELLIJ_SESSION_NAME: sessionName
         };
         const role = String(input.ctx.agent.naruto_role || input.ctx.agent.role || input.ctx.agent.persona_id || 'worker');
+        await this.telemetry(input.ctx, {
+            eventType: 'slot_reserved',
+            status: 'queued',
+            artifacts: [path.join(input.workerDirRel, 'worker-intake.json'), input.heartbeatRel, input.resultRel],
+            logTail: `zellij=${sessionName}`
+        });
         const workerCommand = uiMode === 'full-debug'
             ? buildPaneWorkerCommand({
                 args: input.args,
@@ -346,11 +385,25 @@ class NativeCliSessionSwarmRecorder {
         input.record.slot_visualization = uiMode === 'full-debug' ? 'worker-command-pane' : 'zellij-slot-pane-renderer';
         input.record.status = launchBlockers.length ? 'failed' : 'running';
         input.record.blockers = launchBlockers;
+        await this.telemetry(input.ctx, {
+            eventType: 'worker_spawned',
+            status: launchBlockers.length ? 'failed' : 'launching',
+            artifacts: [input.resultRel, input.heartbeatRel, input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane.json')],
+            blockers: launchBlockers,
+            logTail: paneRecord.pane_title || ''
+        });
         await this.record(input.record);
         if (launchBlockers.length) {
             this.active.delete(activeToken);
             input.record.closed_at = nowIso();
             input.record.status = 'failed';
+            await this.telemetry(input.ctx, {
+                eventType: 'worker_failed',
+                status: 'failed',
+                artifacts: [input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane.json')],
+                blockers: launchBlockers,
+                logTail: 'Zellij worker pane launch failed.'
+            });
             await this.record(input.record);
             return validateAgentWorkerResult({
                 mission_id: this.input.missionId,
@@ -384,6 +437,12 @@ class NativeCliSessionSwarmRecorder {
             await this.record(input.record);
         }
         await waitForWorkerHeartbeat(path.join(this.root, input.heartbeatRel), Number(process.env.SKS_ZELLIJ_WORKER_HEARTBEAT_TIMEOUT_MS || 30000));
+        await this.telemetry(input.ctx, {
+            eventType: 'heartbeat',
+            status: 'running',
+            artifacts: [input.heartbeatRel],
+            logTail: await tailFile(path.join(this.root, input.heartbeatRel), 600)
+        });
         await appendJsonl(path.join(this.root, input.workerDirRel, 'zellij-worker-pane-events.jsonl'), {
             schema: 'sks.zellij-worker-pane-event.v1',
             ts: nowIso(),
@@ -426,6 +485,12 @@ class NativeCliSessionSwarmRecorder {
                 session_id: input.ctx.agent.session_id,
                 result_path: input.resultRel
             });
+            await this.telemetry(input.ctx, {
+                eventType: 'artifact_written',
+                status: 'verifying',
+                artifacts: [input.resultRel],
+                logTail: parsed.summary || 'worker result written'
+            });
         }
         input.record.pid = Number(workerProcessReport?.pid || processRun?.pid) || null;
         input.record.process_id = input.record.pid;
@@ -458,6 +523,13 @@ class NativeCliSessionSwarmRecorder {
         input.record.zellij_worker_pane_closed_at = paneRecord.closed_at;
         await this.record(input.record);
         if (!parsed) {
+            await this.telemetry(input.ctx, {
+                eventType: 'worker_failed',
+                status: 'failed',
+                artifacts: [input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane.json')],
+                blockers: input.record.blockers,
+                logTail: 'Zellij pane worker result timed out.'
+            });
             return validateAgentWorkerResult({
                 mission_id: this.input.missionId,
                 agent_id: input.ctx.agent.id,
@@ -475,6 +547,13 @@ class NativeCliSessionSwarmRecorder {
                 goal_mode_ref: input.ctx.agent.goal_mode_ref || null
             });
         }
+        await this.telemetry(input.ctx, {
+            eventType: parsed.status === 'done' ? 'worker_completed' : 'worker_failed',
+            status: parsed.status === 'done' ? 'completed' : 'failed',
+            artifacts: [...new Set([...(Array.isArray(parsed.artifacts) ? parsed.artifacts : []), input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane.json')])],
+            blockers: input.record.blockers,
+            logTail: parsed.summary || ''
+        });
         return validateAgentWorkerResult({
             ...parsed,
             blockers: input.record.blockers,
@@ -493,6 +572,28 @@ class NativeCliSessionSwarmRecorder {
             this.records.push(record);
         await this.persist();
     }
+    async telemetry(ctx, input) {
+        await appendZellijSlotTelemetry(this.root, {
+            schema: 'sks.zellij-slot-telemetry-event.v1',
+            ts: nowIso(),
+            mission_id: this.input.missionId,
+            slot_id: String(ctx.agent?.slot_id || ctx.agent?.id || 'slot-001'),
+            generation_index: Number(ctx.agent?.generation_index || 1),
+            worker_id: String(ctx.agent?.id || ctx.agent?.slot_id || 'worker'),
+            event_type: input.eventType,
+            status: input.status,
+            role: String(ctx.agent?.naruto_role || ctx.agent?.role || ctx.agent?.persona_id || ctx.agent?.id || 'worker'),
+            backend: this.input.backend,
+            service_tier: this.input.fastModePolicy.service_tier,
+            worktree_id: ctx.agent?.worktree?.id || ctx.slice?.worktree?.id || null,
+            worktree_path: ctx.agent?.worktree?.path || ctx.slice?.worktree?.path || null,
+            task_title: String(ctx.slice?.description || ctx.slice?.title || ctx.slice?.id || 'worker task'),
+            current_file: firstString([ctx.slice?.write_paths?.[0], ctx.slice?.readonly_paths?.[0], ctx.slice?.input_files?.[0]]) || null,
+            artifact_paths: input.artifacts || [],
+            log_tail: input.logTail || '',
+            blockers: input.blockers || []
+        }).catch(() => undefined);
+    }
     async persist() {
         this.writeLock = this.writeLock.catch(() => undefined).then(async () => {
             await writeJsonAtomic(path.join(this.root, 'agent-native-cli-session-swarm.json'), this.summary());
@@ -656,6 +757,23 @@ function normalizeWorkerWorktree(value) {
         main_repo_root: value?.main_repo_root == null ? null : String(value.main_repo_root)
     };
 }
+function firstString(values) {
+    for (const value of values) {
+        const text = String(value || '').trim();
+        if (text)
+            return text;
+    }
+    return null;
+}
+async function tailFile(file, max) {
+    try {
+        const text = await fs.promises.readFile(file, 'utf8');
+        return text.length > max ? text.slice(-max) : text;
+    }
+    catch {
+        return '';
+    }
+}
 async function waitForChildExit(child, exitPromise, timeoutMs) {
     let timer = null;
     const timeout = new Promise((resolve) => {

package/dist/core/agents/native-cli-worker.js

@@ -4,6 +4,7 @@ import { scanAgentTextForRecursion } from './agent-recursion-guard.js';
 import { validateAgentWorkerResult } from './agent-worker-pipeline.js';
 import { resolveFastModePolicy } from './fast-mode-policy.js';
 import { runNativeWorkerBackendRouter } from './native-worker-backend-router.js';
+import { appendZellijSlotTelemetry } from '../zellij/zellij-slot-telemetry.js';
 export const NATIVE_CLI_WORKER_SCHEMA = 'sks.native-cli-worker.v1';
 export async function runNativeCliWorkerFromArgs(args = []) {
     const parsed = parseNativeCliWorkerArgs(args);
@@ -85,6 +86,14 @@ export async function runNativeCliWorker(input = {}) {
         strategy_refs: slice.strategy_refs || intake.strategy_refs || null,
         no_recursive_orchestrator_guard: guard.ok
     });
+    await workerTelemetry(agentRoot, intake, agent, slice, {
+        eventType: 'task_started',
+        status: 'running',
+        backend,
+        serviceTier: policy.service_tier,
+        artifacts: [path.join(workerDirRel, 'worker-intake.json'), heartbeatRel],
+        logTail: String(slice.description || slice.title || slice.id || 'worker task started')
+    });
     await appendJsonl(path.resolve(agentRoot, heartbeatRel), {
         schema: 'sks.native-cli-worker-heartbeat.v1',
         ts: nowIso(),
@@ -96,6 +105,14 @@ export async function runNativeCliWorker(input = {}) {
         fast_mode: policy.fast_mode,
         service_tier: policy.service_tier
     });
+    await workerTelemetry(agentRoot, intake, agent, slice, {
+        eventType: 'heartbeat',
+        status: 'running',
+        backend,
+        serviceTier: policy.service_tier,
+        artifacts: [heartbeatRel],
+        logTail: 'worker heartbeat started'
+    });
     await writeJsonAtomic(path.join(workerDir, 'worker-fast-mode.json'), {
         schema: 'sks.native-cli-worker-fast-mode.v1',
         generated_at: nowIso(),
@@ -131,6 +148,14 @@ export async function runNativeCliWorker(input = {}) {
             proof_level: routed.report.proof_level,
             envelopes: patchEnvelopes
         });
+        await workerTelemetry(agentRoot, intake, agent, slice, {
+            eventType: 'patch_candidate',
+            status: 'running',
+            backend,
+            serviceTier: policy.service_tier,
+            artifacts: [patchRel],
+            logTail: `patch envelopes ${patchEnvelopes.length}`
+        });
     }
     else {
         noPatchReason = {
@@ -145,6 +170,15 @@ export async function runNativeCliWorker(input = {}) {
             blockers: Array.isArray(slice.write_paths) && slice.write_paths.length && backend !== 'fake' ? ['write_capable_no_patch_envelope'] : []
         };
         await writeJsonAtomic(path.join(workerDir, 'worker-no-patch-reason.json'), noPatchReason);
+        await workerTelemetry(agentRoot, intake, agent, slice, {
+            eventType: 'artifact_written',
+            status: 'running',
+            backend,
+            serviceTier: policy.service_tier,
+            artifacts: [path.join(workerDirRel, 'worker-no-patch-reason.json')],
+            blockers: noPatchReason.blockers || [],
+            logTail: noPatchReason.reason
+        });
     }
     const minRuntimeMs = Number(intake.min_runtime_ms || input.minRuntimeMs || 0);
     if (Number.isFinite(minRuntimeMs) && minRuntimeMs > 0)
@@ -226,6 +260,15 @@ export async function runNativeCliWorker(input = {}) {
         recursion_guard: { ok: guard.ok, violations: guard.violations }
     });
     await writeJsonAtomic(path.resolve(agentRoot, resultRel), result);
+    await workerTelemetry(agentRoot, intake, agent, slice, {
+        eventType: result.status === 'done' ? 'worker_completed' : 'worker_failed',
+        status: result.status === 'done' ? 'completed' : 'failed',
+        backend,
+        serviceTier: policy.service_tier,
+        artifacts: result.artifacts || [],
+        blockers: result.blockers || [],
+        logTail: result.summary || ''
+    });
     await writeJsonAtomic(path.join(workerDir, 'worker-session-proof.json'), {
         schema: 'sks.native-cli-worker-session-proof.v1',
         generated_at: nowIso(),
@@ -260,6 +303,15 @@ export async function runNativeCliWorker(input = {}) {
         session_id: agent.session_id,
         status: result.status
     });
+    await workerTelemetry(agentRoot, intake, agent, slice, {
+        eventType: 'heartbeat',
+        status: result.status === 'done' ? 'completed' : 'failed',
+        backend,
+        serviceTier: policy.service_tier,
+        artifacts: [heartbeatRel, resultRel],
+        blockers: result.blockers || [],
+        logTail: 'worker heartbeat finished'
+    });
     await writeJsonAtomic(path.join(workerDir, 'worker-terminal-close-report.json'), {
         schema: 'sks.native-cli-worker-terminal-close-report.v1',
         generated_at: nowIso(),
@@ -317,4 +369,37 @@ function normalizeWorkerWorktree(value) {
         main_repo_root: value?.main_repo_root == null ? null : String(value.main_repo_root)
     };
 }
+async function workerTelemetry(agentRoot, intake, agent, slice, input) {
+    const missionId = String(intake.mission_id || intake.parent_mission_id || '');
+    if (!missionId)
+        return;
+    await appendZellijSlotTelemetry(agentRoot, {
+        schema: 'sks.zellij-slot-telemetry-event.v1',
+        ts: nowIso(),
+        mission_id: missionId,
+        slot_id: String(agent.slot_id || agent.id || 'slot-001'),
+        generation_index: Number(agent.generation_index || 1),
+        worker_id: String(agent.id || agent.slot_id || 'worker'),
+        event_type: input.eventType,
+        status: input.status,
+        role: String(agent.naruto_role || agent.role || agent.persona_id || agent.id || 'worker'),
+        backend: input.backend,
+        service_tier: input.serviceTier,
+        worktree_id: agent.worktree?.id || slice.worktree?.id || intake.worktree?.id || null,
+        worktree_path: agent.worktree?.path || slice.worktree?.path || intake.worktree?.path || null,
+        task_title: String(slice.description || slice.title || slice.id || 'worker task'),
+        current_file: firstString([slice.write_paths?.[0], slice.readonly_paths?.[0], slice.input_files?.[0]]) || null,
+        artifact_paths: input.artifacts || [],
+        log_tail: input.logTail || '',
+        blockers: input.blockers || []
+    }).catch(() => undefined);
+}
+function firstString(values) {
+    for (const value of values) {
+        const text = String(value || '').trim();
+        if (text)
+            return text;
+    }
+    return null;
+}
 //# sourceMappingURL=native-cli-worker.js.map

package/dist/core/commands/basic-cli.js

@@ -101,7 +101,7 @@ export function quickstartCommand() {
   sks dollar-commands
   sks all-features selftest --mock --execute-fixtures --strict-artifacts --json
 
-For implementation work, use Codex App prompt routes such as $Team, $Goal, $QA-LOOP, $Image-UX-Review, and $Computer-Use.`);
+For implementation work, use Codex App prompt routes such as $Naruto, $Goal, $QA-LOOP, $Image-UX-Review, and $Computer-Use.`);
 }
 export async function updateCheckCommand(args = []) {
     const result = await runSksUpdateCheck();

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

@@ -1,7 +1,7 @@
 export const COMMAND_SUGGESTIONS_SCHEMA = 'sks.command-suggestions.v1';
 export function suggestSksCommands(input) {
     const query = String(input || '').toLowerCase();
-    const commands = ['$Team', '$Goal', '$DFix', '$QA-LOOP', '$Research', '$PPT', '$Image-UX-Review', '$Computer-Use'];
+    const commands = ['$Naruto', '$Goal', '$DFix', '$QA-LOOP', '$Research', '$PPT', '$Image-UX-Review', '$Computer-Use'];
     const suggestions = commands.filter((command) => command.toLowerCase().includes(query.replace(/^\$/, ''))).slice(0, 8);
     return {
         schema: COMMAND_SUGGESTIONS_SCHEMA,

package/dist/core/commands/mad-db-command.js

@@ -0,0 +1,106 @@
+import { initProject } from '../init.js';
+import { createMission, findLatestMission, setCurrent } from '../mission.js';
+import { exists, sksRoot } from '../fsx.js';
+import path from 'node:path';
+import { createMadDbCapability, isMadDbCapabilityActive, MAD_DB_ACK, readMadDbCapability, resolveMadDbMissionId, revokeMadDbCapability } from '../mad-db/mad-db-capability.js';
+export async function madDbCommand(args = []) {
+    const action = String(args[0] && !String(args[0]).startsWith('--') ? args[0] : 'status');
+    const rest = action === args[0] ? args.slice(1) : args;
+    const root = await sksRoot();
+    if (!(await exists(path.join(root, '.sneakoscope'))))
+        await initProject(root, {});
+    if (action === 'enable')
+        return enableMadDb(root, rest);
+    if (action === 'revoke')
+        return revokeMadDb(root, rest);
+    if (action === 'status')
+        return statusMadDb(root, rest);
+    console.error('Usage: sks mad-db enable --ack "I AUTHORIZE ONE-CYCLE DB BREAK-GLASS" [--mission latest|new|M-...] | status | revoke');
+    process.exitCode = 1;
+}
+async function enableMadDb(root, args) {
+    const json = hasFlag(args, '--json');
+    const ack = readOption(args, '--ack', '');
+    if (ack !== MAD_DB_ACK) {
+        const result = { schema: 'sks.mad-db-command.v1', ok: false, action: 'enable', reason: 'ack_phrase_required', required_ack: MAD_DB_ACK };
+        if (json)
+            return console.log(JSON.stringify(result, null, 2));
+        console.error(`Mad-DB enable blocked. Required --ack ${JSON.stringify(MAD_DB_ACK)}`);
+        process.exitCode = 2;
+        return result;
+    }
+    const requestedMission = readOption(args, '--mission', 'latest');
+    let missionId = requestedMission === 'new' ? null : await resolveMadDbMissionId(root, {}, requestedMission);
+    if (!missionId) {
+        const created = await createMission(root, { mode: 'mad-db', prompt: 'sks mad-db enable one-cycle DB break-glass' });
+        missionId = created.id;
+    }
+    const capability = await createMadDbCapability(root, {
+        missionId,
+        ack,
+        cwd: process.cwd(),
+        ttlMs: Number(readOption(args, '--ttl-ms', String(2 * 60 * 60 * 1000)))
+    });
+    await setCurrent(root, {
+        mission_id: missionId,
+        route: 'MadDB',
+        route_command: '$MAD-DB',
+        mode: 'MADDB',
+        phase: 'MADDB_ONE_CYCLE_CAPABILITY_ACTIVE',
+        mad_db_active: true,
+        mad_db_cycle_id: capability.cycle_id,
+        mad_db_capability_file: 'mad-db-capability.json',
+        mad_db_ack_phrase: 'accepted',
+        stop_gate: 'mad-db-capability.json'
+    });
+    const result = { schema: 'sks.mad-db-command.v1', ok: true, action: 'enable', mission_id: missionId, capability };
+    if (json)
+        return console.log(JSON.stringify(result, null, 2));
+    console.log(`Mad-DB one-cycle capability active for ${missionId}; expires ${capability.expires_at}.`);
+    return result;
+}
+async function statusMadDb(root, args) {
+    const json = hasFlag(args, '--json');
+    const missionId = await resolveMadDbMissionId(root, {}, readOption(args, '--mission', 'latest'));
+    const capability = missionId ? await readMadDbCapability(root, missionId) : null;
+    const result = {
+        schema: 'sks.mad-db-command.v1',
+        ok: true,
+        action: 'status',
+        mission_id: missionId,
+        active: isMadDbCapabilityActive(capability),
+        capability
+    };
+    if (json)
+        return console.log(JSON.stringify(result, null, 2));
+    if (!missionId || !capability)
+        console.log('Mad-DB: no capability found.');
+    else
+        console.log(`Mad-DB: ${result.active ? 'active' : 'inactive'} for ${missionId}; consumed=${capability.consumed}; expires=${capability.expires_at}.`);
+    return result;
+}
+async function revokeMadDb(root, args) {
+    const json = hasFlag(args, '--json');
+    const missionId = await resolveMadDbMissionId(root, {}, readOption(args, '--mission', 'latest')) || await findLatestMission(root);
+    const revoked = missionId ? await revokeMadDbCapability(root, missionId, readOption(args, '--reason', 'operator_revoked')) : null;
+    await setCurrent(root, { mad_db_active: false, phase: 'MADDB_REVOKED' });
+    const result = { schema: 'sks.mad-db-command.v1', ok: Boolean(revoked), action: 'revoke', mission_id: missionId, capability: revoked };
+    if (json)
+        return console.log(JSON.stringify(result, null, 2));
+    if (!revoked)
+        console.log('Mad-DB: no capability to revoke.');
+    else
+        console.log(`Mad-DB capability revoked for ${missionId}.`);
+    return result;
+}
+function hasFlag(args, flag) {
+    return args.includes(flag);
+}
+function readOption(args, name, fallback) {
+    const index = args.indexOf(name);
+    if (index >= 0 && args[index + 1] && !String(args[index + 1]).startsWith('--'))
+        return String(args[index + 1]);
+    const prefixed = args.find((arg) => String(arg).startsWith(name + '='));
+    return prefixed ? prefixed.slice(name.length + 1) : fallback;
+}
+//# sourceMappingURL=mad-db-command.js.map