sneakoscope 2.0.14 → 2.0.16

package/dist/scripts/flagship-proof-graph-v3-check.js

@@ -1,67 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { pathToFileURL } from 'node:url';
-import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
-const reportDir = path.join(root, '.sneakoscope', 'reports');
-fs.mkdirSync(reportDir, { recursive: true });
-const initialFreshness = ensureDistFresh({ rebuild: true });
-if (!initialFreshness.ok) {
-    const report = { schema: 'sks.flagship-proof-graph.v3', ok: false, blocker: 'dist_not_fresh_before_dependencies', freshness: initialFreshness };
-    fs.writeFileSync(path.join(reportDir, 'flagship-proof-graph-v3.json'), `${JSON.stringify(report, null, 2)}\n`);
-    console.log(JSON.stringify(report, null, 2));
-    process.exit(1);
-}
-const dependencies = [
-    ['flagship-proof-graph-v2.json', './dist/scripts/flagship-proof-graph-v2-check.js'],
-    ['mad-sks-permission-model.json', './dist/scripts/mad-sks-permission-model-check.js'],
-    ['mad-sks-immutable-harness.json', './dist/scripts/mad-sks-immutable-harness-check.js'],
-    ['mad-sks-write-guard.json', './dist/scripts/mad-sks-write-guard-check.js'],
-    ['mad-sks-audit-proof.json', './dist/scripts/mad-sks-audit-proof-check.js'],
-    ['mad-sks-no-harness-modification.json', './dist/scripts/mad-sks-no-harness-modification-check.js'],
-    ['legacy-multiagent-removal.json', './dist/scripts/legacy-multiagent-removal-check.js'],
-    ['release-native-agent-fixture-check.json', './dist/scripts/release-native-agent-fixture-check.js'],
-    ['codex-exec-output-schema-actual-syntax.json', './dist/scripts/codex-exec-output-schema-actual-syntax-check.js'],
-    ['release-dist-freshness.json', './dist/scripts/release-dist-freshness-check.js']
-];
-for (const [name, script] of dependencies) {
-    const run = spawnSync(process.execPath, [script], { cwd: root, encoding: 'utf8', env: process.env, maxBuffer: 20 * 1024 * 1024 });
-    const parsed = parseLastJson(run.stdout);
-    if (parsed)
-        fs.writeFileSync(path.join(reportDir, name), `${JSON.stringify(parsed, null, 2)}\n`);
-    if (run.status !== 0) {
-        const report = { schema: 'sks.flagship-proof-graph.v3', ok: false, blocker: `dependency_failed:${script}`, stdout_tail: run.stdout.slice(-3000), stderr_tail: run.stderr.slice(-3000) };
-        fs.writeFileSync(path.join(reportDir, 'flagship-proof-graph-v3.json'), `${JSON.stringify(report, null, 2)}\n`);
-        console.log(JSON.stringify(report, null, 2));
-        process.exit(1);
-    }
-}
-const freshness = ensureDistFresh({ rebuild: true });
-if (!freshness.ok) {
-    const report = { schema: 'sks.flagship-proof-graph.v3', ok: false, blocker: 'dist_not_fresh', freshness };
-    fs.writeFileSync(path.join(reportDir, 'flagship-proof-graph-v3.json'), `${JSON.stringify(report, null, 2)}\n`);
-    console.log(JSON.stringify(report, null, 2));
-    process.exit(1);
-}
-const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'evidence', 'flagship-proof-graph-validator.js')).href);
-const report = await mod.validateFlagshipProofGraphV3(root);
-fs.writeFileSync(path.join(reportDir, 'flagship-proof-graph-v3.json'), `${JSON.stringify(report, null, 2)}\n`);
-console.log(JSON.stringify(report, null, 2));
-if (!report.ok)
-    process.exitCode = 1;
-function parseLastJson(text) {
-    const raw = String(text || '').trim();
-    if (!raw)
-        return null;
-    const start = raw.lastIndexOf('\n{');
-    const jsonText = start >= 0 ? raw.slice(start + 1) : raw;
-    try {
-        return JSON.parse(jsonText);
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=flagship-proof-graph-v3-check.js.map

package/dist/scripts/flagship-proof-graph-v4-check.js

@@ -1,61 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { pathToFileURL } from 'node:url';
-import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
-const reportDir = path.join(root, '.sneakoscope', 'reports');
-fs.mkdirSync(reportDir, { recursive: true });
-const initialFreshness = ensureDistFresh({ rebuild: true });
-if (!initialFreshness.ok)
-    fail('dist_not_fresh_before_dependencies', { freshness: initialFreshness });
-const dependencies = [
-    ['flagship-proof-graph-v3.json', './dist/scripts/flagship-proof-graph-v3-check.js'],
-    ['mad-sks-actual-executor-blackbox.json', './dist/scripts/mad-sks-actual-executor-blackbox.js'],
-    ['mad-sks-file-write-executor.json', './dist/scripts/mad-sks-file-write-executor-check.js'],
-    ['mad-sks-shell-executor.json', './dist/scripts/mad-sks-shell-executor-check.js'],
-    ['mad-sks-package-executor.json', './dist/scripts/mad-sks-package-executor-check.js'],
-    ['mad-sks-service-executor.json', './dist/scripts/mad-sks-service-executor-check.js'],
-    ['mad-sks-db-executor.json', './dist/scripts/mad-sks-db-executor-check.js'],
-    ['mad-sks-rollback-apply.json', './dist/scripts/mad-sks-rollback-apply-check.js'],
-    ['mad-sks-live-protected-core-smoke.json', './dist/scripts/mad-sks-live-protected-core-smoke.js'],
-    ['mad-sks-executor-proof-graph.json', './dist/scripts/mad-sks-executor-proof-graph-check.js']
-];
-for (const [name, script] of dependencies) {
-    const run = spawnSync(process.execPath, [script], { cwd: root, encoding: 'utf8', env: process.env, maxBuffer: 20 * 1024 * 1024 });
-    const parsed = parseLastJson(run.stdout);
-    if (parsed)
-        fs.writeFileSync(path.join(reportDir, name), `${JSON.stringify(parsed, null, 2)}\n`);
-    if (run.status !== 0)
-        fail(`dependency_failed:${script}`, { stdout_tail: run.stdout.slice(-3000), stderr_tail: run.stderr.slice(-3000) });
-}
-const freshness = ensureDistFresh({ rebuild: true });
-if (!freshness.ok)
-    fail('dist_not_fresh', { freshness });
-const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'evidence', 'flagship-proof-graph-validator.js')).href);
-const report = await mod.validateFlagshipProofGraphV4(root);
-fs.writeFileSync(path.join(reportDir, 'flagship-proof-graph-v4.json'), `${JSON.stringify(report, null, 2)}\n`);
-console.log(JSON.stringify(report, null, 2));
-if (!report.ok)
-    process.exitCode = 1;
-function fail(blocker, extra = {}) {
-    const report = { schema: 'sks.flagship-proof-graph.v4', ok: false, blocker, ...extra };
-    fs.writeFileSync(path.join(reportDir, 'flagship-proof-graph-v4.json'), `${JSON.stringify(report, null, 2)}\n`);
-    console.log(JSON.stringify(report, null, 2));
-    process.exit(1);
-}
-function parseLastJson(text) {
-    const raw = String(text || '').trim();
-    if (!raw)
-        return null;
-    const start = raw.lastIndexOf('\n{');
-    const jsonText = start >= 0 ? raw.slice(start + 1) : raw;
-    try {
-        return JSON.parse(jsonText);
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=flagship-proof-graph-v4-check.js.map

package/dist/scripts/git-precommit-fixture-check.js

@@ -1,41 +0,0 @@
-// @ts-nocheck
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import assert from 'node:assert/strict';
-import { runProcess } from '../core/fsx.js';
-const bin = path.join(process.cwd(), 'dist', 'bin', 'sks.js');
-const runtimeRoot = await fixtureRoot('runtime');
-await runProcess('git', ['init'], { cwd: runtimeRoot });
-await runSks(runtimeRoot, ['git', 'install', '--json']);
-await fs.mkdir(path.join(runtimeRoot, '.sneakoscope', 'missions'), { recursive: true });
-await fs.writeFile(path.join(runtimeRoot, '.sneakoscope', 'missions', 'runtime.json'), '{}\n');
-await runProcess('git', ['add', '-f', '.sneakoscope/missions/runtime.json'], { cwd: runtimeRoot });
-const blocked = await runProcess(process.execPath, [bin, 'git', 'precommit', '--json'], { cwd: runtimeRoot });
-assert.equal(blocked.code, 1, blocked.stdout || blocked.stderr);
-assert.match(blocked.stdout, /runtime_noise_not_staged/);
-const sharedRoot = await fixtureRoot('shared');
-await runProcess('git', ['init'], { cwd: sharedRoot });
-await runSks(sharedRoot, ['git', 'install', '--json']);
-await fs.mkdir(path.join(sharedRoot, '.sneakoscope', 'wiki', 'records', 'claims'), { recursive: true });
-await fs.writeFile(path.join(sharedRoot, '.sneakoscope', 'wiki', 'records', 'claims', 'ok.json'), JSON.stringify({
-    schema: 'sks.triwiki-claim-record.v1',
-    id: 'ok',
-    status: 'supported',
-    claim: { text: 'Valid shared claim.' }
-}, null, 2));
-await runProcess('git', ['add', '.sneakoscope/wiki/records/claims/ok.json'], { cwd: sharedRoot });
-const allowed = await runProcess(process.execPath, [bin, 'git', 'precommit', '--json'], { cwd: sharedRoot });
-assert.equal(allowed.code, 0, allowed.stdout || allowed.stderr);
-console.log(JSON.stringify({ ok: true, schema: 'sks.git-precommit-fixture.v1' }, null, 2));
-async function fixtureRoot(name) {
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), `sks-precommit-fixture-${name}-`));
-    await fs.writeFile(path.join(root, 'package.json'), '{"name":"fixture","private":true}\n');
-    return root;
-}
-async function runSks(root, args) {
-    const result = await runProcess(process.execPath, [bin, ...args], { cwd: root, env: { ...process.env, SKS_SKIP_NPM_FRESHNESS_CHECK: '1', CI: 'true' } });
-    assert.equal(result.code, 0, result.stdout || result.stderr);
-    return JSON.parse(result.stdout);
-}
-//# sourceMappingURL=git-precommit-fixture-check.js.map

