sneakoscope 6.0.3 → 6.1.2

package/dist/scripts/agent-native-release-gate.js

@@ -1,274 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, root, runSksJson } from './sks-1-11-gate-lib.js';
-const gate = process.argv[2] || path.basename(process.argv[1], '.mjs').replace(/-check$/, '');
-const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-const runtimeFiles = [
-    'src/core/commands/team-command.ts',
-    'src/core/team-dag.ts',
-    'src/core/team-live.ts',
-    'src/core/research.ts',
-    'src/core/commands/research-command.ts',
-    'src/core/commands/qa-loop-command.ts',
-    'src/core/pipeline-internals/runtime-core.ts',
-    'src/core/pipeline-internals/runtime-gates.ts',
-    'src/core/proof/auto-finalize.ts',
-    'src/core/proof/route-finalizer.ts',
-    'src/core/proof/route-proof-gate.ts'
-];
-const agentFiles = [
-    'src/core/agents/agent-schema.ts',
-    'src/core/agents/agent-command-surface.ts',
-    'src/core/agents/agent-orchestrator.ts',
-    'src/core/agents/agent-worker-pipeline.ts',
-    'src/core/agents/agent-runner-codex-exec.ts',
-    'src/core/agents/agent-runner-process.ts',
-    'src/core/agents/agent-runner-fake.ts',
-    'src/core/agents/agent-runner-zellij.ts',
-    'src/core/agents/zellij-right-lane-cockpit.ts',
-    'src/core/agents/zellij-lane-supervisor.ts',
-    'src/core/agents/agent-persona.ts',
-    'src/core/agents/agent-roster.ts',
-    'src/core/agents/agent-effort-policy.ts',
-    'src/core/agents/route-collaboration-ledger.ts',
-    'src/core/agents/agent-task-slicer.ts',
-    'src/core/agents/agent-work-partition.ts',
-    'src/core/agents/agent-lease.ts',
-    'src/core/agents/agent-conflict-graph.ts',
-    'src/core/agents/agent-central-ledger.ts',
-    'src/core/agents/agent-ledger-schemas.ts',
-    'src/core/agents/agent-message-bus.ts',
-    'src/core/agents/agent-lifecycle.ts',
-    'src/core/agents/agent-heartbeat.ts',
-    'src/core/agents/agent-consensus.ts',
-    'src/core/agents/agent-proof-evidence.ts',
-    'src/core/agents/agent-recursion-guard.ts',
-    'src/core/agents/agent-output-validator.ts',
-    'src/core/agents/agent-cleanup.ts',
-    'src/core/agents/agent-trust-report.ts',
-    'src/core/agents/agent-wrongness.ts',
-    'src/core/commands/agent-command.ts'
-];
-const workPartitionFiles = [
-    'src/core/agents/work-partition/repo-inventory.ts',
-    'src/core/agents/work-partition/dependency-graph.ts',
-    'src/core/agents/work-partition/semantic-domain-graph.ts',
-    'src/core/agents/work-partition/task-slicer.ts',
-    'src/core/agents/work-partition/lease-planner.ts',
-    'src/core/agents/work-partition/conflict-detector.ts',
-    'src/core/agents/work-partition/no-overlap-proof.ts'
-];
-function text(rel) {
-    return fs.readFileSync(path.join(root, rel), 'utf8');
-}
-function exists(rel) {
-    return fs.existsSync(path.join(root, rel));
-}
-function assertFiles(files) {
-    for (const file of files)
-        assertGate(exists(file), `missing required file: ${file}`);
-}
-function assertLegacyMultiagentRemoved() {
-    const forbidden = [
-        /\brunFiveScoutIntake\b/,
-        /\bsks\s+scouts\s+run\b/,
-        /\bparallel_analysis_scouting\b/,
-        /\banalysis_scout(?:_\d+)?\b/
-    ];
-    for (const file of runtimeFiles) {
-        const body = text(file);
-        const hits = forbidden.filter((re) => re.test(body)).map(String);
-        assertGate(hits.length === 0, `legacy multi-agent runtime reference found in ${file}`, { hits });
-    }
-    for (const rel of ['src/core/scouts', 'src/core/commands/scouts-command.ts', 'src/commands/scouts.ts', 'schemas/codex/scout-result.schema.json']) {
-        assertGate(!exists(rel), `legacy multi-agent surface still present: ${rel}`);
-    }
-    const registry = text('src/cli/command-registry.ts');
-    assertGate(!/\bscouts?\s*:\s*entry\b/.test(registry), 'command registry must not expose legacy multi-agent commands');
-}
-function assertAgentSurface() {
-    assertFiles(agentFiles);
-    const registry = text('src/cli/command-registry.ts');
-    const zellij = text('src/core/agents/agent-runner-zellij.ts');
-    assertGate(/\bagent:\s+entry/.test(registry), 'command registry must expose sks agent');
-    assertGate(/'--agent': 'agent'/.test(registry), 'CLI parser must route --agent to agent command');
-    assertGate(zellij.includes('buildZellijAgentPanePlan') && zellij.includes('persistent_worker_slot') && zellij.includes('agent-zellij-report.json'), 'Zellij agent backend must declare lane plan and report policy');
-}
-function assertNonRecursive() {
-    const pipeline = text('src/core/agents/agent-worker-pipeline.ts');
-    const guard = text('src/core/agents/agent-recursion-guard.ts');
-    const docs = text('docs/agent-non-recursive-pipeline.md');
-    const orchestrator = text('src/core/agents/agent-orchestrator.ts');
-    const hooks = text('src/core/hooks-runtime.ts');
-    assertGate(exists('src/scripts/non-recursive-pipeline-check.ts'), 'missing non-recursive pipeline checker script');
-    assertGate(exists('schemas/codex/non-recursive-pipeline-report.schema.json'), 'missing non-recursive pipeline report schema');
-    for (const token of ['AGENT_WORKER_PIPELINE', 'SKS_AGENT_WORKER', 'SKS_PIPELINE_MODE', 'SKS_DISABLE_ROUTE_RECURSION', 'SKS_AGENT_SESSION_ID', 'SKS_AGENT_ID']) {
-        assertGate(pipeline.includes(token), `agent worker pipeline missing ${token}`);
-    }
-    for (const token of ['sks team', 'sks --agent', 'sks agent run', 'sks research run', 'sks autoresearch run', 'sks goal', '$Team', '$Research', '$AutoResearch', '$QA-LOOP', '$Goal']) {
-        assertGate(guard.includes(token), `agent recursion denylist missing ${token}`);
-    }
-    assertGate(guard.includes('agent-recursion-guard.json'), 'recursion guard report must be written');
-    for (const token of ['NON_RECURSIVE_PIPELINE_REPORT_SCHEMA', 'scanNonRecursivePipelinePolicy', 'wrongness_records', 'trust_report', 'evidence_router', 'next_action', 'local_only', 'secret_redaction_ok', 'performance_budget_ms']) {
-        assertGate(guard.includes(token), `non-recursive policy module missing ${token}`);
-    }
-    for (const token of ['env guard', 'command denylist', 'route denylist', 'worker mission creation block', 'current.json write block', 'stdout transcript scan', 'stderr transcript scan', 'agent result scan', 'wrongness record']) {
-        assertGate(guard.includes(token), `non-recursive policy contract missing ${token}`);
-    }
-    assertGate(docs.includes('Non-Recursive Pipeline Policy Report'), 'non-recursive policy docs section missing');
-    assertGate(orchestrator.includes('writeAgentRecursionGuardReport'), 'orchestrator must detect recursion attempts');
-    assertGate(hooks.includes('agentWorkerHookRecursionDecision') && hooks.includes('scanAgentTextForRecursion'), 'Codex PreToolUse hook must integrate agent recursion guard');
-}
-function assertCentralLedger() {
-    const ledger = text('src/core/agents/agent-central-ledger.ts');
-    const schemas = text('src/core/agents/agent-ledger-schemas.ts');
-    for (const token of ['agent-events.jsonl', 'agent-sessions.json', 'agent-roster.json', 'agent-task-board.json', 'agent-task-board.md', 'agent-messages.jsonl', 'agent-handoffs.jsonl', 'agent-leases.json', 'agent-conflict-graph.json', 'agent-consensus.json', 'agent-proof-evidence.json', 'current_hash', 'previous_hash']) {
-        assertGate(ledger.includes(token), `central ledger missing ${token}`);
-    }
-    for (const token of ['sks.agent-event.v1', 'sks.agent-message.v1', 'sks.agent-task-board.v1', 'sks.agent-session-record.v1', 'sks.agent-lease-ledger.v1', 'sks.agent-conflict-graph.v1', 'sks.agent-consensus.v1', 'sks.agent-proof-evidence.v1', 'sks.agent-cleanup.v1', 'sks.agent-non-recursive-pipeline.v1', 'additionalProperties: false', 'validateJsonSchemaRecursive']) {
-        assertGate(schemas.includes(token), `central ledger schema registry missing ${token}`);
-    }
-    for (const token of ['validateAgentLedgerWriteScope', 'agent_cannot_modify_other_session_record', 'agent_cannot_modify_orchestrator_only_file']) {
-        assertGate(ledger.includes(token), `central ledger write-scope policy missing ${token}`);
-    }
-    const lifecycle = text('src/core/agents/agent-lifecycle.ts');
-    for (const token of ['agent-lifecycle-policy.json', 'agent-lifecycle-aggregate.json', 'agent-timeout-kill-report.json', 'killTimedOutAgentSessions', 'agentHardTimeoutMs', 'SKS_AGENT_HARD_TIMEOUT_MS', 'sks.agent-session-record.v1']) {
-        assertGate(lifecycle.includes(token), `agent lifecycle missing ${token}`);
-    }
-}
-function assertWorkPartition() {
-    assertFiles(workPartitionFiles);
-    const partition = text('src/core/agents/agent-work-partition.ts');
-    for (const token of ['inventory', 'dependency', 'semantic', 'lease', 'conflict', 'no_overlap_proof']) {
-        assertGate(partition.includes(token), `work partition missing ${token}`);
-    }
-}
-function assertOutputSchema() {
-    const schema = JSON.parse(text('schemas/codex/agent-result.schema.json'));
-    assertGate(schema.additionalProperties === false, 'agent result schema must close additionalProperties');
-    for (const key of ['mission_id', 'agent_id', 'session_id', 'persona_id', 'task_slice_id', 'status', 'summary', 'findings', 'proposed_changes', 'changed_files', 'lease_compliance', 'recursion_guard', 'verification', 'blockers', 'confidence', 'handoff_notes']) {
-        assertGate(schema.required.includes(key), `agent result schema missing required ${key}`);
-    }
-    const validator = text('src/core/agents/agent-output-validator.ts');
-    const worker = text('src/core/agents/agent-worker-pipeline.ts');
-    assertGate(validator.includes('validateJsonSchemaRecursive'), 'agent output schema must use recursive validator');
-    assertGate(worker.includes('schema_invalid:'), 'agent output invalid result must block proof');
-}
-function assertProofAndTrustArtifacts() {
-    const proof = text('src/core/agents/agent-proof-evidence.ts');
-    const orchestrator = text('src/core/agents/agent-orchestrator.ts');
-    const writers = {
-        'agent-cleanup.json': 'writeAgentCleanupReport',
-        'agent-trust-report.json': 'writeAgentTrustReport',
-        'agent-wrongness-records.json': 'writeAgentWrongnessRecords',
-        'agent-output-tails.json': 'writeAgentOutputTailReport',
-        'agent-timeout-kill-report.json': 'killTimedOutAgentSessions'
-    };
-    for (const [token, writer] of Object.entries(writers)) {
-        assertGate(proof.includes(token), `agent proof missing ${token}`);
-        assertGate(orchestrator.includes(writer), `agent orchestrator does not write ${token}`);
-    }
-}
-function assertPersonaAndCaps() {
-    const persona = text('src/core/agents/agent-persona.ts');
-    const roster = text('src/core/agents/agent-roster.ts');
-    const schema = text('src/core/agents/agent-schema.ts');
-    for (const role of ['architect', 'implementer', 'verifier', 'safety', 'integrator']) {
-        assertGate(persona.includes(role), `default persona missing ${role}`);
-    }
-    assertGate(schema.includes('DEFAULT_AGENT_COUNT = 5'), 'default agent count must be 5');
-    assertGate(schema.includes('MAX_AGENT_COUNT = 20'), 'max agent count must be 20');
-    assertGate(roster.includes('validatePersonaUniqueness'), 'persona uniqueness must be validated');
-    assertGate(roster.includes('buildAgentEffortPolicy') && text('src/core/agents/agent-effort-policy.ts').includes('escalation_triggers'), 'agent effort policy must be dynamic and recorded');
-    assertGate(roster.includes('exceeds max'), 'agent max cap must block overflow');
-}
-function assertReleaseScripts() {
-    const required = [
-        'agent:non-recursive-pipeline',
-        'agent:non-recursive-pipeline-report',
-        'agent:legacy-multiagent-removed',
-        'agent:central-ledger',
-        'agent:work-partition',
-        'agent:no-overlap-proof',
-        'agent:persona-uniqueness',
-        'agent:max-cap',
-        'agent:fake-backend-blackbox',
-        'agent:lifecycle-close',
-        'agent:output-schema',
-        'agent:lease-conflicts',
-        'agent:proof-graph',
-        'team:native-agent-backend',
-        'research:native-agent-backend',
-        'qa:native-agent-backend'
-    ];
-    for (const name of required) {
-        assertGate(Boolean(pkg.scripts?.[name]), `package script missing ${name}`);
-    }
-    const releaseCheck = String(pkg.scripts?.['release:check'] || '');
-    const affectedReleaseCheck = String(pkg.scripts?.['release:check:affected'] || '');
-    const delegatesToParallel = releaseCheck.includes('release:check:parallel');
-    const delegatesToAffectedDag = releaseCheck.includes('release:check:affected')
-        && affectedReleaseCheck.includes('release-gate-dag-runner')
-        && /--preset\s+affected/.test(affectedReleaseCheck);
-    const delegatesDirectlyToDag = releaseCheck.includes('release-gate-dag-runner')
-        && /--preset\s+(?:release|affected)/.test(releaseCheck);
-    assertGate(delegatesToParallel || delegatesToAffectedDag || delegatesDirectlyToDag, 'release:check must delegate to the parallel P0 DAG or v2 affected/release DAG', { release_check: releaseCheck, release_check_affected: affectedReleaseCheck });
-}
-function assertRouteNativeBlackbox(routeName) {
-    const routeFixtureArgs = ['--agents', '5', '--work-items', '8', '--target-active-slots', '5', '--minimum-work-items', '5', '--max-queue-expansion', '10', '--mock', '--json'];
-    if (routeName === 'team') {
-        const result = runSksJson(['team', 'native backend fixture', ...routeFixtureArgs, '--no-open-zellij']);
-        assertGate(result.mock === true, 'Team mock blackbox did not execute', result);
-        assertGate(result.native_agent_run?.proof?.ok === true, 'Team blackbox missing native agent proof', result.native_agent_run?.proof);
-        assertGate(!JSON.stringify(result).includes('analysis_scout'), 'Team runtime artifact leaked legacy analysis_scout');
-    }
-    if (routeName === 'research') {
-        const prepared = runSksJson(['research', 'prepare', 'native backend fixture', '--json']);
-        const result = runSksJson(['research', 'run', prepared.mission_id, ...routeFixtureArgs, '--native-proof-only']);
-        assertGate(result.ok === true, 'Research mock blackbox did not pass', result);
-        assertGate(result.gate?.gate?.native_agent_proof === true || result.gate?.native_agent_proof === true || result.proof?.ok === true, 'Research proof missing native agent evidence artifact', result);
-        assertGate(!JSON.stringify(result).includes('scout-ledger'), 'Research runtime artifact leaked scout-ledger as SSOT');
-    }
-    if (routeName === 'qa') {
-        const prepared = runSksJson(['qa-loop', 'prepare', 'native backend API fixture', '--json']);
-        const result = runSksJson(['qa-loop', 'run', prepared.mission_id, ...routeFixtureArgs, '--native-proof-only']);
-        assertGate(result.ok === true, 'QA mock blackbox did not pass', result);
-        assertGate(result.gate?.gate?.native_agent_proof === true || result.gate?.native_agent_proof === true || result.proof?.ok === true, 'QA proof missing native agent evidence artifact', result);
-    }
-}
-function assertBlackboxAgent() {
-    const result = runSksJson(['agent', 'run', 'fixture', '--mock', '--json']);
-    assertGate(result.ok === true, 'fake agent blackbox run failed', result);
-    assertGate(result.proof?.fake_backend_disclaimer, 'fake backend disclaimer missing', result.proof);
-    assertGate(result.proof?.all_sessions_closed === true, 'agent lifecycle close proof missing', result.proof);
-    assertGate(result.proof?.no_overlap_ok === true, 'agent no-overlap proof missing', result.proof);
-    assertGate(result.proof?.ledger_hash_chain_ok === true, 'agent ledger hash proof missing', result.proof);
-}
-assertAgentSurface();
-assertReleaseScripts();
-if (gate.includes('legacy-multiagent') || gate === 'team-native-agent-backend' || gate === 'research-native-agent-backend' || gate === 'qa-native-agent-backend')
-    assertLegacyMultiagentRemoved();
-if (gate === 'team-native-agent-backend')
-    assertRouteNativeBlackbox('team');
-if (gate === 'research-native-agent-backend')
-    assertRouteNativeBlackbox('research');
-if (gate === 'qa-native-agent-backend')
-    assertRouteNativeBlackbox('qa');
-if (gate.includes('non-recursive'))
-    assertNonRecursive();
-if (gate.includes('central-ledger'))
-    assertCentralLedger();
-if (gate.includes('work-partition') || gate.includes('no-overlap') || gate.includes('lease-conflicts'))
-    assertWorkPartition();
-if (gate.includes('persona') || gate.includes('max-cap'))
-    assertPersonaAndCaps();
-if (gate.includes('output-schema'))
-    assertOutputSchema();
-if (gate.includes('proof-graph') || gate.includes('lifecycle-close') || gate.includes('lease-conflicts'))
-    assertProofAndTrustArtifacts();
-if (gate.includes('fake-backend') || gate.includes('lifecycle-close') || gate.includes('proof-graph') || gate.includes('no-overlap') || gate.includes('lease-conflicts'))
-    assertBlackboxAgent();
-emitGate(gate, { version: pkg.version, native_agent_kernel: true });
-//# sourceMappingURL=agent-native-release-gate.js.map

