sneakoscope 2.0.6 → 2.0.8

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

@@ -0,0 +1,62 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { runGitCommand } from './git-worktree-runner.js';
+export async function cleanupGitWorktree(input) {
+    const repoRoot = path.resolve(input.repoRoot);
+    const worktreePath = path.resolve(input.worktreePath);
+    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',
+            generated_at: nowIso(),
+            repo_root: repoRoot,
+            worktree_path: worktreePath,
+            branch: input.branch || null,
+            reason: status.ok ? 'dirty_worktree_retained' : 'status_failed_retained',
+            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',
+            ok: true,
+            generated_at: nowIso(),
+            repo_root: repoRoot,
+            worktree_path: worktreePath,
+            branch: input.branch || null,
+            clean: false,
+            action: 'retained_dirty',
+            retention_lock_path: lockPath,
+            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]);
+    const blockers = remove.ok ? [] : ['git_worktree_remove_failed'];
+    if (remove.ok && input.deleteBranch === true && input.branch) {
+        await runGitCommand(repoRoot, ['branch', '-D', input.branch]);
+    }
+    return {
+        schema: 'sks.git-worktree-cleanup.v1',
+        ok: blockers.length === 0,
+        generated_at: nowIso(),
+        repo_root: repoRoot,
+        worktree_path: worktreePath,
+        branch: input.branch || null,
+        clean: true,
+        action: remove.ok ? 'removed' : 'remove_failed',
+        retention_lock_path: null,
+        blockers,
+        git_locked: false,
+        unlock_command: null,
+        cleanup_command: null
+    };
+}
+//# sourceMappingURL=git-worktree-cleanup.js.map

package/dist/core/git/git-worktree-conflict-resolver.js

@@ -0,0 +1,13 @@
+export function summarizeGitWorktreeConflict(input) {
+    const stderr = String(input.stderr || '');
+    return {
+        schema: 'sks.git-worktree-conflict.v1',
+        ok: false,
+        worker_id: input.workerId,
+        changed_files: input.changedFiles,
+        stderr_tail: stderr.slice(-4000),
+        conflict_markers_possible: /conflict|patch failed|does not apply/i.test(stderr),
+        blockers: ['git_worktree_diff_apply_failed']
+    };
+}
+//# sourceMappingURL=git-worktree-conflict-resolver.js.map

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

