sneakoscope 2.0.13 → 2.0.15

package/dist/scripts/agent-terminal-generations-check.js

@@ -1,23 +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/agents/agent-terminal-session.js');
-const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-terminal-generations-'));
-await fs.mkdir(path.join(root, 'sessions'), { recursive: true });
-await fs.writeFile(path.join(root, 'agent-events.jsonl'), '');
-const sessions = {};
-for (const generationIndex of [1, 2]) {
-    const agent = { id: 'slot-001', slot_id: 'slot-001', generation_index: generationIndex, session_id: `agent_slot-001-gen_${generationIndex}`, session_artifact_dir: path.join('sessions', 'slot-001', `gen-${generationIndex}`) };
-    sessions[agent.session_id] = { agent_id: agent.id, slot_id: agent.slot_id, generation_index: generationIndex, session_id: agent.session_id, status: 'closed', session_artifact_dir: agent.session_artifact_dir };
-    await mod.startAgentTerminalSession(root, agent, { backend: 'fake', real: false });
-    await mod.closeAgentTerminalSession(root, agent, { exitCode: 0, status: 'done' });
-}
-await fs.writeFile(path.join(root, 'agent-sessions.json'), JSON.stringify({ schema: 'sks.agent-sessions.v1', sessions }, null, 2));
-const closed = await mod.assertAgentTerminalSessionsClosed(root);
-assertGate(closed.ok === true, 'terminal close reports must exist for every generation', closed);
-assertGate(closed.total_sessions === 2, 'terminal generation count must be 2', closed);
-emitGate('agent:terminal-generations', { terminal_generation_count: closed.total_sessions });
-//# sourceMappingURL=agent-terminal-generations-check.js.map

package/dist/scripts/agent-visual-consistency-check.js

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
-const cockpit = readText('src/core/agents/agent-codex-cockpit.ts');
-for (const token of ['source_intelligence_status', 'xai_status', 'codex_web_search_status', 'goal_mode_status', 'terminal_session_status', 'zellij_attach_command']) {
-    assertGate(cockpit.includes(token), `Codex App cockpit missing ${token}`);
-}
-emitGate('agent:visual-consistency', { dashboard_fields: 6 });
-//# sourceMappingURL=agent-visual-consistency-check.js.map

package/dist/scripts/agent-wiki-context-proof-check.js

