sneakoscope 3.0.4 → 3.1.1

package/dist/core/skills/core-skill-meta-update.js

@@ -0,0 +1,24 @@
+// SKS Core Skill Engine — SkillOpt-style epoch-wise meta-update.
+//
+// SkillOpt adjusts its textual learning rate between epochs: rejected edits decay
+// the budget (smaller, safer proposals), accepted edits regrow it toward the
+// default ceiling. Deterministic, bounded, never exceeds the configured maximum.
+import { DEFAULT_TEXTUAL_LEARNING_RATE } from './core-skill-epoch.js';
+export const MIN_TEXTUAL_LEARNING_RATE = { max_added_chars: 100, max_deleted_chars: 50, max_replaced_chars: 75 };
+export const META_UPDATE_DECAY = 0.5;
+export const META_UPDATE_GROWTH = 1.25;
+/** Epoch-wise textual learning-rate adjustment: decay on rejection, bounded regrowth on acceptance. */
+export function metaUpdateLearningRate(rate, outcome, opts = {}) {
+    const decay = opts.decay ?? META_UPDATE_DECAY;
+    const growth = opts.growth ?? META_UPDATE_GROWTH;
+    const min = opts.min ?? MIN_TEXTUAL_LEARNING_RATE;
+    const max = opts.max ?? DEFAULT_TEXTUAL_LEARNING_RATE;
+    const factor = outcome === 'rejected' ? decay : growth;
+    const adjust = (value, lo, hi) => Math.min(hi, Math.max(lo, Math.round(value * factor)));
+    return {
+        max_added_chars: adjust(rate.max_added_chars, min.max_added_chars, max.max_added_chars),
+        max_deleted_chars: adjust(rate.max_deleted_chars, min.max_deleted_chars, max.max_deleted_chars),
+        max_replaced_chars: adjust(rate.max_replaced_chars, min.max_replaced_chars, max.max_replaced_chars)
+    };
+}
+//# sourceMappingURL=core-skill-meta-update.js.map

package/dist/core/skills/core-skill-reflection.js

