sneakoscope 2.0.14 → 2.0.16

package/dist/scripts/side-effect-runtime-report-check.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const { buildSideEffectRuntimeReport } = await importDist('core/safety/side-effect-runtime-report.js');
-const report = await buildSideEffectRuntimeReport(root);
-const out = path.join(root, '.sneakoscope', 'reports', 'side-effect-runtime-report.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(report.unexpected_applied_mutations === 0, 'unexpected applied mutations must be zero', report);
-assertGate(report.global_mutations_without_confirmation === 0, 'global mutations without confirmation must be zero', report);
-assertGate(report.config_mutations_without_backup_or_noop === 0, 'config/global mutations without backup or noop must be zero', report);
-emitGate('side-effect:runtime-report', {
-    ledgers: report.ledger_paths.length,
-    applied: report.applied_entries,
-    unexpected_applied_mutations: report.unexpected_applied_mutations
-});
-//# sourceMappingURL=side-effect-runtime-report-check.js.map

package/dist/scripts/side-effect-zero-gate-check.js

@@ -1,226 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-// Gate: safety:side-effect-zero
-// Proves the requested-scope contract is deny-by-default: only project files are
-// mutable, every global/destructive mutation requires explicit confirmation, and
-// every applied mutation must be recorded in the mutation ledger with a backup or
-// no-op reason. Operates entirely on temp dirs; never touches the real ~/.codex.
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { root, assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const scope = await importDist('core/safety/requested-scope-contract.js');
-const ledger = await importDist('core/safety/mutation-ledger.js');
-const guardMod = await importDist('core/safety/mutation-guard.js');
-const { createRequestedScopeContract, isMutationAllowed, isPathAllowed, REQUESTED_SCOPE_CONTRACT_SCHEMA, CONFIRMATION_REQUIRED } = scope;
-const { evaluateMutation, recordMutation, mutationLedgerPath, MUTATION_KINDS, MUTATION_LEDGER_SCHEMA } = ledger;
-const { guardedWriteFile, guardedRename, guardContextForRoute, MutationGuardViolationError } = guardMod;
-function mkTmp(prefix) {
-    return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-}
-function rmTmp(dir) {
-    try {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-    catch {
-        // best-effort cleanup; never fail the gate on teardown
-    }
-}
-const tmpDirs = [];
-const summary = { checks: {}, generated_at: new Date().toISOString() };
-try {
-    // ---------------------------------------------------------------------------
-    // Schema + deny-by-default contract surface.
-    // ---------------------------------------------------------------------------
-    assertGate(REQUESTED_SCOPE_CONTRACT_SCHEMA === 'sks.requested-scope-contract.v1', 'schema: REQUESTED_SCOPE_CONTRACT_SCHEMA mismatch', { schema: REQUESTED_SCOPE_CONTRACT_SCHEMA });
-    assertGate(Array.isArray(CONFIRMATION_REQUIRED) && CONFIRMATION_REQUIRED.length > 0, 'schema: CONFIRMATION_REQUIRED is not a non-empty array', { confirmation_required: CONFIRMATION_REQUIRED });
-    const contract = createRequestedScopeContract({
-        route: 'MAD',
-        userRequest: 'repair project config',
-        projectRoot: '/tmp/proj'
-    });
-    assertGate(contract.schema === REQUESTED_SCOPE_CONTRACT_SCHEMA, 'contract: default contract carries the wrong schema', { contract });
-    // ---------------------------------------------------------------------------
-    // project_files allowed; global/destructive kinds denied by default.
-    // ---------------------------------------------------------------------------
-    const projectAllowed = isMutationAllowed(contract, 'project_files');
-    assertGate(projectAllowed.allowed === true, 'scope: project_files must be allowed', { decision: projectAllowed });
-    const globalDenied = isMutationAllowed(contract, 'global_codex_config');
-    assertGate(globalDenied.allowed === false && globalDenied.reason === 'mutation_not_in_scope:global_codex_config', 'scope: global_codex_config must be denied (not in scope) by default', { decision: globalDenied });
-    const pkgDenied = isMutationAllowed(contract, 'package_install');
-    assertGate(pkgDenied.allowed === false, 'scope: package_install must be denied by default', { decision: pkgDenied });
-    const lbAuthDenied = isMutationAllowed(contract, 'codex_lb_auth');
-    assertGate(lbAuthDenied.allowed === false, 'scope: codex_lb_auth must be denied by default', { decision: lbAuthDenied });
-    // process_kill maps to the codex_app_process scope, denied by default.
-    const appProcessDenied = isMutationAllowed(contract, 'codex_app_process');
-    assertGate(appProcessDenied.allowed === false, 'scope: codex_app_process (process_kill) must be denied by default', { decision: appProcessDenied });
-    summary.checks.deny_by_default = {
-        project_files: projectAllowed.allowed,
-        global_codex_config: globalDenied.allowed,
-        package_install: pkgDenied.allowed,
-        codex_lb_auth: lbAuthDenied.allowed,
-        codex_app_process: appProcessDenied.allowed
-    };
-    // ---------------------------------------------------------------------------
-    // Even with an override allowing the kind, confirmation is still required.
-    // ---------------------------------------------------------------------------
-    const overridden = createRequestedScopeContract({
-        route: 'MAD',
-        userRequest: 'repair project config',
-        projectRoot: '/tmp/proj',
-        overrides: { global_codex_config: true }
-    });
-    const overriddenNoConfirm = isMutationAllowed(overridden, 'global_codex_config');
-    assertGate(overriddenNoConfirm.allowed === false && overriddenNoConfirm.reason.startsWith('requires_explicit_confirmation'), 'confirmation: overridden global_codex_config must still require explicit confirmation', { decision: overriddenNoConfirm });
-    const overriddenConfirmed = isMutationAllowed(overridden, 'global_codex_config', { confirmed: true });
-    assertGate(overriddenConfirmed.allowed === true, 'confirmation: confirmed global_codex_config must be allowed', { decision: overriddenConfirmed });
-    summary.checks.explicit_confirmation = {
-        denied_without_confirm: overriddenNoConfirm.allowed,
-        allowed_with_confirm: overriddenConfirmed.allowed
-    };
-    // ---------------------------------------------------------------------------
-    // Path scoping: project paths allowed; the global Codex config is forbidden.
-    // ---------------------------------------------------------------------------
-    const projectPath = isPathAllowed(contract, '/tmp/proj/src/x.ts');
-    assertGate(projectPath.allowed === true, 'path: project source path must be allowed', { decision: projectPath });
-    const codexConfigPath = isPathAllowed(contract, '~/.codex/config.toml');
-    assertGate(codexConfigPath.allowed === false && codexConfigPath.reason.startsWith('forbidden_path'), 'path: ~/.codex/config.toml must be a forbidden path', { decision: codexConfigPath });
-    summary.checks.path_scope = {
-        project_path: projectPath.allowed,
-        forbidden_codex_config: codexConfigPath.allowed
-    };
-    // Guard wrappers must enforce path scope before applying mutations.
-    const guardRoot = mkTmp('sks-mutation-guard-path-');
-    tmpDirs.push(guardRoot);
-    const guardContract = createRequestedScopeContract({
-        route: 'guard-fixture',
-        userRequest: 'mutate project fixture',
-        projectRoot: guardRoot
-    });
-    guardContract.forbidden_paths.push(path.join(guardRoot, 'forbidden/**'));
-    const guardCtx = guardContextForRoute(guardRoot, guardContract, 'side-effect-zero-fixture');
-    const insideTarget = path.join(guardRoot, 'ok.txt');
-    await guardedWriteFile(guardCtx, insideTarget, 'ok');
-    assertGate(fs.existsSync(insideTarget), 'guard path fixture: project file mutation should apply', { insideTarget });
-    const outsideTarget = path.join(os.tmpdir(), `sks-outside-${Date.now()}.txt`);
-    let outsideBlocked = false;
-    try {
-        await guardedWriteFile(guardCtx, outsideTarget, 'no');
-    }
-    catch (err) {
-        outsideBlocked = err instanceof MutationGuardViolationError || String(err?.message || err).includes('path_not_in_scope');
-    }
-    assertGate(outsideBlocked && !fs.existsSync(outsideTarget), 'guard path fixture: outside project write must fail before apply', { outsideTarget });
-    const forbiddenTarget = path.join(guardRoot, 'forbidden', 'no.txt');
-    let forbiddenBlocked = false;
-    try {
-        await guardedWriteFile(guardCtx, forbiddenTarget, 'no');
-    }
-    catch (err) {
-        forbiddenBlocked = err instanceof MutationGuardViolationError || String(err?.message || err).includes('forbidden_path');
-    }
-    assertGate(forbiddenBlocked && !fs.existsSync(forbiddenTarget), 'guard path fixture: forbidden path write must fail before apply', { forbiddenTarget });
-    const renameSource = path.join(guardRoot, 'rename-source.txt');
-    fs.writeFileSync(renameSource, 'keep');
-    let renameBlocked = false;
-    try {
-        await guardedRename(guardCtx, renameSource, path.join(guardRoot, 'forbidden', 'renamed.txt'));
-    }
-    catch (err) {
-        renameBlocked = err instanceof MutationGuardViolationError || String(err?.message || err).includes('forbidden_path');
-    }
-    assertGate(renameBlocked && fs.existsSync(renameSource), 'guard path fixture: forbidden rename target must fail before apply', { renameSource });
-    summary.checks.mutation_guard_path_scope = {
-        project_write_applied: true,
-        outside_project_blocked: outsideBlocked,
-        forbidden_path_blocked: forbiddenBlocked,
-        rename_target_forbidden_blocked: renameBlocked
-    };
-    // ---------------------------------------------------------------------------
-    // Mutation ledger violations.
-    // ---------------------------------------------------------------------------
-    assertGate(MUTATION_LEDGER_SCHEMA === 'sks.mutation-ledger.v1', 'ledger: MUTATION_LEDGER_SCHEMA mismatch', { schema: MUTATION_LEDGER_SCHEMA });
-    // Applied global_config_write with no scope permission -> violation.
-    const appliedOutOfScope = evaluateMutation(contract, 'global_config_write', {
-        target: '~/.codex/config.toml',
-        applied: true
-    });
-    assertGate(appliedOutOfScope.violation === true, 'ledger: global config write applied out of scope must be a violation', { entry: appliedOutOfScope });
-    // Allowed (overridden + confirmed) global config write applied WITHOUT a
-    // backup/no-op reason -> still a violation (config mutations need a backup).
-    const configContract = createRequestedScopeContract({
-        route: 'MAD',
-        userRequest: 'repair project config',
-        projectRoot: '/tmp/proj',
-        overrides: { global_codex_config: true }
-    });
-    const configNoBackup = evaluateMutation(configContract, 'global_config_write', {
-        target: 'x',
-        confirmed: true,
-        applied: true,
-        backupPath: null,
-        noOpReason: null
-    });
-    assertGate(configNoBackup.violation === true, 'ledger: in-scope config write applied without backup/no-op reason must be a violation', { entry: configNoBackup });
-    // Allowed project_files file_write applied -> no violation.
-    const projectWrite = evaluateMutation(contract, 'file_write', {
-        target: '/tmp/proj/src/x.ts',
-        applied: true,
-        backupPath: null,
-        noOpReason: null
-    });
-    assertGate(projectWrite.violation === false && projectWrite.requested_scope_allowed === true, 'ledger: allowed project file_write must not be a violation', { entry: projectWrite });
-    summary.checks.ledger_violations = {
-        applied_out_of_scope: appliedOutOfScope.violation,
-        config_without_backup: configNoBackup.violation,
-        project_write_ok: projectWrite.violation === false
-    };
-    // ---------------------------------------------------------------------------
-    // No-mutation-without-ledger: required kinds are recordable, and recordMutation
-    // produces the ledger file on disk.
-    // ---------------------------------------------------------------------------
-    const requiredKinds = [
-        'file_write',
-        'global_config_write',
-        'package_install',
-        'process_kill',
-        'codex_app_flag_change',
-        'codex_lb_auth_change',
-        'zellij_install',
-        'skill_snapshot_promotion'
-    ];
-    for (const kind of requiredKinds) {
-        assertGate(MUTATION_KINDS.includes(kind), `ledger: MUTATION_KINDS is missing required kind '${kind}'`, { mutation_kinds: MUTATION_KINDS });
-    }
-    const ledgerRoot = mkTmp('sks-side-effect-ledger-');
-    tmpDirs.push(ledgerRoot);
-    const recordedPath = await recordMutation(ledgerRoot, projectWrite);
-    assertGate(recordedPath === mutationLedgerPath(ledgerRoot) && fs.existsSync(recordedPath), 'ledger: recordMutation did not write the ledger file at mutationLedgerPath', { recorded_path: recordedPath, expected: mutationLedgerPath(ledgerRoot) });
-    summary.checks.no_mutation_without_ledger = {
-        required_kinds_present: true,
-        ledger_file_written: true
-    };
-    // ---------------------------------------------------------------------------
-    // Write the report and emit the gate.
-    // ---------------------------------------------------------------------------
-    const reportDir = path.join(root, '.sneakoscope', 'reports');
-    fs.mkdirSync(reportDir, { recursive: true });
-    const reportPath = path.join(reportDir, 'side-effect-zero.json');
-    fs.writeFileSync(reportPath, `${JSON.stringify({ schema: 'sks.side-effect-zero.v1', ok: true, ...summary }, null, 2)}\n`, 'utf8');
-    emitGate('safety:side-effect-zero', {
-        report_path: reportPath,
-        checks_performed: [
-            'deny_by_default',
-            'explicit_confirmation',
-            'path_scope',
-            'mutation_guard_path_scope',
-            'ledger_violations',
-            'no_mutation_without_ledger'
-        ]
-    });
-}
-finally {
-    for (const dir of tmpDirs)
-        rmTmp(dir);
-}
-//# sourceMappingURL=side-effect-zero-gate-check.js.map

package/dist/scripts/sks-1-11-fixture-check.js

@@ -1,130 +0,0 @@
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const mode = process.argv[2] || '';
-function runSks(args) {
-    const entry = path.join(root, 'dist', 'bin', 'sks.js');
-    const result = spawnSync(process.execPath, [entry, ...args], {
-        cwd: root,
-        encoding: 'utf8',
-        env: { ...process.env, SKS_SKIP_NPM_FRESHNESS_CHECK: '1' },
-        timeout: 120_000
-    });
-    if (result.status !== 0) {
-        throw new Error(`sks ${args.join(' ')} failed\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`);
-    }
-    return parseJson(result.stdout);
-}
-function parseJson(text) {
-    const trimmed = String(text || '').trim();
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch { }
-    const start = trimmed.indexOf('{');
-    const end = trimmed.lastIndexOf('}');
-    if (start >= 0 && end > start)
-        return JSON.parse(trimmed.slice(start, end + 1));
-    throw new Error(`Expected JSON output, got: ${trimmed.slice(0, 400)}`);
-}
-function assert(condition, message) {
-    if (!condition)
-        throw new Error(message);
-}
-async function jsonSchemaRecursiveCheck() {
-    const { validateJsonSchemaRecursive } = await import('../core/json-schema-validator.js');
-    const schema = {
-        type: 'object',
-        required: ['items'],
-        properties: {
-            items: {
-                type: 'array',
-                minItems: 1,
-                items: {
-                    type: 'object',
-                    required: ['id', 'bbox'],
-                    additionalProperties: false,
-                    properties: {
-                        id: { type: 'string', minLength: 1 },
-                        bbox: {
-                            type: 'array',
-                            prefixItems: [
-                                { type: 'number', minimum: 0 },
-                                { type: 'number', minimum: 0 },
-                                { type: 'number', exclusiveMinimum: 0 },
-                                { type: 'number', exclusiveMinimum: 0 }
-                            ],
-                            minItems: 4,
-                            maxItems: 4
-                        }
-                    }
-                }
-            }
-        },
-        additionalProperties: false
-    };
-    assert(validateJsonSchemaRecursive({ items: [{ id: 'a', bbox: [0, 0, 1, 1] }] }, schema).ok, 'valid recursive schema fixture failed');
-    assert(!validateJsonSchemaRecursive({ items: [{ id: '', bbox: [0, 0, 0, 1], extra: true }] }, schema).ok, 'invalid recursive schema fixture passed');
-}
-function uxFixture() {
-    const result = runSks(['image-ux-review', 'fixture', '--mock', '--json']);
-    assert(result.ok === true, 'UX fixture did not pass');
-    assert(result.artifacts?.generated_review_ledger?.mock_fixture !== false, 'UX fixture should remain mock/partial');
-}
-function uxNoFakeCallouts() {
-    const source = fs.readFileSync(path.join(root, 'src', 'core', 'commands', 'image-ux-review-command.ts'), 'utf8');
-    assert(!source.includes('Generated visual callout'), 'generic fake Generated visual callout string is present');
-    assert(/callouts:\s*opts\.mock\s*\?/.test(source), 'attach-generated mock gating is missing');
-}
-function pptFixture() {
-    const result = runSks(['ppt', 'fixture', '--mock', '--json']);
-    assert(result.ok === true, 'PPT fixture did not pass');
-    assert(result.artifacts?.gate?.mock_fixture === true, 'PPT fixture did not record mock fixture');
-    assert(result.artifacts?.slide_callout_ledger?.generated_slide_callout_images_count >= 1, 'PPT generated slide callout missing');
-    assert(result.artifacts?.slide_issue_ledger?.issues?.length >= 1, 'PPT slide issue extraction missing');
-}
-function pptNoTextFallback() {
-    const source = fs.readFileSync(path.join(root, 'src', 'core', 'ppt-review', 'slide-imagegen-review.ts'), 'utf8');
-    assert(source.includes('text_only_fallback_allowed: false'), 'PPT text-only fallback gate missing');
-}
-function pptNoMockAsReal() {
-    const result = runSks(['ppt', 'fixture', '--mock', '--json']);
-    assert(result.artifacts?.gate?.verified_level === 'verified_partial', 'PPT mock fixture was not capped at verified_partial');
-}
-function dfixFixture() {
-    const result = runSks(['dfix', 'fixture', '--json']);
-    assert(result.ok === true, 'DFix fixture did not pass');
-    assert(result.artifacts?.gate?.diagnosis_present === true, 'DFix diagnosis missing');
-    assert(result.artifacts?.gate?.verification_present === true, 'DFix verification missing');
-}
-function allFeaturesCompletion() {
-    const result = runSks(['all-features', 'complete', '--json']);
-    assert(result.schema === 'sks.all-feature-completion.v1', 'all-feature completion schema missing');
-    assert(Array.isArray(result.features), 'all-feature completion rows missing');
-}
-const runners = {
-    'ux-generate': uxFixture,
-    'ux-extract': uxFixture,
-    'ux-patch': uxFixture,
-    'ux-recapture': uxFixture,
-    'ux-no-fake': uxNoFakeCallouts,
-    'ppt-review': pptFixture,
-    'ppt-export': pptFixture,
-    'ppt-no-text': pptNoTextFallback,
-    'ppt-no-mock-real': pptNoMockAsReal,
-    'ppt-extract': pptFixture,
-    'ppt-voxel': pptFixture,
-    'ppt-proof': pptFixture,
-    'dfix-fixture': dfixFixture,
-    'dfix-verification': dfixFixture,
-    'all-features': allFeaturesCompletion,
-    'json-schema': jsonSchemaRecursiveCheck
-};
-if (!runners[mode])
-    throw new Error(`Unknown SKS 1.11 fixture mode: ${mode}`);
-await runners[mode]();
-console.log(JSON.stringify({ ok: true, mode }, null, 2));
-//# sourceMappingURL=sks-1-11-fixture-check.js.map

package/dist/scripts/source-intelligence-all-modes-check.js

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/source-intelligence/source-intelligence-runner.js');
-const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-source-intelligence-'));
-const noXai = await mod.runSourceIntelligence({
-    missionDir: dir,
-    route: '$Team',
-    query: 'fixture',
-    context7: async () => [{ title: 'docs' }],
-    codexWebSearch: async () => [{ title: 'web', url: 'https://example.com' }],
-    xaiDetection: { configured: false, search_capable: false, configured_but_unverified: false, status: 'missing' },
-    env: { SKS_CODEX_WEB_SEARCH_AVAILABLE: '1' }
-});
-const withXai = await mod.runSourceIntelligence({
-    missionDir: dir,
-    route: '$Research',
-    query: 'fixture',
-    context7: async () => [{ title: 'docs' }],
-    codexWebSearch: async () => [{ title: 'web', url: 'https://example.com' }],
-    xaiSearch: async () => [{ title: 'x', url: 'https://x.ai' }],
-    xaiDetection: { configured: true, search_capable: true, configured_but_unverified: false, status: 'search_capable' },
-    env: { SKS_CODEX_WEB_SEARCH_AVAILABLE: '1' }
-});
-assertGate(noXai.ok === true && noXai.mode === 'context7_codex_web', 'no-XAI mode must pass with Context7+Codex Web', noXai);
-assertGate(withXai.ok === true && withXai.mode === 'context7_codex_web_xai', 'XAI mode must pass with all providers', withXai);
-assertGate(withXai.parallel.providers_requested.length === 3, 'providers must run through parallel provider plan', withXai.parallel);
-emitGate('source-intelligence:all-modes', { modes: [noXai.mode, withXai.mode] });
-//# sourceMappingURL=source-intelligence-all-modes-check.js.map

package/dist/scripts/source-intelligence-policy-check.js

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertFiles, assertGate, emitGate, importDist, SOURCE_INTELLIGENCE_FILES } from './sks-1-18-gate-lib.js';
-assertFiles(SOURCE_INTELLIGENCE_FILES);
-const mod = await importDist('core/source-intelligence/source-intelligence-policy.js');
-const base = mod.buildSourceIntelligencePolicy({ context7Available: true, codexWebCapability: { available: true, status: 'available', reason: 'fixture' }, xaiDetection: { configured: false, search_capable: false, configured_but_unverified: false, status: 'missing' } });
-const xai = mod.buildSourceIntelligencePolicy({ context7Available: true, codexWebCapability: { available: true, status: 'available', reason: 'fixture' }, xaiDetection: { configured: true, search_capable: true, configured_but_unverified: false, status: 'search_capable' } });
-const blocked = mod.buildSourceIntelligencePolicy({ context7Available: false });
-assertGate(base.mode === 'context7_codex_web', 'default mode must be context7_codex_web', base);
-assertGate(xai.mode === 'context7_codex_web_xai' && xai.xai_mcp.required === true, 'X AI available mode must require X evidence', xai);
-assertGate(blocked.mode === 'blocked' && blocked.blockers.includes('docs_context_missing'), 'Context7 missing must block docs context');
-emitGate('source-intelligence:policy', { modes: [base.mode, xai.mode, blocked.mode] });
-//# sourceMappingURL=source-intelligence-policy-check.js.map

package/dist/scripts/strategy-adhd-orchestrating-gate-check.js

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/strategy/adhd-orchestrating-gate.js');
-const gate = mod.runAdhdOrchestratingGate({
-    prompt: 'Implement strategy-first parallel write gates in `src/core/strategy/strategy-gate.ts` with Appshots evidence.',
-    agentCount: 5,
-    visualRequired: true
-});
-const artifacts = mod.buildDopamineOrchestrationArtifacts(gate);
-const report = { schema: 'sks.strategy-adhd-orchestrating-gate-check.v1', ok: gate.ok, gate, artifacts };
-const out = path.join(root, '.sneakoscope', 'reports', 'strategy-adhd-orchestrating-gate.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(gate.ok === true, 'ADHD orchestration gate must pass a concrete prompt', report);
-assertGate(gate.scheduler_requires_gate === true, 'strategy scheduler gate must be explicit', report);
-assertGate(gate.micro_wins.length >= 4, 'micro-win board must contain executable slices', report);
-assertGate(artifacts.microWinBoard.dashboard_visible === true, 'micro-win board must be dashboard visible', report);
-emitGate('strategy:adhd-orchestrating-gate', { micro_wins: gate.micro_wins.length });
-//# sourceMappingURL=strategy-adhd-orchestrating-gate-check.js.map

package/dist/scripts/strategy-file-ownership-plan-check.js

@@ -1,18 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/strategy/strategy-compiler.js');
-const compiled = mod.compileStrategy({
-    prompt: 'Patch separate source and docs files.',
-    writeTargets: ['src/core/strategy/strategy-gate.ts', 'docs/strategy-first-parallel-write.md']
-});
-const report = { schema: 'sks.strategy-file-ownership-plan-check.v1', ok: compiled.file_ownership_plan.no_overlap, ownership: compiled.file_ownership_plan };
-const out = path.join(root, '.sneakoscope', 'reports', 'strategy-file-ownership-plan.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(compiled.file_ownership_plan.no_overlap === true, 'file ownership plan must prove no overlapping writes', report);
-assertGate(compiled.file_ownership_plan.protected_write_paths.length === 0, 'file ownership plan must block protected paths', report);
-emitGate('strategy:file-ownership-plan', { owners: compiled.file_ownership_plan.owners.length });
-//# sourceMappingURL=strategy-file-ownership-plan-check.js.map

package/dist/scripts/strategy-parallel-modification-plan-check.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/strategy/strategy-compiler.js');
-const compiled = mod.compileStrategy({
-    prompt: 'Update independent release files.',
-    writeTargets: ['src/core/version.ts', 'README.md', 'CHANGELOG.md'],
-    agentCount: 5
-});
-const report = { schema: 'sks.strategy-parallel-modification-plan-check.v1', ok: compiled.parallel_modification_plan.can_parallelize_writes, plan: compiled.parallel_modification_plan };
-const out = path.join(root, '.sneakoscope', 'reports', 'strategy-parallel-modification-plan.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(compiled.parallel_modification_plan.batches.length >= 1, 'parallel modification plan must include a batch', report);
-assertGate(compiled.parallel_modification_plan.serial_conflicts.length === 0, 'independent write targets must not serialize', report);
-emitGate('strategy:parallel-modification-plan', { batches: compiled.parallel_modification_plan.batches.length });
-//# sourceMappingURL=strategy-parallel-modification-plan-check.js.map

package/dist/scripts/strategy-verification-rollback-dag-check.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/strategy/strategy-compiler.js');
-const compiled = mod.compileStrategy({
-    prompt: 'Patch with rollback proof.',
-    writeTargets: ['src/core/agents/agent-patch-proof.ts']
-});
-const dag = compiled.verification_rollback_dag;
-const report = { schema: 'sks.strategy-verification-rollback-dag-check.v1', ok: dag.rollback_ready, dag };
-const out = path.join(root, '.sneakoscope', 'reports', 'strategy-verification-rollback-dag.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(dag.rollback_ready === true, 'verification rollback DAG must include rollback node', report);
-assertGate(dag.nodes.some((node) => node.kind === 'verification'), 'verification rollback DAG must include verification node', report);
-emitGate('strategy:verification-rollback-dag', { nodes: dag.nodes.length });
-//# sourceMappingURL=strategy-verification-rollback-dag-check.js.map

package/dist/scripts/team-actual-route-backfill-check.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { runActualTeamBackfillBlackbox } from './agent-route-blackbox-lib.js';
-runActualTeamBackfillBlackbox('team:actual-route-backfill');
-//# sourceMappingURL=team-actual-route-backfill-check.js.map

package/dist/scripts/team-backfill-route-blackbox.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { runRouteBackfillBlackbox } from './agent-route-blackbox-lib.js';
-runRouteBackfillBlackbox('$Team', 'team:backfill-route-blackbox');
-//# sourceMappingURL=team-backfill-route-blackbox.js.map

package/dist/scripts/team-parallel-write-blackbox.js

@@ -1,55 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const mergeMod = await importDist('core/agents/agent-merge-coordinator.js');
-const applyMod = await importDist('core/agents/agent-patch-apply-worker.js');
-const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-team-patch-'));
-fs.writeFileSync(path.join(tmp, 'team-a.txt'), 'lane-a\n');
-fs.writeFileSync(path.join(tmp, 'team-b.txt'), 'lane-b\n');
-const envelopes = [
-    { schema: 'sks.agent-patch-envelope.v1', agent_id: 'reviewer-a', session_id: 'team-session-a', slot_id: 'team-slot-a', generation_index: 1, lease_id: 'lease:reviewer-a:team-a.txt', operations: [{ op: 'replace', path: 'team-a.txt', search: 'lane-a', replace: 'lane-a-done' }] },
-    { schema: 'sks.agent-patch-envelope.v1', agent_id: 'reviewer-b', session_id: 'team-session-b', slot_id: 'team-slot-b', generation_index: 1, lease_id: 'lease:reviewer-b:team-b.txt', operations: [{ op: 'replace', path: 'team-b.txt', search: 'lane-b', replace: 'lane-b-done' }] }
-];
-const merge = mergeMod.coordinateAgentPatchMerge(envelopes);
-const applyResults = [];
-for (const envelope of envelopes)
-    applyResults.push(await applyMod.applyAgentPatchEnvelope(tmp, envelope));
-const teamRun = spawnSync(process.execPath, [
-    'dist/bin/sks.js',
-    'team',
-    'team parallel write blackbox route fixture',
-    'executor:1',
-    'reviewer:5',
-    '--mock',
-    '--write-mode',
-    'parallel',
-    '--apply-patches',
-    '--dry-run-patches',
-    '--max-write-agents',
-    '1',
-    '--json'
-], { cwd: root, encoding: 'utf8', maxBuffer: 2 * 1024 * 1024 });
-const teamJson = parseJson(teamRun.stdout);
-const routePolicy = teamJson?.native_agent_run?.parallel_write_policy || null;
-const report = { schema: 'sks.team-parallel-write-blackbox.v1', ok: merge.ok && applyResults.every((item) => item.ok) && teamRun.status === 0 && routePolicy?.route_level_flags_wired === true, merge, applyResults, route_command: { status: teamRun.status, stderr_tail: teamRun.stderr.slice(-2000), mission_id: teamJson?.mission_id || null, route_policy: routePolicy } };
-const out = path.join(root, '.sneakoscope', 'reports', 'team-parallel-write-blackbox.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(report.ok === true, 'Team parallel write blackbox must pass', report);
-assertGate(routePolicy?.write_mode === 'parallel', 'Team route must carry --write-mode parallel into native agent policy', report);
-assertGate(routePolicy?.apply_patches === true, 'Team route must carry --apply-patches into native agent policy', report);
-assertGate(routePolicy?.dry_run_patches === true, 'Team route must carry --dry-run-patches into native agent policy', report);
-emitGate('team:parallel-write-blackbox', { changed_files: applyResults.flatMap((item) => item.changed_files).length });
-function parseJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=team-parallel-write-blackbox.js.map

package/dist/scripts/team-patch-swarm-route-blackbox.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { runPatchSwarmRouteBlackbox } from './agent-patch-swarm-gate-lib.js';
-await runPatchSwarmRouteBlackbox({
-    gate: 'team:patch-swarm-route-blackbox',
-    route: '$Team',
-    routeCommand: 'sks team',
-    reportName: 'team-patch-swarm-route-blackbox'
-});
-//# sourceMappingURL=team-patch-swarm-route-blackbox.js.map

package/dist/scripts/terminal-keyboard-enhancement-safety-check.js

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-const report = {
-    schema: 'sks.keyboard-enhancement-safety-check.v1',
-    ok: true,
-    runtime: 'zellij',
-    removed_runtime: 'tmux',
-    checks: ['no control-mode keyboard setup is attempted by SKS runtime']
-};
-console.log(JSON.stringify(report, null, 2));
-export {};
-//# sourceMappingURL=terminal-keyboard-enhancement-safety-check.js.map

package/dist/scripts/terminal-tui-output-stability-check.js

@@ -1,35 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
-const freshness = ensureDistFresh({ rebuild: true });
-if (!freshness.ok) {
-    console.log(JSON.stringify({ schema: 'sks.tui-output-stability-check.v1', ok: false, blockers: ['dist_not_fresh'], freshness }, null, 2));
-    process.exit(1);
-}
-const layoutMod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-layout-builder.js')).href);
-const madLayout = layoutMod.buildZellijLayoutKdl({
-    missionId: 'M-tui-output-stability',
-    ledgerRoot: path.join(root, '.sneakoscope', 'tmp', 'tui-output-stability'),
-    cwd: root,
-    kind: 'mad',
-    slotCount: 1,
-    codexArgs: ['--profile', 'sks-mad-high']
-});
-const codexScrollbackOk = madLayout.codex_args.includes('--no-alt-screen')
-    && madLayout.layout_kdl.includes('--no-alt-screen');
-const report = {
-    schema: 'sks.tui-output-stability-check.v1',
-    ok: codexScrollbackOk,
-    runtime: 'zellij',
-    stdout_frame_policy: 'lane renderer stdout only',
-    stderr_policy: 'errors only',
-    codex_scrollback_policy: 'zellij interactive Codex panes launch with --no-alt-screen so trackpad wheel scrolls terminal conversation history instead of the prompt textarea',
-    codex_no_alt_screen: codexScrollbackOk,
-    blockers: codexScrollbackOk ? [] : ['codex_no_alt_screen_missing']
-};
-console.log(JSON.stringify(report, null, 2));
-if (!report.ok)
-    process.exitCode = 1;
-//# sourceMappingURL=terminal-tui-output-stability-check.js.map