@@ -1,62 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-// Gate: agent:wiki-context-proof
-// Proves the native agent kernel consults the TriWiki context pack (read-only) and
-// references it in proof: (1) the read-only pack loader behaves correctly with and
-// without a pack, (2) the orchestrator wires loadTriWikiRuntimeContext + writes the
-// artifact + passes it to proof, (3) agent-proof-evidence records the wiki proof fields.
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, readText, root } from './sks-1-18-gate-lib.js';
-const triwiki = await importDist('core/triwiki-runtime.js');
-const { loadTriWikiRuntimeContext, triWikiProofRecord, writeTriWikiContextArtifact } = triwiki;
-// 1) Absent pack -> graceful fallback (present:false, warning, not consulted).
-const emptyRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-triwiki-empty-'));
-const emptyCtx = await loadTriWikiRuntimeContext(emptyRoot);
-assertGate(emptyCtx.present === false, 'absent pack must yield present:false', { ctx: emptyCtx });
-assertGate(typeof emptyCtx.warning === 'string' && emptyCtx.warning.length > 0, 'absent pack must carry a warning');
-assertGate(emptyCtx.context_pack_hash === null && emptyCtx.use_first.length === 0, 'absent pack must have null hash + no use_first');
-assertGate(triWikiProofRecord(emptyCtx).triwiki_context_consulted === false, 'absent pack proof must report not consulted');
-// 2) Present pack -> consulted with hash + attention rows.
-const packRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-triwiki-pack-'));
-const packDir = path.join(packRoot, '.sneakoscope', 'wiki');
-fs.mkdirSync(packDir, { recursive: true });
-const pack = {
-    mission: 'project-wiki',
-    attention: { mode: 'aggressive_triwiki_active_recall', use_first: [['claim-a', [48, 132, 212, 240], 'h1']], hydrate_first: [['claim-b', 'risk:high']] },
-    wiki: { a: [['claim-a'], ['claim-b']] },
-    claims: [{ id: 'claim-a' }, { id: 'claim-b' }],
-    trust_summary: { avg: 0.71 }
-};
-fs.writeFileSync(path.join(packDir, 'context-pack.json'), `${JSON.stringify(pack, null, 2)}\n`);
-const ctx = await loadTriWikiRuntimeContext(packRoot);
-assertGate(ctx.present === true, 'present pack must yield present:true', { ctx });
-assertGate(typeof ctx.context_pack_hash === 'string' && /^[0-9a-f]{64}$/.test(ctx.context_pack_hash), 'present pack must carry a sha256 hash', { hash: ctx.context_pack_hash });
-assertGate(ctx.mission === 'project-wiki', 'pack mission must be read', { mission: ctx.mission });
-assertGate(ctx.use_first.length === 1 && ctx.hydrate_first.length === 1, 'attention rows must be surfaced', { use: ctx.use_first.length, hyd: ctx.hydrate_first.length });
-assertGate(ctx.claim_count === 2 && ctx.anchor_count === 2, 'claim/anchor counts must be read', { claims: ctx.claim_count, anchors: ctx.anchor_count });
-const proof = triWikiProofRecord(ctx);
-assertGate(proof.triwiki_context_consulted === true && proof.context_pack_hash === ctx.context_pack_hash, 'present pack proof must report consulted + hash');
-// 3) Artifact write.
-const ledger = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-triwiki-ledger-'));
-const artifactPath = await writeTriWikiContextArtifact(ledger, ctx);
-assertGate(fs.existsSync(artifactPath), 'context artifact must be written');
-const artifact = JSON.parse(fs.readFileSync(artifactPath, 'utf8'));
-assertGate(artifact.proof?.triwiki_context_consulted === true, 'artifact must embed proof record');
-// 4) Kernel + proof wiring (source-level so the consult cannot be silently removed).
-const orchestrator = readText('src/core/agents/agent-orchestrator.ts');
-assertGate(orchestrator.includes('loadTriWikiRuntimeContext') && orchestrator.includes('writeTriWikiContextArtifact') && orchestrator.includes('triwikiContext'), 'orchestrator must consult TriWiki + write artifact + pass to proof');
-const proofSrc = readText('src/core/agents/agent-proof-evidence.ts');
-assertGate(proofSrc.includes('triwiki_context_consulted') && proofSrc.includes('context_pack_hash') && proofSrc.includes("triwiki_context: 'agent-triwiki-context.json'"), 'agent-proof-evidence must record the TriWiki proof fields');
-for (const dir of [emptyRoot, packRoot, ledger]) {
-    try {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-    catch { /* best-effort */ }
-}
-const reportDir = path.join(root, '.sneakoscope', 'reports');
-fs.mkdirSync(reportDir, { recursive: true });
-fs.writeFileSync(path.join(reportDir, 'agent-wiki-context-proof.json'), `${JSON.stringify({ schema: 'sks.agent-wiki-context-proof.v1', ok: true, present_pack_hash: ctx.context_pack_hash, use_first: ctx.use_first.length, hydrate_first: ctx.hydrate_first.length }, null, 2)}\n`);
-emitGate('agent:wiki-context-proof', { kernel_consults_triwiki: true, proof_records_hash: true });
-//# sourceMappingURL=agent-wiki-context-proof-check.js.map

package/dist/scripts/agent-worker-backend-router-check.js

@@ -1,63 +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, root as repoRoot } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/agents/native-cli-worker.js');
-const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-worker-router-'));
-const old = snapshotEnv();
-process.env.SKS_DISABLE_ROUTE_RECURSION = '1';
-process.env.SKS_AGENT_WORKER = '1';
-process.env.SKS_FAST_MODE = '1';
-process.env.SKS_SERVICE_TIER = 'fast';
-try {
-    const result = await mod.runNativeCliWorker({
-        intakeJson: {
-            mission_id: 'M-router-check',
-            parent_mission_id: 'M-router-check',
-            route: '$Agent',
-            backend: 'process',
-            agent_root: root,
-            agent: { id: 'router-agent', session_id: 'router-session', slot_id: 'slot-001', generation_index: 1, persona_id: 'executor' },
-            slice: { id: 'router-task', write_paths: ['router-output.txt'], description: 'exercise real process child backend' },
-            worker_artifact_dir: 'sessions/slot-001/gen-1/worker',
-            result_path: 'sessions/slot-001/gen-1/worker/worker-result.json',
-            heartbeat_path: 'sessions/slot-001/gen-1/worker/worker-heartbeat.jsonl',
-            patch_envelope_path: 'sessions/slot-001/gen-1/worker/worker-patch-envelope.json',
-            fast_mode: true,
-            service_tier: 'fast'
-        }
-    });
-    const workerDir = path.join(root, 'sessions', 'slot-001', 'gen-1', 'worker');
-    const router = JSON.parse(await fs.readFile(path.join(workerDir, 'worker-backend-router-report.json'), 'utf8'));
-    const patch = JSON.parse(await fs.readFile(path.join(workerDir, 'worker-patch-envelope.json'), 'utf8'));
-    assertGate(result.status === 'done', 'process backend worker result must be done', result);
-    assertGate(router.selected_backend === 'process', 'router selected backend mismatch', router);
-    assertGate(router.child_process_ids.length === 1, 'router must record child process id', router);
-    assertGate(patch.envelopes[0].source === 'process_generated', 'process backend patch envelope source missing', patch);
-    assertGate(result.backend_router_report?.proof_level === 'process_child_proven', 'router proof level must show process child', result.backend_router_report);
-    await fs.mkdir(path.join(repoRoot, '.sneakoscope', 'reports'), { recursive: true });
-    await fs.writeFile(path.join(repoRoot, '.sneakoscope', 'reports', 'agent-worker-backend-router.json'), `${JSON.stringify({ ok: true, router, patch_source: patch.envelopes[0].source }, null, 2)}\n`);
-    emitGate('agent:worker-backend-router', { backend: router.selected_backend, child_process_ids: router.child_process_ids.length, patch_source: patch.envelopes[0].source });
-}
-finally {
-    restoreEnv(old);
-}
-function snapshotEnv() {
-    return {
-        SKS_DISABLE_ROUTE_RECURSION: process.env.SKS_DISABLE_ROUTE_RECURSION,
-        SKS_AGENT_WORKER: process.env.SKS_AGENT_WORKER,
-        SKS_FAST_MODE: process.env.SKS_FAST_MODE,
-        SKS_SERVICE_TIER: process.env.SKS_SERVICE_TIER
-    };
-}
-function restoreEnv(old) {
-    for (const [key, value] of Object.entries(old)) {
-        if (value === undefined)
-            delete process.env[key];
-        else
-            process.env[key] = value;
-    }
-}
-//# sourceMappingURL=agent-worker-backend-router-check.js.map