package/dist/scripts/git-worktree-cache-performance-check.js

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const policyMod = await importDist('core/git/git-worktree-cache-policy.js');
-const now = Date.now();
-const entries = Array.from({ length: 1000 }, (_, index) => ({
-    path: `/tmp/wt-${index}`,
-    updated_at_ms: now - index * 60000,
-    bytes: 1024 * (index + 1),
-    dirty: index % 137 === 0
-}));
-const start = Date.now();
-const plan = policyMod.planGitWorktreeCachePolicy({ entries, nowMs: now, maxEntries: 120, maxBytes: 40 * 1024 * 1024, ttlMs: 2 * 60 * 60 * 1000 });
-const elapsed = Date.now() - start;
-assertGate(plan.ok === true, 'cache policy plan must pass', plan);
-assertGate(plan.keep.length <= 120 || plan.dirty_retained.length > 0, 'cache policy must bound retained clean entries', plan);
-assertGate(plan.dirty_retained.length > 0, 'dirty entries must be retained by cache policy', plan);
-assertGate(elapsed < 250, 'cache policy must stay fast on 1000 entries', { elapsed });
-emitGate('git:worktree-cache-performance', {
-    elapsed_ms: elapsed,
-    keep: plan.keep.length,
-    prune: plan.prune.length,
-    dirty_retained: plan.dirty_retained.length
-});
-//# sourceMappingURL=git-worktree-cache-performance-check.js.map

