sneakoscope 6.1.0 → 6.1.2

package/dist/core/subagents/official-subagent-preparation.js

@@ -0,0 +1,251 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { nowIso, randomId, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { classifyTaskProfile } from '../runtime/task-profile.js';
+import { chooseVerificationBudget } from '../runtime/verification-budget.js';
+import { buildOfficialSubagentPrompt } from './official-subagent-prompt.js';
+import { readOfficialSubagentConfig } from './official-subagent-config.js';
+import { NARUTO_PARENT_EFFORT, NARUTO_PARENT_MODEL } from './model-policy.js';
+import { officialSubagentFanoutPolicy, officialSubagentRolePlan, recommendOfficialSubagentRoles } from './agent-catalog.js';
+import { resolveSubagentThreadBudget } from './thread-budget.js';
+import { readBoundedTriwikiAttention } from './triwiki-attention.js';
+import { SUBAGENT_EVIDENCE_FILENAME, SUBAGENT_EVENT_LOG_FILENAME, SUBAGENT_PARENT_SUMMARY_FILENAME, normalizeSubagentParentSummary, writeSubagentEvidence } from './subagent-evidence.js';
+export const NARUTO_RESULT_SCHEMA = 'sks.naruto-subagent-workflow.v1';
+export const SUBAGENT_PLAN_FILENAME = 'subagent-plan.json';
+export const NARUTO_SUMMARY_FILENAME = 'naruto-summary.json';
+export const NARUTO_GATE_FILENAME = 'naruto-gate.json';
+export async function prepareOfficialSubagentMission(input) {
+    const goal = String(input.goal || '').trim();
+    const mode = input.mode === 'naruto' ? 'naruto' : 'generic';
+    const taskProfile = classifyTaskProfile(goal);
+    const suggestedAgents = recommendOfficialSubagentRoles({
+        description: goal,
+        readOnly: input.readOnly === true,
+        requiresWrite: input.readOnly !== true
+    });
+    const officialConfig = await readOfficialSubagentConfig(input.root);
+    const triwikiAttention = await readBoundedTriwikiAttention(input.root);
+    const requestedExplicit = input.requestedSubagentsExplicit ?? input.requestedSubagents !== undefined;
+    const selectedFanoutPolicy = officialSubagentFanoutPolicy({
+        ...(input.requestedSubagents === undefined ? {} : { requestedSubagents: input.requestedSubagents }),
+        requestedExplicit,
+        taskProfile,
+        suggestedRoles: suggestedAgents,
+        goal
+    });
+    const budget = resolveSubagentThreadBudget({
+        requested: selectedFanoutPolicy.requested_subagents,
+        configuredMaxThreads: input.maxThreads ?? officialConfig.maxThreads
+    });
+    const verification = chooseVerificationBudget({ taskProfile, changedFiles: [] });
+    const workflowRunId = String(input.workflowRunId || '').trim()
+        || `${mode === 'naruto' ? 'naruto' : 'official'}-${Date.now().toString(36)}-${randomId(8)}`;
+    const fanoutPolicy = {
+        ...selectedFanoutPolicy,
+        requested_subagents: budget.requestedSubagents
+    };
+    const observedParentModel = String(input.observedParentModel || '').trim() || null;
+    const parentModelMatch = observedParentModel ? observedParentModelMatchesPolicy(observedParentModel) : null;
+    const delegationGoal = input.readOnly
+        ? `${goal}\n\nConstraint: run every delegated slice in read-only mode. Do not edit files.`
+        : goal;
+    const delegationPrompt = buildOfficialSubagentPrompt({
+        goal: delegationGoal,
+        slices: [],
+        requestedSubagents: budget.requestedSubagents,
+        requestedSubagentsExplicit: requestedExplicit,
+        maxThreads: budget.maxThreads,
+        decompositionStatus: 'parent_required',
+        triwikiAttention,
+        recommendedAgents: suggestedAgents
+    });
+    const configBlockers = officialConfig.blockers.map((blocker) => `official_subagent_config:${blocker}`);
+    const plan = {
+        schema: 'sks.subagent-plan.v1',
+        mission_id: input.missionId,
+        route: input.route,
+        workflow: 'official_codex_subagent',
+        workflow_run_id: workflowRunId,
+        session_scope: input.sessionScope || null,
+        goal,
+        read_only: input.readOnly === true,
+        task_profile: taskProfile,
+        decomposition_status: 'parent_required',
+        delegation_prompt: delegationPrompt,
+        requested_subagents: budget.requestedSubagents,
+        requested_subagents_explicit: requestedExplicit,
+        max_threads: budget.maxThreads,
+        first_wave: budget.firstWave,
+        wave_count: budget.waveCount,
+        max_depth: budget.maxDepth,
+        config_source: input.maxThreads === undefined ? officialConfig.sources.maxThreads : 'cli',
+        config_sources: officialConfig.sources,
+        config_blockers: officialConfig.blockers,
+        triwiki_attention: triwikiAttention,
+        suggested_agents: suggestedAgents,
+        fanout_policy: fanoutPolicy,
+        slices: [],
+        parent_model_policy: NARUTO_PARENT_MODEL,
+        observed_parent_model: observedParentModel,
+        parent_model_match: parentModelMatch,
+        parent: {
+            model: NARUTO_PARENT_MODEL,
+            model_reasoning_effort: NARUTO_PARENT_EFFORT
+        },
+        agents: officialSubagentRolePlan(),
+        verification_budget: verification,
+        verification_checks: [],
+        verification: { budget: verification },
+        legacy_process_swarm_used: false,
+        created_at: nowIso()
+    };
+    const cleanup = [
+        fsp.rm(path.join(input.dir, SUBAGENT_PARENT_SUMMARY_FILENAME), { force: true }),
+        fsp.rm(path.join(input.dir, SUBAGENT_EVIDENCE_FILENAME), { force: true })
+    ];
+    if (mode === 'naruto') {
+        cleanup.push(fsp.rm(path.join(input.dir, NARUTO_SUMMARY_FILENAME), { force: true }), fsp.rm(path.join(input.dir, NARUTO_GATE_FILENAME), { force: true }));
+    }
+    await Promise.all(cleanup);
+    await writeTextAtomic(path.join(input.dir, SUBAGENT_EVENT_LOG_FILENAME), '');
+    await writeJsonAtomic(path.join(input.dir, SUBAGENT_PLAN_FILENAME), plan);
+    const evidence = await writeSubagentEvidence(input.dir, {
+        requestedSubagents: budget.requestedSubagents,
+        events: [],
+        parentSummaryPresent: false,
+        workflowStatus: 'delegation_context_ready',
+        preparationOnly: input.preparationOnly !== false,
+        runId: workflowRunId,
+        additionalBlockers: configBlockers
+    });
+    if (mode === 'naruto') {
+        const blockers = uniqueStrings([
+            ...evidence.blockers,
+            ...configBlockers,
+            ...(parentModelMatch === false ? [`parent_model_mismatch:${observedParentModel}`] : [])
+        ]);
+        await writeJsonAtomic(path.join(input.dir, NARUTO_SUMMARY_FILENAME), buildNarutoSummary({
+            missionId: input.missionId,
+            workflowRunId,
+            budget,
+            evidence,
+            verification,
+            status: 'delegation_context_ready',
+            ok: false,
+            blockers,
+            sessionKey: input.sessionScope || null,
+            observedParentModel,
+            parentModelMatch
+        }));
+        await writeNarutoGate(input.dir, {
+            missionId: input.missionId,
+            workflowRunId,
+            evidence,
+            passed: false,
+            blockers,
+            configBlockers,
+            observedParentModel,
+            parentModelMatch
+        });
+    }
+    return {
+        plan,
+        evidence,
+        budget,
+        verification,
+        taskProfile,
+        delegationPrompt,
+        workflowRunId,
+        officialConfig,
+        triwikiAttention,
+        suggestedAgents,
+        fanoutPolicy,
+        configBlockers,
+        observedParentModel,
+        parentModelMatch
+    };
+}
+export function buildNarutoSummary(input) {
+    const parentSummary = normalizeSubagentParentSummary(input.parentSummary);
+    return {
+        schema: NARUTO_RESULT_SCHEMA,
+        ok: input.ok === true,
+        completion_evidence: input.ok === true,
+        status: input.status,
+        route: '$Naruto',
+        workflow: 'official_codex_subagent',
+        workflow_run_id: input.workflowRunId || input.evidence?.run_id || null,
+        mission_id: input.missionId,
+        parent: {
+            model: NARUTO_PARENT_MODEL,
+            model_reasoning_effort: NARUTO_PARENT_EFFORT,
+            observed_model: input.observedParentModel || null,
+            observed_model_match: input.parentModelMatch ?? null
+        },
+        requested_subagents: input.budget.requestedSubagents,
+        max_threads: input.budget.maxThreads,
+        max_depth: input.budget.maxDepth,
+        started_subagents: Number(input.evidence?.started_threads || 0),
+        completed_subagents: Number(input.evidence?.completed_threads || 0),
+        failed_subagents: Number(input.evidence?.failed_threads || 0),
+        agents: officialSubagentRolePlan(),
+        verification: {
+            budget: input.verification,
+            checks: []
+        },
+        parent_summary_present: Boolean(input.parentSummary),
+        parent_summary: parentSummary.summary,
+        parent_thread_outcomes: parentSummary.raw?.thread_outcomes || [],
+        app_session: input.appSession === true,
+        session_scope: input.sessionKey || null,
+        blockers: uniqueStrings(input.blockers || input.evidence?.blockers || []),
+        legacy_process_swarm_used: false,
+        updated_at: nowIso()
+    };
+}
+export async function writeNarutoGate(dir, input) {
+    await writeJsonAtomic(path.join(dir, NARUTO_GATE_FILENAME), buildNarutoGateResult(input));
+}
+export function buildNarutoGateResult(input) {
+    const passed = input.passed === true;
+    const requested = Number(input.evidence?.requested_subagents || 0);
+    const completed = Number(input.evidence?.completed_threads || 0);
+    const failed = Number(input.evidence?.failed_threads || 0);
+    return {
+        schema: 'sks.naruto-gate.v1',
+        route: '$Naruto',
+        workflow: 'official_codex_subagent',
+        workflow_run_id: input.workflowRunId || input.evidence?.run_id || null,
+        mission_id: input.missionId,
+        parent_model_policy: NARUTO_PARENT_MODEL,
+        observed_parent_model: input.observedParentModel || null,
+        parent_model_match: input.parentModelMatch ?? null,
+        status: passed ? 'passed' : 'blocked',
+        passed,
+        terminal: passed,
+        terminal_state: passed ? 'completed' : 'blocked',
+        subagent_plan_ready: true,
+        official_subagent_evidence: input.evidence?.ok === true,
+        session_cleanup: failed === 0 && requested > 0 && completed >= requested,
+        subagent_evidence_ready: input.evidence?.ok === true,
+        requested_subagents: requested || null,
+        started_subagents: Number(input.evidence?.started_threads || 0),
+        completed_subagents: Number(input.evidence?.completed_threads || 0),
+        failed_subagents: Number(input.evidence?.failed_threads || 0),
+        parent_summary_present: input.evidence?.parent_summary_present === true,
+        event_sources: input.evidence?.event_sources || [],
+        native_process_proof_required: false,
+        legacy_process_swarm_used: false,
+        config_blockers: uniqueStrings(input.configBlockers || []),
+        blockers: uniqueStrings(input.blockers || input.evidence?.blockers || []),
+        missing_fields: uniqueStrings(input.blockers || input.evidence?.blockers || []),
+        updated_at: nowIso()
+    };
+}
+function observedParentModelMatchesPolicy(model) {
+    return model.toLowerCase() === NARUTO_PARENT_MODEL || /gpt[-_. ]?5\.6[-_. ]?sol|\bsol(?:\s+max)?\b/i.test(model);
+}
+function uniqueStrings(values) {
+    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
+}
+//# sourceMappingURL=official-subagent-preparation.js.map

package/dist/core/subagents/official-subagent-prompt.js

@@ -0,0 +1,137 @@
+import { HARD_NARUTO_MAX_THREADS } from './thread-budget.js';
+import { MAX_AUTOMATIC_REVIEWER_COUNT, MAX_AUTOMATIC_SUBAGENT_COUNT, officialSubagentRoleCatalog, selectOfficialSubagentRole } from './agent-catalog.js';
+export function buildOfficialSubagentPrompt(input) {
+    const maxThreads = clampThreads(input.maxThreads);
+    const requestedSubagents = normalizeRequestedSubagents(input.requestedSubagents, input.slices.length);
+    const waveCount = requestedSubagents === 0 ? 0 : Math.ceil(requestedSubagents / maxThreads);
+    const parentDecompositionRequired = input.decompositionStatus === 'parent_required';
+    const requestedPolicy = input.requestedSubagentsExplicit === true
+        ? `${requestedSubagents} (explicit operator request)`
+        : `${requestedSubagents} (risk-based automatic count; one child is the safe default; keep the plan and evidence count exact)`;
+    const triwiki = renderBoundedTriwikiAttention(input.triwikiAttention);
+    const catalog = renderAgentCatalog(input.recommendedAgents);
+    const rows = input.slices.map((slice, index) => {
+        const agentName = slice.agent || selectOfficialSubagentRole({
+            title: slice.title,
+            description: slice.description,
+            role: slice.kind,
+            ...(slice.paths === undefined ? {} : { paths: slice.paths }),
+            readOnly: slice.readOnly === true,
+            requiresWrite: slice.readOnly !== true
+        });
+        const mode = slice.readOnly ? 'read-only' : 'use the parent permission mode';
+        const paths = (slice.paths || []).map((entry) => String(entry).trim()).filter(Boolean);
+        return [
+            `${index + 1}. [${slice.id}] use custom agent \`${agentName}\``,
+            `   title: ${slice.title}`,
+            `   task: ${slice.description}`,
+            `   mode: ${mode}`,
+            `   paths: ${paths.join(', ') || 'assigned by parent'}`
+        ].join('\n');
+    }).join('\n');
+    return `
+Use a Codex subagent workflow for the independent slices below.
+
+Parent agent:
+- model policy: gpt-5.6-sol with max reasoning
+- owns decomposition, integration, and final answer
+- do not do duplicate work already delegated
+
+Subagent rules:
+- use only Codex official subagent threads; do not launch shell workers, a custom scheduler, a worker pool, or model fanout
+- select the narrowest matching project custom agent by its description; the custom agent name is the spawn type
+- use \`worker\` with gpt-5.6-luna and max reasoning only for clear, bounded, repeatable work
+- use \`expert\` with gpt-5.6-sol and max reasoning only as the read-only judgment fallback
+- automatic fan-out is selected before execution: one by default, two only for explicit parallel work or independent risk domains,
+  and at most ${MAX_AUTOMATIC_SUBAGENT_COUNT} for critical multi-domain risk; never spawn beyond the requested count
+- automatic reviewer-only fan-out is capped at ${MAX_AUTOMATIC_REVIEWER_COUNT} for ordinary work; critical multi-domain review may use the overall cap of ${MAX_AUTOMATIC_SUBAGENT_COUNT}
+- requested subagents: ${requestedPolicy}
+- max open agent threads: ${maxThreads}
+- planned waves: ${waveCount}
+- max depth: 1
+- subagents must not spawn subagents
+- parallel writes require disjoint paths
+- if paths overlap, run those slices serially
+- wait for every requested subagent before integrating
+- close completed threads after collecting results
+${parentDecompositionRequired ? `- decomposition status: parent_required
+- before spawning, decompose the goal into independent, non-overlapping slices
+- do not invent write scopes merely to reach the requested count
+${input.requestedSubagentsExplicit === true
+        ? '- the explicit operator count is authoritative; if it cannot be defended safely, block and report instead of silently changing it'
+        : '- if fewer defensible slices exist, reduce the delegation plan and requested count before execution; never increase automatically beyond the selected count'}` : '- decomposition status: ready'}
+
+Central TriWiki context:
+${triwiki}
+
+Project custom agent catalog:
+${catalog}
+
+Goal:
+${String(input.goal || '').trim()}
+
+Slices:
+${rows || '(parent decomposition required before any subagent is spawned)'}
+
+Final parent output:
+- return one JSON object as the final message; prose outside that object is not completion evidence
+- use this exact schema so SKS can correlate every stopped agent thread with a trustworthy parent outcome:
+{
+  "schema": "sks.subagent-parent-summary.v1",
+  "status": "completed|blocked|failed",
+  "summary": "Completion Summary: concise integrated result. Honest Mode: goal/evidence/checks/gaps assessment.",
+  "thread_outcomes": [
+    { "thread_id": "official agent/thread id", "status": "completed|blocked|failed", "summary": "slice result" }
+  ],
+  "changed_files": [],
+  "verification": [],
+  "blockers": []
+}
+- include one thread_outcomes row for every requested subagent; a SubagentStop event alone never proves success
+- keep completion summary and Honest Mode wording inside the JSON fields; do not add prose outside the object
+`.trim();
+}
+function renderBoundedTriwikiAttention(value) {
+    if (!value?.available || value.anchors.length === 0) {
+        return [
+            '- no bounded attention anchors are available; rely on current scoped sources',
+            '- do not compensate by making every subagent reread the entire repository or full TriWiki pack'
+        ].join('\n');
+    }
+    const anchors = value.anchors.map((anchor) => ({
+        id: anchor.id,
+        claim_hash: anchor.claim_hash,
+        source_hash: anchor.source_hash,
+        hydrate_hint: anchor.hydrate_hint
+    }));
+    return [
+        `- consume these ${anchors.length} attention.use_first anchors before broad discovery`,
+        '- hydrate a referenced source only when its anchor is relevant to the assigned slice or a risky decision',
+        '- do not inject the full context pack or make each subagent repeat repository-wide context discovery',
+        `- bounded anchors: ${JSON.stringify(anchors)}`
+    ].join('\n');
+}
+function renderAgentCatalog(recommended) {
+    const preferred = new Set((recommended || []).map(String));
+    const included = new Set(['worker', 'implementation_specialist', 'expert', ...preferred]);
+    return officialSubagentRoleCatalog()
+        .filter((role) => included.has(role.name))
+        .map((role) => {
+        const marker = preferred.has(role.name) ? ' [suggested for this goal]' : '';
+        return `- \`${role.name}\`${marker}: ${role.model}/${role.model_reasoning_effort}, ${role.sandbox_mode}; ${role.description}`;
+    })
+        .join('\n');
+}
+function clampThreads(value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        return 1;
+    return Math.max(1, Math.min(HARD_NARUTO_MAX_THREADS, Math.floor(parsed)));
+}
+function normalizeRequestedSubagents(value, fallback) {
+    const parsed = value === undefined || value === null || value === '' ? fallback : Number(value);
+    if (!Number.isFinite(parsed))
+        return Math.max(0, Math.min(HARD_NARUTO_MAX_THREADS, fallback));
+    return Math.max(0, Math.min(HARD_NARUTO_MAX_THREADS, Math.floor(parsed)));
+}
+//# sourceMappingURL=official-subagent-prompt.js.map

package/dist/core/subagents/official-subagent-runner.js

@@ -0,0 +1,129 @@
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { runProcess } from '../fsx.js';
+import { NARUTO_PARENT_EFFORT, NARUTO_PARENT_MODEL } from './model-policy.js';
+import { inspectCodexLbCliLaunchRecovery } from '../codex-control/codex-lb-launch-recovery.js';
+export const OFFICIAL_SUBAGENT_WORKFLOW_SCHEMA = 'sks.subagent-workflow.v1';
+export function detectCodexAppSession(env = process.env) {
+    if (env.SKS_NARUTO_STANDALONE_CLI === '1')
+        return false;
+    if (env.SKS_NARUTO_APP_SESSION === '1')
+        return true;
+    return Boolean(env.CODEX_THREAD_ID);
+}
+export function codexAppSessionKey(env = process.env) {
+    if (!detectCodexAppSession(env))
+        return null;
+    const threadId = String(env.CODEX_THREAD_ID || '').trim();
+    return threadId || null;
+}
+export function buildOfficialSubagentCodexArgs(input) {
+    return [
+        'exec',
+        '-m', NARUTO_PARENT_MODEL,
+        '-c', `model_reasoning_effort="${NARUTO_PARENT_EFFORT}"`,
+        '-c', `agents.max_threads=${Math.max(1, Math.floor(input.maxThreads))}`,
+        '-c', 'agents.max_depth=1',
+        '--output-last-message', input.parentSummaryFile,
+        input.prompt
+    ];
+}
+export async function runOfficialSubagentWorkflow(input) {
+    const base = {
+        schema: OFFICIAL_SUBAGENT_WORKFLOW_SCHEMA,
+        workflow: 'official_codex_subagent',
+        requested_subagents: input.requestedSubagents,
+        max_threads: input.maxThreads,
+        max_depth: 1,
+        parent_model: NARUTO_PARENT_MODEL,
+        parent_reasoning_effort: NARUTO_PARENT_EFFORT,
+        session_scope: input.sessionKey || null,
+        legacy_process_swarm_used: false
+    };
+    if (input.appSession) {
+        return {
+            ...base,
+            ok: false,
+            status: 'delegation_context_ready',
+            prepared: true,
+            additionalContext: input.prompt,
+            completion_evidence: false,
+            note: 'The current Codex parent must spawn and await the official subagents. Preparation is not completion evidence.'
+        };
+    }
+    const childEnv = {
+        ...(input.env || {}),
+        SKS_NARUTO_STANDALONE_CLI: '0',
+        SKS_NARUTO_PARENT_LAUNCH: '1',
+        ...(input.missionId ? { SKS_NARUTO_PARENT_MISSION_ID: input.missionId } : {})
+    };
+    const parentSummaryFile = path.join(os.tmpdir(), `sks-naruto-parent-summary-${process.pid}-${Date.now()}.txt`);
+    const args = buildOfficialSubagentCodexArgs({
+        prompt: input.prompt,
+        maxThreads: input.maxThreads,
+        parentSummaryFile
+    });
+    const toolOutputRecovery = await inspectCodexLbCliLaunchRecovery({
+        root: input.root,
+        env: { ...process.env, ...childEnv },
+        cliArgs: args.slice(0, -1)
+    });
+    if (!toolOutputRecovery.ok) {
+        return {
+            ...base,
+            ok: false,
+            status: 'tool_output_recovery_blocked',
+            prepared: false,
+            codex_exit_code: null,
+            parent_summary: null,
+            parent_summary_file: null,
+            tool_output_recovery: toolOutputRecovery,
+            blockers: toolOutputRecovery.blockers,
+            operator_actions: toolOutputRecovery.operator_actions,
+            completion_evidence: false
+        };
+    }
+    await fsp.mkdir(path.dirname(parentSummaryFile), { recursive: true });
+    const execute = input.runProcessImpl || runProcess;
+    let processResult;
+    try {
+        processResult = await execute(input.codexBin || 'codex', args, {
+            cwd: input.root,
+            timeoutMs: input.timeoutMs || 60 * 60 * 1000,
+            maxOutputBytes: 256 * 1024,
+            env: childEnv
+        });
+    }
+    catch (error) {
+        processResult = {
+            code: -1,
+            stdout: '',
+            stderr: String(error?.message || error),
+            stdoutBytes: 0,
+            stderrBytes: 0,
+            truncated: false,
+            timedOut: false
+        };
+    }
+    const parentSummary = await fsp.readFile(parentSummaryFile, 'utf8').catch(() => '');
+    await fsp.rm(parentSummaryFile, { force: true }).catch(() => undefined);
+    return {
+        ...base,
+        ok: processResult.code === 0,
+        status: processResult.code === 0 ? 'parent_completed' : 'parent_failed',
+        codex_exit_code: processResult.code,
+        parent_summary: parentSummary.trim() || null,
+        parent_summary_file: null,
+        tool_output_recovery: toolOutputRecovery,
+        process: {
+            pid: processResult.pid || null,
+            timed_out: processResult.timedOut,
+            stdout_tail: processResult.stdout,
+            stderr_tail: processResult.stderr,
+            output_truncated: processResult.truncated
+        },
+        completion_evidence: false
+    };
+}
+//# sourceMappingURL=official-subagent-runner.js.map