@@ -0,0 +1,55 @@
+import path from 'node:path';
+import { nowIso } from '../fsx.js';
+import { gitOutputLine, runGitCommand } from './git-worktree-runner.js';
+export async function exportGitWorktreeDiff(input) {
+    const worktreePath = path.resolve(input.worktreePath);
+    const blockers = [];
+    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']);
+    if (!status.ok)
+        blockers.push('git_worktree_status_failed');
+    if (!diff.ok)
+        blockers.push('git_worktree_diff_failed');
+    const trackedChanged = lines(names.stdout);
+    const changedFiles = [...new Set([...trackedChanged, ...untrackedFiles, ...statusFiles(status.stdout)])];
+    return {
+        schema: 'sks.git-worktree-diff.v1',
+        ok: blockers.length === 0,
+        generated_at: nowIso(),
+        mission_id: input.missionId,
+        worker_id: input.workerId,
+        main_repo_root: path.resolve(input.mainRepoRoot),
+        worktree_path: worktreePath,
+        branch: gitOutputLine(branch) || null,
+        base_head: null,
+        worktree_head: gitOutputLine(head) || null,
+        status_porcelain: status.stdout,
+        changed_files: changedFiles,
+        untracked_files: untrackedFiles,
+        diff: diff.stdout,
+        diff_bytes: Buffer.byteLength(diff.stdout),
+        clean: changedFiles.length === 0 && status.stdout.trim().length === 0,
+        blockers
+    };
+}
+function lines(text) {
+    return String(text || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+function statusFiles(text) {
+    return lines(text).map((line) => {
+        const match = line.match(/^.{2}\s+(.*)$/) || line.match(/^\S+\s+(.*)$/);
+        const file = (match?.[1] || line).trim();
+        return file.includes(' -> ') ? file.split(' -> ').pop()?.trim() || file : file;
+    }).filter(Boolean);
+}
+//# sourceMappingURL=git-worktree-diff.js.map

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

@@ -0,0 +1,93 @@
+import path from 'node:path';
+import fsp from 'node:fs/promises';
+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';
+export async function allocateWorkerWorktree(input) {
+    const capability = await evaluateGitWorktreeCapability({
+        root: input.repoRoot || process.cwd(),
+        missionId: input.missionId,
+        requireGitWorktree: true
+    });
+    const repoRoot = capability.detection.root || path.resolve(input.repoRoot || process.cwd());
+    const root = capability.root_resolution?.root || path.join(repoRoot, '.sneakoscope', 'blocked-worktrees');
+    const workerId = sanitizePathPart(input.workerId);
+    const slotId = sanitizePathPart(input.slotId || workerId);
+    const generationIndex = Math.max(1, Math.floor(Number(input.generationIndex || 1)));
+    const baseRef = input.baseRef || capability.detection.head || 'HEAD';
+    const branchPrefix = sanitizeBranchPart(input.branchPrefix || 'sks');
+    const branch = `${branchPrefix}/${sanitizeBranchPart(input.missionId)}/${sanitizeBranchPart(slotId)}-gen-${generationIndex}-${workerId}`;
+    const worktreePath = path.join(root, `${slotId}-gen-${generationIndex}-${workerId}`);
+    const blockers = [...capability.blockers];
+    let baseHead = capability.detection.head;
+    if (capability.ok) {
+        await ensureDir(root);
+        let add = null;
+        for (let attempt = 1; attempt <= 3; attempt += 1) {
+            if (attempt > 1) {
+                await sleep(250 * attempt);
+                await runGitCommand(repoRoot, ['worktree', 'prune'], { timeoutMs: 30000 }).catch(() => null);
+                await fsp.rm(worktreePath, { recursive: true, force: true }).catch(() => null);
+            }
+            const existingBranch = await runGitCommand(repoRoot, ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`]);
+            const args = existingBranch.ok
+                ? ['worktree', 'add', worktreePath, branch]
+                : ['worktree', 'add', '-b', branch, worktreePath, baseRef];
+            add = await runGitCommand(repoRoot, args, { timeoutMs: 120000 });
+            if (add.ok)
+                break;
+        }
+        if (!add?.ok)
+            blockers.push(gitBlocker('git_worktree_add_failed', add));
+        if (add?.ok) {
+            const head = await runGitCommand(worktreePath, ['rev-parse', 'HEAD']);
+            baseHead = head.ok ? gitOutputLine(head) : baseHead;
+        }
+    }
+    const allocation = {
+        schema: 'sks.git-worktree-allocation.v1',
+        ok: blockers.length === 0,
+        created_at: nowIso(),
+        mission_id: input.missionId,
+        worker_id: workerId,
+        slot_id: slotId,
+        generation_index: generationIndex,
+        repo_root: repoRoot,
+        main_repo_root: repoRoot,
+        worktree_path: worktreePath,
+        branch,
+        base_ref: baseRef,
+        base_head: baseHead,
+        manifest_path: path.join(root, 'git-worktree-manifest.json'),
+        capability,
+        blockers: [...new Set(blockers)]
+    };
+    await appendWorktreeManifest(allocation);
+    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: nextAllocations
+    };
+    await writeJsonAtomic(allocation.manifest_path, manifest);
+}
+function sanitizeBranchPart(value) {
+    return sanitizePathPart(value).replace(/\./g, '-').slice(0, 48) || 'item';
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=git-worktree-manager.js.map

package/dist/core/git/git-worktree-merge-queue.js

@@ -0,0 +1,55 @@
+import { nowIso } from '../fsx.js';
+import { runGitCommand } from './git-worktree-runner.js';
+import { summarizeGitWorktreeConflict } from './git-worktree-conflict-resolver.js';
+export async function applyGitWorktreeMergeQueue(input) {
+    const conflicts = [];
+    const changedFiles = new Set();
+    let appliedCount = 0;
+    let skippedCleanCount = 0;
+    for (const diff of input.diffs) {
+        for (const file of diff.changed_files)
+            changedFiles.add(file);
+        if (diff.clean || !diff.diff.trim()) {
+            skippedCleanCount += 1;
+            continue;
+        }
+        const check = await runGitCommand(input.integrationWorktreePath, ['apply', '--3way', '--check', '-'], {
+            input: diff.diff,
+            timeoutMs: 30000
+        });
+        if (!check.ok) {
+            conflicts.push(summarizeGitWorktreeConflict({
+                workerId: diff.worker_id,
+                changedFiles: diff.changed_files,
+                stderr: check.stderr || check.stdout
+            }));
+            continue;
+        }
+        const apply = await runGitCommand(input.integrationWorktreePath, ['apply', '--3way', '-'], {
+            input: diff.diff,
+            timeoutMs: 30000
+        });
+        if (apply.ok)
+            appliedCount += 1;
+        else {
+            conflicts.push(summarizeGitWorktreeConflict({
+                workerId: diff.worker_id,
+                changedFiles: diff.changed_files,
+                stderr: apply.stderr || apply.stdout
+            }));
+        }
+    }
+    const blockers = conflicts.length ? ['git_worktree_merge_queue_conflicts'] : [];
+    return {
+        schema: 'sks.git-worktree-merge-queue.v1',
+        ok: blockers.length === 0,
+        generated_at: nowIso(),
+        integration_worktree_path: input.integrationWorktreePath,
+        applied_count: appliedCount,
+        skipped_clean_count: skippedCleanCount,
+        conflicts,
+        changed_files: [...changedFiles],
+        blockers
+    };
+}
+//# sourceMappingURL=git-worktree-merge-queue.js.map

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

@@ -0,0 +1,35 @@
+export function buildGitWorktreePatchEnvelope(input) {
+    const changedFiles = input.diff.changed_files.length ? input.diff.changed_files : ['git-worktree.diff'];
+    return {
+        schema: 'sks.agent-patch-envelope.v1',
+        source: 'git-worktree-diff',
+        mission_id: input.diff.mission_id,
+        route: '$Naruto',
+        agent_id: input.agentId,
+        session_id: input.sessionId,
+        slot_id: input.slotId,
+        generation_index: input.generationIndex,
+        lease_id: `git-worktree:${input.diff.worker_id}`,
+        allowed_paths: changedFiles,
+        git_worktree: {
+            main_repo_root: input.diff.main_repo_root,
+            worktree_path: input.diff.worktree_path,
+            branch: input.diff.branch,
+            base_head: input.diff.base_head,
+            worktree_head: input.diff.worktree_head,
+            changed_files: changedFiles,
+            diff_bytes: input.diff.diff_bytes
+        },
+        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>',
+            notes: 'Apply inside an integration worktree based on the recorded base head.'
+        }
+    };
+}
+//# sourceMappingURL=git-worktree-patch-envelope.js.map

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

@@ -0,0 +1,23 @@
+import { nowIso } from '../fsx.js';
+export function planGitWorktreePool(input) {
+    const reusable = [...(input.reusableWorktrees || [])];
+    const assignments = input.workerIds.map((workerId) => {
+        const worktree = reusable.shift() || null;
+        return {
+            worker_id: workerId,
+            action: worktree ? 'reuse' : 'allocate',
+            worktree_path: worktree
+        };
+    });
+    return {
+        schema: 'sks.git-worktree-pool.v1',
+        ok: true,
+        generated_at: nowIso(),
+        requested_workers: input.workerIds.length,
+        reusable_count: (input.reusableWorktrees || []).length,
+        allocate_count: assignments.filter((row) => row.action === 'allocate').length,
+        assignments,
+        blockers: []
+    };
+}
+//# sourceMappingURL=git-worktree-pool.js.map

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

@@ -0,0 +1,52 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { sha256 } from '../fsx.js';
+export function resolveGitWorktreeRoot(input) {
+    const env = input.env || process.env;
+    const repoRoot = path.resolve(input.repoRoot);
+    const missionId = sanitizePathPart(input.missionId || 'mission');
+    const repoHash = sha256(repoRoot).slice(0, 16);
+    const explicitRoot = env.SKS_WORKTREE_ROOT ? path.resolve(env.SKS_WORKTREE_ROOT) : null;
+    const source = explicitRoot ? 'SKS_WORKTREE_ROOT' : env.XDG_CACHE_HOME ? 'XDG_CACHE_HOME' : 'HOME_CACHE';
+    const cacheBase = explicitRoot || path.join(env.XDG_CACHE_HOME || path.join(env.HOME || os.homedir(), '.cache'), 'sks', 'worktrees');
+    const root = explicitRoot ? path.join(cacheBase, repoHash, missionId) : path.join(cacheBase, repoHash, missionId);
+    const inRepo = isPathInside(root, repoRoot);
+    const allowInRepo = env.SKS_ALLOW_IN_REPO_WORKTREES === '1';
+    const blockers = inRepo && !allowInRepo ? ['git_worktree_root_inside_repo_blocked'] : [];
+    return {
+        schema: 'sks.git-worktree-root.v1',
+        ok: blockers.length === 0,
+        repo_root: repoRoot,
+        mission_id: missionId,
+        root,
+        source,
+        repo_hash: repoHash,
+        in_repo: inRepo,
+        allow_in_repo: allowInRepo,
+        blockers
+    };
+}
+export function sanitizePathPart(value) {
+    return String(value || 'item').replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 80) || 'item';
+}
+export function isPathInside(candidate, parent) {
+    const canonicalParent = canonicalPath(parent);
+    const canonicalCandidate = canonicalPath(candidate);
+    const rel = path.relative(canonicalParent, canonicalCandidate);
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+function canonicalPath(value) {
+    const resolved = path.resolve(value);
+    try {
+        return fs.realpathSync.native(resolved);
+    }
+    catch {
+        const parent = path.dirname(resolved);
+        if (parent === resolved)
+            return resolved;
+        const base = canonicalPath(parent);
+        return path.join(base, path.basename(resolved));
+    }
+}
+//# sourceMappingURL=git-worktree-root.js.map

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

@@ -0,0 +1,40 @@
+import { runProcess } from '../fsx.js';
+export async function runGitCommand(cwd, args, opts = {}) {
+    const processOptions = {
+        cwd,
+        timeoutMs: opts.timeoutMs ?? 30000,
+        maxOutputBytes: 512 * 1024
+    };
+    if (opts.input !== undefined)
+        processOptions.input = opts.input;
+    const result = await runProcess('git', args, processOptions);
+    return normalizeGitResult(cwd, args, result);
+}
+export function normalizeGitResult(cwd, args, result) {
+    const stdout = result.stdout || '';
+    const stderr = result.stderr || '';
+    return {
+        ok: result.code === 0,
+        code: result.code,
+        args,
+        cwd,
+        stdout,
+        stderr,
+        stdout_tail: stdout.slice(-4000),
+        stderr_tail: stderr.slice(-4000),
+        timed_out: result.timedOut
+    };
+}
+export function gitOutputLine(result) {
+    return String(result.stdout || '').split(/\r?\n/).find((line) => line.trim())?.trim() || '';
+}
+export function gitBlocker(prefix, result) {
+    const combined = [result.stderr_tail || result.stderr, result.stdout_tail || result.stdout]
+        .map((value) => String(value || '').trim())
+        .filter(Boolean)
+        .join('\n');
+    const detail = combined.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(-3).join(' | ');
+    const meta = `code=${result.code ?? 'null'} timed_out=${result.timed_out ? '1' : '0'} args=${result.args.join(' ')}`;
+    return detail ? `${prefix}:${meta}:${detail.slice(0, 320)}` : `${prefix}:${meta}`;
+}
+//# sourceMappingURL=git-worktree-runner.js.map

package/dist/core/naruto/naruto-active-pool.js

@@ -1,4 +1,39 @@
 import { createNarutoGeneration, completeNarutoGeneration } from './naruto-generation-scheduler.js';
+export async function runNarutoActivePool(input) {
+    const base = simulateNarutoActivePool(input);
+    const allocations = [];
+    for (const item of input.graph.work_items) {
+        if (!item.write_allowed)
+            continue;
+        const mode = item.worktree?.mode || input.graph.worktree_policy.mode;
+        if (mode !== 'git-worktree') {
+            allocations.push({ work_item_id: item.id, mode, allocation_status: 'skipped', blockers: [] });
+            continue;
+        }
+        if (!input.allocateWorktree) {
+            allocations.push({ work_item_id: item.id, mode, allocation_status: 'planned', blockers: [] });
+            continue;
+        }
+        const allocated = await input.allocateWorktree(item);
+        allocations.push({
+            work_item_id: item.id,
+            mode,
+            allocation_status: allocated.ok ? 'allocated' : 'planned',
+            ...(allocated.worktree_path ? { worktree_path: allocated.worktree_path } : {}),
+            ...(allocated.branch ? { branch: allocated.branch } : {}),
+            blockers: allocated.blockers || []
+        });
+    }
+    const allocationBlockers = allocations.flatMap((row) => row.blockers);
+    return {
+        ...base,
+        ok: base.ok && allocationBlockers.length === 0,
+        worktree_mode: input.graph.worktree_policy.mode,
+        worktree_allocation_required_count: allocations.filter((row) => row.mode === 'git-worktree').length,
+        worktree_allocations: allocations,
+        blockers: [...base.blockers, ...allocationBlockers]
+    };
+}
 export function simulateNarutoActivePool(input) {
     const safeActiveWorkers = Math.max(1, input.governor.safe_active_workers);
     const retryLimit = Math.max(0, Math.floor(Number(input.retryLimit ?? 1)));

package/dist/core/naruto/naruto-gpt-final-pack.js

@@ -12,6 +12,8 @@ export function buildNarutoGptFinalPack(input) {
         },
         role_distribution: input.roleDistribution,
         changed_files: [...new Set((input.changedFiles || []).map(String))],
+        worktree_policy: input.worktreePolicy || input.graph.worktree_policy,
+        worktree_diffs: (input.worktreeDiffs || []).slice(0, maxPatchEnvelopes).map(redactSecrets),
         patch_envelopes: (input.patchEnvelopes || []).slice(0, maxPatchEnvelopes).map(redactSecrets),
         verification_results: (input.verificationResults || []).slice(0, 200).map(redactSecrets),
         failed_shards: (input.failedShards || []).slice(0, 100).map(redactSecrets),

package/dist/core/naruto/naruto-work-graph.js

@@ -33,6 +33,13 @@ export function buildNarutoWorkGraph(input = {}) {
     const basePath = normalizeNarutoPath(input.leaseBasePath || '.sneakoscope/naruto/patch-envelopes');
     const targetPaths = normalizePaths(input.targetPaths || []);
     const readonlyPaths = normalizePaths(input.readonlyPaths || []);
+    const worktreePolicy = input.worktreePolicy || {
+        mode: 'patch-envelope-only',
+        required: false,
+        main_repo_root: null,
+        worktree_root: null,
+        fallback_reason: writeCapable ? 'git_capability_not_evaluated' : 'readonly_or_write_disabled'
+    };
     const workItems = [];
     for (let index = 0; index < totalWorkItems; index += 1) {
         const id = `NW-${String(index + 1).padStart(6, '0')}`;
@@ -64,7 +71,14 @@ export function buildNarutoWorkGraph(input = {}) {
                 requires_patch_envelope: writePaths.length > 0,
                 requires_verification: kind !== 'research' && kind !== 'final_review_input_pack',
                 requires_gpt_final: writePaths.length > 0 || kind === 'final_review_input_pack'
-            }
+            },
+            ...(writePaths.length > 0 ? {
+                worktree: {
+                    mode: worktreePolicy.mode,
+                    required: worktreePolicy.required,
+                    allocation_required: worktreePolicy.mode === 'git-worktree'
+                }
+            } : {})
         });
     }
     const activeWaves = planNarutoWorkWaves(workItems, Math.max(1, normalizePositiveInt(input.maxActiveWorkers, requestedClones)));
@@ -88,6 +102,7 @@ export function buildNarutoWorkGraph(input = {}) {
         active_waves: activeWaves,
         mixed_work_kinds: mixedWorkKinds,
         write_allowed_count: writeAllowedCount,
+        worktree_policy: worktreePolicy,
         ok: blockers.length === 0,
         blockers
     };

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