package/dist/scripts/git-worktree-capability-check.js

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-import { makeGitFixture, makeNonGitFixture } from './lib/git-worktree-fixture.js';
-const capabilityMod = await importDist('core/git/git-worktree-capability.js');
-const nonGit = makeNonGitFixture('worktree-capability-non-git');
-process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-capability-'));
-delete process.env.SKS_ALLOW_IN_REPO_WORKTREES;
-const nonGitCapability = await capabilityMod.evaluateGitWorktreeCapability({ root: nonGit, missionId: 'M-non-git' });
-assertGate(nonGitCapability.mode === 'patch-envelope-only', 'non-Git projects must degrade to patch-envelope-only', nonGitCapability);
-assertGate(nonGitCapability.worktree_probe_attempted === false, 'non-Git projects must not probe git worktree', nonGitCapability);
-const repo = makeGitFixture('worktree-capability-git');
-const gitCapability = await capabilityMod.evaluateGitWorktreeCapability({ root: repo, missionId: 'M-git' });
-assertGate(gitCapability.ok === true && gitCapability.mode === 'git-worktree', 'Git fixture must support worktree mode', gitCapability);
-assertGate(gitCapability.root_resolution?.in_repo === false, 'default worktree root must be outside main repo', gitCapability.root_resolution);
-process.env.SKS_WORKTREE_ROOT = path.join(repo, '.sneakoscope', 'worktrees');
-const blocked = await capabilityMod.evaluateGitWorktreeCapability({ root: repo, missionId: 'M-in-repo' });
-assertGate(blocked.ok === false && blocked.blockers.includes('git_worktree_root_inside_repo_blocked'), 'in-repo worktree root must be blocked by default', blocked);
-emitGate('git:worktree-capability', {
-    non_git_mode: nonGitCapability.mode,
-    git_mode: gitCapability.mode,
-    in_repo_blocked: true
-});
-//# sourceMappingURL=git-worktree-capability-check.js.map

