sneakoscope 4.0.0 → 4.0.1

package/README.md

@@ -35,9 +35,9 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-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.
+SKS **4.0.1** is the TriWiki Turbo completion release. It moves default completion toward affected-scope, release-equivalent proof with reusable TriWiki proof cards, real gate pack execution, SLA scheduling, build-once proof, probe memoization, and explicit legacy-runtime migration instead of silent fallback aliases.
 
-What changed in 4.0.0:
+What changed in 4.0.1:
 
 - **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.

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "4.0.0"
+version = "4.0.1"
 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 4.0.0"),
+        Some("--version") => println!("sks-rs 4.0.1"),
         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 = '4.0.0';
+const FAST_PACKAGE_VERSION = '4.0.1';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

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

@@ -11,7 +11,7 @@ export function runBuildOnce(input) {
         inputs: ['src/**/*.ts', 'package.json', 'package-lock.json', 'tsconfig.json'],
         implementationFiles: ['tsconfig.json'],
         envAllowlist: ['NODE_ENV', 'CI'],
-        fixtureVersion: 'sks-4.0.0'
+        fixtureVersion: 'sks-4.0.1'
     });
     const existing = readBuildOnceProof(input.root);
     if (!input.force && existing?.ok === true && existing.cache_key === key.key) {
@@ -29,6 +29,10 @@ export function runBuildOnce(input) {
         ok: run.status === 0,
         mode,
         cache_key: key.key,
+        source_hash: key.input_hash,
+        package_lock_hash: key.package_lock_hash,
+        tsconfig_hash: computeTriWikiCacheKey({ root: input.root, id: 'build-once:tsconfig', inputs: ['tsconfig.json'] }).input_hash,
+        dist_hash: computeTriWikiCacheKey({ root: input.root, id: 'build-once:dist', inputs: ['dist'] }).input_hash,
         created_at: new Date().toISOString(),
         status: run.status,
         duration_ms: Math.max(0, Date.now() - started),

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

@@ -12,7 +12,8 @@ export async function checkCommand(args = []) {
     const changedSince = readArg(args, '--changed-since', 'auto');
     const json = flag(args, '--json');
     const planOnly = flag(args, '--plan');
-    const plan = buildCheckPlan({ tier, sla, changedSince });
+    const triwiki = !flag(args, '--no-triwiki');
+    const plan = buildCheckPlan({ tier, sla, changedSince, triwiki });
     if (planOnly) {
         const result = { schema: CHECK_SCHEMA, ok: true, mode: 'plan', ...plan };
         if (json)
@@ -73,6 +74,7 @@ function buildCheckPlan(input) {
     return {
         tier,
         sla: input.sla,
+        triwiki: input.triwiki,
         changed_since: input.changedSince,
         build_once: tier === 'release' ? 'clean' : tier === 'real-check' || tier === 'instant' ? 'not_applicable' : 'incremental',
         steps

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

@@ -234,10 +234,15 @@ export async function madHighCommand(args = [], deps = {}) {
         SKS_MAD_SKS_PROTECTED_CORE_DIGEST: madLaunch.gate.protected_core_digest
     };
     const launchOpts = codexLbImmediateLaunchOpts(cleanArgs, launchLb, { codexArgs: profile.launch_args, conciseBlockers: true, madSksEnv, launchEnv: madSksEnv });
-    const workspace = readOption(cleanArgs, '--workspace', readOption(cleanArgs, '--session', launchOpts.session || `sks-mad-${sanitizeZellijSessionName(process.cwd())}`));
+    const explicitWorkspace = readOption(cleanArgs, '--workspace', readOption(cleanArgs, '--session', null));
+    // Only the auto-derived stable `sks-mad-<cwd>` name accumulates panes across
+    // runs; when the user names a session explicitly (or codex-lb already minted a
+    // fresh unique session) respect it and skip the reset.
+    const autoDerivedMadSession = !explicitWorkspace && !launchOpts.session;
+    const workspace = explicitWorkspace || launchOpts.session || `sks-mad-${sanitizeZellijSessionName(process.cwd())}`;
     const launch = headlessZellij
         ? await writeMadHeadlessZellijFallback(madLaunch, workspace)
-        : await launchMadZellijUi([...cleanArgs, '--workspace', workspace], { ...launchOpts, missionId: madLaunch.mission_id, root: madLaunch.root, cwd: process.cwd(), ledgerRoot: path.join(madLaunch.dir, 'agents'), slotCount: 0, requireZellij: process.env.SKS_REQUIRE_ZELLIJ === '1' });
+        : await launchMadZellijUi([...cleanArgs, '--workspace', workspace], { ...launchOpts, missionId: madLaunch.mission_id, root: madLaunch.root, cwd: process.cwd(), ledgerRoot: path.join(madLaunch.dir, 'agents'), slotCount: 0, freshSession: autoDerivedMadSession, requireZellij: process.env.SKS_REQUIRE_ZELLIJ === '1' });
     const afterLaunchUi = beforeUi ? await writeCodexAppUiSnapshot(launchRoot, `mad-after-launch-${uiSnapshotId}`).catch(() => null) : null;
     const launchUiDiff = beforeUi && afterLaunchUi ? diffCodexAppUiSnapshots(beforeUi, afterLaunchUi) : null;
     if (launchUiDiff) {

package/dist/core/daemon/sksd-ipc.js

@@ -0,0 +1,9 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function writeSksdIpcMessage(root, action) {
+    const file = path.join(root, '.sneakoscope', 'cache', 'sksd', 'last-message.json');
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify({ schema: 'sks.sksd-ipc-message.v1', action, created_at: new Date().toISOString(), pid: process.pid }, null, 2)}\n`);
+    return file;
+}
+//# sourceMappingURL=sksd-ipc.js.map

package/dist/core/daemon/sksd.js

@@ -3,7 +3,14 @@ import path from 'node:path';
 export const SKSD_STATE_SCHEMA = 'sks.sksd-state.v1';
 export function sksdStatus(root) {
     const state = readState(root);
-    return state || emptyState();
+    if (!state)
+        return emptyState(root);
+    if (state.pid && !pidAlive(state.pid)) {
+        const stopped = { ...emptyState(root), stale_cleaned: true };
+        writeState(root, stopped);
+        return stopped;
+    }
+    return state;
 }
 export function sksdWarm(root) {
     const state = {
@@ -11,15 +18,23 @@ export function sksdWarm(root) {
         status: 'warm',
         pid: process.pid,
         warmed_at: new Date().toISOString(),
+        ipc_path: ipcPath(root),
         proof_bank_ready: true,
-        build_proof_ready: fs.existsSync(path.join(root, 'dist', '.sks-build-proof.json'))
+        build_proof_ready: fs.existsSync(path.join(root, 'dist', '.sks-build-proof.json')),
+        triwiki_index_ready: fs.existsSync(path.join(root, '.sneakoscope', 'wiki', 'context-pack.json')),
+        probe_memoization_ready: fs.existsSync(path.join(root, '.sneakoscope', 'cache', 'probes'))
     };
     writeState(root, state);
+    fs.writeFileSync(ipcPath(root), `${JSON.stringify({ schema: 'sks.sksd-ipc.v1', pid: process.pid, command: 'warm', at: new Date().toISOString() }, null, 2)}\n`);
     return state;
 }
 export function sksdStop(root) {
-    const state = { ...emptyState(), status: 'stopped' };
+    const state = { ...emptyState(root), status: 'stopped' };
     writeState(root, state);
+    try {
+        fs.rmSync(ipcPath(root), { force: true });
+    }
+    catch { }
     return state;
 }
 function readState(root) {
@@ -42,14 +57,31 @@ function writeState(root, state) {
 function statePath(root) {
     return path.join(root, '.sneakoscope', 'cache', 'sksd-state.json');
 }
-function emptyState() {
+function emptyState(root = process.cwd()) {
     return {
         schema: SKSD_STATE_SCHEMA,
         status: 'stopped',
         pid: null,
         warmed_at: null,
+        ipc_path: ipcPath(root),
         proof_bank_ready: false,
-        build_proof_ready: false
+        build_proof_ready: false,
+        triwiki_index_ready: false,
+        probe_memoization_ready: false
     };
 }
+function ipcPath(root) {
+    const dir = path.join(root, '.sneakoscope', 'cache', 'sksd');
+    fs.mkdirSync(dir, { recursive: true });
+    return path.join(dir, 'sksd.ipc.json');
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=sksd.js.map

package/dist/core/doctor/doctor-dirty-planner.js

@@ -1,25 +1,37 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { hashJson } from '../triwiki/triwiki-cache-key.js';
 export const DOCTOR_DIRTY_PLAN_SCHEMA = 'sks.doctor-dirty-plan.v1';
 export function planDoctorDirtyRepair(root, phaseIds) {
     const phases = phaseIds.map((id) => {
         const marker = markerPath(root, id);
-        if (!fs.existsSync(marker))
-            return { id, status: 'dirty', reason: 'no_clean_marker' };
-        return { id, status: 'clean', reason: 'clean_marker_present' };
+        const inputHash = phaseInputHash(root, id);
+        const postcheckRequired = phaseRequiresPostcheck(id);
+        const markerState = readMarker(marker);
+        if (!markerState)
+            return { id, status: 'dirty', reason: 'no_clean_marker', input_hash: inputHash, last_clean_proof_id: null, postcheck_required: postcheckRequired };
+        if (markerState.input_hash !== inputHash) {
+            return { id, status: 'dirty', reason: 'input_hash_changed', input_hash: inputHash, last_clean_proof_id: markerState.proof_id, postcheck_required: postcheckRequired };
+        }
+        if (postcheckRequired && !markerState.postcheck_passed) {
+            return { id, status: 'dirty', reason: 'postcheck_required', input_hash: inputHash, last_clean_proof_id: markerState.proof_id, postcheck_required: true };
+        }
+        return { id, status: 'clean', reason: 'matching_clean_proof', input_hash: inputHash, last_clean_proof_id: markerState.proof_id, postcheck_required: postcheckRequired };
     });
-    return {
+    const plan = {
         schema: DOCTOR_DIRTY_PLAN_SCHEMA,
         root,
         phases,
         dirty_count: phases.filter((phase) => phase.status === 'dirty').length,
         clean_count: phases.filter((phase) => phase.status === 'clean').length
     };
+    writeDirtyPlan(root, plan);
+    return plan;
 }
 export function markDoctorPhaseClean(root, id) {
     const file = markerPath(root, id);
     fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, `${new Date().toISOString()}\n`);
+    fs.writeFileSync(file, `${JSON.stringify({ schema: 'sks.doctor-dirty-clean-proof.v1', proof_id: `doctor-${id}-${Date.now()}`, cleaned_at: new Date().toISOString(), input_hash: phaseInputHash(root, id), postcheck_passed: true }, null, 2)}\n`);
 }
 export function isDoctorPhaseClean(plan, id) {
     return plan?.phases.find((phase) => phase.id === id)?.status === 'clean';
@@ -27,4 +39,57 @@ export function isDoctorPhaseClean(plan, id) {
 function markerPath(root, id) {
     return path.join(root, '.sneakoscope', 'cache', 'doctor-dirty', `${id.replace(/[^a-zA-Z0-9._-]+/g, '_')}.clean`);
 }
+function readMarker(file) {
+    try {
+        if (!fs.existsSync(file))
+            return null;
+        const raw = fs.readFileSync(file, 'utf8');
+        if (!raw.trim().startsWith('{'))
+            return { proof_id: null, input_hash: null, postcheck_passed: false };
+        const json = JSON.parse(raw);
+        return { proof_id: json.proof_id || null, input_hash: json.input_hash || null, postcheck_passed: json.postcheck_passed === true };
+    }
+    catch {
+        return null;
+    }
+}
+function phaseInputHash(root, id) {
+    const files = phaseInputFiles(id).map((rel) => {
+        const file = path.join(root, rel);
+        if (!fs.existsSync(file))
+            return { rel, hash: 'missing' };
+        const stat = fs.statSync(file);
+        return { rel, hash: stat.isDirectory() ? `dir:${stat.mtimeMs}` : hashJson({ size: stat.size, mtimeMs: stat.mtimeMs, text: stat.size < 512_000 ? fs.readFileSync(file, 'utf8') : '' }) };
+    });
+    return hashJson({ id, files, env: phaseEnvPresence(id) });
+}
+function phaseInputFiles(id) {
+    if (id.includes('zellij'))
+        return ['src/core/zellij', 'src/core/doctor/doctor-zellij-repair.ts'];
+    if (id.includes('context7'))
+        return ['src/core/doctor/context7-mcp-repair.ts', '.codex/config.toml'];
+    if (id.includes('startup'))
+        return ['src/core/doctor/codex-startup-config-repair.ts', '.codex/config.toml'];
+    if (id.includes('supabase'))
+        return ['src/core/doctor/supabase-mcp-repair.ts', '.codex/config.toml'];
+    if (id.includes('skill'))
+        return ['.agents/skills', 'src/scripts/skill-registry-ledger-check.ts'];
+    if (id.includes('native'))
+        return ['src/core/codex-native', 'src/scripts/native-capability-postcheck-check.ts'];
+    if (id.includes('secret'))
+        return ['safety-mutation-allowlist.json', 'src/scripts/secret-preservation-check.ts'];
+    return ['package.json', 'src/core/doctor'];
+}
+function phaseEnvPresence(id) {
+    const keys = id.includes('supabase') ? ['SUPABASE_ACCESS_TOKEN'] : id.includes('context7') ? ['CONTEXT7_API_KEY'] : [];
+    return Object.fromEntries(keys.map((key) => [key, process.env[key] !== undefined]));
+}
+function phaseRequiresPostcheck(id) {
+    return /zellij|context7|startup|supabase|native|secret/i.test(id);
+}
+function writeDirtyPlan(root, plan) {
+    const file = path.join(root, '.sneakoscope', 'reports', 'doctor-dirty-plan.json');
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(plan, null, 2)}\n`);
+}
 //# sourceMappingURL=doctor-dirty-planner.js.map

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 = '4.0.0';
+export const PACKAGE_VERSION = '4.0.1';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/probes/probe-memoization.js

@@ -6,7 +6,8 @@ export function memoizeProbe(input) {
     const key = hashJson({
         probe_id: input.probeId,
         version: input.version,
-        env: (input.envAllowlist || []).sort().map((name) => ({ name, present: process.env[name] !== undefined }))
+        env: envPresence(input.envAllowlist || []),
+        file_hash: input.fileHash || null
     });
     const file = probeCachePath(input.root, key);
     const existing = readProbeRecord(file);
@@ -19,12 +20,41 @@ export function memoizeProbe(input) {
         probe_id: input.probeId,
         created_at: new Date().toISOString(),
         expires_at: new Date(Date.now() + input.ttlMs).toISOString(),
-        value
+        value,
+        tool_version: input.version,
+        ...(input.fileHash ? { file_hash: input.fileHash } : {}),
+        env_allowlist_hash: hashJson(envPresence(input.envAllowlist || []))
     };
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`);
     return { value, reused: false, key };
 }
+export async function memoizeProbeAsync(input) {
+    const key = hashJson({ probe_id: input.probeId, version: input.version, env: envPresence(input.envAllowlist || []), file_hash: input.fileHash || null });
+    const file = probeCachePath(input.root, key);
+    const existing = readProbeRecord(file);
+    if (existing && new Date(existing.expires_at).getTime() > Date.now()) {
+        writeProbeReport(input.root, { repeated_probe_count: 1, reused_probe_count: 1, saved_ms_estimate: Math.max(1, input.ttlMs / 1000) });
+        return { value: existing.value, reused: true, key };
+    }
+    const started = Date.now();
+    const value = await input.run();
+    const record = {
+        schema: PROBE_MEMOIZATION_SCHEMA,
+        key,
+        probe_id: input.probeId,
+        created_at: new Date().toISOString(),
+        expires_at: new Date(Date.now() + input.ttlMs).toISOString(),
+        value,
+        tool_version: input.version,
+        ...(input.fileHash ? { file_hash: input.fileHash } : {}),
+        env_allowlist_hash: hashJson(envPresence(input.envAllowlist || []))
+    };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`);
+    writeProbeReport(input.root, { repeated_probe_count: 1, reused_probe_count: 0, saved_ms_estimate: Math.max(0, Date.now() - started) });
+    return { value, reused: false, key };
+}
 function readProbeRecord(file) {
     try {
         if (!fs.existsSync(file))
@@ -39,4 +69,12 @@ function readProbeRecord(file) {
 function probeCachePath(root, key) {
     return path.join(root, '.sneakoscope', 'cache', 'probes', `${key}.json`);
 }
+function envPresence(keys) {
+    return [...new Set(keys)].sort().map((name) => ({ name, present: process.env[name] !== undefined }));
+}
+function writeProbeReport(root, report) {
+    const file = path.join(root, '.sneakoscope', 'reports', 'probe-memoization.json');
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify({ schema: 'sks.probe-memoization-report.v1', ...report }, null, 2)}\n`);
+}
 //# sourceMappingURL=probe-memoization.js.map

package/dist/core/release/critical-path-ledger.js

@@ -0,0 +1,12 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function buildCriticalPathLedger(input) {
+    return { schema: 'sks.critical-path-ledger.v1', ...input };
+}
+export function writeCriticalPathLedger(root, ledger) {
+    const file = path.join(root, '.sneakoscope', 'reports', 'critical-path-ledger.json');
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(ledger, null, 2)}\n`);
+    return file;
+}
+//# sourceMappingURL=critical-path-ledger.js.map

package/dist/core/release/extreme-parallel-scheduler.js

@@ -1,4 +1,6 @@
 import { buildGatePackManifest } from './gate-pack-manifest.js';
+import { executeGatePack } from './gate-pack-runner.js';
+import { buildCriticalPathLedger, writeCriticalPathLedger } from './critical-path-ledger.js';
 import { computeResourceClassBudget } from './resource-class-budget.js';
 export const EXTREME_PARALLEL_SCHEDULER_SCHEMA = 'sks.extreme-parallel-scheduler.v1';
 export function planExtremeParallelSchedule(root, graph, budget = computeResourceClassBudget()) {
@@ -30,4 +32,55 @@ export function planExtremeParallelSchedule(root, graph, budget = computeResourc
         blockers
     };
 }
+export async function executeExtremeSchedule(input) {
+    const planned = planExtremeParallelSchedule(input.root, input.graph, input.budget);
+    const started = Date.now();
+    const runId = `xs-${new Date().toISOString().replace(/[:.]/g, '-')}-${process.pid}`;
+    const reports = [];
+    let reused = 0;
+    let executedGates = 0;
+    let failedPacks = 0;
+    for (const batch of planned.batches) {
+        const results = await Promise.all(batch.packs.map((packId) => executeGatePack({
+            root: input.root,
+            packId,
+            mode: 'execute',
+            maxParallel: Math.max(1, Math.min(4, input.budget.cpu_light))
+        })));
+        for (const report of results) {
+            reports.push(report);
+            reused += report.reused_proof_count || report.reused || 0;
+            executedGates += report.executed_gate_count || report.executed || 0;
+            if (!report.ok)
+                failedPacks += 1;
+        }
+    }
+    const wallMs = Math.max(0, Date.now() - started);
+    const criticalPathMs = reports.reduce((max, report) => Math.max(max, report.critical_path_ms || 0), planned.critical_path_ms);
+    const sequentialMs = reports.reduce((sum, report) => sum + (report.critical_path_ms || 0), planned.sequential_ms);
+    writeCriticalPathLedger(input.root, buildCriticalPathLedger({
+        run_id: runId,
+        sequential_ms: sequentialMs,
+        critical_path_ms: criticalPathMs,
+        wall_ms: wallMs,
+        parallelism_gain: wallMs > 0 ? Number((sequentialMs / wallMs).toFixed(2)) : 1,
+        resource_wait_ms: {},
+        top_blockers: reports.filter((report) => !report.ok).map((report) => ({ id: report.pack_id, wait_ms: 0, run_ms: report.critical_path_ms || 0 }))
+    }));
+    return {
+        ...planned,
+        ok: planned.ok && failedPacks === 0 && wallMs <= input.slaMs,
+        run_id: runId,
+        mode: 'execute',
+        executed_packs: reports.map((report) => report.pack_id),
+        reused_proof_count: reused,
+        executed_gate_count: executedGates,
+        failed_pack_count: failedPacks,
+        wall_ms: wallMs,
+        critical_path_ms: criticalPathMs,
+        sequential_ms: sequentialMs,
+        pack_reports: reports,
+        blockers: [...planned.blockers, ...(wallMs > input.slaMs ? ['sla_actual_exceeds_budget'] : []), ...(failedPacks ? ['pack_execution_failed'] : [])]
+    };
+}
 //# sourceMappingURL=extreme-parallel-scheduler.js.map

package/dist/core/release/gate-pack-fixture-cache.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const GATE_PACK_FIXTURE_SCHEMA = 'sks.gate-pack-fixture.v1';
+export async function prepareGatePackFixture(input) {
+    const base = path.join(input.root, '.sneakoscope', 'fixture-cache', 'gate-packs', safe(input.packId), safe(input.fixtureVersion));
+    const reusedBase = fs.existsSync(path.join(base, 'fixture.json'));
+    fs.mkdirSync(base, { recursive: true });
+    if (!reusedBase) {
+        fs.writeFileSync(path.join(base, 'fixture.json'), `${JSON.stringify({ schema: GATE_PACK_FIXTURE_SCHEMA, pack_id: input.packId, fixture_version: input.fixtureVersion, created_at: new Date().toISOString() }, null, 2)}\n`);
+    }
+    const runPath = path.join(input.root, '.sneakoscope', 'fixture-cache', 'runs', `${safe(input.packId)}-${process.pid}-${Date.now()}`);
+    fs.mkdirSync(path.dirname(runPath), { recursive: true });
+    copyDir(base, runPath);
+    return {
+        schema: GATE_PACK_FIXTURE_SCHEMA,
+        root: input.root,
+        pack_id: input.packId,
+        fixture_version: input.fixtureVersion,
+        base_path: base,
+        run_path: runPath,
+        reused_base: reusedBase,
+        setup_count: reusedBase ? 0 : 1
+    };
+}
+function copyDir(from, to) {
+    fs.mkdirSync(to, { recursive: true });
+    for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+        const src = path.join(from, entry.name);
+        const dst = path.join(to, entry.name);
+        if (entry.isDirectory())
+            copyDir(src, dst);
+        else if (entry.isFile())
+            fs.copyFileSync(src, dst);
+    }
+}
+function safe(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, '_');
+}
+//# sourceMappingURL=gate-pack-fixture-cache.js.map