package/dist/scripts/agent-worker-scout-limited-check.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/agents/scout-policy.js');
-const local = mod.validateWorkerScoutEvidence(path.join(root, '.sneakoscope/missions/fixture/agents'), {
-    agent_id: 'agent_1',
-    artifact_path: 'sessions/agent_1/worker-scout/evidence.json'
-});
-const global = mod.validateWorkerScoutEvidence(path.join(root, '.sneakoscope/missions/fixture/agents'), {
-    agent_id: 'agent_1',
-    artifact_path: '../scout-ledger.json'
-});
-assertGate(local.ok === true && local.central_proof_ssot === false, 'worker Scout local evidence must be accepted only as local evidence', local);
-assertGate(global.ok === false, 'worker Scout global artifact must be blocked', global);
-emitGate('agent:worker-scout-limited', { local_ok: local.ok, global_ok: global.ok });
-//# sourceMappingURL=agent-worker-scout-limited-check.js.map

package/dist/scripts/agent-zellij-dynamic-backfill-panes-check.js

@@ -1,34 +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)
-    fail('dist_not_fresh', { freshness });
-const proof = await import(pathToFileURL(path.join(root, 'dist', 'core', 'agents', 'agent-slot-pane-binding-proof.js')).href);
-const targetActiveSlots = 5;
-const workItems = 10;
-const records = Array.from({ length: workItems }, (_, index) => {
-    const slotIndex = (index % targetActiveSlots) + 1;
-    const generationIndex = Math.floor(index / targetActiveSlots) + 1;
-    const slotId = `slot-${String(slotIndex).padStart(3, '0')}`;
-    return {
-        slot_id: slotId,
-        generation_index: generationIndex,
-        pane_name: `${slotId}/gen-${generationIndex}`,
-        active_at_once: targetActiveSlots
-    };
-});
-const report = proof.evaluateWorkerPaneBackfillProof(records, targetActiveSlots, workItems);
-const bad = proof.evaluateWorkerPaneBackfillProof(records.slice(0, 5), targetActiveSlots, workItems);
-const ok = report.ok
-    && report.generation_record_count >= 10
-    && report.distinct_pane_count >= 10
-    && bad.ok === false
-    && bad.blockers.includes('dynamic_backfill_generation_records_missing');
-emit({ schema: 'sks.agent-zellij-dynamic-backfill-panes-check.v1', ok, report, bad, blockers: ok ? [] : ['agent_zellij_dynamic_backfill_panes_check_failed'] });
-function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
-    process.exitCode = 1; }
-function fail(blocker, detail) { emit({ schema: 'sks.agent-zellij-dynamic-backfill-panes-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-//# sourceMappingURL=agent-zellij-dynamic-backfill-panes-check.js.map

package/dist/scripts/agent-zellij-runtime-check.js

@@ -1,84 +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 { pathToFileURL } from 'node:url';
-import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
-const freshness = ensureDistFresh({ rebuild: true });
-if (!freshness.ok)
-    fail('dist_not_fresh', { freshness });
-const supervisor = await import(pathToFileURL(path.join(root, 'dist', 'core', 'agents', 'zellij-lane-supervisor.js')).href);
-const runner = await import(pathToFileURL(path.join(root, 'dist', 'core', 'agents', 'agent-runner-zellij.js')).href);
-const nativeSwarm = await import(pathToFileURL(path.join(root, 'dist', 'core', 'agents', 'native-cli-session-swarm.js')).href);
-const manager = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-worker-pane-manager.js')).href);
-const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-agent-zellij-'));
-await supervisor.initializeZellijLaneSupervisorEmpty(tmp, { missionId: 'M-agent-zellij', sessionName: 'sks-M-agent-zellij' });
-const supervisorState = JSON.parse(await fs.readFile(path.join(tmp, 'agent-zellij-lane-supervisor.json'), 'utf8'));
-const runtimeManifest = JSON.parse(await fs.readFile(path.join(tmp, 'zellij-lane-runtime.json'), 'utf8'));
-const agent = { id: 'agent_1', session_id: 'session_1', persona_id: 'agent_1', slot_id: 'slot-001', generation_index: 1 };
-const result = await runner.runZellijAgent(agent, { id: 'work-001' }, { agentRoot: tmp, missionId: 'M-agent-zellij' });
-const supervisorOk = supervisorState.lane_count === 0
-    && supervisorState.lanes.length === 0
-    && supervisorState.all_lanes_closed_after_drain === true
-    && runtimeManifest.lanes.length === 0;
-const paneWorkerCommand = nativeSwarm.buildPaneWorkerCommand({
-    args: ['/tmp/sks.js', '--agent', 'worker', '--intake', '/tmp/worker-intake.json', '--json'],
-    stdoutPath: '/tmp/worker.stdout.log',
-    stderrPath: '/tmp/worker.stderr.log',
-    heartbeatPath: '/tmp/worker-heartbeat.jsonl',
-    env: {
-        SKS_AGENT_WORKER: '1',
-        SKS_PARENT_MISSION_ID: 'M-agent-zellij',
-        SKS_AGENT_SLOT_ID: 'slot-001',
-        SKS_ZELLIJ_WORKER_PANE: '1'
-    }
-});
-const paneArtifact = manager.buildWorkerPaneArtifact({
-    root: tmp,
-    missionId: 'M-agent-zellij',
-    sessionName: 'sks-M-agent-zellij',
-    slotId: 'slot-001',
-    generationIndex: 1,
-    sessionId: 'slot-001-gen-1',
-    workerArtifactDir: 'sessions/slot-001/gen-1/worker',
-    resultPath: 'sessions/slot-001/gen-1/worker/worker-result.json',
-    heartbeatPath: 'sessions/slot-001/gen-1/worker/worker-heartbeat.jsonl',
-    patchEnvelopePath: 'sessions/slot-001/gen-1/worker/worker-patch-envelope.json',
-    stdoutLog: 'sessions/slot-001/gen-1/worker/worker.stdout.log',
-    stderrLog: 'sessions/slot-001/gen-1/worker/worker.stderr.log',
-    paneId: '1',
-    paneIdSource: 'zellij_worker_new_pane_stdout',
-    status: 'running',
-    blockers: []
-});
-const expectedPanePrefix = 'slot-001/gen-1';
-const paneTitle = String(paneArtifact.pane_title || paneArtifact.pane_name || '');
-const providerContext = paneArtifact.provider_context || {};
-const paneWorkerOk = paneWorkerCommand.includes('SKS_ZELLIJ_WORKER_PANE=')
-    && paneWorkerCommand.includes('--agent')
-    && paneWorkerCommand.includes('worker')
-    && paneWorkerCommand.includes('worker.stdout.log')
-    && paneWorkerCommand.includes('worker.stderr.log')
-    && paneWorkerCommand.includes('worker-heartbeat.jsonl')
-    && paneWorkerCommand.includes('code=$?')
-    && paneArtifact.pane_name === paneTitle
-    && paneTitle.startsWith(expectedPanePrefix)
-    && paneTitle.includes('codex-sdk')
-    && paneTitle.includes('tier-unknown')
-    && paneTitle.includes('provider-unknown')
-    && paneArtifact.provider === 'unknown'
-    && paneArtifact.service_tier === 'unknown'
-    && providerContext.schema === 'sks.provider-context.v1'
-    && providerContext.provider === 'unknown'
-    && providerContext.service_tier === 'unknown'
-    && paneArtifact.scaling_primitive === 'native_cli_process_in_zellij_worker_pane';
-const ok = result.status === 'done' && result.backend === 'zellij' && supervisorOk && paneWorkerOk;
-const report = { schema: 'sks.agent-zellij-runtime-check.v1', ok, result, supervisor_ok: supervisorOk, pane_worker_ok: paneWorkerOk, pane_worker_command: paneWorkerCommand, pane_artifact: paneArtifact, supervisor: supervisorState, runtime_manifest: runtimeManifest, blockers: ok ? [] : ['agent_zellij_runtime_check_failed'] };
-await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
-await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'agent-zellij-runtime.json'), `${JSON.stringify(report, null, 2)}\n`);
-emit(report);
-function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
-    process.exitCode = 1; }
-function fail(blocker, detail) { emit({ schema: 'sks.agent-zellij-runtime-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-//# sourceMappingURL=agent-zellij-runtime-check.js.map

package/dist/scripts/all-feature-deep-completion-check.js

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, requireContains, requirePackageScripts, runSksJson } from './sks-1-12-real-execution-check-lib.js';
-const requiredScripts = [
-    'ux-review:run-wires-imagegen',
-    'ux-review:extract-wires-real-extractor',
-    'ux-review:patch-diff-recheck',
-    'ppt:real-export-adapter',
-    'ppt:real-imagegen-wiring',
-    'ppt:reexport-rereview',
-    'dfix:patch-handoff',
-    'dfix:verification-recommendation',
-    'all-features:deep-completion',
-    'evidence:flagship-coverage'
-];
-requirePackageScripts('all-features:deep-completion', requiredScripts);
-requireContains('all-features:deep-completion', 'src/core/feature-registry.ts', [
-    'command_registry',
-    'evidence_router',
-    'completion_proof',
-    'trust_report',
-    'wrongness',
-    'blackbox',
-    'mock_not_real',
-    'unavailable_blocker'
-]);
-const report = runSksJson(['features', 'complete', '--json']);
-assertGate(report.schema === 'sks.all-feature-completion.v1', 'all-feature completion schema mismatch', report);
-assertGate(Array.isArray(report.features) && report.features.length > 0, 'all-feature completion rows missing', report);
-emitGate('all-features:deep-completion', { version: report.version, features: report.features.length, status: report.status });
-//# sourceMappingURL=all-feature-deep-completion-check.js.map

package/dist/scripts/appshots-capability-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/codex/appshots-detector.js');
-const notRequired = mod.detectAppshotsCapability({ prompt: 'nonvisual release metadata' });
-const visualWithOperator = mod.detectAppshotsCapability({ prompt: 'verify UI with Appshots', operatorActionRecorded: true });
-const visualMissing = mod.detectAppshotsCapability({ prompt: 'verify UI with Appshots' });
-const report = { schema: 'sks.appshots-capability-check.v1', ok: notRequired.ok && visualWithOperator.ok && !visualMissing.ok, notRequired, visualWithOperator, visualMissing };
-const out = path.join(root, '.sneakoscope', 'reports', 'appshots-capability.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(notRequired.status === 'not_required', 'nonvisual prompts must not require Appshots', report);
-assertGate(visualWithOperator.ok === true, 'operator-recorded visual Appshots must pass', report);
-assertGate(visualMissing.ok === false, 'missing visual Appshots operator action must block', report);
-emitGate('appshots:capability', { visual_required: visualWithOperator.visual_required });
-//# sourceMappingURL=appshots-capability-check.js.map

package/dist/scripts/appshots-evidence-check.js

@@ -1,48 +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/source-intelligence/appshots-evidence.js');
-const fixture = writeAppshotFixture('evidence');
-const evidence = mod.buildAppshotsEvidence({
-    root,
-    prompt: 'visual Appshots proof',
-    sourcePaths: [fixture.rel],
-    sourceMetadata: [fixture.metadata],
-    operatorActionRecorded: true
-});
-const report = { schema: 'sks.appshots-evidence-check.v1', ok: evidence.ok, evidence };
-const out = path.join(root, '.sneakoscope', 'reports', 'appshots-evidence.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(evidence.ok === true, 'Appshots evidence must pass with source path', report);
-assertGate(evidence.status === 'recorded', 'Appshots evidence must mark recorded visual source', report);
-assertGate(evidence.proof_level === 'fixture_instrumented_real', 'Appshots fixture evidence must not be promoted to proven', report);
-assertGate(evidence.source_verification.every((row) => row.accepted === true), 'Appshots evidence must verify source metadata', report);
-emitGate('appshots:evidence', { source_count: evidence.source_count });
-function writeAppshotFixture(name) {
-    const dir = path.join(root, '.sneakoscope', 'reports', 'appshots-fixtures');
-    fs.mkdirSync(dir, { recursive: true });
-    const file = path.join(dir, `${name}.redacted-appshot.json`);
-    fs.writeFileSync(file, `${JSON.stringify({ fixture: true, redacted: true, text: '[redacted appshot fixture]' })}\n`);
-    const rel = path.relative(root, file).split(path.sep).join('/');
-    return {
-        rel,
-        metadata: {
-            path: rel,
-            source_type: 'codex_appshot',
-            origin: 'fixture',
-            operator_attached: true,
-            frontmost_window: true,
-            redacted: true,
-            local_only: true,
-            fixture: true,
-            thread_id: 'thread-fixture-evidence',
-            attachment_id: 'attachment-fixture-evidence',
-            source_app: 'Codex',
-            source_window: 'Fixture Appshot'
-        }
-    };
-}
-//# sourceMappingURL=appshots-evidence-check.js.map

package/dist/scripts/appshots-operator-policy-check.js

@@ -1,25 +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 detector = await importDist('core/codex/appshots-detector.js');
-const policyMod = await importDist('core/codex/appshots-operator-policy.js');
-const fixture = writeAppshotFixture('operator-policy');
-const capability = detector.detectAppshotsCapability({ prompt: 'visual Appshots check', operatorActionRecorded: true });
-const policy = policyMod.buildAppshotsOperatorPolicy(capability, { operatorActionRecorded: true, sourcePaths: [fixture.rel] });
-const report = { schema: 'sks.appshots-operator-policy-check.v1', ok: policy.ok, policy };
-const out = path.join(root, '.sneakoscope', 'reports', 'appshots-operator-policy.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(policy.ok === true, 'Appshots operator policy must pass when action is recorded', report);
-assertGate(policy.privacy_safety.no_background_screen_capture === true, 'Appshots policy must prevent background capture', report);
-emitGate('appshots:operator-policy', { mode: policy.mode });
-function writeAppshotFixture(name) {
-    const dir = path.join(root, '.sneakoscope', 'reports', 'appshots-fixtures');
-    fs.mkdirSync(dir, { recursive: true });
-    const file = path.join(dir, `${name}.redacted-appshot.json`);
-    fs.writeFileSync(file, `${JSON.stringify({ fixture: true, redacted: true, text: '[redacted appshot fixture]' })}\n`);
-    return { rel: path.relative(root, file).split(path.sep).join('/') };
-}
-//# sourceMappingURL=appshots-operator-policy-check.js.map

package/dist/scripts/appshots-privacy-safety-check.js

@@ -1,48 +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/source-intelligence/appshots-evidence.js');
-const fixture = writeAppshotFixture('privacy');
-const evidence = mod.buildAppshotsEvidence({
-    root,
-    prompt: 'visual Appshots privacy',
-    sourcePaths: [fixture.rel],
-    sourceMetadata: [fixture.metadata],
-    operatorActionRecorded: true
-});
-const policy = evidence.operator_policy.privacy_safety;
-const report = { schema: 'sks.appshots-privacy-safety-check.v1', ok: evidence.privacy_safety_ok, policy };
-const out = path.join(root, '.sneakoscope', 'reports', 'appshots-privacy-safety.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(evidence.privacy_safety_ok === true, 'Appshots privacy safety must pass', report);
-assertGate(policy.avoid_secrets_and_credentials === true, 'Appshots privacy safety must avoid secrets', report);
-assertGate(evidence.source_verification.every((row) => row.redacted && row.local_only), 'Appshots privacy safety must verify redacted local-only sources', report);
-emitGate('appshots:privacy-safety', { privacy_safety_ok: evidence.privacy_safety_ok });
-function writeAppshotFixture(name) {
-    const dir = path.join(root, '.sneakoscope', 'reports', 'appshots-fixtures');
-    fs.mkdirSync(dir, { recursive: true });
-    const file = path.join(dir, `${name}.redacted-appshot.json`);
-    fs.writeFileSync(file, `${JSON.stringify({ fixture: true, redacted: true, text: '[redacted appshot fixture]' })}\n`);
-    const rel = path.relative(root, file).split(path.sep).join('/');
-    return {
-        rel,
-        metadata: {
-            path: rel,
-            source_type: 'codex_appshot',
-            origin: 'fixture',
-            operator_attached: true,
-            frontmost_window: true,
-            redacted: true,
-            local_only: true,
-            fixture: true,
-            thread_id: 'thread-fixture-privacy',
-            attachment_id: 'attachment-fixture-privacy',
-            source_app: 'Codex',
-            source_window: 'Fixture Appshot'
-        }
-    };
-}
-//# sourceMappingURL=appshots-privacy-safety-check.js.map

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

@@ -1,53 +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, root } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/source-intelligence/source-intelligence-runner.js');
-const missionDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-appshots-source-intelligence-'));
-const fixture = writeAppshotFixture(missionDir);
-const evidence = await mod.runSourceIntelligence({
-    root,
-    missionDir,
-    route: '$UX-Review',
-    query: 'visual Appshots source intelligence',
-    offline: true,
-    context7Available: true,
-    appshots: {
-        sourcePaths: [fixture.rel],
-        sourceMetadata: [fixture.metadata],
-        operatorActionRecorded: true
-    }
-});
-const report = { schema: 'sks.appshots-source-intelligence-check.v1', ok: evidence.ok, evidence };
-const out = path.join(root, '.sneakoscope', 'reports', 'appshots-source-intelligence.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(evidence.appshots?.ok === true, 'Source Intelligence must carry Appshots evidence', report);
-assertGate(evidence.proof.source_intelligence.appshots_ok === true, 'Source Intelligence proof must mark Appshots ok', report);
-assertGate(evidence.appshots?.proof_level === 'fixture_instrumented_real', 'Source Intelligence must not promote fixture Appshots to proven', report);
-emitGate('appshots:source-intelligence', { mode: evidence.mode });
-function writeAppshotFixture(dir) {
-    const file = path.join(dir, 'redacted-appshot-fixture.json');
-    fs.writeFileSync(file, `${JSON.stringify({ fixture: true, redacted: true, text: '[redacted appshot fixture]' })}\n`);
-    const rel = path.relative(root, file).split(path.sep).join('/');
-    return {
-        rel,
-        metadata: {
-            path: rel,
-            source_type: 'codex_appshot',
-            origin: 'fixture',
-            operator_attached: true,
-            frontmost_window: true,
-            redacted: true,
-            local_only: true,
-            fixture: true,
-            thread_id: 'thread-fixture-source-intelligence',
-            attachment_id: 'attachment-fixture-source-intelligence',
-            source_app: 'Codex',
-            source_window: 'Fixture Appshot'
-        }
-    };
-}
-//# sourceMappingURL=appshots-source-intelligence-check.js.map

package/dist/scripts/appshots-thread-attachment-discovery-check.js

@@ -1,87 +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 detector = await importDist('core/codex/appshots-detector.js');
-const evidenceMod = await importDist('core/source-intelligence/appshots-evidence.js');
-const fixture = writeAppshotFixture();
-const threadAttachments = [
-    {
-        thread_id: 'thread-appshot-001',
-        attachment_id: 'att-appshot-001',
-        kind: 'appshot',
-        mime_type: 'image/png',
-        source_app: 'Codex',
-        source_window: 'Release Fixture',
-        local_only: true,
-        codex_appshot: true
-    },
-    {
-        thread_id: 'thread-appshot-001',
-        attachment_id: 'att-text-001',
-        kind: 'text',
-        mime_type: 'text/plain',
-        local_only: true
-    }
-];
-const discovery = detector.discoverAppshotsThreadAttachments(threadAttachments, { visualRequired: true });
-const evidence = evidenceMod.buildAppshotsEvidence({
-    root,
-    prompt: 'visual Appshots thread attachment discovery fixture',
-    sourcePaths: [fixture.rel],
-    sourceMetadata: [fixture.metadata],
-    threadAttachments,
-    operatorActionRecorded: true
-});
-const missing = detector.detectAppshotsCapability({
-    prompt: 'visual Appshots required',
-    visualRequired: true,
-    operatorActionRecorded: false,
-    appshotsToolAvailable: false,
-    threadAttachments: []
-});
-const report = {
-    schema: 'sks.appshots-thread-attachment-discovery-check.v1',
-    ok: discovery.ok === true && evidence.ok === true && missing.operator_action_required === true,
-    discovery,
-    evidence,
-    missing_required_status: missing.status,
-    missing_required_blockers: missing.blockers
-};
-const out = path.join(root, '.sneakoscope', 'reports', 'appshots-thread-attachment-discovery.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(discovery.attachments.some((row) => row.kind === 'appshot' && row.thread_id && row.attachment_id), 'Appshots discovery must retain thread and attachment ids', report);
-assertGate(discovery.attachments.some((row) => row.kind === 'appshot' && row.source_app && row.source_window && row.local_only === true), 'Appshots discovery must retain source app, source window, and local-only provenance', report);
-assertGate(discovery.attachments.some((row) => row.kind === 'text'), 'Appshots discovery must classify text attachments when metadata exists', report);
-assertGate(evidence.thread_attachment_discovery.appshot_attachment_count === 1, 'Appshots evidence must embed thread attachment discovery', report);
-assertGate(evidence.source_verification.every((row) => row.source_type !== 'codex_appshot' || (row.thread_id && row.attachment_id && row.source_app && row.source_window && row.local_only === true)), 'Appshots codex_appshot evidence must preserve thread, attachment, source, and local-only fields', report);
-assertGate(!JSON.stringify(report).includes('CLI-created'), 'Appshots evidence must not claim CLI-created Appshots', report);
-assertGate(missing.operator_action_required === true, 'Missing required Appshot must request operator action', report);
-emitGate('appshots:thread-attachment-discovery', { appshot_attachment_count: discovery.appshot_attachment_count });
-function writeAppshotFixture() {
-    const dir = path.join(root, '.sneakoscope', 'reports', 'appshots-fixtures');
-    fs.mkdirSync(dir, { recursive: true });
-    const file = path.join(dir, 'thread-attachment.redacted-appshot.json');
-    fs.writeFileSync(file, `${JSON.stringify({ fixture: true, redacted: true, text: '[redacted appshot fixture]' })}\n`);
-    const rel = path.relative(root, file).split(path.sep).join('/');
-    return {
-        rel,
-        metadata: {
-            path: rel,
-            source_type: 'codex_appshot',
-            origin: 'fixture',
-            operator_attached: true,
-            frontmost_window: true,
-            redacted: true,
-            local_only: true,
-            fixture: true,
-            thread_id: 'thread-appshot-001',
-            attachment_id: 'att-appshot-001',
-            source_app: 'Codex',
-            source_window: 'Release Fixture'
-        }
-    };
-}
-//# sourceMappingURL=appshots-thread-attachment-discovery-check.js.map