package/dist/scripts/git-worktree-checkpoint-check.js

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-import { checkpointWorkerWorktree } from '../core/git/git-worktree-checkpoint.js';
-import { runGitCommand } from '../core/git/git-worktree-runner.js';
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-worktree-checkpoint-'));
-await runGitCommand(root, ['init']);
-await runGitCommand(root, ['config', 'user.email', 'sks@example.test']);
-await runGitCommand(root, ['config', 'user.name', 'SKS Test']);
-fs.writeFileSync(path.join(root, 'a.txt'), 'a\n');
-await runGitCommand(root, ['add', 'a.txt']);
-await runGitCommand(root, ['commit', '-m', 'base']);
-fs.writeFileSync(path.join(root, 'a.txt'), 'a2\n');
-fs.writeFileSync(path.join(root, 'b.txt'), 'b\n');
-const report = await checkpointWorkerWorktree({ worktreePath: root, repoRoot: root, workerId: 'W1', taskId: 'T1', mode: 'auto' });
-assertGate(report.ok && report.mode_applied === 'checkpoint-commit' && Boolean(report.commit_hash), 'Git worktree checkpoint must create checkpoint commits for multi-file changes', report);
-emitGate('git:worktree-checkpoint', report);
-//# sourceMappingURL=git-worktree-checkpoint-check.js.map

package/dist/scripts/git-worktree-cleanup-check.js

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-import { makeGitFixture } from './lib/git-worktree-fixture.js';
-const managerMod = await importDist('core/git/git-worktree-manager.js');
-const cleanupMod = await importDist('core/git/git-worktree-cleanup.js');
-const repo = makeGitFixture('worktree-cleanup');
-process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-cleanup-'));
-const cleanAllocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-cleanup', workerId: 'clean', slotId: 'slot-001' });
-const clean = await cleanupMod.cleanupGitWorktree({ repoRoot: repo, worktreePath: cleanAllocation.worktree_path, branch: cleanAllocation.branch, deleteBranch: true });
-assertGate(clean.ok === true && clean.action === 'removed', 'clean worktree must be removed by cleanup manager', clean);
-assertGate(!fs.existsSync(cleanAllocation.worktree_path), 'removed clean worktree path should be gone');
-const dirtyAllocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-cleanup', workerId: 'dirty', slotId: 'slot-002' });
-fs.writeFileSync(path.join(dirtyAllocation.worktree_path, 'a.txt'), 'dirty\n');
-const dirty = await cleanupMod.cleanupGitWorktree({ repoRoot: repo, worktreePath: dirtyAllocation.worktree_path, branch: dirtyAllocation.branch, deleteBranch: true });
-assertGate(dirty.ok === true && dirty.action === 'retained_dirty', 'dirty worktree must be retained', dirty);
-assertGate(fs.existsSync(dirtyAllocation.worktree_path), 'dirty worktree path must still exist');
-assertGate(dirty.retention_lock_path && fs.existsSync(dirty.retention_lock_path), 'dirty retention lock must be written outside the retained worktree', dirty);
-emitGate('git:worktree-cleanup', {
-    clean_action: clean.action,
-    dirty_action: dirty.action,
-    retention_lock_path: dirty.retention_lock_path
-});
-//# sourceMappingURL=git-worktree-cleanup-check.js.map

package/dist/scripts/git-worktree-cross-rebase-check.js

@@ -1,39 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-import { crossRebaseIdleWorktrees } from '../core/git/git-worktree-cross-rebase.js';
-import { runGitCommand, gitOutputLine } from '../core/git/git-worktree-runner.js';
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-worktree-cross-rebase-'));
-await runGitCommand(root, ['init']);
-await runGitCommand(root, ['config', 'user.email', 'sks@example.test']);
-await runGitCommand(root, ['config', 'user.name', 'SKS Test']);
-fs.writeFileSync(path.join(root, 'base.txt'), 'base\n');
-await runGitCommand(root, ['add', 'base.txt']);
-await runGitCommand(root, ['commit', '-m', 'base']);
-const workerPath = path.join(root, '..', `worker-${process.pid}`);
-const dirtyWorkerPath = path.join(root, '..', `worker-dirty-${process.pid}`);
-const runningWorkerPath = path.join(root, '..', `worker-running-${process.pid}`);
-await runGitCommand(root, ['worktree', 'add', workerPath, 'HEAD']);
-await runGitCommand(root, ['worktree', 'add', dirtyWorkerPath, 'HEAD']);
-await runGitCommand(root, ['worktree', 'add', runningWorkerPath, 'HEAD']);
-fs.writeFileSync(path.join(dirtyWorkerPath, 'dirty.txt'), 'dirty\n');
-fs.writeFileSync(path.join(root, 'integration.txt'), 'integration\n');
-await runGitCommand(root, ['add', 'integration.txt']);
-await runGitCommand(root, ['commit', '-m', 'integration']);
-const head = gitOutputLine(await runGitCommand(root, ['rev-parse', 'HEAD']));
-const report = await crossRebaseIdleWorktrees({
-    integrationHead: head,
-    workers: [
-        { worker_id: 'W1', worktree_path: workerPath, state: 'idle' },
-        { worker_id: 'W-dirty', worktree_path: dirtyWorkerPath, state: 'idle' },
-        { worker_id: 'W-running', worktree_path: runningWorkerPath, state: 'running' }
-    ]
-});
-assertGate(report.ok && report.applied_count === 1, 'Idle worktrees must cross-rebase to the integration head', report);
-assertGate(report.skipped_count === 2, 'Dirty and running worktrees must be skipped during cross-rebase', report);
-assertGate(report.records.some((row) => row.worker_id === 'W-dirty' && row.status === 'skipped' && row.reason === 'dirty_worktree_skipped'), 'Dirty worktree must skip cross-rebase', report);
-assertGate(report.records.some((row) => row.worker_id === 'W-running' && row.status === 'skipped' && row.reason === 'worker_not_idle'), 'Running worktree must skip cross-rebase', report);
-emitGate('git:worktree-cross-rebase', report);
-//# sourceMappingURL=git-worktree-cross-rebase-check.js.map

