sneakoscope 6.1.2 → 6.4.0

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/gate-pack-fixture-cache-check.js

@@ -1,9 +0,0 @@
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/release/gate-pack-fixture-cache.js');
-const packId = `fixture-check-${process.pid}-${Date.now()}`;
-const first = await mod.prepareGatePackFixture({ root, packId, fixtureVersion: 'sks-4.0.1' });
-const second = await mod.prepareGatePackFixture({ root, packId, fixtureVersion: 'sks-4.0.1' });
-assertGate(first.schema === 'sks.gate-pack-fixture.v1', 'fixture schema mismatch', first);
-assertGate(first.setup_count === 1 && second.reused_base === true, 'fixture base must be created once and reused', { first, second });
-emitGate('gate-pack:fixture-cache', { pack_id: packId, setup_count: first.setup_count, reused_base: second.reused_base });
-//# sourceMappingURL=gate-pack-fixture-cache-check.js.map

package/dist/scripts/gate-pack-runner-check.js

@@ -1,6 +0,0 @@
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/release/gate-pack-runner.js');
-const report = await mod.executeGatePack({ root, packId: 'triwiki', mode: 'plan' });
-assertGate(report.schema === 'sks.gate-pack-runner.v1' && report.mode === 'plan' && report.ok === true, 'gate pack runner plan must pass', report);
-emitGate('gate-pack:runner', { pack: report.pack_id, reused: report.reused, executed: report.executed });
-//# sourceMappingURL=gate-pack-runner-check.js.map

package/dist/scripts/geo-llms-txt-optional-check.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, assertMissionArtifact, emitGate, makeSearchVisibilityFixture, runSksJson } from './search-visibility-gate-lib.js';
-const fixture = makeSearchVisibilityFixture('geo-llms');
-const audit = runSksJson(['seo-geo-optimizer', 'audit', '--mode', 'geo', '--root', fixture, '--target', 'package', '--offline', '--json']).json;
-const plan = runSksJson(['seo-geo-optimizer', 'plan', audit.mission_id, '--mode', 'geo', '--root', fixture, '--json']).json;
-const llmsPlan = assertMissionArtifact(audit.mission_id, 'llms-txt-plan.json', fixture);
-assertGate(audit.ok === true, 'missing llms.txt must not block GEO gate', audit);
-assertGate(plan.operations === 0, 'GEO plan must not create llms.txt unless --include-llms-txt is explicit', plan);
-assertGate(llmsPlan.required_for_gate === false && llmsPlan.experimental_assistive_surface === true, 'llms.txt must be optional and experimental', llmsPlan);
-assertGate(!fs.existsSync(path.join(fixture, 'llms.txt')), 'llms.txt must not be created by default');
-const explicitPlan = runSksJson(['seo-geo-optimizer', 'plan', audit.mission_id, '--mode', 'geo', '--root', fixture, '--include-llms-txt', '--json']).json;
-assertGate(explicitPlan.operations === 1, 'explicit --include-llms-txt should plan managed llms.txt creation', explicitPlan);
-const apply = runSksJson(['seo-geo-optimizer', 'apply', audit.mission_id, '--mode', 'geo', '--root', fixture, '--include-llms-txt', '--apply', '--json']).json;
-assertGate(apply.ok === true && fs.existsSync(path.join(fixture, 'llms.txt')), 'explicit llms.txt apply must create managed file', apply);
-emitGate('geo:llms-txt-optional', { mission_id: audit.mission_id });
-//# sourceMappingURL=geo-llms-txt-optional-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-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-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-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-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-prewarm-runtime-check.js

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
-const src = readText('src/core/agents/agent-orchestrator.ts');
-assertGate(src.includes('preparedWorktreeAllocations') && src.includes('prewarmed_allocations') && src.includes('allocateWorkerWorktreesBatch'), 'orchestrator must prewarm write-capable git worktrees before scheduler launch');
-emitGate('git:worktree-prewarm-runtime');
-//# sourceMappingURL=git-worktree-prewarm-runtime-check.js.map

package/dist/scripts/goal-legacy-runtime-escape-check.js

@@ -1,3 +0,0 @@
-import { runLoopDirectiveCheck } from './loop-directive-check-lib.js';
-await runLoopDirectiveCheck('goal:legacy-runtime-escape');
-//# sourceMappingURL=goal-legacy-runtime-escape-check.js.map

package/dist/scripts/goal-loop-compat-check.js

@@ -1,3 +0,0 @@
-import { runLoopDirectiveCheck } from './loop-directive-check-lib.js';
-await runLoopDirectiveCheck('goal:loop-compat');
-//# sourceMappingURL=goal-loop-compat-check.js.map

package/dist/scripts/goal-loop-runtime-default-check.js

@@ -1,3 +0,0 @@
-import { runLoopDirectiveCheck } from './loop-directive-check-lib.js';
-await runLoopDirectiveCheck('goal:loop-runtime-default');
-//# sourceMappingURL=goal-loop-runtime-default-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

