sneakoscope 10.3.8 → 10.3.10

package/dist/core/agents/agent-effort-policy.js

@@ -2,9 +2,6 @@ import { codexModelEffortCapability } from '../codex-control/codex-model-capabil
 import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
 import { decideSubagentModel, subagentModelProfile } from '../subagents/model-policy.js';
 import { MODEL_TIERS, resolveLatestModelTiers } from '../subagents/model-tiers.js';
-export function decideAgentEffort(input = {}) {
-    return decideOfficialSubagentModel(input);
-}
 export function decideOfficialSubagentModel(input = {}) {
     const persona = input.persona || {};
     const prompt = String(input.prompt || '');
@@ -46,7 +43,7 @@ export function decideOfficialSubagentModel(input = {}) {
             downshift_triggers: [
                 'instructed UI, logic, backend, or native implementation selects the balanced tier',
                 'long-context, Browser/Chrome, Computer Use, image-generation, or large search selects the context tier',
-                'tiny short-context mechanical search/typing/rename work selects the balanced tier'
+                'tiny short-context mechanical search/typing/rename work selects the fast tier'
             ]
         };
     }
@@ -100,7 +97,7 @@ export function decideOfficialSubagentModel(input = {}) {
         downshift_triggers: [
             'instructed UI, logic, backend, or native implementation selects the balanced tier',
             'long-context, Browser/Chrome, Computer Use, or image-generation execution selects the context tier',
-            'tiny short-context mechanical work selects the balanced tier'
+            'tiny short-context mechanical work selects the fast tier'
         ]
     };
 }
@@ -125,7 +122,7 @@ export function buildAgentEffortPolicy(roster = {}) {
         policy_version: 1,
         dynamic: true,
         service_tier: 'fast',
-        model_catalog_policy: 'official_subagent_four_profile_matrix',
+        model_catalog_policy: 'official_subagent_model_tiers',
         model_constraint: [...new Set(MODEL_TIERS.map((tier) => latest.models[tier]))],
         model_tiers: MODEL_TIERS.map((tier) => `${tier}:${latest.models[tier]}-${latest.efforts[tier]}`),
         allowed_efforts: ['low', 'medium', 'high', 'max'],

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

@@ -13,7 +13,7 @@ import { writeAgentProofEvidence } from './agent-proof-evidence.js';
 import { selectRouteSkill, skillProofRecord } from '../skills/core-skill-runtime.js';
 import { routeSkillId } from '../skills/core-skill-card.js';
 import { loadTriWikiRuntimeContext, writeTriWikiContextArtifact } from '../triwiki-runtime.js';
-import { DEFAULT_AGENT_CONCURRENCY, MAX_AGENT_COUNT, normalizeAgentBackend } from './agent-schema.js';
+import { MAX_AGENT_COUNT, normalizeAgentBackend } from './agent-schema.js';
 import { PersistentAgentPatchQueueStore } from './agent-patch-queue-store.js';
 import { applyAgentPatchQueueEntry, rollbackAgentPatchApply } from './agent-patch-apply-worker.js';
 import { coordinateAgentPatchMerge, writeAgentMergeCoordinatorArtifacts } from './agent-merge-coordinator.js';
@@ -93,7 +93,6 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         concurrency: opts.concurrency,
         prompt,
         maxAgentCount,
-        officialSubagentPolicy,
         ...(opts.readonly === undefined ? {} : { readonly: opts.readonly })
     });
     roster = applyFastModeToRoster(roster, fastModePolicy);

package/dist/core/agents/agent-patch-transaction-journal.js

@@ -1,6 +1,5 @@
-import fs from 'node:fs/promises';
 import path from 'node:path';
