sneakoscope 7.3.0 → 7.6.0

package/dist/core/commands/naruto-command.js

@@ -1,10 +1,13 @@
 import path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
 import { ui as cliUi } from '../../cli/cli-theme.js';
 import { createMission, findLatestMission, getOrCreateExplicitNarutoMission, getOrCreateSessionMission, loadStateForSession, loadMission, sessionStateKey, setCurrent, updateCurrentIfMissionAndRun } from '../mission.js';
 import { closeWorkOrderLedgerForRouteResult, createAndWriteWorkOrderLedgerForPrompt } from '../work-order-ledger.js';
 import { appendJsonl, exists, nowIso, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
-import { SUBAGENT_EVENT_LOG_FILENAME, SUBAGENT_PARENT_SUMMARY_FILENAME, bindTrustworthySubagentParentSummaryToRun, persistOrReuseTrustworthySubagentParentSummary, readSubagentEvents, writeSubagentEvidence } from '../subagents/subagent-evidence.js';
+import { SUBAGENT_EVENT_LOG_FILENAME, SUBAGENT_EVIDENCE_FILENAME, SUBAGENT_PARENT_SUMMARY_FILENAME, bindTrustworthySubagentParentSummaryToRun, normalizeSubagentParentSummary, persistOrReuseTrustworthySubagentParentSummary, readSubagentEvents, writeSubagentEvidence } from '../subagents/subagent-evidence.js';
 import { buildNarutoHelpResult } from '../subagents/naruto-help-contract.js';
+import { resolveNarutoCredentialPolicy } from '../subagents/naruto-host-credentials.js';
+import { DEFAULT_SUBAGENT_EFFORT, DEFAULT_SUBAGENT_MODEL, NARUTO_PARENT_EFFORT, NARUTO_PARENT_MODEL } from '../subagents/model-policy.js';
 import { buildNarutoProofProjection } from '../subagents/naruto-proof-projection.js';
 import { withFileLock } from '../locks/file-lock.js';
 import { codexAppSessionKey, detectCodexAppSession, runOfficialSubagentWorkflow } from '../subagents/official-subagent-runner.js';
@@ -14,7 +17,9 @@ import { effectiveSubagentTarget, refreshSubagentWaveLifecycle } from '../subage
 import { HOST_CAPABILITY_HOOK_RUNTIME_FILENAME, bindParentSummaryToHostCapabilityEvidence, createHostCapabilityHookRuntimeBinding, resolveHostCapabilityHookRuntimeBinding } from '../agent-bridge/host-capability-runtime.js';
 import { renderHostCapabilityBlockedLines } from '../agent-bridge/host-capability-policy.js';
 import { uniqueStrings } from '../text/strings.js';
+import { completeNarutoTerminalBundle, refreshOfficialSubagentCompletionArtifacts } from '../hooks-runtime/official-subagent-lifecycle.js';
 export { buildNarutoGateResult } from '../subagents/official-subagent-preparation.js';
+const MAX_PARENT_SUMMARY_STDIN_BYTES = 1024 * 1024;
 let nextNarutoPreparationFailureInjectionForTest = null;
 export function injectNextNarutoPreparationFailureForTest(value) {
     nextNarutoPreparationFailureInjectionForTest = value;
@@ -24,6 +29,23 @@ export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
     if (args.some((arg) => arg === '--glm' || arg.startsWith('--glm=')))
         return blockGlmOverride(args.includes('--json'));
     const parsed = parseNarutoArgs(args);
+    const credentialPolicy = parsed.credentialPolicy;
+    if (credentialPolicy.blockers.length) {
+        const blocked = {
+            schema: 'sks.naruto-credential-policy.v1',
+            ok: false,
+            blockers: credentialPolicy.blockers,
+            hint: 'sks naruto run --auth-mode=host --model-provider=<config.toml provider block> --provider-env-key=<ENV NAME>'
+        };
+        if (args.includes('--json'))
+            console.log(JSON.stringify(blocked, null, 2));
+        else {
+            console.error(`Naruto credential policy blocked: ${credentialPolicy.blockers.join(', ')}`);
+            console.error(blocked.hint);
+        }
+        process.exitCode = 2;
+        return null;
+    }
     if (parsed.argumentErrors.length) {
         const result = argumentBlock(parsed.argumentErrors);
         return emit(parsed, result, () => {
@@ -41,8 +63,197 @@ export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
         return narutoSubagents(parsed);
     if (parsed.action === 'proof')
         return narutoProof(parsed);
+    if (parsed.action === 'parent-summary')
+        return narutoParentSummary(parsed);
     return narutoRun(parsed);
 }
+async function narutoParentSummary(parsed) {
+    const root = await sksRoot();
+    const appSession = detectCodexAppSession();
+    const sessionKey = appSession ? codexAppSessionKey() : null;
+    if (!appSession || !sessionKey) {
+        return blockedParentSummary(parsed, ['naruto_parent_summary_app_session_required']);
+    }
+    return withFileLock({
+        lockPath: path.join(root, '.sneakoscope', 'state', `naruto-session-${sessionStateKey(sessionKey)}.lock`),
+        timeoutMs: 20_000,
+        staleMs: 120_000
+    }, () => narutoParentSummaryTransaction(parsed, root, sessionKey));
+}
+async function narutoParentSummaryTransaction(parsed, root, sessionKey) {
+    const state = await loadStateForSession(root, sessionKey).catch(() => null);
+    const route = String(state?.route || state?.route_command || state?.mode || '')
+        .replace(/^\$/, '')
+        .replace(/[-_]/g, '')
+        .toUpperCase();
+    const officialSubagentRoute = route === 'NARUTO'
+        || (state?.subagents_required === true
+            && typeof state?.official_subagent_run_id === 'string'
+            && state.official_subagent_run_id.trim().length > 0);
+    const stateBlockers = uniqueStrings([
+        ...(state?._session_key === sessionStateKey(sessionKey) ? [] : ['naruto_parent_summary_session_state_mismatch']),
+        ...(state?.session_scope === sessionKey ? [] : ['naruto_parent_summary_session_scope_mismatch']),
+        ...(state?.mission_id === parsed.missionId ? [] : ['naruto_parent_summary_active_mission_mismatch']),
+        ...(officialSubagentRoute ? [] : ['naruto_parent_summary_active_route_mismatch']),
+        ...(state?.route_closed === true ? ['naruto_parent_summary_route_closed'] : [])
+    ]);
+    if (stateBlockers.length > 0)
+        return blockedParentSummary(parsed, stateBlockers);
+    const loaded = await loadMission(root, parsed.missionId).catch(() => null);
+    if (!loaded)
+        return blockedParentSummary(parsed, [`naruto_parent_summary_mission_not_found:${parsed.missionId}`]);
+    const plan = await readJson(path.join(loaded.dir, SUBAGENT_PLAN_FILENAME), null).catch(() => null);
+    const workflowRunId = String(plan?.workflow_run_id || '').trim();
+    const planBlockers = uniqueStrings([
+        ...(plan?.schema === 'sks.subagent-plan.v1' ? [] : ['naruto_parent_summary_plan_schema_invalid']),
+        ...(plan?.workflow === 'official_codex_subagent' ? [] : ['naruto_parent_summary_plan_workflow_invalid']),
+        ...(plan?.mission_id === parsed.missionId ? [] : ['naruto_parent_summary_plan_mission_mismatch']),
+        ...(plan?.session_scope === sessionKey ? [] : ['naruto_parent_summary_plan_session_scope_mismatch']),
+        ...(workflowRunId ? [] : ['naruto_parent_summary_plan_run_id_missing']),
+        ...(workflowRunId && state?.official_subagent_run_id === workflowRunId
+            ? []
+            : ['naruto_parent_summary_active_run_mismatch'])
+    ]);
+    if (planBlockers.length > 0)
+        return blockedParentSummary(parsed, planBlockers);
+    const stdin = await readBoundedParentSummaryStdin();
+    if (!stdin.ok)
+        return blockedParentSummary(parsed, [stdin.blocker]);
+    const raw = stdin.value;
+    let submitted;
+    try {
+        submitted = JSON.parse(raw);
+    }
+    catch {
+        return blockedParentSummary(parsed, ['naruto_parent_summary_stdin_json_invalid']);
+    }
+    if (!submitted || typeof submitted !== 'object' || Array.isArray(submitted)) {
+        return blockedParentSummary(parsed, ['naruto_parent_summary_stdin_object_required']);
+    }
+    const normalized = normalizeSubagentParentSummary(submitted);
+    const summaryBlockers = uniqueStrings([
+        ...(normalized.trustworthy && normalized.raw ? [] : normalized.blockers.length
+            ? normalized.blockers.map((blocker) => `naruto_parent_summary_schema:${blocker}`)
+            : ['naruto_parent_summary_schema_invalid']),
+        ...(!normalized.run_id
+            ? ['naruto_parent_summary_run_id_missing']
+            : normalized.run_id === workflowRunId
+                ? []
+                : ['naruto_parent_summary_run_id_mismatch'])
+    ]);
+    if (summaryBlockers.length > 0)
+        return blockedParentSummary(parsed, summaryBlockers);
+    const submittedSummary = normalized.raw;
+    if (!submittedSummary)
+        return blockedParentSummary(parsed, ['naruto_parent_summary_schema_invalid']);
+    const existing = await readJson(path.join(loaded.dir, SUBAGENT_PARENT_SUMMARY_FILENAME), null).catch(() => null);
+    if (existing !== null) {
+        const normalizedExisting = normalizeSubagentParentSummary(existing);
+        const [existingGate, existingSummary, existingEvidence] = await Promise.all([
+            readJson(path.join(loaded.dir, NARUTO_GATE_FILENAME), null).catch(() => null),
+            readJson(path.join(loaded.dir, NARUTO_SUMMARY_FILENAME), null).catch(() => null),
+            readJson(path.join(loaded.dir, SUBAGENT_EVIDENCE_FILENAME), null).catch(() => null)
+        ]);
+        const terminal = completeNarutoTerminalBundle({
+            workflowRunId,
+            gate: existingGate,
+            summary: existingSummary,
+            evidence: existingEvidence,
+            parentSummary: existing
+        });
+        if (terminal) {
+            if (!normalizedExisting.trustworthy || !normalizedExisting.raw) {
+                return blockedParentSummary(parsed, ['naruto_parent_summary_existing_canonical_invalid']);
+            }
+            if (normalizedExisting.run_id !== workflowRunId) {
+                return blockedParentSummary(parsed, ['naruto_parent_summary_existing_run_id_mismatch']);
+            }
+            if (!sameParentAuthoredSummary(normalizedExisting.raw, submittedSummary)) {
+                return blockedParentSummary(parsed, ['naruto_parent_summary_conflicts_with_canonical']);
+            }
+        }
+    }
+    const evidence = await refreshOfficialSubagentCompletionArtifacts(root, state, submittedSummary, sessionKey);
+    if (!evidence)
+        return blockedParentSummary(parsed, ['naruto_parent_summary_lifecycle_commit_rejected']);
+    const [persisted, summary, gate] = await Promise.all([
+        readJson(path.join(loaded.dir, SUBAGENT_PARENT_SUMMARY_FILENAME), null).catch(() => null),
+        readJson(path.join(loaded.dir, NARUTO_SUMMARY_FILENAME), null).catch(() => null),
+        readJson(path.join(loaded.dir, NARUTO_GATE_FILENAME), null).catch(() => null)
+    ]);
+    const normalizedPersisted = normalizeSubagentParentSummary(persisted);
+    if (!normalizedPersisted.trustworthy
+        || normalizedPersisted.run_id !== workflowRunId
+        || !sameParentAuthoredSummary(normalizedPersisted.raw, submittedSummary)) {
+        return blockedParentSummary(parsed, ['naruto_parent_summary_canonical_commit_mismatch']);
+    }
+    const hardBlocked = normalizedPersisted.status === 'failed';
+    const completionEvidence = route === 'NARUTO'
+        ? gate?.passed === true
+        : evidence?.ok === true;
+    const completionBlockers = route === 'NARUTO'
+        ? (Array.isArray(gate?.blockers) ? gate.blockers : [])
+        : (Array.isArray(evidence?.blockers) ? evidence.blockers : []);
+    const accepted = completionEvidence || hardBlocked;
+    const result = {
+        schema: NARUTO_RESULT_SCHEMA,
+        action: 'parent-summary',
+        ok: completionEvidence,
+        accepted,
+        status: route === 'NARUTO'
+            ? summary?.status || evidence?.status || normalizedPersisted.status || 'incomplete'
+            : evidence?.status || normalizedPersisted.status || 'incomplete',
+        mission_id: parsed.missionId,
+        workflow_run_id: workflowRunId,
+        parent_summary_status: normalizedPersisted.status,
+        completion_evidence: completionEvidence,
+        blockers: completionBlockers,
+        artifacts: narutoArtifactLinks(evidence)
+    };
+    return emit(parsed, result, () => renderParentSummaryResult(result), result.ok !== true);
+}
+async function readBoundedParentSummaryStdin() {
+    let value = '';
+    let bytes = 0;
+    process.stdin.setEncoding('utf8');
+    for await (const chunk of process.stdin) {
+        const text = String(chunk);
+        bytes += Buffer.byteLength(text, 'utf8');
+        if (bytes > MAX_PARENT_SUMMARY_STDIN_BYTES) {
+            return { ok: false, blocker: `naruto_parent_summary_stdin_too_large:${MAX_PARENT_SUMMARY_STDIN_BYTES}` };
+        }
+        value += text;
+    }
+    if (!value.trim())
+        return { ok: false, blocker: 'naruto_parent_summary_stdin_empty' };
+    return { ok: true, value };
+}
+function sameParentAuthoredSummary(left, right) {
+    if (!left || typeof left !== 'object' || Array.isArray(left))
+        return false;
+    if (!right || typeof right !== 'object' || Array.isArray(right))
+        return false;
+    const omitHostReceipts = (value) => {
+        const { artifacts: _artifacts, capabilities_used: _capabilitiesUsed, ...authored } = value;
+        return authored;
+    };
+    return isDeepStrictEqual(omitHostReceipts(left), omitHostReceipts(right));
+}
+function blockedParentSummary(parsed, blockers) {
+    const result = {
+        schema: NARUTO_RESULT_SCHEMA,
+        action: 'parent-summary',
+        ok: false,
+        accepted: false,
+        status: 'blocked',
+        mission_id: parsed.missionId || null,
+        blockers: uniqueStrings(blockers)
+    };
+    return emit(parsed, result, () => {
+        for (const line of renderNarutoBlockedLines(result.blockers))
+            console.error(line);
+    }, true);
+}
 async function narutoRun(parsed) {
     const root = await sksRoot();
     const appSession = detectCodexAppSession();
@@ -152,6 +363,7 @@ async function narutoRunTransaction(parsed, root, appSession, sessionKey, resolv
         missionId: id,
         workflowRunId,
         sessionKey,
+        credentialPolicy: parsed.credentialPolicy,
         ...(missionLease ? { onChildSpawn: missionLease.protectChildPid } : {})
     });
     const result = await withOfficialSubagentLifecycleLock(dir, async () => {
@@ -482,6 +694,7 @@ function narutoHelp(parsed) {
         console.log(`Nesting: max_depth=${result.max_depth}; Naruto children must not spawn children`);
         console.log('Context: bounded TriWiki attention.use_first anchors with on-demand source hydration');
         console.log('Evidence: SubagentStop is lifecycle-only; completion requires subagent-parent-summary.json with one structured outcome per Naruto child thread.');
+        console.log('Codex App finalization: submit the structured object with parent-summary --mission <id> --stdin, then return localized Markdown without exposing JSON.');
     });
 }
 async function resolveRunMission(root, parsed, sessionKey = null) {
@@ -541,7 +754,7 @@ export function parseNarutoArgs(args) {
         : args;
     const first = normalized[0] && !normalized[0].startsWith('-') ? normalized[0] : '';
     const actionName = first;
-    const actions = new Set(['run', 'status', 'subagents', 'proof', 'help']);
+    const actions = new Set(['run', 'status', 'subagents', 'proof', 'parent-summary', 'help']);
     const action = (actions.has(actionName) ? actionName : 'run');
     const explicitAction = actions.has(actionName);
     const rest = explicitAction ? normalized.slice(1) : normalized;
@@ -571,7 +784,7 @@ export function parseNarutoArgs(args) {
         ? positional.join(' ').trim()
         : '';
     const positionalHead = String(positional[0] || '').toLowerCase();
-    const subcommandNames = new Set(['run', 'status', 'subagents', 'proof', 'help']);
+    const subcommandNames = new Set(['run', 'status', 'subagents', 'proof', 'parent-summary', 'help']);
     if (!first && !explicitAction && positionalHead && !subcommandNames.has(positionalHead)) {
         argumentErrors.push(`unknown_subcommand:${positionalHead}`);
     }
@@ -599,6 +812,22 @@ export function parseNarutoArgs(args) {
     }
     if (action === 'run' && !prompt)
         argumentErrors.push('empty_task');
+    if (action === 'parent-summary') {
+        if (!missionOption.present || !missionOption.value || missionOption.value === 'latest') {
+            argumentErrors.push('parent_summary_requires_explicit_mission');
+        }
+        if (missionIdOption.present)
+            argumentErrors.push('parent_summary_mission_id_alias_not_supported');
+        if (!normalized.includes('--stdin'))
+            argumentErrors.push('parent_summary_requires_stdin');
+        if (agentsOption.present || maxThreadsOption.present || normalized.includes('--readonly')
+            || normalized.includes('--read-only') || normalized.includes('--trusted-project')) {
+            argumentErrors.push('parent_summary_unsupported_run_option');
+        }
+    }
+    else if (normalized.includes('--stdin')) {
+        argumentErrors.push('stdin_only_supported_for_parent_summary');
+    }
     return {
         action,
         prompt,
@@ -606,17 +835,28 @@ export function parseNarutoArgs(args) {
         maxThreads,
         missionId: String(missionFlag || positionalMission || 'latest'),
         json: normalized.includes('--json'),
+        stdin: normalized.includes('--stdin'),
         readOnly: normalized.includes('--readonly') || normalized.includes('--read-only'),
         trustedProject: optionArgs.includes('--trusted-project'),
-        argumentErrors: uniqueStrings(argumentErrors)
+        argumentErrors: uniqueStrings(argumentErrors),
+        credentialPolicy: resolveNarutoCredentialPolicy({
+            args: optionArgs,
+            env: process.env,
+            defaultParentModel: NARUTO_PARENT_MODEL,
+            defaultParentEffort: NARUTO_PARENT_EFFORT,
+            defaultSubagentModel: DEFAULT_SUBAGENT_MODEL,
+            defaultSubagentEffort: DEFAULT_SUBAGENT_EFFORT
+        })
     };
 }
 function positionalValues(args) {
     const valueFlags = new Set([
-        '--agents', '--max-threads', '--mission', '--mission-id'
+        '--agents', '--max-threads', '--mission', '--mission-id',
+        '--auth-mode', '--model-provider', '--provider-env-key',
+        '--parent-model', '--parent-effort', '--subagent-model', '--subagent-effort'
     ]);
     const booleanFlags = new Set([
-        '--json', '--readonly', '--read-only', '--trusted-project'
+        '--json', '--stdin', '--readonly', '--read-only', '--trusted-project', '--no-forced-login-method'
     ]);
     const result = [];
     for (let index = 0; index < args.length; index += 1) {
@@ -679,7 +919,7 @@ function optionErrors(name, option, numeric) {
 function unknownOptionErrors(args) {
     const canonical = new Set([
         '--agents', '--max-threads', '--mission', '--mission-id',
-        '--json', '--readonly', '--read-only', '--trusted-project', '--help', '-h', '--'
+        '--json', '--stdin', '--readonly', '--read-only', '--trusted-project', '--help', '-h', '--'
     ]);
     const errors = [];
     const optionArgs = args.includes('--') ? args.slice(0, args.indexOf('--')) : args;
@@ -693,7 +933,7 @@ function unknownOptionErrors(args) {
     return errors;
 }
 function booleanOptionErrors(args) {
-    const booleanNames = new Set(['--json', '--readonly', '--read-only', '--trusted-project', '--help', '-h']);
+    const booleanNames = new Set(['--json', '--stdin', '--readonly', '--read-only', '--trusted-project', '--no-forced-login-method', '--help', '-h']);
     const optionArgs = args.includes('--') ? args.slice(0, args.indexOf('--')) : args;
     const errors = [];
     for (const arg of optionArgs) {
@@ -785,6 +1025,15 @@ function renderRunResult(result) {
     if (result.status === 'delegation_context_ready')
         console.log('Continue in the current Naruto parent and wait for every requested child before summarizing.');
 }
+function renderParentSummaryResult(result) {
+    if (result.ok !== true) {
+        for (const line of renderNarutoBlockedLines(result.blockers || []))
+            console.log(line);
+        return;
+    }
+    console.log(`$sks-naruto parent summary committed: ${result.mission_id}`);
+    console.log(`Workflow run: ${result.workflow_run_id}`);
+}
 function renderStatusResult(result) {
     if (['blocked', 'incomplete'].includes(result.status) && Array.isArray(result.blockers) && result.blockers.length) {
         for (const line of renderNarutoBlockedLines(result.blockers))

package/dist/core/commands/ppt-command.js

@@ -47,7 +47,7 @@ export async function pptCommand(command, args = []) {
                 process.exitCode = 1;
                 if (flag(args, '--json'))
                     return printJson(result);
-                console.error('PPT build blocked: Codex App imagegen/gpt-image-2 is unavailable.');
+                console.error('PPT build blocked: no selected Codex imagegen/gpt-image-2 provider is ready.');
                 for (const action of imagegenRequired.blocker?.next_actions || [])
                     console.error(`- ${action}`);
                 return result;
@@ -159,7 +159,7 @@ async function pptImagegenReview(root, command, action, args = []) {
             process.exitCode = 1;
             if (flag(args, '--json'))
                 return printJson(result);
-            console.error('PPT imagegen review blocked: Codex App imagegen/gpt-image-2 is unavailable.');
+            console.error('PPT imagegen review blocked: no selected Codex imagegen/gpt-image-2 provider is ready.');
             for (const action of imagegenRequired.blocker?.next_actions || [])
                 console.error(`- ${action}`);
             return result;