@@ -0,0 +1,94 @@
+// SKS Core Skill Engine — SkillOpt-style reflection stage.
+//
+// SkillOpt's training loop is rollout → reflection → aggregation → selection →
+// validation-gated update. This module implements the reflect/aggregate/select
+// stages deterministically (no model call): each scored rollout yields reflection
+// records for its deficient score dimensions, reflections are aggregated and
+// ranked across the batch, and the top-ranked deficiencies are mapped to bounded
+// add-operations on the single skill document.
+import { scoreRollout } from './core-skill-scorer.js';
+// dimension → { instruction line, target section, regex proving the card already covers it }
+const DIMENSION_LESSONS = {
+    proof_completeness: {
+        target: 'section:verification',
+        text: '- Always emit a proof artifact before reporting success.',
+        covered: /proof artifact/i
+    },
+    rollback_ready: {
+        target: 'section:rollback',
+        text: '- Record a rollback-ready checkpoint before mutating anything.',
+        covered: /rollback/i
+    },
+    latency_budget: {
+        target: 'section:latency',
+        text: '- Prefer the smallest sufficient probe; stop expanding scope once the latency budget is at risk.',
+        covered: /latency budget/i
+    },
+    requested_scope_compliance: {
+        target: 'section:scope',
+        text: '- Touch only what the request names; treat any out-of-scope mutation as a hard stop.',
+        covered: /out-of-scope mutation/i
+    },
+    side_effect_zero: {
+        target: 'section:scope',
+        text: '- Leave zero side effects: never mutate outside the requested scope.',
+        covered: /zero side effects/i
+    },
+    task_success: {
+        target: 'section:method',
+        text: '- Re-read the recorded failure reason and address it directly before retrying.',
+        covered: /failure reason/i
+    }
+};
+/** Reflect on one scored rollout: one reflection per deficient score dimension. */
+export function reflectOnTrace(trace, opts = {}) {
+    const score = scoreRollout(trace, opts);
+    const reflections = [];
+    for (const dimension of Object.keys(score.components)) {
+        const value = score.components[dimension];
+        if (value >= 1)
+            continue;
+        reflections.push({
+            dimension,
+            severity: Number((1 - value).toFixed(6)),
+            note: trace.failure_reason ? `deficient ${dimension} (failure: ${trace.failure_reason})` : `deficient ${dimension}`
+        });
+    }
+    return reflections;
+}
+/** Aggregate reflections across a rollout batch, ranked by total severity then count. */
+export function aggregateReflections(reflections) {
+    const byDimension = new Map();
+    for (const reflection of reflections) {
+        const entry = byDimension.get(reflection.dimension) ?? { dimension: reflection.dimension, count: 0, severity: 0 };
+        entry.count += 1;
+        entry.severity = Number((entry.severity + reflection.severity).toFixed(6));
+        byDimension.set(reflection.dimension, entry);
+    }
+    return [...byDimension.values()].sort((a, b) => b.severity - a.severity || b.count - a.count || a.dimension.localeCompare(b.dimension));
+}
+/**
+ * Select bounded patch operations from aggregated reflections. Skips lessons the
+ * card body already covers, and truncates the selection so total added chars fit
+ * the textual learning-rate budget.
+ */
+export function selectPatchOperations(card, aggregated, learningRate, opts = {}) {
+    const maxOperations = Math.max(1, opts.maxOperations ?? 2);
+    const operations = [];
+    let addedChars = 0;
+    for (const entry of aggregated) {
+        if (operations.length >= maxOperations)
+            break;
+        const lesson = DIMENSION_LESSONS[entry.dimension];
+        if (!lesson || lesson.covered.test(card.body))
+            continue;
+        if (operations.some((op) => op.op === 'add' && op.text === lesson.text))
+            continue;
+        if (addedChars + lesson.text.length > learningRate.max_added_chars)
+            continue;
+        operations.push({ op: 'add', target: lesson.target, text: lesson.text });
+        addedChars += lesson.text.length;
+    }
+    return operations;
+}
+//# sourceMappingURL=core-skill-reflection.js.map

package/dist/core/skills/core-skill-trainer.js