package/dist/scripts/codex-0142-capability-check.js

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-import { CODEX_0142_FEATURE_KEYS, detectCodex0142Capability, writeCodex0142CapabilityArtifacts } from '../core/codex-control/codex-0142-capability.js';
-const requireReal = process.argv.includes('--require-real') || process.env.SKS_REQUIRE_CODEX_0142 === '1';
-if (!requireReal)
-    process.env.SKS_CODEX_0142_FAKE = '1';
-const cap = await detectCodex0142Capability({ requireReal });
-assertGate(cap.ok === true, 'Codex 0.142 capability probe must pass', cap);
-assertGate(Object.keys(cap.feature_states).length === CODEX_0142_FEATURE_KEYS.length, 'Codex 0.142 feature count mismatch', cap);
-assertGate(Object.values(cap.feature_states).every((state) => String(state.certainty) !== 'assumed_by_version'), 'Codex 0.142 capability must not use assumed_by_version evidence', cap);
-if (requireReal) {
-    assertGate(cap.probe_mode === 'real-schema', 'Codex 0.142 require-real must use generated schema evidence', cap);
-    assertGate(cap.release_authorizing === true, 'Codex 0.142 require-real must be release-authorizing', cap);
-    await writeCodex0142CapabilityArtifacts(process.cwd(), { requireReal: true });
-}
-emitGate('codex:0142-capability', {
-    features: CODEX_0142_FEATURE_KEYS.length,
-    probe_mode: cap.probe_mode,
-    release_authorizing: cap.release_authorizing
-});
-//# sourceMappingURL=codex-0142-capability-check.js.map

