sneakoscope 2.0.7 → 2.0.8

package/README.md

@@ -16,7 +16,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **2.0.7** adds Git worktree parallel coding foundations for Naruto/MAD-SKS-style high-throughput work. Write-capable Git missions can now declare `git-worktree` mode, allocate worker worktrees outside the main checkout by default, export full-index diffs into patch envelopes, apply them through an integration worktree queue, and retain dirty worktrees instead of deleting evidence. Non-Git projects degrade to patch-envelope-only without calling `git worktree`.
+SKS **2.0.8** makes the release path DAG-parallel by default and hardens the Naruto/MAD-SKS worktree proof chain. `release:check` now runs a manifest-backed DAG runner with resource-aware scheduling, hermetic per-gate environments, bounded logs, per-gate reports, cache proof, and parallel speed-budget evidence. Git worktree coding now preserves allocation manifests, detects dirty main worktrees, includes untracked content in exported diffs, emits one `git_apply_patch` envelope operation, applies worktree diffs through an integration queue, and locks retained dirty worktrees.
 
 What changed:
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "2.0.7"
+version = "2.0.8"
 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.7"),
+        Some("--version") => println!("sks-rs 2.0.8"),
         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.7",
-  "source_digest": "fd9b0bc3d9a5a09bcd2b90988719b11e844448de39f28cf27e98c1b4cae82a0f",
-  "source_file_count": 1979,
-  "built_at_source_time": 1780686416915
+  "package_version": "2.0.8",
+  "source_digest": "5009938d20628f783aa7ac19da170d2737fef89481b49d9c8dc3f2f97c0dcf9d",
+  "source_file_count": 2004,
+  "built_at_source_time": 1780739165211
 }

package/dist/bin/sks.js

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

package/dist/build-manifest.json