package/dist/scripts/git-worktree-diff-envelope-check.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const envelopeMod = await importDist('core/git/git-worktree-patch-envelope.js');
-const schemaMod = await importDist('core/agents/agent-patch-schema.js');
-const envelope = envelopeMod.buildGitWorktreePatchEnvelope({
-    diff: { schema: 'sks.git-worktree-diff.v1', mission_id: 'M-env', worker_id: 'worker-1', main_repo_root: '.', worktree_path: '.', branch: null, base_head: null, worktree_head: null, changed_files: ['a.txt', 'b.txt'], diff_bytes: 12, diff: 'diff --git a/a.txt b/a.txt\n', clean: false },
-    agentId: 'agent-1',
-    sessionId: 'session-1',
-    slotId: 'slot-001',
-    generationIndex: 1
-});
-const validation = schemaMod.validateAgentPatchEnvelope(schemaMod.normalizeAgentPatchEnvelope(envelope));
-assertGate(envelope.operations.length === 1 && envelope.operations[0].op === 'git_apply_patch', 'git worktree envelope must use one git_apply_patch operation', envelope);
-assertGate(validation.ok === true, 'git_apply_patch envelope must validate', validation);
-emitGate('git:worktree-diff-envelope', { operations: envelope.operations.length, op: envelope.operations[0].op });
-//# sourceMappingURL=git-worktree-diff-envelope-check.js.map

package/dist/scripts/git-worktree-diff-export-check.js

@@ -1,43 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-import { makeGitFixture, run } from './lib/git-worktree-fixture.js';
-const managerMod = await importDist('core/git/git-worktree-manager.js');
-const diffMod = await importDist('core/git/git-worktree-diff.js');
-const envelopeMod = await importDist('core/git/git-worktree-patch-envelope.js');
-const schemaMod = await importDist('core/agents/agent-patch-schema.js');
-const cleanupMod = await importDist('core/git/git-worktree-cleanup.js');
-const repo = makeGitFixture('worktree-diff');
-process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-diff-'));
-const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-diff', workerId: 'worker-1', slotId: 'slot-001' });
-fs.writeFileSync(path.join(allocation.worktree_path, 'a.txt'), 'alpha\nchanged\n');
-const diff = await diffMod.exportGitWorktreeDiff({
-    mainRepoRoot: repo,
-    worktreePath: allocation.worktree_path,
-    missionId: 'M-diff',
-    workerId: 'worker-1'
-});
-const envelope = envelopeMod.buildGitWorktreePatchEnvelope({
-    diff,
-    agentId: 'agent-1',
-    sessionId: 'session-1',
-    slotId: 'slot-001',
-    generationIndex: 1
-});
-const validation = schemaMod.validateAgentPatchEnvelope(schemaMod.normalizeAgentPatchEnvelope(envelope));
-assertGate(diff.ok === true && diff.clean === false, 'diff export must detect changed worktree', diff);
-assertGate(diff.changed_files.includes('a.txt'), 'diff export must include changed file', diff);
-assertGate(/index [0-9a-f]{40}\.\.[0-9a-f]{40}/.test(diff.diff), 'diff export must use full-index diff hashes', { diff: diff.diff });
-assertGate(envelope.source === 'git-worktree-diff' && validation.ok === true, 'git worktree diff patch envelope must validate', { envelope, validation });
-assertGate(run('git', ['status', '--porcelain=v1'], repo).trim() === '', 'main repo must stay clean after diff export');
-run('git', ['checkout', '--', 'a.txt'], allocation.worktree_path);
-await cleanupMod.cleanupGitWorktree({ repoRoot: repo, worktreePath: allocation.worktree_path, branch: allocation.branch, deleteBranch: true });
-emitGate('git:worktree-diff-export', {
-    changed_files: diff.changed_files,
-    diff_bytes: diff.diff_bytes,
-    envelope_source: envelope.source
-});
-//# sourceMappingURL=git-worktree-diff-export-check.js.map