package/dist/scripts/gpt-final-arbiter-check.js

@@ -1,66 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, readJsonFile, root } from './lib/codex-sdk-gate-lib.js';
-const mod = await importDist('core/codex-control/gpt-final-arbiter.js');
-const old = snapshotEnv();
-process.env.NODE_ENV = 'test';
-process.env.SKS_CODEX_SDK_FAKE = '1';
-delete process.env.SKS_GPT_FINAL_ARBITER_UNAVAILABLE;
-try {
-    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-gpt-final-arbiter-'));
-    const approved = await mod.runGptFinalArbiter(fixtureInput('approved'), { cwd: root, mutationLedgerRoot: tmp });
-    assertGate(approved.ok === true, 'GPT final arbiter fixture must approve safe candidate', approved);
-    assertGate(approved.backend === 'codex-sdk', 'GPT final arbiter backend must be codex-sdk');
-    assertGate(approved.result.status === 'approved', 'safe candidate must return approved');
-    assertGate(approved.result.lean_review?.status === 'pass', 'safe candidate must pass lean review');
-    assertGate(approved.result.lean_review?.selected_rung === 'minimal-custom', 'lean review must record selected rung');
-    assertGate(approved.final_gate.ok === true, 'approved arbiter result must pass final gate');
-    const artifact = await readJsonFile(path.join(tmp, 'gpt-final-arbiter.json'));
-    assertGate(artifact.result.schema === 'sks.gpt-final-arbiter-result.v1', 'arbiter artifact must contain schema-valid result');
-    assertGate(artifact.result.lean_review?.verification_minimum_present === true, 'arbiter artifact must record lean verification minimum');
-    const unsafeTmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-gpt-final-arbiter-unsafe-'));
-    const rejected = await mod.runGptFinalArbiter({ ...fixtureInput('unsafe'), candidate_diff: 'unsafe delete all credential patch' }, { cwd: root, mutationLedgerRoot: unsafeTmp });
-    assertGate(rejected.ok === false, 'unsafe candidate must not pass final arbiter');
-    assertGate(rejected.result.status === 'rejected', 'unsafe candidate must be rejected');
-    assertGate(rejected.result.lean_review?.status === 'rejected', 'unsafe candidate must reject lean review');
-    assertGate(rejected.blockers.includes('unsafe_candidate_patch'), 'unsafe rejection blocker must be preserved');
-    emitGate('local-collab:gpt-final-arbiter', { approved: approved.result.status, rejected: rejected.result.status });
-}
-finally {
-    restoreEnv(old);
-}
-function fixtureInput(label) {
-    return {
-        schema: 'sks.gpt-final-arbiter-input.v1',
-        route: '$Naruto',
-        mission_id: `M-${label}`,
-        local_mode: 'local-parallel-gpt-final',
-        local_outputs: [
-            { worker_id: 'slot-001/gen-1', backend: 'local-llm', summary: 'candidate patch drafted', patch_envelopes: [], proof: 'local draft' }
-        ],
-        candidate_diff: 'diff --git a/example.ts b/example.ts',
-        candidate_patch_envelopes: [],
-        verification_results: [{ ok: true, status: 'passed' }],
-        side_effect_report: { ok: true },
-        mutation_ledger: { ok: true },
-        rollback_plan: { ok: true }
-    };
-}
-function snapshotEnv() {
-    return {
-        NODE_ENV: process.env.NODE_ENV,
-        SKS_CODEX_SDK_FAKE: process.env.SKS_CODEX_SDK_FAKE,
-        SKS_GPT_FINAL_ARBITER_UNAVAILABLE: process.env.SKS_GPT_FINAL_ARBITER_UNAVAILABLE
-    };
-}
-function restoreEnv(old) {
-    for (const [key, value] of Object.entries(old)) {
-        if (value === undefined)
-            delete process.env[key];
-        else
-            process.env[key] = value;
-    }
-}
-//# sourceMappingURL=gpt-final-arbiter-check.js.map

