sneakoscope 2.0.13 → 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.13** is the public-ready research pipeline stabilization release. It closes the Research quality contract, claim-evidence matrix, source-quality report, implementation handoff, experiment/replication pack, final-reviewer, and read-only stage-aware work graph path while preserving the 2.0.12 parallel runtime stabilization work.
+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.13, Research also writes a quality contract and handoff package: `research-quality-contract.json`, `claim-evidence-matrix.json`, `source-quality-report.json`, `implementation-blueprint.json`/`.md`, `experiment-plan.json`/`.md`, `replication-pack.json`, `research-work-graph.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, and a 2200-word report 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.13"
+version = "2.0.15"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "2.0.13"
+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.13"),
+        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.13",
-  "source_digest": "4e6d812c7572cee4b51a8e1d0374fff3b908c58e2173b6255122b87ce9e8b83e",
-  "source_file_count": 2090,
-  "built_at_source_time": 1780843454792
+  "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.13';
+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-orchestrator.js

@@ -209,7 +209,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         microWins: strategyCompiled.gate.micro_wins
     });
     if (opts.narutoWorkGraph?.work_items?.length) {
-        partition = applyNarutoWorkGraphToPartition(partition, opts.narutoWorkGraph, roster, targetActiveSlots);
+        partition = applyNarutoWorkGraphToPartition(partition, opts.narutoWorkGraph, roster, targetActiveSlots, prompt);
         augmentVerificationRollbackDagForNaruto(strategyCompiled.verification_rollback_dag, partition.slices);
     }
     await runAgentJanitor({ missionDir: dir, missionId, projectHash: namespace.root_hash });
@@ -620,7 +620,7 @@ function withFinalGptPatchEnvelopes(results, patchEnvelopes = []) {
         next[0] = { ...next[0], patch_envelopes: patchEnvelopes };
     return next;
 }
-function applyNarutoWorkGraphToPartition(partition, graph, roster, targetActiveSlots) {
+function applyNarutoWorkGraphToPartition(partition, graph, roster, targetActiveSlots, parentPrompt = '') {
     const activeRoster = (Array.isArray(roster?.roster) ? roster.roster : []).slice(0, Math.max(1, targetActiveSlots));
     const activeAgentIds = new Set(activeRoster.map((row) => String(row.id || '')).filter(Boolean));
     const fallbackOwners = activeRoster.length ? activeRoster : [{ id: 'naruto_clone_001', role: 'verifier' }];
@@ -639,6 +639,7 @@ function applyNarutoWorkGraphToPartition(partition, graph, roster, targetActiveS
         const targetPaths = normalizePathList(item.target_paths);
         const verificationNodeId = writePaths.length ? `verify:${sliceId}` : null;
         const rollbackNodeId = writePaths.length ? `rollback:${sliceId}` : null;
+        const parentObjective = normalizeWorkerPromptText(parentPrompt);
         return {
             id: sliceId,
             owner_agent_id: owner,
@@ -669,12 +670,15 @@ function applyNarutoWorkGraphToPartition(partition, graph, roster, targetActiveS
             source_intelligence_refs: sourceIntelligenceRefs,
             goal_mode_ref: goalModeRef,
             strategy_refs: strategyRefs,
+            parent_prompt: parentObjective,
             max_attempts: 1,
             description: [
+                parentObjective ? `Parent Naruto objective:\n${parentObjective}` : null,
                 String(item.title || item.id || 'Naruto work item'),
                 `Naruto owner: ${owner}`,
                 item.allocation_reason ? `Allocation: ${item.allocation_reason}` : null,
-                writePaths.length ? `Write paths: ${writePaths.join(', ')}` : 'Read-only or no-write work item.'
+                writePaths.length ? `Write paths: ${writePaths.join(', ')}` : 'Read-only or no-write work item.',
+                writePaths.length ? null : 'Read-only instruction: inspect the requested files/artifacts and do not run package scripts, build commands, tests, or temp-file-creating checks unless the parent objective explicitly requires them.'
             ].filter(Boolean).join('\n')
         };
     });
@@ -1687,10 +1691,13 @@ function buildDirectSdkWorkerPrompt(slice) {
         '',
         write.length
             ? `Write-capable slice. Return JSON matching ${CODEX_AGENT_WORKER_RESULT_SCHEMA_ID}; include patch_envelopes for write_paths=${JSON.stringify(write)}. Each patch envelope must include schema, source "model_authored", agent_id, session_id, slot_id, generation_index, task_slice_id, lease_id, allowed_paths, operations, and rationale. Each operation must include op, path, search, replace, content, and diff; use empty strings for operation fields that do not apply.`
-            : `Read-only slice. Return JSON matching ${CODEX_AGENT_WORKER_RESULT_SCHEMA_ID}; do not report pre-existing repository dirtiness as changed_files.`,
+            : `Read-only slice. Return JSON matching ${CODEX_AGENT_WORKER_RESULT_SCHEMA_ID}; inspect relevant files/artifacts, do not mutate files, do not create temporary/build outputs, do not run package scripts/build/test commands unless explicitly required, and do not report pre-existing repository dirtiness as changed_files.`,
         'Required JSON fields: status, summary, findings, changed_files, patch_envelopes, verification, rollback_notes, blockers.'
     ].join('\n');
 }
+function normalizeWorkerPromptText(value) {
+    return String(value || '').replace(/\s+/g, ' ').trim().slice(0, 4000);
+}
 function buildDirectNoPatchReason(slice, opts) {
     const writePathCount = sdkWritePaths(slice, opts).length;
     return {

package/dist/core/agents/agent-output-validator.js

@@ -33,7 +33,7 @@ export const AGENT_RESULT_RUNTIME_SCHEMA = {
         persona_id: { type: 'string' },
         task_slice_id: { type: 'string' },
         status: { enum: ['done', 'blocked', 'failed'] },
-        backend: { enum: ['fake', 'process', 'codex-sdk', 'zellij', 'ollama'] },
+        backend: { enum: ['fake', 'process', 'codex-sdk', 'python-codex-sdk', 'zellij', 'ollama', 'local-llm'] },
         summary: { type: 'string' },
         findings: { type: 'array', items: { type: 'string' } },
         proposed_changes: { type: 'array', items: { type: 'string' } },

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/codex-control/codex-fake-sdk-adapter.js

@@ -34,11 +34,11 @@ function fakeStructuredOutput(input) {
             summary: unsafe
                 ? 'Fake Codex SDK GPT final arbiter rejected an unsafe candidate for hermetic verification.'
                 : 'Fake Codex SDK GPT final arbiter approved the candidate for hermetic verification.',
-            gpt_review_findings: unsafe ? [{ severity: 'high', message: 'unsafe candidate rejected' }] : [],
+            gpt_review_findings: unsafe ? [{ id: 'unsafe-candidate', severity: 'high', summary: 'unsafe candidate rejected' }] : [],
             accepted_patch_envelopes: unsafe ? [] : [],
             modified_patch_envelopes: [],
-            rejected_patch_envelopes: unsafe ? [{ reason: 'unsafe candidate' }] : [],
-            required_followup_work: unsafe ? [{ blocker: 'unsafe_candidate_patch' }] : [],
+            rejected_patch_envelopes: unsafe ? [{ id: 'unsafe-candidate', summary: 'unsafe candidate', patch_envelope_json: '{}' }] : [],
+            required_followup_work: unsafe ? [{ id: 'unsafe_candidate_patch', severity: 'high', summary: 'unsafe_candidate_patch' }] : [],
             verification_plan: ['schema validation', 'local collaboration final gate'],
             rollback_notes: [],
             blockers: unsafe ? ['unsafe_candidate_patch'] : [],