package/dist/scripts/git-worktree-dirty-lock-check.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-import { makeGitFixture } from './lib/git-worktree-fixture.js';
-const managerMod = await importDist('core/git/git-worktree-manager.js');
-const cleanupMod = await importDist('core/git/git-worktree-cleanup.js');
-const repo = makeGitFixture('dirty-lock');
-process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-lock-'));
-const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-lock', workerId: 'worker-1', slotId: 'slot-001' });
-fs.writeFileSync(path.join(allocation.worktree_path, 'a.txt'), 'dirty\n');
-const cleanup = await cleanupMod.cleanupGitWorktree({ repoRoot: repo, worktreePath: allocation.worktree_path, branch: allocation.branch });
-assertGate(cleanup.action === 'retained_dirty' && cleanup.git_locked === true, 'dirty retained worktree must be git locked', cleanup);
-emitGate('git:worktree-dirty-lock', { git_locked: cleanup.git_locked, unlock_command: cleanup.unlock_command });
-//# sourceMappingURL=git-worktree-dirty-lock-check.js.map

package/dist/scripts/git-worktree-dirty-main-detection-check.js

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-import { makeGitFixture } from './lib/git-worktree-fixture.js';
-const detectionMod = await importDist('core/git/git-repo-detection.js');
-const repo = makeGitFixture('dirty-main-detection');
-fs.writeFileSync(path.join(repo, 'dirty.txt'), 'dirty\n');
-const detection = await detectionMod.detectGitRepo(repo);
-assertGate(detection.main_worktree_dirty === true, 'dirty main worktree must be detected', detection);
-assertGate(String(detection.status_porcelain).includes('dirty.txt'), 'status_porcelain must include dirty file', detection);
-emitGate('git:worktree-dirty-main-detection', { dirty: detection.main_worktree_dirty });
-//# sourceMappingURL=git-worktree-dirty-main-detection-check.js.map

package/dist/scripts/git-worktree-integration-primary-check.js

@@ -1,24 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-import { makeGitFixture } from './lib/git-worktree-fixture.js';
-const managerMod = await importDist('core/git/git-worktree-manager.js');
-const diffMod = await importDist('core/git/git-worktree-diff.js');
-const mergeMod = await importDist('core/git/git-worktree-merge-queue.js');
-const repo = makeGitFixture('integration-primary');
-process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-integration-'));
-const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-integrate', workerId: 'worker-1', slotId: 'slot-001' });
-fs.writeFileSync(path.join(allocation.worktree_path, 'a.txt'), 'alpha\nintegrated\n');
-const diff = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: allocation.worktree_path, missionId: 'M-integrate', workerId: 'worker-1' });
-const integrationPath = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-integration-'));
-fs.rmSync(integrationPath, { recursive: true, force: true });
-const integration = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-integrate', workerId: 'integration', slotId: 'integration' });
-const report = await mergeMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: integration.worktree_path, diffs: [diff] });
-const mainReport = await mergeMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: repo, diffs: [diff] });
-const mainContent = fs.readFileSync(path.join(repo, 'a.txt'), 'utf8');
-assertGate(report.ok === true && report.applied_count === 1 && mainReport.ok === true && mainReport.applied_count === 1 && mainContent.includes('integrated'), 'git-worktree-diff must prevalidate in integration worktree and apply to main repo', { report, mainReport, mainContent });
-emitGate('git:worktree-integration-primary', { applied_count: report.applied_count, main_applied_count: mainReport.applied_count });
-//# sourceMappingURL=git-worktree-integration-primary-check.js.map