@@ -0,0 +1,103 @@
+// SKS Core Skill Engine — SkillOpt-style multi-epoch trainer.
+//
+// Closes the SkillOpt training loop over the existing primitives: per epoch a
+// rollout batch is reflected on (reflect → aggregate → select), the selected
+// bounded edit goes through the strict held-out gate (runSkillEpoch), and the
+// textual learning rate is meta-updated from the outcome. The best held-out
+// accepted card is exported as the deployable best-skill artifact (SkillOpt's
+// best_skill.md analogue). Pure/deterministic: the caller supplies the held-out
+// evaluator; no model call is made here. Forbidden in deployment context.
+import path from 'node:path';
+import { ensureDir, nowIso, writeJsonAtomic } from '../fsx.js';
+import { assertNotInDeployment } from './core-skill-deployment.js';
+import { DEFAULT_TEXTUAL_LEARNING_RATE, runSkillEpoch } from './core-skill-epoch.js';
+import { metaUpdateLearningRate } from './core-skill-meta-update.js';
+import { applyPatch } from './core-skill-patch-apply.js';
+import { aggregateReflections, reflectOnTrace, selectPatchOperations } from './core-skill-reflection.js';
+import { CORE_SKILL_PATCH_SCHEMA } from './core-skill-types.js';
+export const CORE_SKILL_TRAINING_REPORT_SCHEMA = 'sks.core-skill-training-report.v1';
+/** Run the SkillOpt training loop in a TRAINING/EVALUATION context. */
+export async function trainSkill(root, input) {
+    assertNotInDeployment('trainSkill');
+    let current = input.card;
+    let learningRate = { ...(input.learningRate ?? DEFAULT_TEXTUAL_LEARNING_RATE) };
+    let currentProbe = input.evaluateHeldout(current);
+    const baselineHeldout = currentProbe.heldout;
+    const records = [];
+    let acceptedCount = 0;
+    for (let epoch = 0; epoch < input.epochs.length; epoch += 1) {
+        const traces = input.epochs[epoch] ?? [];
+        const reflections = traces.flatMap((trace) => reflectOnTrace(trace, { ...(input.latencyBudgetMs === undefined ? {} : { latencyBudgetMs: input.latencyBudgetMs }) }));
+        const aggregated = aggregateReflections(reflections);
+        const operations = selectPatchOperations(current, aggregated, learningRate, { ...(input.maxOperationsPerEpoch === undefined ? {} : { maxOperations: input.maxOperationsPerEpoch }) });
+        if (!operations.length) {
+            records.push({ epoch, accepted: false, reason: 'no_proposal', patch_hash: null, score_delta: 0, learning_rate: { ...learningRate } });
+            continue;
+        }
+        const patch = {
+            schema: CORE_SKILL_PATCH_SCHEMA,
+            skill_id: current.skill_id,
+            base_version: current.version,
+            operations,
+            textual_learning_rate: { ...learningRate }
+        };
+        // Probe the candidate's held-out score BEFORE the gated update.
+        const preview = applyPatch(current, patch);
+        const candidateProbe = preview.ok && preview.candidate ? input.evaluateHeldout(preview.candidate) : currentProbe;
+        const result = await runSkillEpoch(root, {
+            card: current,
+            trainTraces: traces,
+            patch,
+            validation: {
+                baselineHeldout: currentProbe.heldout,
+                candidateHeldout: candidateProbe.heldout,
+                sideEffectZero: candidateProbe.sideEffectZero,
+                requestedScopeCompliant: candidateProbe.requestedScopeCompliant,
+                proofCompletenessBaseline: currentProbe.proofCompleteness,
+                proofCompletenessCandidate: candidateProbe.proofCompleteness,
+                rollbackReadyBaseline: currentProbe.rollbackReady,
+                rollbackReadyCandidate: candidateProbe.rollbackReady,
+                latencyBaselineMs: currentProbe.latencyMs,
+                latencyCandidateMs: candidateProbe.latencyMs
+            }
+        });
+        records.push({ epoch, accepted: result.accepted, reason: result.reason, patch_hash: result.patch_hash, score_delta: result.score_delta, learning_rate: { ...learningRate } });
+        if (result.accepted && result.candidate) {
+            current = result.candidate;
+            currentProbe = candidateProbe;
+            acceptedCount += 1;
+            learningRate = metaUpdateLearningRate(learningRate, 'accepted');
+        }
+        else {
+            learningRate = metaUpdateLearningRate(learningRate, 'rejected');
+        }
+    }
+    const reportsDir = path.join(path.resolve(root), '.sneakoscope', 'reports');
+    await ensureDir(reportsDir);
+    const reportPath = path.join(reportsDir, 'core-skill-training-report.json');
+    const skillDir = path.join(path.resolve(root), '.sneakoscope', 'skills', current.route, current.skill_id);
+    await ensureDir(skillDir);
+    const bestSkillPath = path.join(skillDir, 'best-skill.json');
+    await writeJsonAtomic(bestSkillPath, { ...current, exported_as: 'best_skill', exported_at: nowIso() });
+    await writeJsonAtomic(reportPath, {
+        schema: CORE_SKILL_TRAINING_REPORT_SCHEMA,
+        skill_id: input.card.skill_id,
+        route: input.card.route,
+        baseline_heldout: baselineHeldout,
+        best_heldout: currentProbe.heldout,
+        best_version: current.version,
+        accepted_count: acceptedCount,
+        epochs: records,
+        generated_at: nowIso()
+    });
+    return {
+        epochs: records,
+        best: current,
+        best_heldout: currentProbe.heldout,
+        baseline_heldout: baselineHeldout,
+        accepted_count: acceptedCount,
+        report_path: reportPath,
+        best_skill_path: bestSkillPath
+    };
+}
+//# sourceMappingURL=core-skill-trainer.js.map

