sneakoscope 10.3.8 → 10.3.9

package/dist/core/agents/agent-recursion-guard.js

@@ -1,8 +1,6 @@
 import path from 'node:path';
 import { writeJsonAtomic } from '../fsx.js';
 export const AGENT_RECURSION_GUARD_REPORT_SCHEMA = 'sks.agent-recursion-guard.v1';
-export const NON_RECURSIVE_PIPELINE_REPORT_SCHEMA = 'sks.non-recursive-pipeline-report.v1';
-export const NON_RECURSIVE_PIPELINE_PERFORMANCE_BUDGET_MS = 1500;
 export const AGENT_RECURSIVE_COMMAND_DENYLIST = Object.freeze([
     'sks naruto run',
     'sks research run',
@@ -18,53 +16,9 @@ export const AGENT_RECURSIVE_COMMAND_DENYLIST = Object.freeze([
     'node dist/bin/sks.js naruto',
     'node dist/bin/sks.js research run'
 ]);
-export const AGENT_WORKER_ENV_GUARD_TOKENS = Object.freeze([
-    'AGENT_WORKER_PIPELINE',
-    'SKS_AGENT_WORKER',
-    'SKS_PIPELINE_MODE',
-    'SKS_DISABLE_ROUTE_RECURSION',
-    'SKS_AGENT_SESSION_ID',
-    'SKS_AGENT_ID',
-    'SKS_AGENT_ALLOWED_COMMANDS_FILE'
-]);
-const COMMAND_DENYLIST = AGENT_RECURSIVE_COMMAND_DENYLIST.filter((entry) => !entry.startsWith('$'));
-const ROUTE_DENYLIST = AGENT_RECURSIVE_COMMAND_DENYLIST.filter((entry) => entry.startsWith('$'));
 const DENY_PATTERNS = AGENT_RECURSIVE_COMMAND_DENYLIST.map((entry) => entry.startsWith('$')
     ? new RegExp('(^|\\s)\\' + entry + '(\\s|$)', 'i')
     : new RegExp('(^|\\s)' + escapeRe(entry).replace(/\\ /g, '\\s+') + '(\\s|$)', 'i'));
-const SECRET_PATTERNS = [
-    { id: 'openai_api_key', pattern: /\bsk-[A-Za-z0-9_-]{12,}\b/g },
-    { id: 'github_token', pattern: /\bgh[pousr]_[A-Za-z0-9_]{12,}\b/g },
-    { id: 'slack_token', pattern: /\bxox[baprs]-[A-Za-z0-9-]{12,}\b/g },
-    { id: 'jwt_like_token', pattern: /\beyJ[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{8,}\b/g }
-];
-const WORKER_MISSION_CREATION_PATTERNS = [
-    { id: 'createMission', pattern: /\bcreateMission\s*\(/g },
-    { id: 'missionDir', pattern: /\bmissionDir\s*\(/g }
-];
-const CURRENT_JSON_WRITE_PATTERNS = [
-    { id: 'setCurrent', pattern: /\bsetCurrent\s*\(/g },
-    { id: 'stateFile', pattern: /\bstateFile\s*\(/g },
-    { id: 'current_json_path', pattern: /\.sneakoscope\/state\/current\.json/g }
-];
-export const NON_RECURSIVE_PIPELINE_SCAN_CONTRACT = Object.freeze({
-    schema: NON_RECURSIVE_PIPELINE_REPORT_SCHEMA,
-    local_only: true,
-    scan_groups: [
-        'env guard',
-        'command denylist',
-        'route denylist',
-        'worker mission creation block',
-        'current.json write block',
-        'top-level command block',
-        'stdout transcript scan',
-        'stderr transcript scan',
-        'agent result scan',
-        'wrongness record'
-    ],
-    artifacts: ['non-recursive-pipeline-report.json', 'non-recursive-pipeline-report.md'],
-    performance_budget_ms: NON_RECURSIVE_PIPELINE_PERFORMANCE_BUDGET_MS
-});
 export function scanAgentTextForRecursion(text) {
     const body = String(text || '');
     const violations = AGENT_RECURSIVE_COMMAND_DENYLIST.filter((entry, index) => DENY_PATTERNS[index]?.test(body));
@@ -114,188 +68,6 @@ export function nextAgentGenerationEnv(env = process.env) {
 export function agentGenerationDepthExceeded(env = process.env) {
     return agentGenerationDepth(env) > MAX_AGENT_GENERATION_DEPTH;
 }
-export function assertNoAgentRecursion(text) {
-    const result = scanAgentTextForRecursion(text);
-    if (!result.ok)
-        throw new Error('Agent recursion blocked: ' + result.violations.join(', '));
-    return result;
-}
-export function scanNonRecursivePipelinePolicy(records, opts = {}) {
-    const started = Date.now();
-    const performanceBudgetMs = opts.performanceBudgetMs || NON_RECURSIVE_PIPELINE_PERFORMANCE_BUDGET_MS;
-    const violations = [];
-    const scannedRecords = [];
-    const redactionSamples = [];
-    const envCorpus = [];
-    const guardCorpus = [];
-    const workerCorpus = [];
-    const channelCoverage = {
-        stdout: false,
-        stderr: false,
-        agent_result: false
-    };
-    for (const record of records) {
-        const rel = normalizePath(record.path);
-        const text = String(record.text || '');
-        const channel = record.channel || classifyNonRecursivePipelinePath(rel);
-        scannedRecords.push({ path: rel, channel, bytes: Buffer.byteLength(text, 'utf8') });
-        redactionSamples.push(...collectSecretRedactionSamples(text));
-        if (channel === 'env' || rel.includes('agent-worker-pipeline'))
-            envCorpus.push(text);
-        if (rel.includes('agent-recursion-guard'))
-            guardCorpus.push(text);
-        if (isWorkerExecutionSurface(rel, channel)) {
-            workerCorpus.push(text);
-            scanWorkerExecutionSurface({ rel, text, channel, violations });
-        }
-        if (channel === 'stdout')
-            channelCoverage.stdout = true;
-        if (channel === 'stderr')
-            channelCoverage.stderr = true;
-        if (channel === 'agent_result')
-            channelCoverage.agent_result = true;
-    }
-    const envText = envCorpus.join('\n');
-    for (const token of AGENT_WORKER_ENV_GUARD_TOKENS) {
-        if (!envText.includes(token)) {
-            violations.push(nonRecursivePipelineViolation({
-                file: 'src/core/agents/agent-worker-pipeline.ts',
-                channel: 'env',
-                group: 'env guard',
-                rule_id: `missing_env_guard:${token}`,
-                snippet: token,
-                index: null
-            }));
-        }
-    }
-    const guardText = guardCorpus.join('\n');
-    for (const token of COMMAND_DENYLIST) {
-        if (!guardText.includes(token)) {
-            violations.push(nonRecursivePipelineViolation({
-                file: 'src/core/agents/agent-recursion-guard.ts',
-                channel: 'source',
-                group: 'command denylist',
-                rule_id: `missing_command_denylist:${token}`,
-                snippet: token,
-                index: null
-            }));
-        }
-    }
-    for (const token of ROUTE_DENYLIST) {
-        if (!guardText.includes(token)) {
-            violations.push(nonRecursivePipelineViolation({
-                file: 'src/core/agents/agent-recursion-guard.ts',
-                channel: 'source',
-                group: 'route denylist',
-                rule_id: `missing_route_denylist:${token}`,
-                snippet: token,
-                index: null
-            }));
-        }
-    }
-    const elapsedMs = Date.now() - started;
-    const ok = violations.length === 0;
-    const secretRedactionOk = violations.every((row) => !containsSecret(row.snippet));
-    const groupsWithViolations = new Set(violations.map((row) => row.group));
-    return {
-        schema: NON_RECURSIVE_PIPELINE_REPORT_SCHEMA,
-        ok,
-        generated_at: new Date().toISOString(),
-        local_only: true,
-        secret_redaction_ok: secretRedactionOk,
-        performance_budget_ms: performanceBudgetMs,
-        elapsed_ms: elapsedMs,
-        performance_ok: elapsedMs <= performanceBudgetMs,
-        scan_contract: NON_RECURSIVE_PIPELINE_SCAN_CONTRACT,
-        env_policy: {
-            schema: 'sks.agent-worker-env-policy.v1',
-            required_tokens: [...AGENT_WORKER_ENV_GUARD_TOKENS],
-            present: AGENT_WORKER_ENV_GUARD_TOKENS.filter((token) => envText.includes(token)),
-            missing: AGENT_WORKER_ENV_GUARD_TOKENS.filter((token) => !envText.includes(token))
-        },
-        denylist: {
-            schema: 'sks.agent-worker-recursion-denylist.v1',
-            commands: [...COMMAND_DENYLIST],
-            routes: [...ROUTE_DENYLIST]
-        },
-        scanned_records: scannedRecords,
-        channel_coverage: channelCoverage,
-        worker_surface_records: workerCorpus.length,
-        violations,
-        redaction_samples: [...new Set(redactionSamples)].slice(0, 20),
-        wrongness_records: violations.map((row) => ({
-            schema: 'sks.non-recursive-pipeline-wrongness.v1',
-            kind: 'agent_recursive_pipeline_attempt',
-            file: row.file,
-            channel: row.channel,
-            group: row.group,
-            rule_id: row.rule_id,
-            next_action: row.next_action
-        })),
-        proof: {
-            schema: 'sks.non-recursive-pipeline-proof.v1',
-            ok,
-            env_guard_configured: !groupsWithViolations.has('env guard'),
-            command_denylist_enforced: !groupsWithViolations.has('command denylist'),
-            route_denylist_enforced: !groupsWithViolations.has('route denylist'),
-            worker_mission_creation_blocked: !groupsWithViolations.has('worker mission creation block'),
-            current_json_write_blocked: !groupsWithViolations.has('current.json write block'),
-            top_level_command_blocked: !groupsWithViolations.has('top-level command block'),
-            stdout_transcript_scan: channelCoverage.stdout && !groupsWithViolations.has('stdout transcript scan'),
-            stderr_transcript_scan: channelCoverage.stderr && !groupsWithViolations.has('stderr transcript scan'),
-            agent_result_scan: channelCoverage.agent_result && !groupsWithViolations.has('agent result scan'),
-            wrongness_records_written: violations.length === 0 || violations.length === violations.map((row) => row.rule_id).length
-        },
-        trust_report: {
-            schema: 'sks.non-recursive-pipeline-trust.v1',
-            ok,
-            trust: ok ? 'high' : 'blocked',
-            evidence_count: scannedRecords.length,
-            local_only: true
-        },
-        evidence_router: {
-            schema: 'sks.non-recursive-pipeline-evidence-router.v1',
-            records: scannedRecords.map((row) => ({ file: row.path, channel: row.channel, source: 'local_scan', redacted: true })),
-            blocked_records: violations.length
-        },
-        next_action: ok
-            ? 'keep agent workers non-recursive and continue writing proof through the parent orchestrator'
-            : 'remove nested route launches or state writes from worker surfaces before accepting agent proof'
-    };
-}
-export function nonRecursivePipelineMarkdown(report) {
-    const proof = report.proof || {};
-    const lines = [
-        '# Non-Recursive Agent Pipeline Report',
-        '',
-        `Status: ${report.ok ? 'passed' : 'blocked'}`,
-        `Generated: ${report.generated_at}`,
-        `Local only: ${report.local_only ? 'yes' : 'no'}`,
-        `Records scanned: ${report.scanned_records?.length || 0}`,
-        `Performance: ${report.elapsed_ms}ms / ${report.performance_budget_ms}ms`,
-        '',
-        '## Proof',
-        '',
-        `- env_guard_configured: ${Boolean(proof.env_guard_configured)}`,
-        `- command_denylist_enforced: ${Boolean(proof.command_denylist_enforced)}`,
-        `- route_denylist_enforced: ${Boolean(proof.route_denylist_enforced)}`,
-        `- worker_mission_creation_blocked: ${Boolean(proof.worker_mission_creation_blocked)}`,
-        `- current_json_write_blocked: ${Boolean(proof.current_json_write_blocked)}`,
-        `- top_level_command_blocked: ${Boolean(proof.top_level_command_blocked)}`,
-        `- stdout_transcript_scan: ${Boolean(proof.stdout_transcript_scan)}`,
-        `- stderr_transcript_scan: ${Boolean(proof.stderr_transcript_scan)}`,
-        `- agent_result_scan: ${Boolean(proof.agent_result_scan)}`,
-        `- wrongness_records_written: ${Boolean(proof.wrongness_records_written)}`,
-        '',
-        '## Violations',
-        ''
-    ];
-    if (!report.violations?.length)
-        lines.push('- none');
-    for (const violation of report.violations || [])
-        lines.push(`- ${violation.file}: ${violation.group}/${violation.rule_id} -> ${violation.next_action}`);
-    return `${lines.join('\n')}\n`;
-}
 export async function writeAgentRecursionGuardReport(dir, input) {
     const result = scanAgentTextForRecursion(input);
     const report = {
@@ -307,147 +79,6 @@ export async function writeAgentRecursionGuardReport(dir, input) {
     await writeJsonAtomic(path.join(dir, 'agent-recursion-guard.json'), report);
     return report;
 }
-function scanWorkerExecutionSurface(input) {
-    const transcriptGroup = transcriptGroupForChannel(input.channel);
-    scanPatterns(input.text, commandRules(COMMAND_DENYLIST), (rule, match) => {
-        input.violations.push(nonRecursivePipelineViolation({
-            file: input.rel,
-            channel: input.channel,
-            group: transcriptGroup || 'command denylist',
-            rule_id: rule.id,
-            snippet: match[0] || rule.id,
-            index: match.index ?? null
-        }));
-        input.violations.push(nonRecursivePipelineViolation({
-            file: input.rel,
-            channel: input.channel,
-            group: 'top-level command block',
-            rule_id: rule.id,
-            snippet: match[0] || rule.id,
-            index: match.index ?? null
-        }));
-    });
-    scanPatterns(input.text, commandRules(ROUTE_DENYLIST), (rule, match) => {
-        input.violations.push(nonRecursivePipelineViolation({
-            file: input.rel,
-            channel: input.channel,
-            group: transcriptGroup || 'route denylist',
-            rule_id: rule.id,
-            snippet: match[0] || rule.id,
-            index: match.index ?? null
-        }));
-    });
-    scanPatterns(input.text, WORKER_MISSION_CREATION_PATTERNS, (rule, match) => {
-        input.violations.push(nonRecursivePipelineViolation({
-            file: input.rel,
-            channel: input.channel,
-            group: 'worker mission creation block',
-            rule_id: rule.id,
-            snippet: match[0] || rule.id,
-            index: match.index ?? null
-        }));
-    });
-    scanPatterns(input.text, CURRENT_JSON_WRITE_PATTERNS, (rule, match) => {
-        input.violations.push(nonRecursivePipelineViolation({
-            file: input.rel,
-            channel: input.channel,
-            group: 'current.json write block',
-            rule_id: rule.id,
-            snippet: match[0] || rule.id,
-            index: match.index ?? null
-        }));
-    });
-}
-function scanPatterns(text, rules, onMatch) {
-    for (const rule of rules) {
-        const flags = rule.pattern.flags.includes('g') ? rule.pattern.flags : `${rule.pattern.flags}g`;
-        const pattern = new RegExp(rule.pattern.source, flags);
-        for (const match of text.matchAll(pattern))
-            onMatch(rule, match);
-    }
-}
-function commandRules(entries) {
-    return entries.map((entry) => ({
-        id: entry,
-        pattern: entry.startsWith('$')
-            ? new RegExp('(^|\\s)\\' + entry + '(\\s|$)', 'gi')
-            : new RegExp('(^|\\s)' + escapeRe(entry).replace(/\\ /g, '\\s+') + '(\\s|$)', 'gi')
-    }));
-}
-function nonRecursivePipelineViolation(input) {
-    return {
-        schema: 'sks.non-recursive-pipeline-violation.v1',
-        file: input.file,
-        channel: input.channel,
-        group: input.group,
-        rule_id: input.rule_id,
-        index: input.index,
-        snippet: redactPolicyText(input.snippet),
-        next_action: nextActionForNonRecursiveRule(input.group, input.rule_id)
-    };
-}
-function nextActionForNonRecursiveRule(group, ruleId) {
-    if (group === 'env guard')
-        return 'restore SKS_AGENT_WORKER and SKS_DISABLE_ROUTE_RECURSION in agentWorkerEnv';
-    if (group === 'worker mission creation block')
-        return 'move mission creation to the parent orchestrator and keep workers route-local';
-    if (group === 'current.json write block')
-        return 'remove global current.json writes from worker code and record state in agent ledgers';
-    if (group === 'top-level command block')
-        return `replace ${ruleId} with parent-owned orchestration or a read-only local check`;
-    if (group.endsWith('transcript scan') || group === 'agent result scan')
-        return 'block the worker result and convert the finding into an agent wrongness record';
-    if (group === 'route denylist')
-        return 'remove nested SKS dollar-route launch from the worker prompt or result';
-    return 'remove nested SKS route command from worker execution surfaces';
-}
-function transcriptGroupForChannel(channel) {
-    if (channel === 'stdout')
-        return 'stdout transcript scan';
-    if (channel === 'stderr')
-        return 'stderr transcript scan';
-    if (channel === 'agent_result')
-        return 'agent result scan';
-    return null;
-}
-function isWorkerExecutionSurface(rel, channel) {
-    if (channel === 'stdout' || channel === 'stderr' || channel === 'agent_result')
-        return true;
-    return /(?:^|\/)agent-worker-pipeline\.(?:ts|mjs|js)$/.test(rel) || /(?:^|\/)agent-runner-process\.(?:ts|mjs|js)$/.test(rel);
-}
-function classifyNonRecursivePipelinePath(file) {
-    const normalized = normalizePath(file);
-    if (normalized.endsWith('.json'))
-        return 'agent_result';
-    if (normalized.includes('/docs/') || normalized.startsWith('docs/'))
-        return 'docs';
-    return 'source';
-}
-function redactPolicyText(text) {
-    let out = String(text || '');
-    for (const rule of SECRET_PATTERNS)
-        out = out.replace(rule.pattern, `[REDACTED:${rule.id}]`);
-    return out;
-}
-function collectSecretRedactionSamples(text) {
-    const samples = [];
-    for (const rule of SECRET_PATTERNS) {
-        rule.pattern.lastIndex = 0;
-        const matches = [...String(text || '').matchAll(rule.pattern)];
-        for (const match of matches)
-            samples.push(redactPolicyText(match[0]));
-    }
-    return samples;
-}
-function containsSecret(text) {
-    return SECRET_PATTERNS.some((rule) => {
-        rule.pattern.lastIndex = 0;
-        return rule.pattern.test(String(text || ''));
-    });
-}
-function normalizePath(file) {
-    return String(file || '').replace(/\\/g, '/');
-}
 function escapeRe(value) {
     return value.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
 }

package/dist/core/agents/agent-role-config.js

@@ -3,23 +3,9 @@ import os from 'node:os';
 import path from 'node:path';
 import { nowIso, readText, writeJsonAtomic } from '../fsx.js';
 import { inspectConfinedPath, moveConfinedPath, removeConfinedDirectoryIfEmpty, removeManagedPathVerified, uniqueConfinedPath, walkConfinedEntries } from '../managed-path-safety.js';
-import { MANAGED_OFFICIAL_SUBAGENT_ROLES, RETIRED_MANAGED_AGENT_ROLE_TOMBSTONES, managedAgentRoleOwnsText, managedOfficialSubagentRoleByFile, managedOfficialSubagentRoleByName, managedOfficialSubagentRoleContent } from '../managed-assets/managed-assets-manifest.js';
+import { MANAGED_OFFICIAL_SUBAGENT_ROLES, RETIRED_MANAGED_AGENT_ROLE_TOMBSTONES, managedAgentRoleOwnsText } from '../managed-assets/managed-assets-manifest.js';
 import { installOfficialSubagentAgentConfigs, refreshGlobalOfficialSubagentAgentConfigs } from '../subagents/official-subagent-config.js';
 export const AGENT_ROLE_CONFIG_REPAIR_SCHEMA = 'sks.agent-role-config-repair.v1';
-export const SKS_OWNED_AGENT_CONFIGS = new Map([
-    ...MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => [
-        role.filename,
-        { name: role.codex_name, sandbox: role.sandbox ?? null, content: managedOfficialSubagentRoleContent(role), id: role.id }
-    ]),
-]);
-export function managedAgentRoleConfigForFile(file) {
-    const official = managedOfficialSubagentRoleByFile(file);
-    return official ? managedOfficialSubagentRoleContent(official) : null;
-}
-export function managedAgentRoleConfigForRole(role) {
-    const official = managedOfficialSubagentRoleByName(role);
-    return official ? { file: official.filename, content: managedOfficialSubagentRoleContent(official) } : null;
-}
 export async function repairAgentRoleConfigs(input) {
     const root = path.resolve(input.root);
     const defaultHome = path.resolve(input.home || process.env.HOME || os.homedir());

package/dist/core/agents/agent-runner-fake.js

@@ -1,56 +1,3 @@
-import { validateAgentWorkerResult } from './agent-worker-pipeline.js';
-export async function runFakeAgent(agent, slice, opts = {}) {
-    if (Number(slice?.delay_ms || 0) > 0)
-        await delay(Number(slice.delay_ms));
-    const patchEnvelopes = buildFixturePatchEnvelopes(agent, slice, opts);
-    return validateAgentWorkerResult({
-        mission_id: opts.missionId || opts.mission_id || '',
-        agent_id: agent.id,
-        session_id: agent.session_id,
-        persona_id: agent.persona_id || agent.id,
-        task_slice_id: slice?.id || '',
-        status: 'done',
-        backend: 'fake',
-        summary: 'Fixture agent ' + agent.id + ' completed ' + (slice?.id || 'slice') + ' for ' + (opts.route || 'agent-run') + '.',
-        findings: ['fixture agent completed assigned slice'],
-        proposed_changes: [],
-        changed_files: [],
-        lease_compliance: { ok: true, violations: [] },
-        artifacts: ['agent-events.jsonl', 'agent-task-board.json'],
-        blockers: [],
-        confidence: 'fixture',
-        handoff_notes: 'No handoff required for fake backend fixture.',
-        unverified: ['fake backend does not prove real parallel execution'],
-        writes: [],
-        ...(patchEnvelopes.length ? { patch_envelopes: patchEnvelopes } : {}),
-        ...(isBugfixSlice(slice) && patchEnvelopes.length ? { regression_proof: fixtureRegressionProof(slice) } : {}),
-        ...(isRepairSlice(slice) && patchEnvelopes.length ? { repair_hypothesis: fixtureRepairHypothesis(slice) } : {}),
-        ...(slice?.work_item_kind ? { work_item_kind: String(slice.work_item_kind) } : {}),
-        ...(slice?.tournament_group_id ? { tournament: fixtureTournament(slice) } : {}),
-        source_intelligence_refs: agent.source_intelligence_refs || null,
-        goal_mode_ref: agent.goal_mode_ref || null,
-        ...(opts.emitFollowUpWorkItems ? { follow_up_work_items: [buildFixtureFollowUp(agent, slice)] } : {}),
-        verification: { status: 'fixture', checks: ['schema-normalized-result'] },
-        recursion_guard: { ok: true, violations: [] }
-    });
-}
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function buildFixtureFollowUp(agent, slice) {
-    return {
-        id: `${String(slice?.id || agent.id)}-follow-up-001`,
-        title: 'Fixture follow-up work item',
-        description: 'Schema-valid follow-up generated by the fake backend fixture.',
-        required_persona_category: 'verifier',
-        priority: 100,
-        dependencies: [],
-        lease_requirements: [],
-        max_attempts: 1,
-        reason: 'exercise follow_up_work_items scheduler enqueue path',
-        source_agent_session_id: agent.session_id
-    };
-}
 export function buildFixturePatchEnvelopes(agent, slice, opts = {}) {
     const writePaths = Array.isArray(slice?.write_paths) ? slice.write_paths.map(String).filter(Boolean) : [];
     if (!writePaths.length)

package/dist/core/agents/agent-schema.js

@@ -1,13 +1,9 @@
 import { DEFAULT_NARUTO_MAX_THREADS, HARD_NARUTO_MAX_THREADS } from '../subagents/thread-budget.js';
 export { DEFAULT_NARUTO_MAX_THREADS, DEFAULT_NARUTO_REQUESTED_SUBAGENTS, HARD_NARUTO_MAX_THREADS } from '../subagents/thread-budget.js';
-export const AGENT_KERNEL_SCHEMA = 'sks.native-agent-kernel.v1';
 export const AGENT_RESULT_SCHEMA = 'sks.agent-result.v1';
 export const AGENT_LEDGER_EVENT_SCHEMA = 'sks.agent-ledger-event.v1';
 export const AGENT_PROOF_EVIDENCE_SCHEMA = 'sks.agent-proof-evidence.v1';
-export const AGENT_WORKER_PIPELINE = 'AGENT_WORKER_PIPELINE';
-export const AGENT_ORCHESTRATOR_PIPELINE = 'AGENT_ORCHESTRATOR_PIPELINE';
 export const DEFAULT_AGENT_COUNT = 5;
-export const AGENT_COUNT = DEFAULT_AGENT_COUNT;
 export const OFFICIAL_SUBAGENT_EXECUTION_STAGE_ID = 'official_subagent_execution';
 export const MAX_AGENT_COUNT = 20;
 export const DEFAULT_AGENT_CONCURRENCY = DEFAULT_NARUTO_MAX_THREADS;

package/dist/core/agents/agent-work-queue.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { appendJsonl, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { appendJsonl, nowIso, writeJsonAtomic } from '../fsx.js';
 import { normalizeAgentFollowUpWorkItems } from './agent-follow-up-work-items.js';
 export const AGENT_WORK_QUEUE_SCHEMA = 'sks.agent-work-queue.v1';
 export const AGENT_WORK_QUEUE_EVENT_SCHEMA = 'sks.agent-work-queue-event.v1';
@@ -145,13 +145,3 @@ export async function appendAgentWorkQueueEvent(root, eventType, payload = {}) {
         payload
     });
 }
-export async function readAgentWorkQueue(root) {
-    return readJson(path.join(root, 'agent-work-queue.json'), {
-        schema: AGENT_WORK_QUEUE_SCHEMA,
-        updated_at: nowIso(),
-        total_work_items: 0,
-        generated_work_item_count: 0,
-        max_queue_expansion: 10,
-        items: []
-    });
-}

package/dist/core/agents/agent-worker-pipeline.js

@@ -1,4 +1,4 @@
-import { AGENT_RESULT_SCHEMA, AGENT_WORKER_PIPELINE } from './agent-schema.js';
+import { AGENT_RESULT_SCHEMA } from './agent-schema.js';
 import { normalizeAgentPatchEnvelope, validateAgentPatchEnvelope } from './agent-patch-schema.js';
 import { scanAgentTextForRecursion } from './agent-recursion-guard.js';
 import { validateAgentResultSchema, validateAndNormalizeAgentFollowUps } from './agent-output-validator.js';
@@ -117,24 +117,6 @@ function validWriteVerification(verification) {
         return checks.length > 0;
     return status === 'not_applicable' && Boolean(String(verification?.reason || '').trim());
 }
-export function agentWorkerPipelineContract() {
-    return {
-        schema: 'sks.agent-worker-pipeline.v1',
-        pipeline_id: AGENT_WORKER_PIPELINE,
-        creates_mission: false,
-        route_classifier_allowed: false,
-        writes_global_current_json: false,
-        route_finalizer_allowed: false,
-        writes_only_agent_session_and_central_ledger: true,
-        patch_envelope_result_fields: {
-            result_field: 'patch_envelopes',
-            required_for_write_tasks: true,
-            envelope_schema: 'sks.agent-patch-envelope.v1',
-            metadata: ['agent_id', 'session_id', 'slot_id', 'generation_index', 'lease_id_or_lease_proof'],
-            optional_hints: ['rationale', 'verification_hint', 'rollback_hint', 'cochange_acknowledged_reason', 'regression_proof', 'repair_hypothesis']
-        }
-    };
-}
 function normalizePatchEnvelopes(value) {
     const envelopes = Array.isArray(value) ? value.map((raw) => ({
         ...normalizeAgentPatchEnvelope(raw),

package/dist/core/agents/agent-worker-slot.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
 export const AGENT_WORKER_SLOT_SCHEMA = 'sks.agent-worker-slot.v1';
 export const AGENT_WORKER_SLOTS_SCHEMA = 'sks.agent-worker-slots.v1';
 export function workerSlotId(index) {
@@ -84,12 +84,3 @@ export async function writeAgentWorkerSlots(root, slots) {
     await writeJsonAtomic(path.join(root, 'agent-worker-slots.json'), artifact);
     return artifact;
 }
-export async function readAgentWorkerSlots(root) {
-    return readJson(path.join(root, 'agent-worker-slots.json'), {
-        schema: AGENT_WORKER_SLOTS_SCHEMA,
-        updated_at: nowIso(),
-        slot_count: 0,
-        slots: [],
-        all_slots_closed_after_drain: false
-    });
-}

package/dist/core/agents/runtime-proof-summary.js

@@ -14,7 +14,6 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest',
     const scheduler = await readJson(path.join(agentsDir, 'agent-scheduler-state.json'), null);
     const runtime = await readJson(path.join(agentsDir, 'native-cli-worker-runtime.json'), null);
     const stopGate = await readJson(path.join(dir, 'stop-gate.json'), null);
-    const governor = await readJson(path.join(agentsDir, 'naruto-concurrency-governor.json'), null);
     const messagesAll = await readAgentMessageBus(root, missionId, { max: 500 });
     const recentMessages = await readAgentMessageBus(root, missionId, { max: opts.maxMessages || 8 });
     const loopSummary = summarizeLoopGraphProof(await readLoopGraphProof(root, missionId).catch(() => null));

package/dist/core/align/align-route.js

@@ -257,9 +257,6 @@ export async function refreshAlignGate(dir, missionId, rootInput) {
     await writeJsonAtomic(path.join(dir, ALIGN_GATE_ARTIFACT), gate);
     return { plan, ledger, gate };
 }
-export async function readAlignGate(dir) {
-    return readJson(path.join(dir, ALIGN_GATE_ARTIFACT), null);
-}
 export function alignNextActionText(missionId) {
     return `Run sks align run ${missionId}; Align accepts an absent or existing TriWiki, rebuilds the code-only index from current repository bytes, replaces the active generation, and retains no previous generation.`;
 }

package/dist/core/align/code-navigation-align.js

@@ -19,7 +19,7 @@ import { clearContextGraphSnapshotCache, clearWorkspaceContextIndex } from '../t
 import { withTriWikiStateLock } from '../triwiki/triwiki-cleanup.js';
 import { publishArchitectureMapToStage } from '../triwiki/context-graph/store/architecture-map-store.js';
 import { alignPendingRoot, alignPendingWiki, alignSourceFingerprint, projectAlignCodePack, publishAlignContextIndex } from './align-context-index.js';
-import { ALIGN_GATE_ARTIFACT, ALIGN_LEDGER_ARTIFACT, ALIGN_OUTPUT_ARTIFACTS, ALIGN_PLAN_ARTIFACT, ALIGN_STAGING_ROOT_REL, buildInitialAlignLedger, refreshAlignGate } from './align-route.js';
+import { ALIGN_LEDGER_ARTIFACT, ALIGN_OUTPUT_ARTIFACTS, ALIGN_PLAN_ARTIFACT, ALIGN_STAGING_ROOT_REL, buildInitialAlignLedger, refreshAlignGate } from './align-route.js';
 const WIKI_PREFIX = '.sneakoscope/wiki/';
 function isArchitectureMapOptionalSkip(skip) {
     const rel = skip.path.replace(/\\/g, '/');

package/dist/core/architecture-hardening/contracts/contracts.js

@@ -2,7 +2,6 @@ import { createHash } from 'node:crypto';
 import { BRIDGE_PROVIDER_IDS } from '../../codex-lb/bridge-contracts.js';
 import { canonicalizeBridgeModelId, normalizeBridgeUpstreamModelId } from '../../codex-lb/route-index.js';
 import { canonicalJson } from '../../json/canonical.js';
-export const ARCHITECTURE_HARDENING_CONTRACT_VERSION = 'sks.architecture-hardening.contracts.v2';
 export const MAX_AUDIT_PROJECTION_DEPTH = 32;
 export class ArchitectureContractError extends Error {
     code;
@@ -125,9 +124,6 @@ export function stableArchitectureHash(value) {
     const projection = createSafeAuditProjection(value);
     return createHash('sha256').update(canonicalJson(projection)).digest('hex');
 }
-export function jsonRoundTrip(value) {
-    return JSON.parse(JSON.stringify(createSafeAuditProjection(value)));
-}
 function projectAuditValue(value, depth, ancestors) {
     if (depth > MAX_AUDIT_PROJECTION_DEPTH)
         fail('audit_projection_depth_exceeded');

package/dist/core/architecture-map-pipeline.js

@@ -5,24 +5,6 @@ import { ARCHITECTURE_CAPSULE_ARTIFACT, ARCHITECTURE_MAP_BASELINE_ARTIFACT, ARCH
 import { readContextGraphSnapshot } from './triwiki/context-graph/store/snapshot-store.js';
 export { ARCHITECTURE_MAP_REVIEW_ARTIFACT };
 export const ARCHITECTURE_MAP_BASELINE_STAGE = 'architecture_map_baseline';
-export const ARCHITECTURE_MAP_REVIEW_STAGE = 'architecture_map_review';
-const ARCHITECTURE_MAP_EXEMPT_ROUTES = new Set([
-    'Answer',
-    'DFix',
-    'Help',
-    'Wiki',
-    'Goal',
-    'GX',
-    'DB'
-]);
-export function routeNeedsArchitectureMap(route) {
-    const id = String(route?.id || '');
-    if (!id)
-        return false;
-    if (ARCHITECTURE_MAP_EXEMPT_ROUTES.has(id))
-        return false;
-    return true;
-}
 export function createArchitectureMapPlanBinding() {
     return Object.freeze({
         baseline_artifact: ARCHITECTURE_MAP_BASELINE_ARTIFACT,
@@ -38,13 +20,6 @@ export function planStagesArchitectureMap(plan) {
         && plan.stages.some((stage) => String(stage?.id || '') === ARCHITECTURE_MAP_BASELINE_STAGE
             && !['skipped', 'not_applicable'].includes(String(stage?.status || '')));
 }
-export async function seedArchitectureMapPlanBinding(dir, plan) {
-    if (!planStagesArchitectureMap(plan))
-        return plan;
-    plan.architecture_map = createArchitectureMapPlanBinding();
-    await writeJsonAtomic(path.join(dir, 'pipeline-plan.json'), plan);
-    return plan;
-}
 export async function maybeSeedArchitectureMapForPlan(input) {
     if (!input.plan?.architecture_map || !input.missionId) {
         return { ok: false, reason: 'architecture_map_not_planned' };