package/dist/scripts/git-worktree-integration-primary-runtime-check.js

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const orchestrator = fs.readFileSync(path.join(root, 'src/core/agents/agent-orchestrator.ts'), 'utf8');
-const report = {
-    schema: 'sks.git-worktree-integration-primary-runtime-check.v1',
-    splits_worktree_entries: orchestrator.includes("entry.envelope?.source === 'git-worktree-diff'"),
-    uses_integration_worktree: orchestrator.includes('createGitIntegrationWorktree'),
-    uses_merge_queue: orchestrator.includes('applyGitWorktreeMergeQueue'),
-    applies_to_main_repo: orchestrator.includes('main_repo_apply') && orchestrator.includes('integrationWorktreePath: repoRoot'),
-    rollback_evidence: orchestrator.includes('rollback_evidence') && orchestrator.includes('captureGitWorktreeRollbackPlan') && orchestrator.includes('completeGitWorktreeRollbackPlan'),
-    bypasses_normal_apply: orchestrator.includes('const normalEntries') && orchestrator.includes('applyAgentPatchQueueEntry(root, entry') && orchestrator.includes('parallelEntries = disjointEntries'),
-    writes_report: orchestrator.includes('git-worktree-merge-queue-report.json')
-};
-const ok = report.splits_worktree_entries && report.uses_integration_worktree && report.uses_merge_queue && report.applies_to_main_repo && report.rollback_evidence && report.bypasses_normal_apply && report.writes_report;
-assertGate(ok, 'git-worktree-diff entries must use integration merge queue primary path', report);
-emitGate('git:worktree-integration-primary-runtime', report);
-//# sourceMappingURL=git-worktree-integration-primary-runtime-check.js.map

package/dist/scripts/git-worktree-manager-check.js

@@ -1,37 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-import { makeGitFixture, run } from './lib/git-worktree-fixture.js';
-const managerMod = await importDist('core/git/git-worktree-manager.js');
-const cleanupMod = await importDist('core/git/git-worktree-cleanup.js');
-const repo = makeGitFixture('worktree-manager');
-process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-manager-'));
-delete process.env.SKS_ALLOW_IN_REPO_WORKTREES;
-const allocation = await managerMod.allocateWorkerWorktree({
-    repoRoot: repo,
-    missionId: 'M-manager',
-    workerId: 'worker-1',
-    slotId: 'slot-001',
-    generationIndex: 1
-});
-assertGate(allocation.ok === true, 'worker worktree allocation must pass', allocation);
-assertGate(fs.existsSync(allocation.worktree_path), 'allocated worktree path must exist', allocation);
-assertGate(!path.resolve(allocation.worktree_path).startsWith(path.resolve(repo) + path.sep), 'worktree must be outside main repo by default', allocation);
-assertGate(fs.existsSync(allocation.manifest_path), 'worktree manifest must be written', allocation);
-assertGate(run('git', ['status', '--porcelain=v1'], repo).trim() === '', 'main repo must stay clean after allocation');
-const cleanup = await cleanupMod.cleanupGitWorktree({
-    repoRoot: repo,
-    worktreePath: allocation.worktree_path,
-    branch: allocation.branch,
-    deleteBranch: true
-});
-assertGate(cleanup.ok === true && cleanup.action === 'removed', 'clean worktree cleanup must remove allocation', cleanup);
-emitGate('git:worktree-manager', {
-    worktree_outside_repo: true,
-    branch: allocation.branch,
-    cleanup: cleanup.action
-});
-//# sourceMappingURL=git-worktree-manager-check.js.map

package/dist/scripts/git-worktree-manifest-append-check.js

@@ -1,18 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-import { makeGitFixture } from './lib/git-worktree-fixture.js';
-const managerMod = await importDist('core/git/git-worktree-manager.js');
-const repo = makeGitFixture('worktree-manifest-append');
-process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-manifest-'));
-const allocations = [];
-for (let index = 0; index < 4; index += 1) {
-    allocations.push(await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-manifest', workerId: `worker-${index}`, slotId: `slot-${index}` }));
-}
-const manifest = JSON.parse(fs.readFileSync(allocations[0].manifest_path, 'utf8'));
-assertGate(manifest.allocations.length >= allocations.length, 'manifest append must preserve allocations', manifest);
-emitGate('git:worktree-manifest-append', { allocations: manifest.allocations.length });
-//# sourceMappingURL=git-worktree-manifest-append-check.js.map

package/dist/scripts/git-worktree-merge-queue-check.js

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-import { makeGitFixture } from './lib/git-worktree-fixture.js';
-const managerMod = await importDist('core/git/git-worktree-manager.js');
-const diffMod = await importDist('core/git/git-worktree-diff.js');
-const integrationMod = await importDist('core/git/git-integration-worktree.js');
-const queueMod = await importDist('core/git/git-worktree-merge-queue.js');
-const repo = makeGitFixture('worktree-merge');
-process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-merge-'));
-const a = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-merge', workerId: 'a', slotId: 'slot-001' });
-const b = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-merge', workerId: 'b', slotId: 'slot-002' });
-fs.writeFileSync(path.join(a.worktree_path, 'a.txt'), 'alpha\nfrom-a\n');
-fs.writeFileSync(path.join(b.worktree_path, 'b.txt'), 'bravo\nfrom-b\n');
-const diffA = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: a.worktree_path, missionId: 'M-merge', workerId: 'a' });
-const diffB = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: b.worktree_path, missionId: 'M-merge', workerId: 'b' });
-const integration = await integrationMod.createGitIntegrationWorktree({ repoRoot: repo, missionId: 'M-merge' });
-const report = await queueMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: integration.worktree_path, diffs: [diffA, diffB] });
-assertGate(report.ok === true && report.applied_count === 2, 'merge queue must apply non-conflicting worktree diffs', report);
-assertGate((report.strategy_results || []).every((row) => row.strategy === 'diff-apply-3way'), 'merge queue must record the diff apply strategy for worktree diffs', report.strategy_results || []);
-assertGate(fs.readFileSync(path.join(integration.worktree_path, 'a.txt'), 'utf8').includes('from-a'), 'integration worktree must include first diff');
-assertGate(fs.readFileSync(path.join(integration.worktree_path, 'b.txt'), 'utf8').includes('from-b'), 'integration worktree must include second diff');
-assertGate(fs.readFileSync(path.join(repo, 'a.txt'), 'utf8') === 'alpha\n', 'main worktree must remain unchanged before integration commit');
-emitGate('git:worktree-merge-queue', {
-    applied_count: report.applied_count,
-    changed_files: report.changed_files
-});
-//# sourceMappingURL=git-worktree-merge-queue-check.js.map

