sneakoscope 6.2.0 → 6.4.0

package/dist/core/proof/runtime-truth-matrix.js

@@ -1,10 +1,10 @@
 import path from 'node:path';
 import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
-export const RUNTIME_TRUTH_MATRIX_SCHEMA = 'sks.runtime-truth-matrix.v1';
+import { OFFICIAL_SUBAGENT_EXECUTION_ARTIFACTS, OFFICIAL_SUBAGENT_EXECUTION_AUTHORITY, evaluateOfficialSubagentExecutionProof } from './fake-real-proof-policy.js';
+export const RUNTIME_TRUTH_MATRIX_SCHEMA = 'sks.runtime-truth-matrix.v2';
 export const RUNTIME_TRUTH_SUBSYSTEMS = [
+    'official_codex_subagent',
     'zellij_pane',
-    'codex_dynamic',
-    'codex_patch_envelope_smoke',
     'cleanup',
     'intelligent_work_graph',
     'source_intelligence',
@@ -20,13 +20,7 @@ export const RUNTIME_TRUTH_SUBSYSTEMS = [
     'appshots',
     'parallel_write',
     'patch_proof',
-    'native_cli_session_swarm',
-    'real_codex_parallel_workers',
     'native_worker_backend_router',
-    'codex_child_overlap',
-    'model_authored_patch_envelopes',
-    'fast_mode_child_propagation',
-    'fast_mode_default',
     'cleanup_v4',
     'ast_type_work_graph',
     'warp_mad_right_lanes'
@@ -50,22 +44,14 @@ export async function buildRuntimeTruthMatrix(input) {
         }
         return null;
     };
-    const required = {
-        zellij_pane: process.env.SKS_REQUIRE_ZELLIJ === '1',
-        codex_dynamic: process.env.SKS_REQUIRE_REAL_DYNAMIC_AGENTS === '1',
-        codex_patch_envelope_smoke: process.env.SKS_REQUIRE_REAL_CODEX_PATCHES === '1',
-        real_codex_parallel_workers: process.env.SKS_REQUIRE_REAL_CODEX_PARALLEL === '1',
-        warp_mad_lanes: process.env.SKS_REQUIRE_WARP_MAD_LANES === '1',
-        ...(input.required || {})
-    };
-    const [zellijPane, codex, codexPatch, realCodexParallel, workerBackendRouter, codexChildOverlap, modelAuthoredPatch, zellijRightLanePhysical, zellijRightLaneCoordinate, zellijRightLaneContent, madWarpRightLaneAttach, cleanup, workGraph, fakeReal, sourceIntel, goalMode, scheduler, warpMad, codex0136, codex0134, mcp0134, mcpReadonlyRuntime, adhdOrchestration, appshots, parallelWrite, patchProof, nativeCliSession, fastModeDefault] = await Promise.all([
+    const required = { ...(input.required || {}) };
+    const [subagentPlan, subagentEvidence, narutoSummary, narutoGate, zellijPane, workerBackendRouter, zellijRightLanePhysical, zellijRightLaneCoordinate, zellijRightLaneContent, madWarpRightLaneAttach, cleanup, workGraph, fakeReal, sourceIntel, goalMode, scheduler, warpMad, codex0136, codex0134, mcp0134, mcpReadonlyRuntime, adhdOrchestration, appshots, parallelWrite, patchProof] = await Promise.all([
+        readReport('subagent-plan.json'),
+        readReport('subagent-evidence.json'),
+        readReport('naruto-summary.json'),
+        readReport('naruto-gate.json'),
         readReport('zellij-pane-proof.json'),
-        readReport(`agent-real-codex-dynamic-smoke-${input.releaseVersion}.json`, ['agent-real-codex-dynamic-smoke-1.18.6.json']),
-        readReport('agent-real-codex-patch-envelope-smoke.json'),
-        readReport('agent-real-codex-parallel-workers.json', ['real-codex-parallel-proof.json']),
-        readReport('agent-worker-backend-router.json'),
-        readReport('agent-codex-child-overlap.json'),
-        readReport('agent-model-authored-patch-envelope.json'),
+        readReport('agent-worker-backend-router.json', ['worker-backend-router-report.json']),
         readReport('zellij-layout-proof.json'),
         readReport('zellij-coordinate-proof.json'),
         readReport('zellij-content-proof.json'),
@@ -84,39 +70,38 @@ export async function buildRuntimeTruthMatrix(input) {
         readReport('strategy-gate.json', ['strategy-adhd-orchestrating-gate.json', 'adhd-orchestrating-gate.json']),
         readReport('appshots-evidence.json'),
         readReport('agent-parallel-write-kernel.json'),
-        readReport('agent-patch-proof.json'),
-        readReport('native-cli-session-proof.json', ['agent-native-cli-session-swarm.json']),
-        readReport('fast-mode-propagation-proof.json')
+        readReport('agent-patch-proof.json')
     ]);
+    const official = evaluateOfficialSubagentExecutionProof({
+        subagent_plan: subagentPlan,
+        subagent_evidence: subagentEvidence,
+        naruto_summary: narutoSummary,
+        naruto_gate: narutoGate
+    }, {
+        required: required.official_codex_subagent === true
+    });
     const rows = [
-        row('zellij_pane', levelFromOk(zellijPane, required.zellij_pane === true ? 'real_required_missing' : 'integration_optional'), ['zellij-pane-proof.json'], required.zellij_pane === true, zellijPane, 'run `SKS_REQUIRE_ZELLIJ=1 npm run zellij:pane-proof`'),
-        row('codex_dynamic', levelFromCodex(codex, required.codex_dynamic === true), ['agent-real-codex-dynamic-smoke'], required.codex_dynamic === true, codex, 'run `SKS_TEST_REAL_DYNAMIC_AGENTS=1 npm run agent:real-codex-dynamic-smoke-v2`'),
-        row('codex_patch_envelope_smoke', levelFromCodex(codexPatch, required.codex_patch_envelope_smoke === true), ['agent-real-codex-patch-envelope-smoke.json'], required.codex_patch_envelope_smoke === true, codexPatch, 'run `SKS_TEST_REAL_CODEX_PATCHES=1 npm run agent:real-codex-patch-envelope-smoke`'),
-        row('cleanup', levelFromOk(cleanup, 'integration_optional'), ['agent-cleanup-proof.json'], false, cleanup, 'run `npm run agent:cleanup-executor-v2`'),
-        row('intelligent_work_graph', levelFromWorkGraph(workGraph || fakeReal), ['agent-intelligent-work-graph-v2.json', 'agent-symbol-ownership-map.json'], false, workGraph, 'run `npm run agent:ast-aware-work-graph`'),
+        row('official_codex_subagent', official.proof_level, official.evidence_artifacts, official.required_mode, { blockers: official.blockers }, official.next_action, 'execution_authority'),
+        row('zellij_pane', levelFromOk(zellijPane, required.zellij_pane === true ? 'real_required_missing' : 'integration_optional'), ['zellij-pane-proof.json'], required.zellij_pane === true, zellijPane, 'capture current Zellij pane evidence'),
+        row('cleanup', levelFromOk(cleanup, 'integration_optional'), ['agent-cleanup-proof.json'], false, cleanup, 'run the managed cleanup verification'),
+        row('intelligent_work_graph', levelFromWorkGraph(workGraph || fakeReal), ['agent-intelligent-work-graph-v2.json', 'agent-symbol-ownership-map.json'], false, workGraph, 'run AST-aware work-graph verification'),
         row('source_intelligence', sourceIntel?.ok === true ? 'proven' : 'integration_optional', ['source-intelligence-evidence.json'], false, sourceIntel, 'refresh source intelligence evidence'),
         row('goal_mode', goalMode?.ok === true ? 'proven' : 'integration_optional', ['goal-mode-applied.json'], false, goalMode, 'record official goal mode evidence'),
-        row('route_blackbox', fakeReal?.subsystem_levels?.route_blackbox || 'integration_optional', ['fake-real-proof-policy.json', 'agent-proof-evidence.json'], false, fakeReal, 'run actual route blackbox proof'),
-        row('dynamic_scheduler', scheduler?.pending_queue_drained === true || scheduler?.ok === true ? 'proven' : 'integration_optional', ['agent-scheduler-state.json'], false, scheduler, 'run dynamic scheduler proof gate'),
-        row('warp_mad_lanes', levelFromWarp(warpMad || madWarpRightLaneAttach || zellijRightLanePhysical, required.warp_mad_lanes === true), ['zellij-session.json', 'zellij-pane-proof.json'], required.warp_mad_lanes === true, warpMad || madWarpRightLaneAttach || zellijRightLanePhysical, 'run `sks --mad` with Zellij and capture visible lane proof'),
+        row('route_blackbox', fakeReal?.subsystem_levels?.route_blackbox || (official.proof_level === 'proven' ? 'proven' : 'integration_optional'), ['subagent-evidence.json', 'naruto-gate.json', 'fake-real-proof-policy.json'], false, fakeReal, official.next_action),
+        row('dynamic_scheduler', scheduler?.pending_queue_drained === true || scheduler?.ok === true ? 'proven' : 'integration_optional', ['agent-scheduler-state.json'], false, scheduler, 'record scheduler drain evidence'),
+        row('warp_mad_lanes', levelFromWarp(warpMad || madWarpRightLaneAttach || zellijRightLanePhysical, required.warp_mad_lanes === true), ['zellij-session.json', 'zellij-pane-proof.json'], required.warp_mad_lanes === true, warpMad || madWarpRightLaneAttach || zellijRightLanePhysical, 'capture visible MAD Zellij lane evidence'),
         row('codex_0_136', levelFromOk(codex0136, 'integration_optional'), ['codex-0.136-compat.json'], false, codex0136, 'run `npm run codex:0.136-compat`'),
         row('codex_0_134', levelFromOk(codex0134, 'integration_optional'), ['codex-0-134-official-compat.json'], false, codex0134, 'run `npm run codex:0.134-official-compat`'),
         row('mcp_0_134', levelFromOk(mcp0134, 'integration_optional'), ['mcp-0-134-modernization.json'], false, mcp0134, 'run `npm run mcp:0.134-modernization`'),
         row('mcp_readonly_runtime_scheduler', levelFromOk(mcpReadonlyRuntime, 'integration_optional'), ['mcp-readonly-runtime-scheduler.json'], false, mcpReadonlyRuntime, 'run `npm run mcp:readonly-runtime-scheduler`'),
         row('adhd_orchestration', levelFromOk(adhdOrchestration, 'integration_optional'), ['strategy-gate.json', 'adhd-orchestrating-gate.json'], false, adhdOrchestration, 'run `npm run strategy:adhd-orchestrating-gate`'),
         row('appshots', levelFromAppshots(appshots), ['appshots-evidence.json'], false, appshots, 'run `npm run appshots:evidence`'),
-        row('parallel_write', levelFromOk(parallelWrite, 'integration_optional'), ['agent-parallel-write-kernel.json'], false, parallelWrite, 'run `npm run agent:parallel-write-kernel`'),
-        row('patch_proof', levelFromOk(patchProof, 'integration_optional'), ['agent-patch-proof.json'], false, patchProof, 'run `npm run agent:patch-proof`'),
-        row('native_cli_session_swarm', levelFromOk(nativeCliSession, 'integration_optional'), ['native-cli-session-proof.json', 'agent-native-cli-session-swarm.json'], false, nativeCliSession, 'run `npm run agent:native-cli-session-swarm-20`'),
-        row('real_codex_parallel_workers', levelFromCodex(realCodexParallel, required.real_codex_parallel_workers === true), ['real-codex-parallel-proof.json', 'agent-real-codex-parallel-workers.json'], required.real_codex_parallel_workers === true, realCodexParallel, 'run `SKS_TEST_REAL_CODEX_PARALLEL=1 npm run agent:real-codex-parallel-workers`'),
-        row('native_worker_backend_router', levelFromOk(workerBackendRouter, 'integration_optional'), ['agent-worker-backend-router.json', 'worker-backend-router-report.json'], false, workerBackendRouter, 'run `npm run agent:worker-backend-router`'),
-        row('codex_child_overlap', levelFromOk(codexChildOverlap || realCodexParallel, 'integration_optional'), ['agent-codex-child-overlap.json', 'real-codex-parallel-proof.json'], required.real_codex_parallel_workers === true, codexChildOverlap || realCodexParallel, 'run `npm run agent:codex-child-overlap`'),
-        row('model_authored_patch_envelopes', levelFromOk(modelAuthoredPatch || realCodexParallel, 'integration_optional'), ['agent-model-authored-patch-envelope.json', 'real-codex-parallel-proof.json'], required.real_codex_parallel_workers === true, modelAuthoredPatch || realCodexParallel, 'run `npm run agent:model-authored-patch-envelope`'),
-        row('fast_mode_child_propagation', levelFromOk(realCodexParallel || fastModeDefault, 'integration_optional'), ['real-codex-parallel-proof.json', 'fast-mode-propagation-proof.json'], false, realCodexParallel || fastModeDefault, 'run `npm run agent:fast-mode-worker-propagation`'),
-        row('fast_mode_default', levelFromOk(fastModeDefault, 'integration_optional'), ['fast-mode-propagation-proof.json'], false, fastModeDefault, 'run `npm run agent:fast-mode-default`'),
-        row('cleanup_v4', levelFromOk(cleanup, 'integration_optional'), ['agent-cleanup-proof.json'], false, cleanup, 'run `npm run agent:cleanup-executor-v2`'),
-        row('ast_type_work_graph', levelFromWorkGraph(workGraph || fakeReal), ['agent-intelligent-work-graph-v2.json', 'agent-symbol-ownership-map.json'], false, workGraph, 'run `npm run agent:ast-aware-work-graph`'),
-        row('warp_mad_right_lanes', levelFromWarp(warpMad || madWarpRightLaneAttach || zellijRightLanePhysical || zellijRightLaneCoordinate || zellijRightLaneContent, required.warp_mad_lanes === true), ['zellij-session.json', 'zellij-pane-proof.json'], required.warp_mad_lanes === true, warpMad || madWarpRightLaneAttach || zellijRightLanePhysical || zellijRightLaneCoordinate || zellijRightLaneContent, 'run `sks --mad` with Zellij and capture right-lane proof')
+        row('parallel_write', levelFromOk(parallelWrite, 'integration_optional'), ['agent-parallel-write-kernel.json'], false, parallelWrite, 'run parallel-write kernel verification'),
+        row('patch_proof', levelFromOk(patchProof, 'integration_optional'), ['agent-patch-proof.json'], false, patchProof, 'run patch handoff verification'),
+        row('native_worker_backend_router', levelFromOk(workerBackendRouter, 'integration_optional'), ['agent-worker-backend-router.json', 'worker-backend-router-report.json'], false, workerBackendRouter, 'run current backend-router verification'),
+        row('cleanup_v4', levelFromOk(cleanup, 'integration_optional'), ['agent-cleanup-proof.json'], false, cleanup, 'run the managed cleanup verification'),
+        row('ast_type_work_graph', levelFromWorkGraph(workGraph || fakeReal), ['agent-intelligent-work-graph-v2.json', 'agent-symbol-ownership-map.json'], false, workGraph, 'run AST-aware work-graph verification'),
+        row('warp_mad_right_lanes', levelFromWarp(warpMad || madWarpRightLaneAttach || zellijRightLanePhysical || zellijRightLaneCoordinate || zellijRightLaneContent, required.warp_mad_lanes === true), ['zellij-session.json', 'zellij-pane-proof.json'], required.warp_mad_lanes === true, warpMad || madWarpRightLaneAttach || zellijRightLanePhysical || zellijRightLaneCoordinate || zellijRightLaneContent, 'capture visible MAD Zellij right-lane evidence')
     ];
     const blockers = rows.flatMap((item) => item.required_mode && ['blocked', 'real_required_missing', 'integration_optional'].includes(item.proof_level)
         ? [`required_runtime_truth_missing:${item.subsystem}`, ...item.blockers]
@@ -134,6 +119,12 @@ export async function buildRuntimeTruthMatrix(input) {
         release_version: input.releaseVersion,
         generated_at: nowIso(),
         ok: blockers.length === 0,
+        execution_authority: {
+            workflow: OFFICIAL_SUBAGENT_EXECUTION_AUTHORITY,
+            subsystem: OFFICIAL_SUBAGENT_EXECUTION_AUTHORITY,
+            required_mode_source: 'explicit_input',
+            evidence_artifacts: [...OFFICIAL_SUBAGENT_EXECUTION_ARTIFACTS]
+        },
         proof_levels: ['fixture_only', 'fixture_instrumented_real', 'proven', 'integration_optional', 'real_required_missing', 'partial', 'blocked'],
         rows,
         subsystems: rows,
@@ -148,15 +139,16 @@ export async function writeRuntimeTruthMatrix(root, matrix, opts = {}) {
         await writeJsonAtomic(path.join(opts.agentRoot, 'runtime-truth-matrix.json'), matrix);
     return matrix;
 }
-function row(subsystem, proofLevel, evidenceArtifacts, requiredMode, report, nextAction) {
+function row(subsystem, proofLevel, evidenceArtifacts, requiredMode, report, nextAction, evidenceRole = 'supporting') {
     const blockers = Array.isArray(report?.blockers) ? report.blockers.map(String) : [];
     return {
         subsystem,
         proof_level: proofLevel,
         evidence_artifacts: evidenceArtifacts,
         blockers,
-        next_action: blockers.length ? nextAction : proofLevel === 'integration_optional' ? nextAction : 'no action required',
-        required_mode: requiredMode
+        next_action: blockers.length ? nextAction : proofLevel === 'integration_optional' || proofLevel === 'real_required_missing' ? nextAction : 'no action required',
+        required_mode: requiredMode,
+        evidence_role: evidenceRole
     };
 }
 function levelFromOk(report, missing) {
@@ -174,6 +166,8 @@ function levelFromAppshots(report) {
     if (!report)
         return 'integration_optional';
     const evidence = report.evidence || report;
+    if (evidence.status === 'not_required' || evidence.proof_level === 'not_required')
+        return 'integration_optional';
     if (Array.isArray(evidence.blockers) && evidence.blockers.length > 0)
         return 'blocked';
     if (evidence.ok !== true && report.ok !== true)
@@ -182,27 +176,12 @@ function levelFromAppshots(report) {
         return 'proven';
     if (evidence.proof_level === 'fixture_instrumented_real')
         return 'fixture_instrumented_real';
-    if (evidence.status === 'not_required')
-        return 'integration_optional';
     const sources = Array.isArray(evidence.source_verification) ? evidence.source_verification : [];
     if (sources.length && sources.every((source) => source?.accepted === true)) {
         return sources.some((source) => source?.fixture === true) ? 'fixture_instrumented_real' : 'proven';
     }
     return 'blocked';
 }
-function levelFromCodex(report, required) {
-    if (!report)
-        return required ? 'real_required_missing' : 'integration_optional';
-    if (report.proof_level)
-        return report.proof_level;
-    if (report.fixture_instrumented_real === true || report.status === 'fixture_instrumented_real')
-        return 'fixture_instrumented_real';
-    if (report.status === 'passed' || report.status === 'proven')
-        return 'proven';
-    if (report.status === 'integration_optional')
-        return required ? 'real_required_missing' : 'integration_optional';
-    return required ? 'real_required_missing' : 'blocked';
-}
 function levelFromWorkGraph(report) {
     if (!report)
         return 'integration_optional';
@@ -220,4 +199,3 @@ function levelFromWarp(report, required) {
         return 'proven';
     return required ? 'real_required_missing' : 'blocked';
 }
-//# sourceMappingURL=runtime-truth-matrix.js.map

package/dist/core/proof/selftest-proof-fixtures.js

@@ -1,28 +1,28 @@
 import { writeRouteCompletionProof } from './route-adapter.js';
 const CLAIM_TEXT = {
     hard_blocker: 'Hard blocker unblocks incomplete active gate after repeated identical compliance stops.',
-    team_gate: 'Team selftest fixture reached Completion Proof gate before reflection validation.',
+    route_gate: 'Naruto selftest fixture reached Completion Proof gate before reflection validation.',
     subagent_gate: 'Subagent selftest fixture records Completion Proof after subagent evidence.'
 };
 const DEFAULTS = {
     hard_blocker: {
         artifacts: ['hard-blocker.json', 'compliance-loop-guard.json'],
         gateSource: 'selftest-hard-blocker',
-        unverified: ['selftest fixture does not claim a real Team run completed']
+        unverified: ['selftest fixture does not claim a real Naruto run completed']
     },
-    team_gate: {
-        artifacts: ['team-gate.json', 'team-session-cleanup.json'],
+    route_gate: {
+        artifacts: ['naruto-gate.json', 'subagent-evidence.json'],
         gateSource: 'selftest-route-gate',
-        unverified: ['selftest fixture does not claim a real Team implementation run completed']
+        unverified: ['selftest fixture does not claim a real Naruto implementation run completed']
     },
     subagent_gate: {
-        artifacts: ['team-gate.json', 'team-session-cleanup.json', 'reflection-gate.json'],
+        artifacts: ['naruto-gate.json', 'subagent-evidence.json', 'reflection-gate.json'],
         gateSource: 'selftest-subagent-gate',
         unverified: ['selftest fixture records mocked subagent evidence only']
     }
 };
-export async function writeSelftestRouteProof(root, { missionId, route = '$Team', kind = 'team_gate', artifacts = null, gateSource = null, unverified = null } = {}) {
-    const defaults = DEFAULTS[kind] || DEFAULTS.team_gate;
+export async function writeSelftestRouteProof(root, { missionId, route = '$Naruto', kind = 'route_gate', artifacts = null, gateSource = null, unverified = null } = {}) {
+    const defaults = DEFAULTS[kind] || DEFAULTS.route_gate;
     return writeRouteCompletionProof(root, {
         missionId,
         route,
@@ -54,11 +54,10 @@ export async function writeSelftestRouteProof(root, { missionId, route = '$Team'
         },
         claims: [{
                 id: `selftest-${kind.replaceAll('_', '-')}-proof`,
-                text: CLAIM_TEXT[kind] || CLAIM_TEXT.team_gate,
+                text: CLAIM_TEXT[kind] || CLAIM_TEXT.route_gate,
                 status: 'verified_partial'
             }],
         unverified: unverified || defaults.unverified,
         blockers: ['selftest_fixture_cannot_claim_real_route_completion']
     });
 }
-//# sourceMappingURL=selftest-proof-fixtures.js.map

package/dist/core/proof/validation.js

@@ -32,4 +32,3 @@ export function validateCompletionProof(proof = {}) {
         issues
     };
 }
-//# sourceMappingURL=validation.js.map

package/dist/core/proof-field.js

@@ -14,14 +14,14 @@ export const OUTCOME_RUBRIC = Object.freeze([
     { id: 'goal_fit', description: 'The selected work directly satisfies the user goal without drifting into adjacent pipeline work.', adversarial_lens: 'creative: challenge the literal framing and keep only the user goal that survives.' },
     { id: 'minimum_surface', description: 'Only touched surfaces inside the proof cone are included; unrelated routes, docs, DB, visual, or release work are skipped with evidence.', adversarial_lens: 'skeptic+architect: subtract unneeded surface and reject coupling that does not pay for itself now.' },
     { id: 'bounded_verification', description: 'Verification is enough to prove the selected cone and no broader than the risk requires.', adversarial_lens: 'researcher+validator: require current evidence and test the integration edge that can actually break.' },
-    { id: 'escalation_defined', description: 'The path names the exact failure signals that should promote the work back to the full Team/Honest proof path.', adversarial_lens: 'validator+architect: name the failure signal before work starts and fail closed when it appears.' }
+    { id: 'escalation_defined', description: 'The path names the exact failure signals that should promote the work back to the full Naruto/Honest proof path.', adversarial_lens: 'validator+architect: name the failure signal before work starts and fail closed when it appears.' }
 ]);
 export const SPEED_LANE_POLICY = Object.freeze({
     min_score: FAST_LANE_MIN_SCORE,
     fast_lane: 'proof_field_fast_lane',
     balanced_lane: 'proof_field_balanced_lane',
-    full_lane: 'full_team_honest_path',
-    skip_when_fast: ['native_agent_intake', 'planning_debate', 'fresh_executor_team', 'broad_route_rework'],
+    full_lane: 'full_naruto_honest_path',
+    skip_when_fast: ['native_agent_intake', 'planning_debate', 'fresh_subagent_execution', 'broad_route_rework'],
     always_keep: ['listed_verification', 'honest_mode', 'triwiki_validate_before_final'],
     fail_closed_on: ['database_surface', 'security_surface', 'visual_forensic_surface', 'unknown_surface', 'broad_change_set', 'verification_failed', 'unsupported_claim']
 });
@@ -79,10 +79,10 @@ export async function buildProofField(root, opts = {}) {
     const sourceHash = await sourceDigest(root, changedFiles);
     const contractClarity = contractClarityScore({ intent, changedFiles, selectedCones, risk });
     const workflowComplexity = workflowComplexityScore({ changedFiles, selectedCones, risk, verification: fastLane.verification });
-    const teamTriggerMatrix = teamTriggerDecision({ intent, changedFiles, risk });
+    const narutoTriggerMatrix = narutoTriggerDecision({ intent, changedFiles, risk });
     const verificationStageCache = verificationStageCachePlan({ sourceHash, changedFiles, verification: fastLane.verification });
     const simplicity = outcomeScorecard({ intent, changedFiles, selectedCones, risk, negativeWork, fastLane, workflowComplexity });
-    const executionLane = executionLaneDecision({ fastLane, simplicity, workflowComplexity, teamTriggerMatrix });
+    const executionLane = executionLaneDecision({ fastLane, simplicity, workflowComplexity, narutoTriggerMatrix });
     const decisionLattice = normalizeDecisionLatticeReport(await buildDecisionLatticeReport({
         intent,
         changed_files: changedFiles,
@@ -90,12 +90,12 @@ export async function buildProofField(root, opts = {}) {
         risk,
         contract_clarity: contractClarity,
         workflow_complexity: workflowComplexity,
-        team_trigger_matrix: teamTriggerMatrix,
+        naruto_trigger_matrix: narutoTriggerMatrix,
         verification_stage_cache: verificationStageCache,
         simplicity_scorecard: simplicity,
         fast_lane_decision: fastLane,
         execution_lane: executionLane,
-        scoring_formula: 'simplicity_scorecard.score + contract_clarity.score - workflow_complexity.score - active_team_trigger_penalty'
+        scoring_formula: 'simplicity_scorecard.score + contract_clarity.score - workflow_complexity.score - active_naruto_trigger_penalty'
     }));
     return {
         schema_version: PROOF_FIELD_SCHEMA_VERSION,
@@ -109,7 +109,7 @@ export async function buildProofField(root, opts = {}) {
         speed_lane_policy: SPEED_LANE_POLICY,
         contract_clarity: contractClarity,
         workflow_complexity: workflowComplexity,
-        team_trigger_matrix: teamTriggerMatrix,
+        naruto_trigger_matrix: narutoTriggerMatrix,
         verification_stage_cache: verificationStageCache,
         decision_lattice: decisionLattice,
         simplicity_scorecard: simplicity,
@@ -150,8 +150,8 @@ export function validateProofFieldReport(report = {}) {
         issues.push('contract_clarity_components');
     if (!Number.isFinite(Number(report.workflow_complexity?.score)))
         issues.push('workflow_complexity');
-    if (!Array.isArray(report.team_trigger_matrix?.triggers))
-        issues.push('team_trigger_matrix');
+    if (!Array.isArray(report.naruto_trigger_matrix?.triggers))
+        issues.push('naruto_trigger_matrix');
     if (report.verification_stage_cache?.report_only !== true || !report.verification_stage_cache?.cache_key)
         issues.push('verification_stage_cache');
     const latticeValidation = validateDecisionLatticeReport(report.decision_lattice);
@@ -186,7 +186,7 @@ export async function proofFieldFixture() {
             negative_release_work_recorded: report.negative_work_cache.some((item) => item.id === 'full_release_gate' && item.disposition === 'skip_with_evidence'),
             outcome_rubric_present: report.outcome_rubric.length === OUTCOME_RUBRIC.length,
             adversarial_lenses_present: report.outcome_rubric.every((item) => item.adversarial_lens) && report.simplicity_scorecard.criteria.every((item) => item.adversarial_lens),
-            route_economy_present: report.contract_clarity?.report_only === true && report.workflow_complexity?.report_only === true && report.team_trigger_matrix?.report_only === true && report.verification_stage_cache?.report_only === true,
+            route_economy_present: report.contract_clarity?.report_only === true && report.workflow_complexity?.report_only === true && report.naruto_trigger_matrix?.report_only === true && report.verification_stage_cache?.report_only === true,
             decision_lattice_present: validateDecisionLatticeReport(report.decision_lattice).ok,
             decision_lattice_report_only: report.decision_lattice?.report_only === true,
             decision_lattice_selected_path: Boolean(report.decision_lattice?.selected_path?.id),
@@ -363,9 +363,9 @@ function workflowComplexityScore({ changedFiles, selectedCones, risk, verificati
         weighted
     };
 }
-function teamTriggerDecision({ intent, changedFiles, risk }) {
+function narutoTriggerDecision({ intent, changedFiles, risk }) {
     const triggers = [
-        { id: 'explicit_team', active: /\$?team\b/i.test(intent || ''), reason: 'user explicitly selected Team' },
+        { id: 'explicit_naruto', active: /\$?naruto\b/i.test(intent || ''), reason: 'user explicitly selected Naruto' },
         { id: 'broad_change_set', active: changedFiles.length > 3, reason: `${changedFiles.length} changed file(s)` },
         { id: 'database_surface', active: risk.flags.database, reason: 'database risk flag present' },
         { id: 'security_surface', active: risk.flags.security, reason: 'security risk flag present' },
@@ -378,7 +378,7 @@ function teamTriggerDecision({ intent, changedFiles, risk }) {
     return {
         schema_version: 1,
         report_only: true,
-        full_team_recommended: active.length > 0,
+        full_naruto_honest_path_recommended: active.length > 0,
         active_triggers: active,
         triggers
     };
@@ -417,7 +417,7 @@ function outcomeScorecard({ intent, changedFiles, selectedCones, risk, negativeW
         decision_mode: fastLane.mode
     };
 }
-function executionLaneDecision({ fastLane, simplicity, workflowComplexity, teamTriggerMatrix }) {
+function executionLaneDecision({ fastLane, simplicity, workflowComplexity, narutoTriggerMatrix }) {
     const score = Number(simplicity?.score || 0);
     const fast = Boolean(fastLane?.eligible) && score >= FAST_LANE_MIN_SCORE;
     const lane = fast
@@ -435,7 +435,7 @@ function executionLaneDecision({ fastLane, simplicity, workflowComplexity, teamT
         escalate_on: [...new Set([...(fastLane?.escalate_on || []), ...SPEED_LANE_POLICY.fail_closed_on])],
         reason: fast
             ? `Proof Field score ${score} >= ${FAST_LANE_MIN_SCORE} with no fast-lane blockers`
-            : `Fast lane not allowed: mode=${fastLane?.mode || 'unknown'}, score=${score}, complexity=${workflowComplexity?.band || 'unknown'}, team_triggers=${(teamTriggerMatrix?.active_triggers || []).join(', ') || 'none'}, blockers=${(fastLane?.blockers || []).join(', ') || 'none'}`
+            : `Fast lane not allowed: mode=${fastLane?.mode || 'unknown'}, score=${score}, complexity=${workflowComplexity?.band || 'unknown'}, naruto_triggers=${(narutoTriggerMatrix?.active_triggers || []).join(', ') || 'none'}, blockers=${(fastLane?.blockers || []).join(', ') || 'none'}`
     };
 }
 function nextAction(decision, simplicity) {
@@ -444,7 +444,7 @@ function nextAction(decision, simplicity) {
         return `apply minimal patch, run listed verification, then Honest Mode against the proof field report;${score}`;
     if (decision.mode === 'balanced')
         return `narrow the change set or run parent-led implementation with listed verification and reviewer escalation if checks fail;${score}`;
-    return 'use full Team/Honest proof path; fast lane is intentionally blocked for this risk state';
+    return 'use full Naruto/Honest proof path; fast lane is intentionally blocked for this risk state';
 }
 async function sourceDigest(root, files) {
     const rows = [];
@@ -457,4 +457,3 @@ async function sourceDigest(root, files) {
     }
     return sha256(JSON.stringify(rows)).slice(0, 24);
 }
-//# sourceMappingURL=proof-field.js.map

package/dist/core/provider/model-router.js

@@ -107,4 +107,3 @@ function reasoningForExplicitModel(model, judgment) {
         return TERRA_SUBAGENT_EFFORT;
     return judgment ? SOL_MAX_SUBAGENT_EFFORT : DEFAULT_SUBAGENT_EFFORT;
 }
-//# sourceMappingURL=model-router.js.map

package/dist/core/provider/provider-badge.js

@@ -29,4 +29,3 @@ export function buildProviderBadge(context) {
         blockers: context.conflict ? ['provider_conflict'] : []
     };
 }
-//# sourceMappingURL=provider-badge.js.map

package/dist/core/provider/provider-context.js

@@ -64,7 +64,7 @@ export async function resolveProviderContext(input = {}) {
         generated_at: nowIso(),
         provider,
         auth_mode: authMode,
-        route: String(input.route || env.SKS_ROUTE || '$Agent'),
+        route: String(input.route || env.SKS_ROUTE || '$Naruto'),
         service_tier: normalizeServiceTier(input.serviceTier || env.SKS_SERVICE_TIER),
         source,
         confidence,
@@ -142,4 +142,3 @@ function codexLbProviderBody(text) {
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-//# sourceMappingURL=provider-context.js.map

package/dist/core/provider/provider-self-heal.js

@@ -149,4 +149,3 @@ async function writeReport(root, input, body) {
     await writeJsonAtomic(reportPath, report);
     return report;
 }
-//# sourceMappingURL=provider-self-heal.js.map

package/dist/core/providers/glm/bench/glm-bench-comparison.js

@@ -45,4 +45,3 @@ export function computeGlmBenchmarkComparison(cases) {
         reason
     };
 }
-//# sourceMappingURL=glm-bench-comparison.js.map

package/dist/core/providers/glm/bench/glm-bench-fixture.js

@@ -62,4 +62,3 @@ function runGit(args, cwd) {
         child.on('error', reject);
     });
 }
-//# sourceMappingURL=glm-bench-fixture.js.map

package/dist/core/providers/glm/bench/glm-bench-model-lock-proof.js

@@ -50,4 +50,3 @@ export function buildGlmBenchModelLockProof(cases, proofInput = {}) {
         passed: mismatches.length === 0
     };
 }
-//# sourceMappingURL=glm-bench-model-lock-proof.js.map

package/dist/core/providers/glm/bench/glm-bench-report.js

@@ -72,4 +72,3 @@ function formatCaseRow(c) {
     const metricLatency = c.metric_status.latency;
     return `| ${c.name} | ${c.kind} | ${c.workers} | ${c.wall_clock_ms} | ${ttft} | ${total} | ${candidates} | ${gate} | ${verifier} | ${merge} | ${patchGen} | ${patchGate} | ${metricLatency} |`;
 }
-//# sourceMappingURL=glm-bench-report.js.map

package/dist/core/providers/glm/bench/glm-benchmark-runner.js

@@ -241,4 +241,3 @@ async function captureGitStatus(cwd) {
         child.on('error', () => resolve(''));
     });
 }
-//# sourceMappingURL=glm-benchmark-runner.js.map

package/dist/core/providers/glm/bench/glm-benchmark-types.js

@@ -1,2 +1 @@
 export const GLM_BENCHMARK_VERSION = '4.2.0';
-//# sourceMappingURL=glm-benchmark-types.js.map

package/dist/core/providers/glm/bench/glm-direct-bench-runner.js

@@ -70,4 +70,3 @@ export async function runGlmDirectBenchCase(input, deps = {}) {
     await writeJsonAtomic(path.join(input.caseDir, 'case-result.json'), result);
     return result;
 }
-//# sourceMappingURL=glm-direct-bench-runner.js.map

package/dist/core/providers/glm/glm-52-profile.js

@@ -80,4 +80,3 @@ export function buildGlmCodexAppModelProfile() {
         }
     };
 }
-//# sourceMappingURL=glm-52-profile.js.map

package/dist/core/providers/glm/glm-52-request.js

@@ -71,4 +71,3 @@ function buildSpeedReasoningConfig(reasoningEffort, reasoningMeta) {
     }
     return buildFastReasoningConfig(reasoningMeta);
 }
-//# sourceMappingURL=glm-52-request.js.map

package/dist/core/providers/glm/glm-52-response-guard.js

@@ -30,4 +30,3 @@ export function assertGlm52ActualModel(responseModel) {
         gptFallbackAllowed: false
     };
 }
-//# sourceMappingURL=glm-52-response-guard.js.map

package/dist/core/providers/glm/glm-52-settings.js

@@ -65,4 +65,3 @@ export function clampGlm52MaxTokens(value) {
     const numeric = Number.isFinite(value) ? Math.floor(Number(value)) : GLM_52_MAX_TOKENS_DEFAULT;
     return Math.max(1, Math.min(numeric, GLM_52_TOP_PROVIDER_MAX_COMPLETION_TOKENS));
 }
-//# sourceMappingURL=glm-52-settings.js.map

package/dist/core/providers/glm/glm-context-budget.js

@@ -12,4 +12,3 @@ export function trimToEstimatedTokens(text, maxTokens) {
         return text;
     return text.slice(0, maxChars);
 }
-//# sourceMappingURL=glm-context-budget.js.map

package/dist/core/providers/glm/glm-context-cache.js

@@ -6,4 +6,3 @@ export function createGlmContextCache(maxEntries = 64) {
         set: (context) => cache.set(context.digest, context)
     };
 }
-//# sourceMappingURL=glm-context-cache.js.map

package/dist/core/providers/glm/glm-direct-run.js

@@ -138,4 +138,3 @@ function extractMentionedPaths(task) {
     const matches = task.match(/(?:^|\s|[`"'])([A-Za-z0-9_.-]+\/[A-Za-z0-9_./-]+\.[A-Za-z0-9]+)(?:\s|[`"']|$)/g) || [];
     return [...new Set(matches.map((value) => value.trim().replace(/^[`"']|[`"']$/g, '')))];
 }
-//# sourceMappingURL=glm-direct-run.js.map

package/dist/core/providers/glm/glm-interactive-launch.js

@@ -1,5 +1,4 @@
 import { madHighCommand } from '../../commands/mad-sks-command.js';
 export async function runGlmInteractiveLaunch(args, readiness) {
-    return madHighCommand(['--glm', '--no-swarm', ...args], { glmReadiness: readiness, glmArgs: args });
+    return madHighCommand(['--glm', ...args], { glmReadiness: readiness, glmArgs: args });
 }
-//# sourceMappingURL=glm-interactive-launch.js.map

package/dist/core/providers/glm/glm-latency-trace.js

@@ -37,4 +37,3 @@ export async function writeGlmLatencyTrace(root, trace) {
 function redactTrace(trace) {
     return JSON.parse(JSON.stringify(trace).replace(/sk-or-[A-Za-z0-9_-]+/g, 'sk-or-...redacted...'));
 }
-//# sourceMappingURL=glm-latency-trace.js.map

package/dist/core/providers/glm/glm-loop-guard.js

@@ -28,4 +28,3 @@ export function recordGlmLoopIteration(input) {
 export function digestNormalizedOutput(output) {
     return crypto.createHash('sha256').update(output.replace(/\s+/g, ' ').trim()).digest('hex');
 }
-//# sourceMappingURL=glm-loop-guard.js.map

package/dist/core/providers/glm/glm-mad-launch.js

@@ -126,4 +126,3 @@ function codexReasoningEffortForProfile(profile) {
         return 'high';
     return 'low';
 }
-//# sourceMappingURL=glm-mad-launch.js.map

package/dist/core/providers/glm/glm-mad-mode.js

@@ -267,4 +267,3 @@ export function buildGlmModeDryRunRequest() {
         parallelToolCalls: false
     });
 }
-//# sourceMappingURL=glm-mad-mode.js.map

package/dist/core/providers/glm/glm-model-meta-cache.js

@@ -16,4 +16,3 @@ export function createGlmModelMetaCache(maxEntries = 16, ttlMs = DAY_MS) {
         }
     };
 }
-//# sourceMappingURL=glm-model-meta-cache.js.map

package/dist/core/providers/glm/glm-patch-apply.js

@@ -49,10 +49,24 @@ function runGitApply(cwd, patch, args) {
         const child = spawn('git', [...args], { cwd, stdio: ['pipe', 'pipe', 'pipe'] });
         let stdout = '';
         let stderr = '';
+        let settled = false;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve({ code, stdout, stderr });
+        };
         child.stdout.on('data', (chunk) => { stdout += String(chunk); });
         child.stderr.on('data', (chunk) => { stderr += String(chunk); });
-        child.on('close', (code) => resolve({ code, stdout, stderr }));
+        child.stdin.on('error', (error) => {
+            if (error.code !== 'EPIPE')
+                stderr += `${stderr ? '\n' : ''}${error.message}`;
+        });
+        child.on('error', (error) => {
+            stderr += `${stderr ? '\n' : ''}${error.message}`;
+            finish(null);
+        });
+        child.on('close', finish);
         child.stdin.end(patch);
     });
 }
-//# sourceMappingURL=glm-patch-apply.js.map

package/dist/core/providers/glm/glm-patch-parser.js

@@ -16,4 +16,3 @@ export function parseUnifiedDiffPatch(patch) {
         empty: !patch.trim() || !/^diff --git /m.test(patch)
     };
 }
-//# sourceMappingURL=glm-patch-parser.js.map

package/dist/core/providers/glm/glm-profile-resolver.js

@@ -166,4 +166,3 @@ function isAllowedGlmSlashModel(value) {
     const normalized = value.trim().toLowerCase();
     return normalized === GLM_52_OPENROUTER_MODEL || normalized === 'glm-5.2' || normalized === 'glm5.2';
 }
-//# sourceMappingURL=glm-profile-resolver.js.map

package/dist/core/providers/glm/glm-readiness.js

@@ -2,4 +2,3 @@ import { runMadGlmMode } from './glm-mad-mode.js';
 export async function runGlmReadinessAndExit(args = []) {
     return runMadGlmMode(args);
 }
-//# sourceMappingURL=glm-readiness.js.map

package/dist/core/providers/glm/glm-reasoning-policy.js

@@ -12,4 +12,3 @@ export function buildFastReasoningConfig(meta = null) {
 export function buildDeepReasoningConfig(effort) {
     return { effort, exclude: true };
 }
-//# sourceMappingURL=glm-reasoning-policy.js.map

package/dist/core/providers/glm/glm-request-cache.js

@@ -74,4 +74,3 @@ function stableStringify(value) {
     return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(object[key])}`).join(',')}}`;
 }
 const defaultEncodedRequestCache = createGlmEncodedRequestCache();
-//# sourceMappingURL=glm-request-cache.js.map