-import { appendJsonl, exists, nowIso, readText, sha256, writeJsonAtomic } from '../fsx.js';
+import { appendJsonl, nowIso, readText, writeJsonAtomic } from '../fsx.js';
 export const AGENT_PATCH_TRANSACTION_JOURNAL_SCHEMA = 'sks.agent-patch-transaction-journal.v1';
 export const AGENT_PATCH_TRANSACTION_JOURNAL_ARTIFACT = 'agent-patch-transaction-journal.jsonl';
 export const AGENT_PATCH_TRANSACTION_JOURNAL_SUMMARY_ARTIFACT = 'agent-patch-transaction-journal-summary.json';
@@ -95,17 +94,3 @@ export async function summarizeAgentPatchTransactionJournal(artifactDir) {
         blockers
     };
 }
-export async function hashFilesForJournal(root, files) {
-    const out = {};
-    for (const file of [...new Set(files.map(normalizeRelPath).filter(Boolean))].sort()) {
-        const absolute = path.resolve(root, file);
-        if (!absolute.startsWith(path.resolve(root) + path.sep))
-            continue;
-        out[file] = await exists(absolute) ? sha256(await fs.readFile(absolute)) : 'missing';
-    }
-    return out;
-}
-function normalizeRelPath(value) {
-    const normalized = path.posix.normalize(String(value || '').replace(/\\/g, '/').replace(/^\.\/+/, ''));
-    return normalized === '.' ? '' : normalized;
-}

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

@@ -7,7 +7,6 @@ const OFFICIAL_SUBAGENT_ROUTE_KEYS = new Set([
     'work', '$work'
 ]);
 const EXPLICIT_SUBAGENT_RE = /\$(Naruto|Work)\b/i;
-const PARALLELIZABLE_RE = /\b(parallel|subagents?|fan out|one agent per|independent|disjoint|multiple files|all files)\b|병렬|하위\s*에이전트|서브\s*에이전트|독립|분리된|여러\s*파일|모든\s*파일|분담/i;
 function routeKey(route) {
     return String(route?.id || route?.command || route?.name || route || '').trim().toLowerCase();
 }
@@ -101,9 +100,6 @@ function capacityOptions(options) {
         ['marginalUsefulThroughputPositive', options.marginalUsefulThroughputPositive]
     ].filter(([, value]) => value !== undefined));
 }
-export function explicitlyParallelizable(prompt) {
-    return PARALLELIZABLE_RE.test(String(prompt || ''));
-}
 function taskProfile(value, task) {
     return isTaskProfile(value) ? value : classifyTaskProfile(task);
 }

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-roster.js

@@ -1,6 +1,6 @@
 import { DEFAULT_AGENT_CONCURRENCY, DEFAULT_AGENT_COUNT, HARD_AGENT_CONCURRENCY, MAX_AGENT_COUNT, agentSessionId } from './agent-schema.js';
 import { defaultAgentPersonas, validatePersonaUniqueness } from './agent-persona.js';
-import { buildAgentEffortPolicy, decideAgentEffort, decideOfficialSubagentModel } from './agent-effort-policy.js';
+import { buildAgentEffortPolicy, decideOfficialSubagentModel } from './agent-effort-policy.js';
 function resolveMaxAgentCount(value) {
     const parsed = Number(value);
     if (!Number.isFinite(parsed) || parsed < 1)
@@ -35,9 +35,7 @@ export function buildAgentRoster(opts = {}) {
     if (!uniqueness.ok)
         throw new Error('Invalid agent personas: ' + JSON.stringify(uniqueness));
     const roster = personas.map((persona, index) => {
-        const effort = opts.officialSubagentPolicy === true
-            ? decideOfficialSubagentModel({ persona, prompt: opts.prompt || '', agentId: persona.id, readonly: opts.readonly === true || persona.read_only })
-            : decideAgentEffort({ persona, prompt: opts.prompt || '', agentId: persona.id, readonly: opts.readonly === true || persona.read_only });
+        const effort = decideOfficialSubagentModel({ persona, prompt: opts.prompt || '', agentId: persona.id, readonly: opts.readonly === true || persona.read_only });
         return {
             id: persona.id,
             session_id: agentSessionId(persona.id, index + 1),

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),