@@ -1,16 +1,16 @@
 {
   "schema": "sks.dist-build.v2",
-  "version": "2.0.7",
-  "package_version": "2.0.7",
+  "version": "2.0.8",
+  "package_version": "2.0.8",
   "typescript": true,
   "mjs_runtime_files": 0,
-  "compiled_file_count": 1043,
-  "compiled_js_count": 1043,
+  "compiled_file_count": 1067,
+  "compiled_js_count": 1067,
   "compiled_dts_count": 0,
-  "source_digest": "fd9b0bc3d9a5a09bcd2b90988719b11e844448de39f28cf27e98c1b4cae82a0f",
-  "source_file_count": 1979,
-  "source_files_hash": "319ce7cd86fb58c825b14eb717a1d7b9c85be197206852aee9646fbfd5d356c6",
-  "source_list_hash": "319ce7cd86fb58c825b14eb717a1d7b9c85be197206852aee9646fbfd5d356c6",
+  "source_digest": "5009938d20628f783aa7ac19da170d2737fef89481b49d9c8dc3f2f97c0dcf9d",
+  "source_file_count": 2004,
+  "source_files_hash": "045de0cf4e0b27b18838e5826c77f19ee281908588bbfde4a00a448b5a3c03eb",
+  "source_list_hash": "045de0cf4e0b27b18838e5826c77f19ee281908588bbfde4a00a448b5a3c03eb",
   "src_mjs_runtime_files": 0,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [
@@ -519,6 +519,13 @@
     "core/release-parallel-full-coverage.js",
     "core/release/gate-cache.js",
     "core/release/gate-manifest.js",
+    "core/release/release-gate-cache-v2.js",
+    "core/release/release-gate-dag.js",
+    "core/release/release-gate-hermetic-env.js",
+    "core/release/release-gate-node.js",
+    "core/release/release-gate-report.js",
+    "core/release/release-gate-resource-governor.js",
+    "core/release/release-gate-scheduler.js",
     "core/reporting/markdown-table.js",
     "core/research.js",
     "core/responses-retry-policy.js",
@@ -616,6 +623,8 @@
     "core/zellij/zellij-capability.js",
     "core/zellij/zellij-clipboard-config.js",
     "core/zellij/zellij-command.js",
+    "core/zellij/zellij-dashboard-pane.js",
+    "core/zellij/zellij-dashboard-renderer.js",
     "core/zellij/zellij-lane-renderer.js",
     "core/zellij/zellij-lane-runtime.js",
     "core/zellij/zellij-launcher.js",
@@ -830,10 +839,16 @@
     "scripts/git-worktree-cache-performance-check.js",
     "scripts/git-worktree-capability-check.js",
     "scripts/git-worktree-cleanup-check.js",
+    "scripts/git-worktree-diff-envelope-check.js",
     "scripts/git-worktree-diff-export-check.js",
+    "scripts/git-worktree-dirty-lock-check.js",
+    "scripts/git-worktree-dirty-main-detection-check.js",
+    "scripts/git-worktree-integration-primary-check.js",
     "scripts/git-worktree-manager-check.js",
+    "scripts/git-worktree-manifest-append-check.js",
     "scripts/git-worktree-merge-queue-check.js",
     "scripts/git-worktree-pool-performance-check.js",
+    "scripts/git-worktree-untracked-diff-check.js",
     "scripts/goal-mode-official-default-check.js",
     "scripts/gpt-final-arbiter-check.js",
     "scripts/gpt-final-arbiter-performance-check.js",
@@ -915,6 +930,7 @@
     "scripts/naruto-shadow-clone-swarm-check.js",
     "scripts/naruto-verification-pool-check.js",
     "scripts/naruto-work-graph-check.js",
+    "scripts/naruto-worktree-coding-blackbox.js",
     "scripts/naruto-worktree-coding-check.js",
     "scripts/naruto-worktree-gpt-final-check.js",
     "scripts/naruto-worktree-zellij-ui-check.js",
@@ -963,8 +979,11 @@
     "scripts/release-dist-freshness-check.js",
     "scripts/release-dynamic-performance-check.js",
     "scripts/release-gate-budget-check.js",
+    "scripts/release-gate-dag-runner-check.js",
+    "scripts/release-gate-dag-runner.js",
     "scripts/release-gate-existence-audit.js",
     "scripts/release-gate-planner.js",
+    "scripts/release-gate-worker.js",
     "scripts/release-metadata-1-11-check.js",
     "scripts/release-metadata-1-12-check.js",
     "scripts/release-metadata-1-13-check.js",
@@ -976,11 +995,13 @@
     "scripts/release-native-agent-fixture-check.js",
     "scripts/release-parallel-check.js",
     "scripts/release-parallel-full-coverage-check.js",
+    "scripts/release-parallel-speed-budget-check.js",
     "scripts/release-provenance-check.js",
     "scripts/release-readiness-report.js",
     "scripts/release-real-check.js",
     "scripts/release-registry-check.js",
     "scripts/release-runtime-truth-matrix-check.js",
+    "scripts/release-stability-report-check.js",
     "scripts/release-version-truth-check.js",
     "scripts/repo-audit.js",
     "scripts/research-actual-route-backfill-check.js",
@@ -1044,6 +1065,8 @@
     "scripts/wrongness-fixture-check.js",
     "scripts/xai-mcp-capability-check.js",
     "scripts/zellij-capability-check.js",
+    "scripts/zellij-dashboard-pane-check.js",
+    "scripts/zellij-dashboard-watch.js",
     "scripts/zellij-doctor-readiness-check.js",
     "scripts/zellij-lane-renderer-check.js",
     "scripts/zellij-launch-command-truth-check.js",
@@ -1057,6 +1080,7 @@
     "scripts/zellij-ui-design-check.js",
     "scripts/zellij-worker-pane-manager-check.js",
     "scripts/zellij-worker-pane-manager-single-owner-check.js",
+    "scripts/zellij-worker-pane-real-ui-blackbox.js",
     "scripts/zellij-worker-pane-spawn-order-check.js",
     "vendor/openai-codex/latest/hooks/permission-request.command.input.schema.json",
     "vendor/openai-codex/latest/hooks/permission-request.command.output.schema.json",

package/dist/core/agents/agent-command-surface.js

@@ -33,6 +33,8 @@ export function parseAgentCommandArgs(command, args = []) {
     const ollamaBaseUrl = String(readOption(args, '--ollama-base-url', readOption(args, '--local-model-base-url', '')) || '') || null;
     const zellijSessionName = String(readOption(args, '--zellij-session-name', '') || '') || null;
     const zellijPaneWorker = hasFlag(args, '--no-zellij-pane-worker') ? false : hasFlag(args, '--zellij-pane-worker') ? true : undefined;
+    const workerPlacement = String(readOption(args, '--worker-placement', zellijPaneWorker === true ? 'zellij-pane' : '') || '') || undefined;
+    const zellijVisiblePaneCap = Number(readOption(args, '--zellij-visible-pane-cap', process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || 12));
     const apply = hasFlag(args, '--apply');
     const dryRun = hasFlag(args, '--dry-run') || hasFlag(args, '--dryrun');
     const drain = hasFlag(args, '--drain');
@@ -40,7 +42,7 @@ export function parseAgentCommandArgs(command, args = []) {
     const graceMs = Number(readOption(args, '--grace-ms', 750));
     const killEscalation = hasFlag(args, '--kill-escalation') || !hasFlag(args, '--no-kill-escalation');
     const codexApp = hasFlag(args, '--codex-app');
-    const positionals = positionalArgs(rest, new Set(['--agents', '--target-active-slots', '--work-items', '--minimum-work-items', '--max-queue-expansion', '--concurrency', '--backend', '--route', '--mission', '--mission-id', '--agent', '--lane', '--stale-ms', '--grace-ms', '--profile', '--write-mode', '--max-write-agents', '--patch-entry-id', '--patch-entry', '--service-tier', '--zellij-session-name', '--intake', '--agent-root', '--artifact-dir', '--result-path', '--heartbeat-path', '--patch-envelope-path', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url']));
+    const positionals = positionalArgs(rest, new Set(['--agents', '--target-active-slots', '--work-items', '--minimum-work-items', '--max-queue-expansion', '--concurrency', '--backend', '--route', '--mission', '--mission-id', '--agent', '--lane', '--stale-ms', '--grace-ms', '--profile', '--write-mode', '--max-write-agents', '--patch-entry-id', '--patch-entry', '--service-tier', '--zellij-session-name', '--worker-placement', '--zellij-visible-pane-cap', '--intake', '--agent-root', '--artifact-dir', '--result-path', '--heartbeat-path', '--patch-envelope-path', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url']));
     const missionDefault = action === 'run' || action === 'spawn' || action === 'plan' ? '' : 'latest';
     const positionalMission = action === 'run' || action === 'spawn' || action === 'plan' ? '' : (positionals[0] || '');
     const missionId = String(readOption(args, '--mission', readOption(args, '--mission-id', positionalMission || missionDefault)));
@@ -48,7 +50,7 @@ export function parseAgentCommandArgs(command, args = []) {
     const patchEntryId = String(readOption(args, '--patch-entry-id', readOption(args, '--patch-entry', '')));
     const promptPositionals = positionalMission ? positionals.slice(1) : positionals;
     const prompt = promptPositionals.join(' ').trim() || 'Native agent run';
-    return { command, action, prompt, route, agents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency, backend, backendExplicit, mock, real, readonly, profile, writeMode, applyPatches, dryRunPatches, maxWriteAgents, fastMode, serviceTier, noFast, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, zellijSessionName, zellijPaneWorker, apply, dryRun, drain, staleMs, graceMs, killEscalation, json, missionId, lane, codexApp, patchEntryId };
+    return { command, action, prompt, route, agents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency, backend, backendExplicit, mock, real, readonly, profile, writeMode, applyPatches, dryRunPatches, maxWriteAgents, fastMode, serviceTier, noFast, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, zellijSessionName, zellijPaneWorker, workerPlacement, zellijVisiblePaneCap, apply, dryRun, drain, staleMs, graceMs, killEscalation, json, missionId, lane, codexApp, patchEntryId };
 }
 function hasFlag(args, flag) {
     return args.includes(flag);

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

@@ -280,7 +280,8 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         backendExplicit: opts.backendExplicit === true,
         noOllama: opts.noOllama === true,
         route,
-        fastModePolicy
+        fastModePolicy,
+        ...(opts.workerPlacement === undefined ? {} : { workerPlacement: String(opts.workerPlacement) })
     });
     await nativeCliSwarm.initialize();
     await setCurrent(root, { mission_id: missionId, mode: 'AGENT', phase: 'AGENT_NATIVE_KERNEL_RUNNING', route_command: routeCommand, native_agent_backend: backend });

package/dist/core/agents/agent-patch-schema.js

@@ -68,8 +68,10 @@ export function validateAgentPatchEnvelope(envelope) {
             violations.push(`write_content_missing:${operation.path}`);
         if (operation.op === 'unified_diff' && typeof operation.diff !== 'string')
             violations.push(`unified_diff_missing:${operation.path}`);
+        if (operation.op === 'git_apply_patch' && typeof operation.diff !== 'string')
+            violations.push(`git_apply_patch_missing:${operation.path}`);
         const allowedPaths = envelope.allowed_paths?.length ? envelope.allowed_paths : envelope.lease_proof?.allowed_paths;
-        if (allowedPaths?.length && !pathAllowedByLease(operation.path, allowedPaths)) {
+        if (operation.op !== 'git_apply_patch' && allowedPaths?.length && !pathAllowedByLease(operation.path, allowedPaths)) {
             violations.push(`lease_path_not_allowed:${operation.path}`);
         }
     }
@@ -83,7 +85,7 @@ function hasFiniteNumber(value) {
     return value !== null && value !== undefined && value !== '' && Number.isFinite(Number(value));
 }
 function normalizeOperation(input) {
-    const op = input?.op === 'write' ? 'write' : input?.op === 'unified_diff' || input?.op === 'patch' ? 'unified_diff' : 'replace';
+    const op = input?.op === 'write' ? 'write' : input?.op === 'git_apply_patch' ? 'git_apply_patch' : input?.op === 'unified_diff' || input?.op === 'patch' ? 'unified_diff' : 'replace';
     return {
         op,
         path: String(input?.path || ''),

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

@@ -101,7 +101,11 @@ class NativeCliSessionSwarmRecorder {
         };
         const stdout = fs.createWriteStream(path.join(this.root, stdoutRel), { flags: 'a' });
         const stderr = fs.createWriteStream(path.join(this.root, stderrRel), { flags: 'a' });
-        if (this.input.backend === 'zellij' && ctx.opts.real === true && ctx.opts.zellijPaneWorker !== false) {
+        const placement = String(ctx.opts.workerPlacement || this.input.workerPlacement || (this.input.backend === 'zellij' ? 'zellij-pane' : 'process'));
+        const useZellijPane = placement === 'zellij-pane'
+            && ctx.opts.zellijPaneWorker !== false
+            && (ctx.opts.zellijSessionName || this.input.missionId);
+        if (useZellijPane) {
             stdout.end();
             stderr.end();
             return this.launchWorkerInZellijPane({
@@ -233,7 +237,8 @@ class NativeCliSessionSwarmRecorder {
             cwd: workerCwd,
             providerContext,
             serviceTier: this.input.fastModePolicy.service_tier,
-            worktree: worktree ? { id: worktree.id, path: worktree.path, branch: worktree.branch } : null
+            worktree: worktree ? { id: worktree.id, path: worktree.path, branch: worktree.branch } : null,
+            backend: this.input.backend
         });
         const launchBlockers = paneRecord.blockers || [];
         input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--direction', paneRecord.direction_applied, '--name', paneRecord.pane_name, '--', 'sh', '-lc', '<native-cli-worker-command>'];

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

@@ -7,6 +7,7 @@ import { createMission, setCurrent } from '../mission.js';
 import { buildMadHighLaunchProfileNoWrite, madHighProfileName } from '../auto-review.js';
 import { permissionGateSummary } from '../permission-gates.js';
 import { attachZellijSessionInteractive, launchMadZellijUi, sanitizeZellijSessionName } from '../zellij/zellij-launcher.js';
+import { openZellijDashboardPane } from '../zellij/zellij-dashboard-pane.js';
 import { createMadSksAuthorizationManifest, validateMadSksAuthorizationManifest } from '../mad-sks/authorization-manifest.js';
 import { createMadSksAuditLedger, madSksAuditAction, writeMadSksAuditLedger } from '../mad-sks/audit-ledger.js';
 import { compareProtectedCoreSnapshots, evaluateMadSksWrite, resolveProtectedCore, snapshotProtectedCore } from '../mad-sks/immutable-harness-guard.js';
@@ -113,6 +114,30 @@ export async function madHighCommand(args = [], deps = {}) {
         console.log(`MAD Zellij action: ${formatMadZellijAction(launch)}`);
         return launch;
     }
+    launch.dashboard_pane = await openZellijDashboardPane({
+        root: madLaunch.root,
+        missionId: madLaunch.mission_id,
+        sessionName: launch.session_name,
+        cwd: process.cwd(),
+        snapshot: {
+            mode: 'mad-sks',
+            backend_counts: { zellij: 1 },
+            placement_counts: { 'zellij-pane': 1, headless: 0 },
+            active_workers: 1,
+            visible_panes: 1,
+            headless_workers: 0,
+            queue_depth: 0,
+            worktrees: { active: 0, completed: 0, retained: 0 },
+            local_llm: { tps: 0, queue: 0 },
+            gpt_final_status: 'pending',
+            gate_progress: 'mad-sks:session-open'
+        }
+    }).catch((err) => ({
+        ok: false,
+        pane_kind: 'dashboard',
+        worker_pane: false,
+        blockers: [`zellij_dashboard_exception:${err?.message || String(err)}`]
+    }));
     const madNativeSwarm = await startMadNativeSwarm(madLaunch.root, madLaunch, args, profile, {
         env: {
             ...madSksEnv,

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

@@ -14,6 +14,7 @@ import { runNarutoActivePool } from '../naruto/naruto-active-pool.js';
 import { buildNarutoVerificationDag } from '../naruto/naruto-verification-dag.js';
 import { buildNarutoGptFinalPack } from '../naruto/naruto-gpt-final-pack.js';
 import { planNarutoZellijDashboard } from '../zellij/zellij-naruto-dashboard.js';
+import { openZellijDashboardPane } from '../zellij/zellij-dashboard-pane.js';
 import { checkPromptPlaceholders } from '../prompt/prompt-placeholder-guard.js';
 import { evaluateGitWorktreeCapability } from '../git/git-worktree-capability.js';
 const NARUTO_RESULT_SCHEMA = 'sks.naruto-command-result.v1';
@@ -149,6 +150,34 @@ async function narutoRun(parsed) {
             attach: false
         });
         if (liveZellij?.ok && liveZellij.capability?.status === 'ok') {
+            liveZellij.dashboard_pane = await openZellijDashboardPane({
+                root,
+                missionId: mission.id,
+                sessionName: liveZellij.session_name,
+                cwd: root,
+                snapshot: {
+                    mode: 'naruto',
+                    backend_counts: { [schedulerBackend]: activeSlots },
+                    placement_counts: { 'zellij-pane': zellijVisiblePanes, headless: Math.max(0, activeSlots - zellijVisiblePanes) },
+                    active_workers: activeSlots,
+                    visible_panes: zellijVisiblePanes,
+                    headless_workers: Math.max(0, activeSlots - zellijVisiblePanes),
+                    queue_depth: Math.max(0, workGraph.total_work_items - activeSlots),
+                    worktrees: {
+                        active: worktreePolicy.mode === 'git-worktree' ? activeSlots : 0,
+                        completed: 0,
+                        retained: 0
+                    },
+                    local_llm: { tps: 0, queue: localWorker.auto_select_eligible ? Math.max(0, activeSlots - zellijVisiblePanes) : 0 },
+                    gpt_final_status: 'pending',
+                    gate_progress: 'naruto:pre-orchestrator'
+                }
+            }).catch((err) => ({
+                ok: false,
+                pane_kind: 'dashboard',
+                worker_pane: false,
+                blockers: [`zellij_dashboard_exception:${err?.message || String(err)}`]
+            }));
             console.log('Zellij: prepared ' + zellijVisiblePanes + ' visible active clone lane(s) in ' + liveZellij.session_name + ' with ' + Math.max(0, activeSlots - zellijVisiblePanes) + ' headless active worker(s). Attach with: ' + (liveZellij.attach_command_with_env || liveZellij.attach_command));
             if (parsed.attach)
                 attachZellijSessionInteractive(liveZellij.session_name, { cwd: process.cwd(), configPath: liveZellij.clipboard_config_path });

package/dist/core/fsx.js

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

package/dist/core/git/git-repo-detection.js

@@ -18,6 +18,7 @@ export async function detectGitRepo(root = process.cwd()) {
     const bare = await runGitCommand(cwd, ['rev-parse', '--is-bare-repository']);
     const branch = await runGitCommand(cwd, ['branch', '--show-current']);
     const head = await runGitCommand(cwd, ['rev-parse', 'HEAD']);
+    const status = await runGitCommand(cwd, ['status', '--porcelain=v1', '--untracked-files=all']);
     if (!top.ok)
         blockers.push(gitBlocker('git_root_unresolved', top));
     if (!gitDir.ok)
@@ -26,6 +27,8 @@ export async function detectGitRepo(root = process.cwd()) {
         blockers.push(gitBlocker('git_common_dir_unresolved', commonDir));
     if (!head.ok)
         blockers.push(gitBlocker('git_head_unresolved', head));
+    if (!status.ok)
+        blockers.push(gitBlocker('git_status_unresolved', status));
     const repoRoot = top.ok ? path.resolve(gitOutputLine(top)) : null;
     const resolvedGitDir = gitDir.ok ? absolutizeGitPath(cwd, gitOutputLine(gitDir)) : null;
     const resolvedCommonDir = commonDir.ok ? absolutizeGitPath(cwd, gitOutputLine(commonDir)) : null;
@@ -43,6 +46,8 @@ export async function detectGitRepo(root = process.cwd()) {
         worktree_git_dir: resolvedGitDir && resolvedCommonDir && resolvedGitDir !== resolvedCommonDir ? resolvedGitDir : null,
         branch: gitOutputLine(branch) || null,
         head: gitOutputLine(head) || null,
+        main_worktree_dirty: status.ok && status.stdout.trim().length > 0,
+        status_porcelain: status.stdout || '',
         blockers
     };
 }
@@ -61,6 +66,8 @@ function baseDetection(cwd, gitBinary, gitAvailable, blockers) {
         worktree_git_dir: null,
         branch: null,
         head: null,
+        main_worktree_dirty: false,
+        status_porcelain: '',
         blockers
     };
 }

package/dist/core/git/git-worktree-cleanup.js

@@ -7,6 +7,8 @@ export async function cleanupGitWorktree(input) {
     const status = await runGitCommand(worktreePath, ['status', '--porcelain=v1', '--untracked-files=all']);
     const clean = status.ok && status.stdout.trim().length === 0;
     if (!clean) {
+        const reason = `SKS retained dirty failed worker ${path.basename(worktreePath)}`;
+        const lock = await runGitCommand(repoRoot, ['worktree', 'lock', '--reason', reason, worktreePath]);
         const lockPath = `${worktreePath}.retained.json`;
         await writeJsonAtomic(lockPath, {
             schema: 'sks.git-worktree-retention-lock.v1',
@@ -15,7 +17,10 @@ export async function cleanupGitWorktree(input) {
             worktree_path: worktreePath,
             branch: input.branch || null,
             reason: status.ok ? 'dirty_worktree_retained' : 'status_failed_retained',
-            status_porcelain: status.stdout || null
+            status_porcelain: status.stdout || null,
+            git_locked: lock.ok,
+            unlock_command: `git worktree unlock ${JSON.stringify(worktreePath)}`,
+            cleanup_command: 'sks worktree cleanup --mission <id>'
         });
         return {
             schema: 'sks.git-worktree-cleanup.v1',
@@ -27,7 +32,10 @@ export async function cleanupGitWorktree(input) {
             clean: false,
             action: 'retained_dirty',
             retention_lock_path: lockPath,
-            blockers: []
+            blockers: lock.ok ? [] : ['git_worktree_lock_failed'],
+            git_locked: lock.ok,
+            unlock_command: `git worktree unlock ${JSON.stringify(worktreePath)}`,
+            cleanup_command: 'sks worktree cleanup --mission <id>'
         };
     }
     const remove = await runGitCommand(repoRoot, ['worktree', 'remove', worktreePath]);
@@ -45,7 +53,10 @@ export async function cleanupGitWorktree(input) {
         clean: true,
         action: remove.ok ? 'removed' : 'remove_failed',
         retention_lock_path: null,
-        blockers
+        blockers,
+        git_locked: false,
+        unlock_command: null,
+        cleanup_command: null
     };
 }
 //# sourceMappingURL=git-worktree-cleanup.js.map

package/dist/core/git/git-worktree-diff.js

@@ -7,14 +7,19 @@ export async function exportGitWorktreeDiff(input) {
     const branch = await runGitCommand(worktreePath, ['branch', '--show-current']);
     const head = await runGitCommand(worktreePath, ['rev-parse', 'HEAD']);
     const status = await runGitCommand(worktreePath, ['status', '--porcelain=v1', '--untracked-files=all']);
+    const untracked = await runGitCommand(worktreePath, ['ls-files', '--others', '--exclude-standard']);
+    const untrackedFiles = lines(untracked.stdout);
+    if (untrackedFiles.length) {
+        const addIntent = await runGitCommand(worktreePath, ['add', '-N', '--', ...untrackedFiles]);
+        if (!addIntent.ok)
+            blockers.push('git_worktree_untracked_intent_to_add_failed');
+    }
     const diff = await runGitCommand(worktreePath, ['diff', '--binary', '--full-index', 'HEAD']);
     const names = await runGitCommand(worktreePath, ['diff', '--name-only', 'HEAD']);
-    const untracked = await runGitCommand(worktreePath, ['ls-files', '--others', '--exclude-standard']);
     if (!status.ok)
         blockers.push('git_worktree_status_failed');
     if (!diff.ok)
         blockers.push('git_worktree_diff_failed');
-    const untrackedFiles = lines(untracked.stdout);
     const trackedChanged = lines(names.stdout);
     const changedFiles = [...new Set([...trackedChanged, ...untrackedFiles, ...statusFiles(status.stdout)])];
     return {

package/dist/core/git/git-worktree-manager.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import fsp from 'node:fs/promises';
-import { ensureDir, nowIso, writeJsonAtomic } from '../fsx.js';
+import { ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { evaluateGitWorktreeCapability } from './git-worktree-capability.js';
 import { gitBlocker, gitOutputLine, runGitCommand } from './git-worktree-runner.js';
 import { sanitizePathPart } from './git-worktree-root.js';
@@ -67,13 +67,20 @@ export async function allocateWorkerWorktree(input) {
     return allocation;
 }
 async function appendWorktreeManifest(allocation) {
+    const current = await readJson(allocation.manifest_path, null).catch(() => null);
+    const allocations = Array.isArray(current?.allocations) ? current.allocations : [];
+    const key = (row) => `${row.mission_id}:${row.slot_id}:${row.generation_index}:${row.worker_id}`;
+    const nextAllocations = [
+        ...allocations.filter((row) => key(row) !== key(allocation)),
+        allocation
+    ];
     const manifest = {
         schema: 'sks.git-worktree-manifest.v1',
         updated_at: nowIso(),
         mission_id: allocation.mission_id,
         repo_root: allocation.repo_root,
         root: path.dirname(allocation.worktree_path),
-        allocations: [allocation]
+        allocations: nextAllocations
     };
     await writeJsonAtomic(allocation.manifest_path, manifest);
 }

package/dist/core/git/git-worktree-patch-envelope.js

@@ -20,11 +20,11 @@ export function buildGitWorktreePatchEnvelope(input) {
             changed_files: changedFiles,
             diff_bytes: input.diff.diff_bytes
         },
-        operations: changedFiles.map((file) => ({
-            op: 'unified_diff',
-            path: file,
-            diff: input.diff.diff
-        })),
+        operations: [{
+                op: 'git_apply_patch',
+                path: '.',
+                diff: input.diff.diff
+            }],
         rationale: 'Process-generated patch envelope exported from an isolated Git worktree diff.',
         verification_hint: {
             command: 'git apply --3way --check <diff>',

package/dist/core/release/release-gate-cache-v2.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+export const RELEASE_GATE_CACHE_V2_SCHEMA = 'sks.release-gate-cache.v2';
+export function releaseGateCacheFile(root) {
+    return path.join(root, '.sneakoscope', 'reports', 'release-gates', 'cache-v2.json');
+}
+export function releaseGateCacheKey(root, gate) {
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    const hash = crypto.createHash('sha256');
+    hash.update(gate.id);
+    hash.update(gate.command);
+    hash.update(String(pkg.version || ''));
+    hash.update(process.version);
+    hash.update(String(process.env.npm_config_user_agent || ''));
+    hash.update(JSON.stringify(gate.resource || []));
+    hash.update(JSON.stringify(gate.preset || []));
+    hashFileIfPresent(hash, path.join(root, 'release-gates.v2.json'));
+    hashFileIfPresent(hash, path.join(root, 'package.json'));
+    hashFileIfPresent(hash, path.join(root, 'dist', 'build-manifest.json'));
+    for (const input of gate.cache.inputs) {
+        const file = path.join(root, input);
+        if (fs.existsSync(file) && fs.statSync(file).isFile())
+            hashFileIfPresent(hash, file);
+        else
+            hash.update(input);
+    }
+    return hash.digest('hex');
+}
+export function readReleaseGateCacheHit(root, gate) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(releaseGateCacheFile(root), 'utf8'));
+        return parsed.schema === RELEASE_GATE_CACHE_V2_SCHEMA && parsed.records?.[releaseGateCacheKey(root, gate)]?.ok === true;
+    }
+    catch {
+        return false;
+    }
+}
+export function writeReleaseGateCacheHit(root, gate) {
+    const file = releaseGateCacheFile(root);
+    let parsed = { schema: RELEASE_GATE_CACHE_V2_SCHEMA, records: {} };
+    try {
+        parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch { }
+    parsed.schema = RELEASE_GATE_CACHE_V2_SCHEMA;
+    parsed.records ||= {};
+    parsed.records[releaseGateCacheKey(root, gate)] = {
+        ok: true,
+        gate_id: gate.id,
+        command: gate.command,
+        resource: gate.resource,
+        preset: gate.preset,
+        recorded_at: new Date().toISOString()
+    };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(parsed, null, 2)}\n`);
+}
+function hashFileIfPresent(hash, file) {
+    if (fs.existsSync(file) && fs.statSync(file).isFile())
+        hash.update(fs.readFileSync(file));
+}
+//# sourceMappingURL=release-gate-cache-v2.js.map