package/dist/scripts/gpt-final-arbiter-performance-check.js

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
-const compressor = await importDist('core/codex-control/gpt-final-context-compressor.js');
-const local_outputs = Array.from({ length: 20 }, (_, index) => ({
-    worker_id: `slot-${String(index + 1).padStart(3, '0')}/gen-1`,
-    backend: 'local-llm',
-    status: 'done',
-    summary: `worker ${index + 1} summarized a bounded shard`,
-    changed_files: [`src/example-${index + 1}.ts`],
-    blockers: []
-}));
-const candidate_patch_envelopes = local_outputs.map((output, index) => ({
-    id: `patch-${index + 1}`,
-    agent_id: output.worker_id,
-    source: 'model_authored',
-    lease_id: `lease-${index + 1}`,
-    rollback_hint: { ok: true },
-    operations: [{ op: 'replace', path: output.changed_files[0], search: 'before', replace: 'after' }]
-}));
-const report = compressor.compressGptFinalContext({
-    route: '$Naruto',
-    mission_id: 'M-20-local-workers',
-    local_mode: 'local-parallel-gpt-final',
-    local_outputs,
-    candidate_patch_envelopes,
-    verification_results: [{ ok: true, status: 'passed' }],
-    side_effect_report: { ok: true },
-    mutation_ledger: { ok: true },
-    rollback_plan: { ok: true }
-});
-assertGate(report.proof_pack.worker_count === 20, 'proof pack must include 20 worker summaries');
-assertGate(report.proof_pack.token_budget_estimate < 8000, '20-worker proof pack must stay under token budget', report.proof_pack);
-assertGate(report.latency_budget.ok === true, 'GPT final latency budget report must pass');
-emitGate('local-collab:gpt-final-performance', { workers: report.proof_pack.worker_count, token_budget_estimate: report.proof_pack.token_budget_estimate });
-//# sourceMappingURL=gpt-final-arbiter-performance-check.js.map

package/dist/scripts/gpt-image-2-request-validator-check.js

@@ -1,35 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { validateGptImage2Request } from '../core/imagegen/gpt-image-2-request-validator.js';
-import { writeValidPngFixture } from './lib/valid-png-fixture.js';
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-gpt-image-2-validator-'));
-const source = path.join(root, 'source.png');
-writeValidPngFixture(source);
-const good = await validateGptImage2Request({
-    provider: 'fake_imagegen_adapter',
-    endpoint: 'local hermetic fixture',
-    model: 'gpt-image-2',
-    prompt: 'Annotate the image with numbered callouts.',
-    source_image_path: source,
-    output_dir: root,
-    params: { size: 'auto' },
-    privacy: 'local-only'
-});
-const bad = await validateGptImage2Request({
-    provider: 'openai_images_api',
-    endpoint: '/v1/images/edits',
-    model: 'gpt-image-2',
-    prompt: 'Bad request.',
-    source_image_path: source,
-    output_dir: root,
-    params: { input_fidelity: 'high' },
-    privacy: 'local-only'
-});
-const ok = good.ok === true && bad.ok === false && bad.blockers.includes('input_fidelity_must_be_omitted_for_gpt_image_2');
-console.log(JSON.stringify({ schema: 'sks.gpt-image-2-request-validator-check.v1', ok, good, bad }, null, 2));
-if (!ok)
-    process.exitCode = 1;
-//# sourceMappingURL=gpt-image-2-request-validator-check.js.map

package/dist/scripts/hooks-0.134-context-parity-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, readText, root } from './sks-1-18-gate-lib.js';
-const hooksSchema = readText('src/core/codex-compat/codex-hook-events.ts');
-const cockpit = readText('src/core/agents/agent-orchestrator.ts');
-const report = {
-    schema: 'sks.hooks-0.134-context-parity-check.v1',
-    ok: hooksSchema.includes('SubagentStart') && hooksSchema.includes('SubagentStop') && cockpit.includes('agent_transcript_path') && cockpit.includes('permission_mode'),
-    hook_events_have_subagents: hooksSchema.includes('SubagentStart') && hooksSchema.includes('SubagentStop'),
-    agent_context_forwarded: cockpit.includes('agent_transcript_path') && cockpit.includes('permission_mode')
-};
-const out = path.join(root, '.sneakoscope', 'reports', 'hooks-0.134-context-parity.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(report.hook_events_have_subagents === true, 'Codex 0.134 hook event parity must include subagent events', report);
-assertGate(report.agent_context_forwarded === true, 'Codex 0.134 hook context parity must forward agent context', report);
-emitGate('hooks:0.134-context-parity', { hook_events_have_subagents: report.hook_events_have_subagents });
-//# sourceMappingURL=hooks-0.134-context-parity-check.js.map

package/dist/scripts/hooks-actual-parity-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 { installManagedCodexHooks } from '../core/codex-hooks/codex-hook-managed-install.js';
-import { writeCodexHookOfficialParityReport } from '../core/codex-hooks/codex-hook-official-parity.js';
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-hooks-actual-parity-'));
-const install = await installManagedCodexHooks(root);
-const report = await writeCodexHookOfficialParityReport(root, {
-    outputPath: path.join(root, '.sneakoscope', 'reports', 'codex-hook-parity-1.14.1.json')
-});
-const ok = install.ok && report.ok && report.policy.managed_only_enforced === true;
-console.log(JSON.stringify({ schema: 'sks.hooks-actual-parity-check.v1', ok, install, report_path: report.path, policy: report.policy }, null, 2));
-if (!ok)
-    process.exitCode = 1;
-//# sourceMappingURL=hooks-actual-parity-check.js.map