sneakoscope 3.1.13 → 4.0.0

package/README.md

@@ -35,16 +35,41 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **3.1.13** is a production-hardening release for Codex 0.140 evidence, transactional `sks doctor --fix` repair, MCP readiness, native capability proof, and protected-secret rollback.
+SKS **4.0.0** is the destructive TriWiki Parallel Turbo release. It moves default completion toward affected-scope, release-equivalent proof with reusable TriWiki proof cards, gate packs, SLA scheduling, build-once proof, probe memoization, and explicit legacy-runtime migration instead of silent fallback aliases.
 
-What changed in 3.1.13:
+What changed in 4.0.0:
+
+- **TriWiki proof bank.** Proof cards now bind reusable gate proof to input hash, implementation hash, package lock hash, environment allowlist, fixture version, and tool version.
+- **Affected release-equivalent verification.** Changed files map to module cards, gate impact maps, and gate packs so small tasks can run fast without giving up scoped release confidence.
+- **Parallel SLA planning.** Release gate packs, resource budgets, and SLA certificates expose the planned critical path for five-minute foreground verification.
+- **New control surface.** `sks check`, `sks task`, `sks release`, `sks triwiki`, `sks proof bank status`, and `sks daemon` expose the fast proof pipeline.
+- **No silent legacy fallback.** Compatibility aliases are removed; removed runtimes now use explicit migration notices.
+
+SKS **3.1.16** was a launch-reliability patch on the 3.1.15 doctor-reliability release. It made `sks --mad` self-bootstrap a fresh project instead of dead-ending on a missing Codex config.
+
+What changed in 3.1.16:
+
+- **`sks --mad` bootstraps a fresh project.** When the only preflight blocker is a missing managed Codex config (`.codex/config.toml` absent), `sks --mad` now regenerates it — the `sks doctor --fix` equivalent — and re-runs the preflight, instead of blocking and making you run a separate command. An existing but unreadable/EPERM/parse-broken config still blocks and routes you to `sks doctor --fix`.
+- **Missing-config diagnostics are honest.** A missing config no longer cascades into misleading `macos_acl_ls_le_failed` / `macos_flags_ls_lO_failed` / `spawned_child_read_failed` blockers from running file checks on a nonexistent path; the preflight reports only `missing_config` / `missing_codex_dir`.
+
+SKS **3.1.15** was a doctor-reliability patch on the 3.1.14 production-hardening release. It ended the endless `sks doctor --fix` loop that kept reporting `codex_cli_config_toml_parse_error` / `cli_ready: no` on the very run that already repaired the config.
+
+What changed in 3.1.15:
+
+- **`sks doctor --fix` no longer loops on a config it already fixed.** The Codex config-load probe is re-run *after* the Context7/Supabase/startup MCP repairs land, so the readiness verdict reflects the repaired config instead of the stale pre-repair snapshot.
+- **Context7 is seeded on the remote transport.** Managed setup writes `[mcp_servers.context7]` with the streamable-HTTP `url` instead of a local stdio `command`, so the project config never merges with a remote `url` in the global Codex config into the `url is not supported for stdio` error Codex 0.140 rejects.
+- **The config-load operator action is accurate.** A `codex_cli_config_toml_parse_error` now points at both misplaced machine-local keys *and* the Context7/MCP stdio-vs-`url` transport conflict, instead of only suggesting a key hoist that does nothing for a transport conflict.
+
+The 3.1.14 production-hardening surface for Codex 0.140 evidence, transactional `sks doctor --fix` repair, MCP readiness, native capability proof, and protected-secret rollback remains intact.
+
+What changed in 3.1.14:
 
 - **Codex 0.140 readiness carries evidence.** Capability reports now expose per-feature state and certainty, real usage parsing, goal attachment roundtrip proof, and usage-budget provenance for loop/Naruto runtime decisions.
 - **Doctor repair is phase-based.** `sks doctor --fix` records phase durations, postchecks, optional manual readiness, and rollback evidence instead of collapsing repair work into a summary writer.
 - **Startup and MCP repair are safer.** Managed agent TOML blocks are repaired without touching unrelated config, missing role files are regenerated from real managed templates, Context7 disabled servers stay disabled, and Supabase write scope is separated from read-only readiness.
 - **Secret rollback is line-level when possible.** Protected key changes are restored without discarding unrelated operator edits, nested guard operations are recorded, and backup artifacts remain ignored.
 - **Native capability proof is stricter.** Computer Use and Chrome/web review no longer become verified from environment variables outside explicit fixture/test modes.