package/dist/scripts/git-worktree-pool-performance-check.js

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const poolMod = await importDist('core/git/git-worktree-pool.js');
-const workerIds = Array.from({ length: 100 }, (_, index) => `worker-${index + 1}`);
-const reusable = Array.from({ length: 32 }, (_, index) => `/tmp/reuse-${index + 1}`);
-const start = Date.now();
-const plan = poolMod.planGitWorktreePool({ workerIds, reusableWorktrees: reusable });
-const elapsed = Date.now() - start;
-assertGate(plan.ok === true, 'pool plan must pass', plan);
-assertGate(plan.assignments.length === 100, 'pool must assign every requested worker', plan);
-assertGate(plan.assignments.filter((row) => row.action === 'reuse').length === 32, 'pool must reuse available worktrees first', plan);
-assertGate(plan.allocate_count === 68, 'pool must allocate only the remaining workers', plan);
-assertGate(elapsed < 100, 'pool plan must stay fast for 100 workers', { elapsed });
-emitGate('git:worktree-pool-performance', {
-    elapsed_ms: elapsed,
-    reusable: 32,
-    allocate_count: plan.allocate_count
-});
-//# sourceMappingURL=git-worktree-pool-performance-check.js.map

package/dist/scripts/git-worktree-untracked-diff-check.js

@@ -1,18 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-import { makeGitFixture } from './lib/git-worktree-fixture.js';
-const managerMod = await importDist('core/git/git-worktree-manager.js');
-const diffMod = await importDist('core/git/git-worktree-diff.js');
-const repo = makeGitFixture('untracked-diff');
-process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-untracked-'));
-const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-untracked', workerId: 'worker-1', slotId: 'slot-001' });
-fs.writeFileSync(path.join(allocation.worktree_path, 'new-file.txt'), 'new content\n');
-const diff = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: allocation.worktree_path, missionId: 'M-untracked', workerId: 'worker-1' });
-assertGate(diff.changed_files.includes('new-file.txt'), 'changed files must include untracked file', diff);
-assertGate(diff.diff.includes('new file mode') && diff.diff.includes('+new content'), 'git diff must include untracked file content', { diff: diff.diff });
-emitGate('git:worktree-untracked-diff', { changed_files: diff.changed_files });
-//# sourceMappingURL=git-worktree-untracked-diff-check.js.map

package/dist/scripts/goal-mode-official-default-check.js

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/codex/official-goal-mode.js');
-const official = await mod.detectOfficialGoalMode({ runCommand: false, codexHelpText: 'Usage: codex /goal create', codexGoalHelpText: 'codex goal --help' });
-const featureListOfficial = await mod.detectOfficialGoalMode({ runCommand: false, codexHelpText: 'Usage: codex', codexGoalHelpText: '', codexFeaturesText: 'goals stable true\n' });
-const fallback = await mod.detectOfficialGoalMode({ runCommand: false, codexHelpText: 'Usage: codex' });
-assertGate(official.official_goal_available === true && official.default_enabled === true, 'official goal availability must default-enable goal mode', official);
-assertGate(featureListOfficial.official_goal_available === true && featureListOfficial.codex_goals_feature_enabled === true, 'Codex goals feature flag must default-enable goal mode without goal subcommand help', featureListOfficial);
-assertGate(fallback.mode === 'sks_goal_fallback', 'missing official goal must use SKS fallback', fallback);
-emitGate('goal-mode:official-default', { official: official.mode, feature_list_official: featureListOfficial.mode, fallback: fallback.mode });
-//# sourceMappingURL=goal-mode-official-default-check.js.map