package/dist/scripts/codex-control-tool-call-sequence-repair-check.js

@@ -1,14 +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-control/codex-reliability-shield.js');
-const repaired = mod.repairToolCallSequence([
-    { type: 'thread.started' },
-    { type: 'item.completed', item: { id: 'call-1', type: 'mcp_tool_call', tool: 'fixture' } },
-    { type: 'item.completed', item: { id: 'call-2', type: 'mcp_tool_call', tool: 'fixture' } },
-    { type: 'tool_result.completed', item: { tool_call_id: 'call-1', type: 'tool_result', text: 'ok' } }
-]);
-assertGate(repaired.repairedToolResultCount === 1, 'one missing parallel tool result must be repaired', repaired);
-assertGate(repaired.events.some((event) => event.type === 'tool_result.stubbed' && event.item?.tool_call_id === 'call-2'), 'missing tool result stub not found', repaired);
-emitGate('codex-control:tool-call-sequence-repair', { repaired_tool_result_count: repaired.repairedToolResultCount });
-//# sourceMappingURL=codex-control-tool-call-sequence-repair-check.js.map

package/dist/scripts/command-performance-scorecard-check.js

@@ -1,204 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { performance } from 'node:perf_hooks';
-import { fileURLToPath } from 'node:url';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-import { runProcess } from '../core/fsx.js';
-export const CRITICAL_COMMANDS = new Set([
-    'doctor',
-    'setup',
-    'bootstrap',
-    'update',
-    'run',
-    'naruto',
-    'super-search',
-    'seo-geo-optimizer',
-    'db',
-    'mad-sks',
-    'qa-loop',
-    'review',
-    'release',
-    'rollback',
-    'commit-and-push'
-]);
-export const COMMAND_SMOKE_MAX_AGE_MS = 60 * 60 * 1000;
-export const smokeCommands = [
-    { name: 'version', argv: ['--version'], budget_p95_ms: 120 },
-    { name: 'commands', argv: ['commands', '--json'], budget_p95_ms: 200 },
-    { name: 'root', argv: ['root', '--json'], budget_p95_ms: 150 },
-    { name: 'dollar-commands', argv: ['dollar-commands', '--json'], budget_p95_ms: 220 },
-    { name: 'super-search', argv: ['super-search', 'doctor', '--json'], budget_p95_ms: 180 },
-    { name: 'doctor', argv: ['doctor', '--json'], budget_p95_ms: 1200 },
-    { name: 'setup', budget_p95_ms: 0, kind: 'fixture', evidence: 'setup_dry_run_contract' },
-    { name: 'bootstrap', budget_p95_ms: 0, kind: 'fixture', evidence: 'bootstrap_fixture_contract' },
-    { name: 'update', budget_p95_ms: 0, kind: 'fixture', evidence: 'update_now_dry_run_contract' },
-    { name: 'run', budget_p95_ms: 0, kind: 'fixture', evidence: 'run_route_classification_fixture' },
-    { name: 'naruto', budget_p95_ms: 0, kind: 'fixture', evidence: 'naruto_route_fixture' },
-    { name: 'seo-geo-optimizer', budget_p95_ms: 0, kind: 'fixture', evidence: 'seo_geo_optimizer_fixture' },
-    { name: 'db', budget_p95_ms: 0, kind: 'blocked_negative', evidence: 'db_destructive_sql_block_contract' },
-    { name: 'mad-sks', budget_p95_ms: 0, kind: 'blocked_negative', evidence: 'mad_sks_restore_and_readback_contract' },
-    { name: 'qa-loop', budget_p95_ms: 0, kind: 'fixture', evidence: 'qa_loop_route_fixture' },
-    { name: 'review', budget_p95_ms: 0, kind: 'fixture', evidence: 'review_diff_fixture' },
-    { name: 'release', budget_p95_ms: 0, kind: 'fixture', evidence: 'release_gate_fixture' },
-    { name: 'rollback', budget_p95_ms: 0, kind: 'blocked_negative', evidence: 'rollback_apply_requires_id_contract' },
-    { name: 'commit-and-push', budget_p95_ms: 0, kind: 'blocked_negative', evidence: 'commit_and_push_remote_contract' }
-];
-if (isMainModule())
-    await main();
-export async function main() {
-    const { COMMAND_MANIFEST_LITE } = await importDist('cli/command-manifest-lite.js');
-    const timings = [];
-    for (const smoke of smokeCommands)
-        timings.push(await measure(smoke));
-    const timingByName = new Map(timings.map((row) => [row.name, row]));
-    const entries = COMMAND_MANIFEST_LITE.filter((entry) => entry.hidden !== true);
-    const rows = entries.map((entry) => scoreEntry(entry, timingByName.get(entry.name)));
-    const average = rows.reduce((sum, row) => sum + row.score, 0) / Math.max(1, rows.length);
-    const blockers = [
-        ...rows.filter((row) => row.critical && row.score === 0).map((row) => `${row.name}:critical_smoke_missing_or_failed`),
-        ...(average >= 94 ? [] : [`average_below_94:${average.toFixed(2)}`])
-    ];
-    const report = {
-        schema: 'sks.command-performance-scorecard.v1',
-        ok: blockers.length === 0,
-        generated_at: new Date().toISOString(),
-        average_score: Number(average.toFixed(2)),
-        command_count: rows.length,
-        timings,
-        rows,
-        blockers
-    };
-    const out = path.join(root, '.sneakoscope', 'reports', 'command-performance-scorecard.json');
-    fs.mkdirSync(path.dirname(out), { recursive: true });
-    fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-    assertGate(report.ok, 'command performance scorecard failed', report);
-    emitGate('command:performance-scorecard', { average_score: report.average_score, command_count: rows.length, report: '.sneakoscope/reports/command-performance-scorecard.json' });
-}
-export function scoreEntry(entry, timing, options = {}) {
-    const now = options.now ? new Date(options.now) : new Date();
-    const critical = CRITICAL_COMMANDS.has(entry.name);
-    const smokeStatus = classifySmoke(timing, now);
-    if (critical && smokeStatus !== 'pass') {
-        return { name: entry.name, maturity: entry.maturity, critical, score: 0, p95_ms: timing?.p95_ms ?? null, smoke: Boolean(timing), smoke_status: smokeStatus, evidence_tier: criticalCommandEvidenceTier(timing), summary: entry.summary };
-    }
-    const hasRunnableSurface = Boolean(timing || entry.summary || entry.readonly || entry.diagnostic || entry.skipMigrationGate || entry.mutatesRouteState);
-    const p95Ok = timing ? (timing.kind === 'blocked_negative' ? timing.blocked === true : timing.ok === true) : true;
-    const jsonContract = timing ? (timing.kind === 'blocked_negative' ? true : timing.json_contract !== false) : true;
-    const failureSummary = Boolean(entry.summary);
-    const installedReady = Array.isArray(entry.packageRequiredFiles)
-        ? entry.packageRequiredFiles.every((file) => fs.existsSync(path.join(root, file)))
-        : true;
-    const lifecyclePenalty = (entry.hidden === true || entry.deprecated === true) && !entry.deprecationReason && !entry.hiddenReason ? 25 : 0;
-    const score = (hasRunnableSurface ? 25 : 0) +
-        (p95Ok ? 25 : 0) +
-        (jsonContract ? 15 : 0) +
-        (failureSummary ? 15 : 0) +
-        (installedReady ? 20 : 0) -
-        lifecyclePenalty;
-    const cappedScore = critical ? Math.min(score, criticalCommandEvidenceMaxScore(timing)) : score;
-    return { name: entry.name, maturity: entry.maturity, critical, score: Math.max(0, cappedScore), p95_ms: timing?.p95_ms ?? null, smoke: Boolean(timing), smoke_status: smokeStatus, evidence_tier: criticalCommandEvidenceTier(timing), summary: entry.summary };
-}
-export function criticalCommandEvidenceTier(timing) {
-    if (!timing)
-        return 'metadata';
-    if (timing.kind === 'fixture')
-        return 'fixture';
-    if (timing.kind === 'blocked_negative')
-        return 'blocked_negative';
-    if (timing.kind === 'dry_run')
-        return 'dry_run';
-    return 'read_only';
-}
-export function criticalCommandEvidenceMaxScore(timing) {
-    const tier = criticalCommandEvidenceTier(timing);
-    if (tier === 'metadata')
-        return 0;
-    if (tier === 'fixture')
-        return 70;
-    if (tier === 'blocked_negative')
-        return 90;
-    return 100;
-}
-export function classifySmoke(timing, now = new Date()) {
-    if (!timing)
-        return 'missing';
-    if (isSmokeStale(timing, now))
-        return 'stale';
-    if (timing.kind === 'blocked_negative')
-        return timing.blocked === true && timing.ok !== true ? 'pass' : 'failed';
-    return timing.ok === true ? 'pass' : 'failed';
-}
-export function isSmokeStale(timing, now = new Date()) {
-    if (!timing.generated_at)
-        return false;
-    const generated = new Date(timing.generated_at).getTime();
-    return !Number.isFinite(generated) || now.getTime() - generated > COMMAND_SMOKE_MAX_AGE_MS;
-}
-export async function measure(smoke) {
-    if (smoke.kind === 'fixture') {
-        return {
-            name: smoke.name,
-            kind: 'fixture',
-            evidence: smoke.evidence,
-            generated_at: new Date().toISOString(),
-            p95_ms: 0,
-            budget_p95_ms: smoke.budget_p95_ms,
-            ok: true,
-            blocked: false,
-            exit_codes: [],
-            json_contract: true
-        };
-    }
-    if (smoke.kind === 'blocked_negative' && !smoke.argv) {
-        return {
-            name: smoke.name,
-            kind: 'blocked_negative',
-            evidence: smoke.evidence,
-            generated_at: new Date().toISOString(),
-            p95_ms: 0,
-            budget_p95_ms: smoke.budget_p95_ms,
-            ok: false,
-            blocked: true,
-            exit_codes: [],
-            json_contract: false
-        };
-    }
-    const durations = [];
-    const exitCodes = [];
-    let jsonContract = false;
-    let blocked = false;
-    for (let i = 0; i < 3; i++) {
-        const started = performance.now();
-        const result = await runProcess(process.execPath, [path.join(root, 'dist', 'bin', 'sks.js'), ...smoke.argv], {
-            cwd: root,
-            timeoutMs: 15_000,
-            maxOutputBytes: 128 * 1024,
-            env: { SKS_DISABLE_NETWORK: '1', SKS_DISABLE_UPDATE_CHECK: '1', SKS_PERF_MEASURE: '1' }
-        });
-        durations.push(Math.round(performance.now() - started));
-        exitCodes.push(result.code);
-        jsonContract ||= smoke.argv.includes('--json') ? parsesJson(result.stdout) : String(result.stdout || '').trim().length > 0;
-        blocked ||= result.code !== 0 && /block|required|missing|denied|explicit/i.test(`${result.stdout || ''}\n${result.stderr || ''}`);
-    }
-    durations.sort((a, b) => a - b);
-    const p95 = durations[Math.min(durations.length - 1, Math.ceil(durations.length * 0.95) - 1)] || 0;
-    const ok = smoke.kind === 'blocked_negative'
-        ? false
-        : p95 <= smoke.budget_p95_ms && exitCodes.every((code) => code === 0);
-    return { name: smoke.name, kind: smoke.kind || 'read_only', generated_at: new Date().toISOString(), p95_ms: p95, budget_p95_ms: smoke.budget_p95_ms, ok, blocked, exit_codes: exitCodes, json_contract: jsonContract };
-}
-function parsesJson(value) {
-    try {
-        JSON.parse(String(value || ''));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function isMainModule() {
-    return process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
-}
-//# sourceMappingURL=command-performance-scorecard-check.js.map