package/dist/core/trust-kernel/completion-contract.js

@@ -1,4 +1,5 @@
 import { validateCompletionProof } from '../proof/validation.js';
+import { rootCauseAnalysisIssue } from '../proof/root-cause-policy.js';
 function asRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
@@ -44,6 +45,9 @@ export function validateCompletionContract(contract = {}, proof = {}, evidenceIn
         issues.push('active_wrongness_requires_verified_partial');
     if (claimLinksActiveWrongness(proofRecord, wrongness))
         issues.push('claim_linked_to_active_wrongness');
+    const rootCauseIssue = rootCauseAnalysisIssue(proofRecord, issues);
+    if (rootCauseIssue)
+        issues.push(rootCauseIssue);
     const status = typeof proofRecord.status === 'string'
         ? proofRecord.status
         : typeof contractRecord.status === 'string'

package/dist/core/trust-kernel/route-contract.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { writeJsonAtomic } from '../fsx.js';
 import { missionDir } from '../mission.js';
 import { routeRequiresCompletionProof, routeRequiresImageVoxelAnchors } from '../proof/route-proof-policy.js';
+import { rootCauseAnalysisRequired } from '../proof/root-cause-policy.js';
 import { ROUTE_COMPLETION_CONTRACT_SCHEMA, normalizeTrustStatus, trustKernelMetadata } from './trust-kernel-schema.js';
 import { validateCompletionContract } from './completion-contract.js';
 function asRecord(value) {
@@ -51,7 +52,8 @@ export function routeRequirements(route, proof = {}) {
         image_voxels: routeRequiresImageVoxelAnchors(route),
         db_safety: route === '$DB' || Boolean(evidence.db || evidence.db_safety),
         tests: Boolean(evidence.tests),
-        blackbox: JSON.stringify(evidence).includes('blackbox')
+        blackbox: JSON.stringify(evidence).includes('blackbox'),
+        root_cause_analysis: rootCauseAnalysisRequired(proofRecord)
     };
 }
 function evidencePathsForContract(missionId, proof, evidenceIndex, required) {
@@ -67,6 +69,7 @@ function evidencePathsForContract(missionId, proof, evidenceIndex, required) {
         tests: pathFromEvidence(proofEvidence.tests),
         db_safety: pathFromEvidence(proofEvidence.db || proofEvidence.db_safety),
         blackbox: pathFromEvidence(proofEvidence.blackbox),
+        root_cause_analysis: required.root_cause_analysis && base ? `${base}/completion-proof.json#failure_analysis` : null,
         evidence_index: base ? `${base}/evidence-index.json` : null,
         trust_report: base ? `${base}/trust-report.json` : null,
         evidence_records: asList(evidenceIndexRecord.records).map((entry) => {

package/dist/core/version.js

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

package/dist/core/zellij/zellij-right-column-manager.js

@@ -135,6 +135,9 @@ async function prepareWorkerInRightColumnUnlocked(input) {
     return { state: next, placement: 'zellij-pane', focusPaneId, yOrder };
 }
 export async function recordWorkerPaneInRightColumn(input) {
+    return withRightColumnLock(input.root, input.missionId, async () => recordWorkerPaneInRightColumnUnlocked(input));
+}
+async function recordWorkerPaneInRightColumnUnlocked(input) {
     const paths = resolveRightColumnPaths(input.root, input.missionId, input.projectRoot);
     const state = await readRightColumnState(input.root, input.missionId, input.projectRoot);
     if (!state)
@@ -154,6 +157,7 @@ export async function recordWorkerPaneInRightColumn(input) {
         ...state,
         updated_at: nowIso(),
         right_anchor_pane_id: input.record.pane_id || state.right_anchor_pane_id,
+        slot_column_anchor_pane_id: input.record.slot_column_anchor_pane_id || state.slot_column_anchor_pane_id || null,
         visible_worker_panes: rows.sort((a, b) => a.y_order - b.y_order),
         blockers: [...new Set([...state.blockers, ...(input.record.blockers || [])])]
     });
@@ -173,6 +177,9 @@ export async function recordWorkerPaneInRightColumn(input) {
     return next;
 }
 export async function recordSlotColumnAnchorInRightColumn(input) {
+    return withRightColumnLock(input.root, input.missionId, async () => recordSlotColumnAnchorInRightColumnUnlocked(input));
+}
+async function recordSlotColumnAnchorInRightColumnUnlocked(input) {
     const paths = resolveRightColumnPaths(input.root, input.missionId, input.projectRoot);
     const state = await readRightColumnState(input.root, input.missionId, input.projectRoot) || {
         schema: ZELLIJ_RIGHT_COLUMN_STATE_SCHEMA,
@@ -238,6 +245,9 @@ async function recordHeadlessWorkerInRightColumnUnlocked(input) {
     return next;
 }
 export async function closeWorkerInRightColumn(input) {
+    return withRightColumnLock(input.root, input.missionId, async () => closeWorkerInRightColumnUnlocked(input));
+}
+async function closeWorkerInRightColumnUnlocked(input) {
     const paths = resolveRightColumnPaths(input.root, input.missionId, input.projectRoot);
     const state = await readRightColumnState(input.root, input.missionId, input.projectRoot);
     if (!state)
@@ -333,14 +343,15 @@ async function withRightColumnLock(root, missionId, fn) {
     const current = new Promise((resolve) => {
         release = resolve;
     });
-    rightColumnLocks.set(key, previous.then(() => current, () => current));
+    const chained = previous.then(() => current, () => current);
+    rightColumnLocks.set(key, chained);
     await previous.catch(() => undefined);
     try {
         return await fn();
     }
     finally {
         release();
-        if (rightColumnLocks.get(key) === current)
+        if (rightColumnLocks.get(key) === chained)
             rightColumnLocks.delete(key);
     }
 }

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

@@ -1,6 +1,17 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { packageRoot } from '../fsx.js';
 import { readZellijSlotTelemetrySnapshot } from './zellij-slot-telemetry.js';
+import { workerBackendTag } from './zellij-worker-pane-manager.js';
+function readPackageVersion() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot(), 'package.json'), 'utf8'));
+        return String(pkg?.version || '?');
+    }
+    catch {
+        return '?';
+    }
+}
 export function renderZellijSlotColumnAnchor(input = {}) {
     const active = nonNegativeInt(input.activeWorkers, 0);
     const visible = Math.max(1, nonNegativeInt(input.visiblePaneCap, active || 1));
@@ -11,9 +22,12 @@ export function renderZellijSlotColumnAnchor(input = {}) {
     const update = input.updateAvailableVersion ? ` · update ${trimInline(input.updateAvailableVersion, 18)} available` : '';
     const madDb = input.madDbActive ? ' · MAD-DB ACTIVE' : '';
     const appHandoff = input.qaAppHandoffPending ? ' · QA /app handoff pending' : '';
-    const header = done || fail
+    const loopHeader = input.loopsTotal != null
+        ? `LOOPS ${nonNegativeInt(input.loopsTotal, 0)} · running ${nonNegativeInt(input.loopsRunning, 0)} · blocked ${nonNegativeInt(input.loopsBlocked, 0)} · done ${nonNegativeInt(input.loopsCompleted, 0)} · workers ${active}`
+        : null;
+    const header = loopHeader || (done || fail
         ? `SLOTS active ${active} · headless ${headless} · done ${done} · fail ${fail} · q ${queue}${update}${madDb}${appHandoff}`
-        : `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}${update}${madDb}${appHandoff}`;
+        : `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}${update}${madDb}${appHandoff}`);
     const workers = Array.isArray(input.workerRows) ? input.workerRows : [];
     const handoffLine = input.qaAppHandoffPending ? `QA app handoff pending · ${trimInline(input.qaAppHandoffArtifact || 'qa-loop/app-handoff.json', 64)}` : null;
     if (!workers.length)
@@ -70,9 +84,35 @@ function renderTelemetryAnchor(snapshot, updateNotice = null, madDbCapability =
     const update = updateNotice?.update_available && updateNotice?.latest_version ? ` · update ${trimInline(String(updateNotice.latest_version), 18)} available` : '';
     const madDb = isMadDbActive(madDbCapability) ? ' · MAD-DB ACTIVE' : '';
     const qaHandoff = ['pending', 'blocked_for_desktop_review'].includes(String(appHandoff?.status || '')) ? ' · QA /app handoff pending' : '';
-    if (staleSeconds != null && staleSeconds > 10)
-        return `SLOTS telemetry stale ${staleSeconds}s · active ?${update}${madDb}${qaHandoff}`;
-    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}${qaHandoff}`;
+    // Compact SKS branding header: package version + mission id so the SLOTS column self-identifies.
+    const brand = `SKS v${readPackageVersion()} · mission ${trimInline(String(snapshot.mission_id || '-'), 28)}`;
+    if (staleSeconds != null && staleSeconds > 60) {
+        return [brand, `SLOTS telemetry stale ${staleSeconds}s · active ?${update}${madDb}${qaHandoff}`].join('\n');
+    }
+    const countsLine = `SLOTS active ${active} · run ${Number(counts.running || 0)} · verify ${Number(counts.verifying || 0)} · headless ${Number(counts.headless || 0)} · done ${Number(counts.completed || 0)} · fail ${Number(counts.failed || 0)} · q ${Number(counts.queued || 0)}${update}${madDb}${qaHandoff}`;
+    const slotRows = renderTelemetrySlotRows(snapshot);
+    return [brand, countsLine, ...slotRows].join('\n');
+}
+function renderTelemetrySlotRows(snapshot) {
+    const slots = Object.values((snapshot?.slots || {}));
+    if (!slots.length)
+        return [];
+    const ordered = slots.sort((a, b) => {
+        const statusDelta = statusWeight(a?.status) - statusWeight(b?.status);
+        if (statusDelta)
+            return statusDelta;
+        return String(a?.slot_id || '').localeCompare(String(b?.slot_id || ''));
+    }).slice(0, 12);
+    return ordered.map((slot) => {
+        const id = `${trimInline(String(slot?.slot_id || 'slot-?'), 12)} g${Math.max(1, Math.floor(Number(slot?.generation_index) || 1))}`;
+        const task = trimInline(String(slot?.task_title || ''), 24);
+        const engine = workerBackendTag(slot?.backend, slot?.provider);
+        const role = trimInline(String(slot?.role || 'worker'), 10);
+        const status = trimInline(String(slot?.status || 'running'), 9);
+        const file = trimInline(String(slot?.current_file || '-'), 30);
+        const hb = slot?.latest_ts ? `${Math.max(0, Math.round((Date.now() - Date.parse(String(slot.latest_ts))) / 1000))}s` : '?';
+        return `${id}${task && task !== 'worker task' ? ` · ${task}` : ''} · ${engine} · ${role} · ${status} · ${file} · hb ${hb}`;
+    });
 }
 function isMadDbActive(capability) {
     if (!capability || capability.enabled !== true || capability.consumed === true)

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

@@ -11,10 +11,12 @@ export function renderZellijSlotPane(input) {
             ? 'now'
             : `${Math.max(1, Math.round(input.heartbeatAgeMs / 1000))}s ago`;
     const files = firstNonEmptyList(input.changedFiles, input.patchFiles, input.plannedFiles, input.currentFile ? [input.currentFile] : []);
-    const events = (input.eventLines || []).filter(Boolean).slice(-3);
-    const stdout = (input.stdoutTail || []).filter(Boolean).slice(-2);
+    const events = (input.eventLines || []).filter(Boolean).slice(-10);
+    const stdout = (input.stdoutTail || []).filter(Boolean).slice(-6);
     const stderr = (input.stderrTail || []).filter(Boolean).slice(-1);
+    const fixtureLoopProof = String(input.backend || '').includes('fixture') || String(input.patchStatus || '').includes('fixture');
     const rows = [
+        input.loopId ? `${trimInline(input.loopId, 28)} · ${trimInline(input.loopRole || input.role || 'worker', 14)} · ${input.slotId}` : null,
         `slot: ${input.slotId} / gen-${Math.max(1, Math.floor(Number(input.generationIndex) || 1))} / ${trimInline(input.status || 'running', 18)}`,
         `role: ${trimInline(input.role || 'worker', 18)}  backend: ${trimInline(input.backend || 'codex-sdk', 20)}  worktree: ${trimInline(input.worktreeId || '-', 18)}`,
         `runtime: fast ${formatFastMode(input.fastMode, input.serviceTier)}  tier: ${trimInline(input.serviceTier || 'unknown', 12)}  provider: ${trimInline(input.provider || 'unknown', 18)}`,
@@ -22,6 +24,8 @@ export function renderZellijSlotPane(input) {
         input.sessionId ? `session: ${trimInline(input.sessionId, 62)}` : null,
         `heartbeat: ${heartbeat}${input.heartbeatEvent ? `  event: ${trimInline(input.heartbeatEvent, 40)}` : ''}`,
         `doing: ${task}`,
+        input.loopGate ? `gate: ${trimInline(input.loopGate, 68)}${input.verifyStatus ? ` · ${trimInline(input.verifyStatus, 18)}` : ''}` : null,
+        fixtureLoopProof ? 'fixture loop proof · not production execution' : null,
         `files: ${trimInline(files.length ? files.join(', ') : 'no changed file yet', 78)}`,
         `patch: ${trimInline(input.patchStatus || 'queued', 24)}  verify: ${trimInline(input.verifyStatus || 'queued', 24)}`,
         input.qaAppHandoffPending ? `QA app handoff pending: ${trimInline(input.qaAppHandoffArtifact || 'qa-loop/app-handoff.json', 55)}` : null,
@@ -89,7 +93,7 @@ async function renderZellijSlotPaneFromArtifactDir(input) {
         path.join(artifactDir, 'python-codex-sdk-events.jsonl'),
         path.join(artifactDir, 'local-llm-events.jsonl'),
         path.join(artifactDir, 'zellij-worker-pane-events.jsonl')
-    ], 6);
+    ], 10);
     const patchFiles = patchPaths(patch || result);
     const changedFiles = normalizeList(result?.changed_files);
     const plannedFiles = normalizeList([
@@ -155,7 +159,7 @@ async function renderZellijSlotPaneFromArtifactDir(input) {
         heartbeatEvent: heartbeatRows.length ? formatArtifactEvent(heartbeatRows[heartbeatRows.length - 1]) : null,
         worktreeId: result?.worktree?.id || intake?.worktree?.id || null,
         eventLines: eventRows.map(formatArtifactEvent).filter(Boolean),
-        stdoutTail: await readTextTailLines(path.join(artifactDir, 'worker.stdout.log'), 2),
+        stdoutTail: await readTextTailLines(path.join(artifactDir, 'worker.stdout.log'), 6),
         stderrTail: await readTextTailLines(path.join(artifactDir, 'worker.stderr.log'), 1),
         qaAppHandoffPending: ['pending', 'blocked_for_desktop_review'].includes(String(qaAppHandoff?.status || '')),
         qaAppHandoffArtifact: qaAppHandoff?.artifact_path || null,
@@ -190,6 +194,24 @@ export async function renderZellijSlotPaneStatusFromArtifacts(input) {
         telemetry_age_ms: status.telemetry_age_ms
     };
 }
+// Root-cause-3 fix: the watch loop never exited, so completed/failed panes lingered forever and
+// kept re-reporting staleness. Resolve whether this slot has reached a terminal state (status is
+// completed/failed/drained in telemetry) AND its worker-result.json exists, so the pane command
+// can render one final frame and exit instead of looping indefinitely.
+export async function resolveZellijSlotPaneExit(input) {
+    const resultExists = Boolean(await readJson(path.join(path.resolve(input.artifactDir), 'worker-result.json')));
+    if (!resultExists)
+        return false;
+    if (!input.missionId || input.missionId === 'latest')
+        return true;
+    const snapshot = await readZellijSlotTelemetrySnapshot(path.resolve(input.artifactRoot || input.artifactDir), input.missionId).catch(() => null);
+    if (!snapshot)
+        return true;
+    const slot = findTelemetrySlot(snapshot, input.slotId, input.generationIndex);
+    if (!slot)
+        return true;
+    return slot.status === 'completed' || slot.status === 'failed' || slot.status === 'drained';
+}
 export function buildZellijSlotPaneCommand(input) {
     const args = [
         input.cliPath,
@@ -257,7 +279,7 @@ function artifactFallbackRows(text) {
         .map((line) => line.replace(/^\|\s?/, '').replace(/\s?\|$/, '').trim())
         .filter((line) => /^(heartbeat|doing|files|event|out|err):\s+/i.test(line))
         .filter((line) => !/unknown|waiting for worker intake|no changed file yet/i.test(line))
-        .slice(-7)
+        .slice(-12)
         .map((line) => `live: ${trimInline(line, 72)}`);
 }
 function findTelemetrySlot(snapshot, slotId, generationIndex) {
@@ -273,16 +295,19 @@ function telemetryStatus(snapshot) {
     const parsed = snapshot?.updated_at ? Date.parse(snapshot.updated_at) : NaN;
     const telemetryAgeMs = Number.isFinite(parsed) ? Math.max(0, Date.now() - parsed) : Number.MAX_SAFE_INTEGER;
     return {
-        telemetry_stale: telemetryAgeMs > 3000,
+        // Root-cause-3 fix: with a 1000ms+jitter flush throttle the old 3000ms threshold flapped
+        // constantly. Raise to 15000ms so brief gaps between flushes don't read as "stale", and only
+        // claim the worker may be gone after 60000ms of true silence.
+        telemetry_stale: telemetryAgeMs > 15000,
         telemetry_age_ms: telemetryAgeMs
     };
 }
 function staleTelemetryRows(ageMs) {
     if (!Number.isFinite(ageMs))
         return ['telemetry stale; worker may still be running'];
-    if (ageMs > 10000)
+    if (ageMs > 60000)
         return ['telemetry stale; worker may still be running'];
-    if (ageMs > 3000)
+    if (ageMs > 15000)
         return [`telemetry stale ${(ageMs / 1000).toFixed(1)}s`];
     return [];
 }
@@ -392,15 +417,17 @@ function formatArtifactEvent(row) {
     if (!row)
         return '';
     const status = trimInline(row.lane_status || row.status || row.event || row.event_type || row.type || row.sdk_event_type || 'event', 18);
+    // Prefer the latest LLM message text (message_tail/message) so the live pane shows what the
+    // model is actually saying, falling back to tool/file/blocker context when no message exists.
     const detail = firstText([
+        row.message_tail,
+        row.message,
         row.current_tool && row.current_file ? `tool ${row.current_tool} file ${row.current_file}` : null,
         row.current_file ? `file ${row.current_file}` : null,
         row.current_tool ? `tool ${row.current_tool}` : null,
-        row.message_tail,
         row.blocker ? `blocker ${row.blocker}` : null,
         row.request_id,
         row.pane_id ? `pane ${row.pane_id}` : null,
-        row.message,
         row.reason
     ]);
     return trimInline(detail ? `${status}: ${detail}` : status, 96);