-- **Release metadata is aligned for 3.1.13.** Package, lockfile, CLI version constants, Rust helper metadata, README, and changelog all point at the same release.
+- **Release metadata is aligned for 3.1.14.** Package, lockfile, CLI version constants, Rust helper metadata, README, changelog, docs, built output, and release stamp all point at the same release.
 
 SKS 3.0.0 was the parallel-runtime stabilization release. The whole live-swarm experience — what you actually *see* while 5, 20, or 100 workers run — was rebuilt and proven end-to-end.
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "3.1.13"
+version = "4.0.0"
 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 3.1.13"),
+        Some("--version") => println!("sks-rs 4.0.0"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/bin/sks.js

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

package/dist/cli/command-registry.js

@@ -77,6 +77,11 @@ export const COMMANDS = {
     help: entry('stable', 'Show SKS help', 'dist/commands/help.js', directCommand(() => import('../commands/help.js'), 'dist/commands/help.js')),
     version: entry('stable', 'Show SKS version', 'dist/commands/version.js', directCommand(() => import('../commands/version.js'), 'dist/commands/version.js')),
     commands: entry('stable', 'List SKS commands', 'dist/core/commands/basic-cli.js', basicArgs('commandsCommand')),
+    check: entry('stable', 'Run five-minute proof-bank affected checks', 'dist/core/commands/check-command.js', argsCommand(() => import('../core/commands/check-command.js'), 'checkCommand', 'dist/core/commands/check-command.js')),
+    task: entry('stable', 'Run an SLA-bounded SKS task check', 'dist/core/commands/task-command.js', argsCommand(() => import('../core/commands/task-command.js'), 'taskCommand', 'dist/core/commands/task-command.js')),
+    release: entry('stable', 'Run affected/full/background release gates', 'dist/core/commands/release-command.js', argsCommand(() => import('../core/commands/release-command.js'), 'releaseCommand', 'dist/core/commands/release-command.js')),
+    triwiki: entry('stable', 'Inspect TriWiki index, affected graph, and proof bank', 'dist/core/commands/triwiki-command.js', argsCommand(() => import('../core/commands/triwiki-command.js'), 'triwikiCommand', 'dist/core/commands/triwiki-command.js')),
+    daemon: entry('stable', 'Inspect or warm the local SKS daemon cache', 'dist/core/commands/daemon-command.js', argsCommand(() => import('../core/commands/daemon-command.js'), 'daemonCommand', 'dist/core/commands/daemon-command.js')),
     run: entry('beta', 'Classify and execute a task through the SKS trust kernel', 'dist/core/commands/run-command.js', argsCommand(() => import('../core/commands/run-command.js'), 'runCommand', 'dist/core/commands/run-command.js')),
     status: entry('stable', 'Show concise active mission and trust status', 'dist/core/commands/status-command.js', argsCommand(() => import('../core/commands/status-command.js'), 'statusCommand', 'dist/core/commands/status-command.js')),
     root: entry('stable', 'Show active SKS root', 'dist/commands/root.js', directCommand(() => import('../commands/root.js'), 'dist/commands/root.js')),
@@ -159,19 +164,7 @@ export const COMMANDS = {
     bench: entry('beta', 'Run core trust-kernel benchmark budgets', 'dist/core/commands/bench-command.js', argsCommand(() => import('../core/commands/bench-command.js'), 'benchCommand', 'dist/core/commands/bench-command.js'))
 };
 export const TYPED_COMMANDS = COMMANDS;
-export const LEGACY_COMMAND_ALIASES = {
-    auth: 'codex-lb',
-    mad: 'mad-sks',
-    autoreview: 'auto-review',
-    dollars: 'dollar-commands',
-    '$': 'dollar-commands',
-    'ux-review': 'image-ux-review',
-    'visual-review': 'image-ux-review',
-    'ui-ux-review': 'image-ux-review',
-    cu: 'computer-use',
-    grok: 'xai',
-    memory: 'gc'
-};
+export const LEGACY_COMMAND_ALIASES = {};
 export const COMMAND_ALIASES = {
     ...LEGACY_COMMAND_ALIASES,
     '--help': 'help',

package/dist/commands/doctor.js

@@ -35,6 +35,7 @@ import { repairCodexStartupConfig } from '../core/doctor/codex-startup-config-re
 import { repairContext7Mcp } from '../core/doctor/context7-mcp-repair.js';
 import { repairSupabaseMcp } from '../core/doctor/supabase-mcp-repair.js';
 import { runDoctorFixTransaction } from '../core/doctor/doctor-transaction.js';
+import { planDoctorDirtyRepair } from '../core/doctor/doctor-dirty-planner.js';
 import { doctorRepairPostcheck } from '../core/doctor/doctor-repair-postcheck.js';
 import { withSecretPreservationGuard } from '../core/config/config-migration-journal.js';
 export async function run(_command, args = []) {
@@ -143,7 +144,7 @@ async function runDoctor(args = [], root, doctorFix) {
     const migrationJournal = flag(args, '--fix')
         ? await writeFixMigrationJournal(root, migrationPreFix, configRepair, setupRepair).catch(() => null)
         : null;
-    const codexConfig = configRepair?.after || await inspectCodexConfigReadability(root, configProbeOpts);
+    let codexConfig = configRepair?.after || await inspectCodexConfigReadability(root, configProbeOpts);
     const codexDoctor = await runCodexDoctorBridge({ codexBin: codexBin || null, cwd: root, required: flag(args, '--require-actual-codex') });
     const codexDoctorDiff = compareCodexDoctorBridge(codexDoctorBefore, codexDoctor);
     codexStartupRepair = mergeObservedCodexStartupWarnings(codexStartupRepair, codexDoctor);
@@ -284,9 +285,22 @@ async function runDoctor(args = [], root, doctorFix) {
             raw_secret_values_recorded: false
         }))
         : null;
+    const doctorDirtyPlan = doctorFix
+        ? planDoctorDirtyRepair(root, [
+            'setup',
+            'codex_startup_repair',
+            'startup_config_repair',
+            'context7_repair',
+            'context7_mcp_repair',
+            'supabase_mcp_repair',
+            'command_alias_cleanup',
+            'native_capability_repair'
+        ])
+        : null;
     const doctorFixTransaction = doctorFix
         ? await runDoctorFixTransaction({
             root,
+            dirtyPlan: doctorDirtyPlan,
             phases: [
                 {
                     id: 'setup',
@@ -459,6 +473,18 @@ async function runDoctor(args = [], root, doctorFix) {
         blockers: [err?.message || String(err)],
         warnings: []
     }));
+    // Re-probe the Codex config AFTER the MCP transport repairs (Context7 remote
+    // migration, Supabase read-only, startup config) have landed. `repairCodexConfigEperm`
+    // ran its config-load probe ~before~ those repairs, so a config that those repairs
+    // fix in THIS run would otherwise keep `codexConfig.ok === false`, making the doctor
+    // report `cli_ready: no` / `codex_cli_config_toml_parse_error` on the very run that
+    // fixed it — the endless "rerun sks doctor --fix" loop. Only re-probe when the initial
+    // probe failed and we are in --fix mode, so healthy configs pay no extra probe cost.
+    if (doctorFix && codexConfig?.ok === false) {
+        const reinspected = await inspectCodexConfigReadability(root, configProbeOpts).catch(() => null);
+        if (reinspected)
+            codexConfig = reinspected;
+    }
     const pkgBytes = await dirSize(root).catch(() => 0);
     const ready = await writeDoctorReadinessMatrix(root, {
         codex,
@@ -474,6 +500,7 @@ async function runDoctor(args = [], root, doctorFix) {
         context7_mcp_repair: context7McpRepair,
         supabase_mcp_repair: supabaseMcpRepair,
         doctor_fix_transaction: doctorFixTransaction,
+        doctor_dirty_plan: doctorDirtyPlan,
         doctor_fix_postcheck: doctorFixPostcheck,
         local_model: localModel,
         agent_role_config: agentRoleConfigRepair,
@@ -540,7 +567,7 @@ async function runDoctor(args = [], root, doctorFix) {
         ready,
         sneakoscope: { ok: await exists(`${root}/.sneakoscope`) },
         package: { bytes: pkgBytes, human: formatBytes(pkgBytes) },
-        repair: { sks_update: sksUpdate, setup: setupRepair, codex_config: configRepair, migration_journal: migrationJournal, global_sks_installs: globalSksInstallCleanup, agent_role_config: agentRoleConfigRepair, zellij: zellijRepair, context7: context7Repair, codex_startup: codexStartupRepair, startup_config: startupConfigRepair, context7_mcp: context7McpRepair, supabase_mcp: supabaseMcpRepair, doctor_transaction: doctorFixTransaction, doctor_postcheck: doctorFixPostcheck, codex_native: codexNativeRepair, doctor_native_capability: doctorNativeCapabilityRepair, command_aliases: commandAliasCleanup }
+        repair: { sks_update: sksUpdate, setup: setupRepair, codex_config: configRepair, migration_journal: migrationJournal, global_sks_installs: globalSksInstallCleanup, agent_role_config: agentRoleConfigRepair, zellij: zellijRepair, context7: context7Repair, codex_startup: codexStartupRepair, startup_config: startupConfigRepair, context7_mcp: context7McpRepair, supabase_mcp: supabaseMcpRepair, doctor_transaction: doctorFixTransaction, doctor_dirty_plan: doctorDirtyPlan, doctor_postcheck: doctorFixPostcheck, codex_native: codexNativeRepair, doctor_native_capability: doctorNativeCapabilityRepair, command_aliases: commandAliasCleanup }
     };
     if (flag(args, '--json')) {
         printJson(result);

package/dist/commands/proof.js

@@ -9,10 +9,18 @@ import { finalizeRouteWithProof } from '../core/proof/route-finalizer.js';
 import { renderProofMarkdown, writeCompletionProof } from '../core/proof/proof-writer.js';
 import { validateCompletionProof } from '../core/proof/validation.js';
 import { buildRuntimeProofSummary, renderRuntimeProofSummary } from '../core/agents/runtime-proof-summary.js';
+import { summarizeTriWikiProofBank } from '../core/triwiki/triwiki-proof-bank.js';
 export async function run(_command, args = []) {
     const root = await projectRoot();
     const action = args[0] || 'show';
     const rest = args.slice(1);
+    if (action === 'bank' && rest[0] === 'status') {
+        const status = summarizeTriWikiProofBank(root);
+        if (flag(args, '--json'))
+            return printJson(status);
+        console.log(JSON.stringify(status, null, 2));
+        return;
+    }
     if (action === 'latest' && !flag(args, '--completion')) {
         const runtime = await tryRuntimeProofSummary(root);
         if (runtime) {

package/dist/core/agents/agent-cleanup-executor.js

@@ -1,8 +1,9 @@
 import fsp from 'node:fs/promises';
 import path from 'node:path';
-import { appendJsonl, exists, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { appendJsonl, exists, nowIso, packageRoot, readJson, writeJsonAtomic } from '../fsx.js';
 import { drainZellijLaneSupervisor } from './zellij-lane-supervisor.js';
 import { normalizeAgentSessionRows } from './agent-session-rows.js';
+import { closeZellijPaneById } from '../zellij/zellij-worker-pane-manager.js';
 export const AGENT_CLEANUP_PROOF_SCHEMA = 'sks.agent-cleanup-proof.v2';
 export const AGENT_CLEANUP_ACTION_LEDGER_SCHEMA = 'sks.agent-cleanup-action-ledger.v1';
 const TERMINAL_STATUSES = new Set(['closed', 'completed', 'done', 'failed', 'blocked', 'killed', 'timed_out']);
@@ -50,6 +51,7 @@ export async function runAgentCleanupExecutor(opts) {
             killEscalation
         }));
     }
+    const seenZellijPaneIds = new Set();
     const zellijReports = await listNamedFiles(path.join(agentRoot, 'sessions'), 'agent-zellij-report.json');
     for (const file of zellijReports) {
         const report = await readJson(file, null);
@@ -57,6 +59,7 @@ export async function runAgentCleanupExecutor(opts) {
         const sessionId = String(report?.session_id || '');
         if (!paneId)
             continue;
+        seenZellijPaneIds.add(paneId);
         if (!processReportInNamespace(report, projectHash)) {
             actions.push({ kind: 'skip_foreign_namespace', target: paneId, status: 'skipped', reason: 'zellij_pane_outside_project_namespace' });
             continue;
@@ -77,6 +80,77 @@ export async function runAgentCleanupExecutor(opts) {
             }
         }));
     }
+    const workerPaneReports = await listNamedFiles(path.join(agentRoot, 'sessions'), 'zellij-worker-pane.json');
+    for (const file of workerPaneReports) {
+        const report = await readJson(file, null);
+        const paneId = String(report?.pane_id || '');
+        const sessionName = String(report?.session_name || '');
+        const sessionId = String(report?.session_id || '');
+        const status = String(report?.status || '');
+        if (!paneId || !sessionName || seenZellijPaneIds.has(paneId))
+            continue;
+        seenZellijPaneIds.add(paneId);
+        if (opts.missionId && report?.mission_id && String(report.mission_id) !== String(opts.missionId)) {
+            actions.push({ kind: 'skip_foreign_namespace', target: paneId, status: 'skipped', reason: 'zellij_pane_wrong_mission' });
+            continue;
+        }
+        const terminal = TERMINAL_STATUSES.has(status) || Boolean(report?.closed_at);
+        if (activeSessionIds.has(sessionId) && !terminal && opts.drain !== true) {
+            actions.push({ kind: 'skip_active_session', target: sessionId || paneId, status: 'skipped', reason: 'managed_zellij_worker_active' });
+            continue;
+        }
+        actions.push(await applyAction({
+            kind: 'close_zellij_pane',
+            target: paneId,
+            reason: terminal ? 'managed_worker_zellij_pane_terminal' : 'managed_worker_zellij_pane_stale',
+            apply,
+            before: async () => ({ listed: true, pane_id: paneId, session_name: sessionName, source: path.relative(agentRoot, file), status }),
+            after: async () => ({ listed: false, pane_id: paneId, session_name: sessionName }),
+            run: async () => {
+                const close = await closeZellijPaneById(sessionName, paneId, packageRoot());
+                if (close && close.ok !== true)
+                    throw new Error(close.blockers.join(',') || close.stderr_tail || 'zellij_pane_close_failed');
+            }
+        }));
+    }
+    const rightColumnReports = await listNamedFiles(opts.missionDir, 'zellij-right-column-state.json');
+    for (const file of rightColumnReports) {
+        const report = await readJson(file, null);
+        const sessionName = String(report?.session_name || '');
+        if (!sessionName)
+            continue;
+        const visibleActive = (Array.isArray(report?.visible_worker_panes) ? report.visible_worker_panes : [])
+            .some((pane) => pane?.status === 'launching' || pane?.status === 'running');
+        const headlessActive = (Array.isArray(report?.headless_workers) ? report.headless_workers : [])
+            .some((row) => !row?.status || row.status === 'running');
+        const anchorPaneIds = [...new Set([
+                report?.slot_column_anchor_pane_id,
+                report?.right_anchor_pane_id,
+                report?.dashboard_pane_id
+            ].map(String).filter((paneId) => paneId && paneId !== 'null' && paneId !== 'undefined'))];
+        for (const paneId of anchorPaneIds) {
+            if (seenZellijPaneIds.has(paneId))
+                continue;
+            seenZellijPaneIds.add(paneId);
+            if ((visibleActive || headlessActive) && opts.drain !== true) {
+                actions.push({ kind: 'skip_active_session', target: paneId, status: 'skipped', reason: 'zellij_right_column_anchor_active' });
+                continue;
+            }
+            actions.push(await applyAction({
+                kind: 'close_zellij_pane',
+                target: paneId,
+                reason: 'zellij_right_column_anchor_terminal',
+                apply,
+                before: async () => ({ listed: true, pane_id: paneId, session_name: sessionName, source: path.relative(opts.missionDir, file), visible_active: visibleActive, headless_active: headlessActive }),
+                after: async () => ({ listed: false, pane_id: paneId, session_name: sessionName }),
+                run: async () => {
+                    const close = await closeZellijPaneById(sessionName, paneId, packageRoot());
+                    if (close && close.ok !== true)
+                        throw new Error(close.blockers.join(',') || close.stderr_tail || 'zellij_anchor_close_failed');
+                }
+            }));
+        }
+    }
     for (const dir of Array.isArray(namespace?.orphan_temp_dirs) ? namespace.orphan_temp_dirs.map(String) : []) {
         if (!namespaceOwnsPath(dir, projectHash)) {
             actions.push({ kind: 'skip_foreign_namespace', target: dir, status: 'skipped', reason: 'path_outside_project_namespace' });

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

@@ -12,10 +12,19 @@ export function parseAgentCommandArgs(command, args = []) {
     const minimumWorkItems = Number(readOption(args, '--minimum-work-items', targetActiveSlots));
     const maxQueueExpansion = Number(readOption(args, '--max-queue-expansion', 10));
     const concurrency = Number(readOption(args, '--concurrency', Math.min(agents, 5)));
-    const useOllama = hasFlag(args, '--ollama') || hasFlag(args, '--local-model');
+    const useOllamaProtocol = hasFlag(args, '--ollama');
+    const useLocalModel = hasFlag(args, '--local-model');
+    const useOllama = useOllamaProtocol || useLocalModel;
     const noOllama = hasFlag(args, '--no-ollama') || hasFlag(args, '--no-local-model');
-    const backendExplicit = hasOption(args, '--backend');
-    const backend = String(readOption(args, '--backend', hasFlag(args, '--mock') ? 'fake' : useOllama && !noOllama ? 'ollama' : 'codex-sdk'));
+    const backendExplicit = hasOption(args, '--backend') || useOllamaProtocol || useLocalModel || noOllama;
+    const defaultBackend = hasFlag(args, '--mock')
+        ? 'fake'
+        : useLocalModel && !noOllama
+            ? 'local-llm'
+            : useOllamaProtocol && !noOllama
+                ? 'ollama'
+                : 'codex-sdk';
+    const backend = String(readOption(args, '--backend', defaultBackend));
     const route = String(readOption(args, '--route', '$Agent'));
     const mock = hasFlag(args, '--mock') || backend === 'fake';
     const real = hasFlag(args, '--real');
@@ -34,7 +43,7 @@ export function parseAgentCommandArgs(command, args = []) {
     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 zellijVisiblePaneCap = resolveZellijVisiblePaneCap(readOption(args, '--zellij-visible-pane-cap', process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || ''), hasOption(args, '--zellij-visible-pane-cap') || Boolean(process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP));
     const apply = hasFlag(args, '--apply');
     const dryRun = hasFlag(args, '--dry-run') || hasFlag(args, '--dryrun');
     const drain = hasFlag(args, '--drain');
@@ -52,6 +61,22 @@ export function parseAgentCommandArgs(command, args = []) {
     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, workerPlacement, zellijVisiblePaneCap, apply, dryRun, drain, staleMs, graceMs, killEscalation, json, missionId, lane, codexApp, patchEntryId };
 }
+export function resolveZellijVisiblePaneCap(value = '', explicit = false) {
+    const requested = Number(value);
+    if (explicit && Number.isFinite(requested) && requested >= 1)
+        return Math.max(1, Math.floor(requested));
+    const columns = Number(process.env.SKS_ZELLIJ_TERMINAL_COLUMNS || process.env.COLUMNS || process.stdout?.columns || 0);
+    const unknownFallback = Number(process.env.SKS_ZELLIJ_UNKNOWN_VISIBLE_PANE_CAP || 3);
+    if (!Number.isFinite(columns) || columns < 120) {
+        return Math.max(1, Math.floor(Number.isFinite(unknownFallback) ? unknownFallback : 3));
+    }
+    const reservedColumns = Number(process.env.SKS_ZELLIJ_RESERVED_COLUMNS || 108);
+    const minWorkerColumns = Number(process.env.SKS_ZELLIJ_MIN_WORKER_PANE_COLUMNS || 72);
+    const maxAutoVisible = Number(process.env.SKS_ZELLIJ_MAX_AUTO_VISIBLE_PANES || 8);
+    const available = Math.max(0, columns - Math.max(80, reservedColumns));
+    const computed = Math.floor(available / Math.max(40, minWorkerColumns));
+    return Math.max(1, Math.min(Math.max(1, Math.floor(maxAutoVisible || 8)), computed || Math.floor(unknownFallback) || 3));
+}
 function hasFlag(args, flag) {
     return args.includes(flag);
 }

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

@@ -1676,7 +1676,8 @@ async function runAgentByBackend(backend, agent, slice, opts) {
         return runProcessAgent(agent, slice, opts);
     if (backend === 'ollama')
         return runOllamaAgent(agent, slice, opts);
-    if (backend === 'codex-sdk' || backend === 'zellij') {
+    if (backend === 'codex-sdk' || backend === 'zellij' || backend === 'local-llm') {
+        const localPreferred = backend === 'local-llm';
         const ledgerRoot = path.resolve(opts.agentRoot || opts.cwd || process.cwd());
         const workerDir = path.join(ledgerRoot, 'codex-sdk-workers', String(agent.session_id || agent.id || 'agent'), String(slice?.id || 'slice'));
         const writePaths = sdkWritePaths(slice, opts);
@@ -1703,6 +1704,9 @@ async function runAgentByBackend(backend, agent, slice, opts) {
                 user_confirmed_full_access: false,
                 mad_sks_authorized: opts.madSksAuthorized === true || process.env.SKS_MAD_SKS_ACTIVE === '1'
             },
+            backendPreference: localPreferred ? ['local-llm', 'codex-sdk'] : ['codex-sdk'],
+            allowLocalLlm: localPreferred,
+            ...(localPreferred ? { localLlmPolicy: { mode: 'local_preferred', requiresGptFinal: true } } : {}),
             mutationLedgerRoot: workerDir,
             zellijPaneId: null
         });
@@ -1710,9 +1714,11 @@ async function runAgentByBackend(backend, agent, slice, opts) {
         const patchEnvelopes = normalizeDirectSdkPatchEnvelopes(sdkWorkerResult?.patch_envelopes || [], agent, opts, sdkTask.sdkThreadId);
         const sdkReport = {
             schema: 'sks.codex-sdk-worker-adapter.v1',
-            backend: 'codex-sdk',
+            backend: sdkTask.backend === 'local-llm' ? 'local-llm' : 'codex-sdk',
+            backend_family: sdkTask.backend_family,
             sdk_thread_id: sdkTask.sdkThreadId,
             sdk_run_id: sdkTask.sdkRunId,
+            local_llm_proof_path: sdkTask.localLlmProofPath || null,
             stream_event_count: sdkTask.streamEventCount,
             structured_output_valid: sdkTask.structuredOutputValid,
             worker_result_path: path.relative(ledgerRoot, sdkTask.workerResultPath),
@@ -1723,18 +1729,31 @@ async function runAgentByBackend(backend, agent, slice, opts) {
         };
         return validateAgentWorkerResult({
             ...sdkWorkerResult,
-            backend: 'codex-sdk',
+            backend: sdkTask.backend === 'local-llm' ? 'local-llm' : 'codex-sdk',
             patch_envelopes: patchEnvelopes,
             ...(patchEnvelopes.length ? {} : { no_patch_reason: buildDirectNoPatchReason(slice, opts) }),
             codex_child_report: sdkReport,
             codex_sdk_thread: sdkReport,
             model_authored_patch_envelopes: patchEnvelopes.length > 0,
             fixture_patch_envelopes: false,
-            artifacts: [...new Set([...(sdkWorkerResult?.artifacts || []), path.relative(ledgerRoot, sdkTask.workerResultPath), path.join(path.relative(ledgerRoot, workerDir), 'codex-control-proof.json'), path.join(path.relative(ledgerRoot, workerDir), 'codex-thread-registry.json'), path.join(path.relative(ledgerRoot, workerDir), 'codex-sdk-events.jsonl')])],
+            artifacts: [...new Set([
+                    ...(sdkWorkerResult?.artifacts || []),
+                    path.relative(ledgerRoot, sdkTask.workerResultPath),
+                    path.join(path.relative(ledgerRoot, workerDir), 'codex-control-proof.json'),
+                    path.join(path.relative(ledgerRoot, workerDir), 'codex-thread-registry.json'),
+                    path.join(path.relative(ledgerRoot, workerDir), sdkTask.backend === 'local-llm' ? 'local-llm-events.jsonl' : 'codex-sdk-events.jsonl'),
+                    ...(sdkTask.localLlmProofPath ? [path.relative(ledgerRoot, sdkTask.localLlmProofPath)] : [])
+                ])],
             blockers: [...(sdkWorkerResult?.blockers || []), ...sdkTask.blockers],
             verification: {
                 status: sdkTask.ok ? 'passed' : 'failed',
-                checks: [...(sdkWorkerResult?.verification?.checks || []), 'codex-sdk-control-plane', 'codex-sdk-event-stream', 'codex-sdk-structured-output']
+                checks: [
+                    ...(sdkWorkerResult?.verification?.checks || []),
+                    sdkTask.backend === 'local-llm' ? 'local-llm-control-plane' : 'codex-sdk-control-plane',
+                    sdkTask.backend === 'local-llm' ? 'local-llm-event-stream' : 'codex-sdk-event-stream',
+                    sdkTask.backend === 'local-llm' ? 'local-llm-structured-output' : 'codex-sdk-structured-output',
+                    ...(sdkTask.backend === 'local-llm' ? ['gpt-final-required-before-acceptance'] : [])
+                ]
             }
         });
     }
@@ -1753,7 +1772,7 @@ async function maybeSelectOllamaBackend(backend, agent, slice, opts) {
     if (!config?.ok || config.enabled !== true)
         return backend;
     const policy = classifyOllamaWorkerSlice(slice, { route: opts.route, agent });
-    return policy.ok ? 'ollama' : backend;
+    return policy.ok ? 'local-llm' : backend;
 }
 function buildDirectSdkWorkerPrompt(slice) {
     const write = sdkWritePaths(slice, {});

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

@@ -66,7 +66,7 @@ class NativeCliSessionSwarmRecorder {
             patch_envelope_path: patchRel,
             service_tier: this.input.fastModePolicy.service_tier,
             fast_mode: this.input.fastModePolicy.fast_mode,
-            ollama_enabled: ctx.opts.ollamaEnabled === true || this.input.backend === 'ollama',
+            ollama_enabled: ctx.opts.ollamaEnabled === true || this.input.backend === 'ollama' || this.input.backend === 'local-llm',
             ollama_model: ctx.opts.ollamaModel || null,
             ollama_base_url: ctx.opts.ollamaBaseUrl || null,
             source_intelligence_refs: ctx.agent.source_intelligence_refs || null,

package/dist/core/build/build-once-runner.js

@@ -0,0 +1,62 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { computeTriWikiCacheKey } from '../triwiki/triwiki-cache-key.js';
+export const BUILD_ONCE_PROOF_SCHEMA = 'sks.build-once-proof.v1';
+export function runBuildOnce(input) {
+    const mode = input.mode || 'incremental';
+    const key = computeTriWikiCacheKey({
+        root: input.root,
+        id: `build-once:${mode}`,
+        inputs: ['src/**/*.ts', 'package.json', 'package-lock.json', 'tsconfig.json'],
+        implementationFiles: ['tsconfig.json'],
+        envAllowlist: ['NODE_ENV', 'CI'],
+        fixtureVersion: 'sks-4.0.0'
+    });
+    const existing = readBuildOnceProof(input.root);
+    if (!input.force && existing?.ok === true && existing.cache_key === key.key) {
+        return { ...existing, reused: true };
+    }
+    const started = Date.now();
+    const run = spawnSync('npm', ['run', mode === 'clean' ? 'build:clean' : 'build:incremental', '--silent'], {
+        cwd: input.root,
+        encoding: 'utf8',
+        maxBuffer: 1024 * 1024 * 20,
+        env: { ...process.env, CI: process.env.CI || 'true' }
+    });
+    const proof = {
+        schema: BUILD_ONCE_PROOF_SCHEMA,
+        ok: run.status === 0,
+        mode,
+        cache_key: key.key,
+        created_at: new Date().toISOString(),
+        status: run.status,
+        duration_ms: Math.max(0, Date.now() - started),
+        reused: false,
+        blockers: run.status === 0 ? [] : [`build_failed:${run.status ?? 'signal'}`]
+    };
+    writeBuildOnceProof(input.root, proof);
+    return proof;
+}
+export function readBuildOnceProof(root) {
+    const file = buildProofPath(root);
+    try {
+        if (!fs.existsSync(file))
+            return null;
+        const json = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return json.schema === BUILD_ONCE_PROOF_SCHEMA ? json : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeBuildOnceProof(root, proof) {
+    const file = buildProofPath(root);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(proof, null, 2)}\n`);
+    return file;
+}
+function buildProofPath(root) {
+    return path.join(root, 'dist', '.sks-build-proof.json');
+}
+//# sourceMappingURL=build-once-runner.js.map