sneakoscope 0.7.13 → 0.7.16

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "0.7.13",
+  "version": "0.7.16",
   "description": "Sneakoscope Codex: database-safe Codex CLI/App harness with Team, Goal, AutoResearch, TriWiki, and Honest Mode.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",

package/src/cli/main.mjs

@@ -39,7 +39,7 @@ import {
 import { contextCapsule } from '../core/triwiki-attention.mjs';
 import { rgbaKey, rgbaToWikiCoord, validateWikiCoordinateIndex } from '../core/wiki-coordinate.mjs';
 import { ALLOWED_REASONING_EFFORTS, CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_COMPUTER_USE_EVIDENCE_SOURCE, CODEX_COMPUTER_USE_ONLY_POLICY, COMMAND_CATALOG, DOLLAR_COMMAND_ALIASES, DOLLAR_COMMANDS, DOLLAR_SKILL_NAMES, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_SOURCE_INVENTORY_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS, FROM_CHAT_IMG_VISUAL_MAP_ARTIFACT, FROM_CHAT_IMG_WORK_ORDER_ARTIFACT, GETDESIGN_REFERENCE, RECOMMENDED_SKILLS, ROUTES, USAGE_TOPICS, context7ConfigToml, hasContext7ConfigText, hasFromChatImgSignal, looksLikeAnswerOnlyRequest, noUnrequestedFallbackCodePolicyText, reflectionRequiredForRoute, reasoningInstruction, routePrompt, routeReasoning, routeRequiresSubagents, speedLanePolicyText, stackCurrentDocsPolicy, triwikiContextTracking } from '../core/routes.mjs';
-import { PIPELINE_PLAN_ARTIFACT, buildPipelinePlan, context7Evidence, evaluateStop, recordContext7Evidence, recordSubagentEvidence, validatePipelinePlan, writePipelinePlan } from '../core/pipeline.mjs';
+import { PIPELINE_PLAN_ARTIFACT, buildPipelinePlan, context7Evidence, evaluateStop, projectGateStatus, recordContext7Evidence, recordSubagentEvidence, validatePipelinePlan, writePipelinePlan } from '../core/pipeline.mjs';
 import { TEAM_DECOMPOSITION_ARTIFACT, TEAM_GRAPH_ARTIFACT, TEAM_INBOX_DIR, TEAM_RUNTIME_TASKS_ARTIFACT, validateTeamRuntimeArtifacts, writeTeamRuntimeArtifacts } from '../core/team-dag.mjs';
 import { appendTeamEvent, initTeamLive, parseTeamSpecText, readTeamDashboard, readTeamLive, readTeamTranscriptTail, renderTeamAgentLane } from '../core/team-live.mjs';
 import { ARTIFACT_FILES, validateDogfoodReport, validateEffortDecision, validateFromChatImgVisualMap, validateSkillCandidate, validateSkillInjectionDecision, validateTeamDashboardState, validateWorkOrderLedger } from '../core/artifact-schemas.mjs';
@@ -469,11 +469,13 @@ async function pipeline(sub = 'status', args = []) {
   const state = await readJson(stateFile(root), {});
   const evidence = await context7Evidence(root, state);
   const plan = state.mission_id ? await readJson(path.join(missionDir(root, state.mission_id), PIPELINE_PLAN_ARTIFACT), null) : null;
+  const gateProjection = await projectGateStatus(root, state);
   const stop = await evaluateStop(root, state, { last_assistant_message: 'SKS Honest Mode verification evidence gap' }, { noQuestion: false });
   const result = {
     root,
     state,
     context7: evidence,
+    gate_projection: gateProjection,
     plan: plan ? pipelinePlanSummary(plan, root, state.mission_id) : null,
     stop_gate: state.stop_gate || null,
     next_action: stop?.reason || 'No active blocking route gate detected.'
@@ -492,6 +494,7 @@ async function pipeline(sub = 'status', args = []) {
   }
   console.log(`Reasoning: ${state.reasoning_effort || 'medium'}${state.reasoning_profile ? ` (${state.reasoning_profile})` : ''}${state.reasoning_temporary ? ' temporary' : ''}`);
   console.log(`Stop gate: ${state.stop_gate || 'none'}`);
+  console.log(`Gate projection: ${gateProjection.ok ? 'ok' : `blocked (${gateProjection.blockers.join(', ')})`}`);
   console.log(`Context7:  ${state.context7_required ? (evidence.ok ? 'ok' : 'required-missing') : 'optional'} (${evidence.count || 0} event(s))`);
   console.log(`Next:      ${result.next_action}`);
 }
@@ -520,10 +523,11 @@ async function pipelinePlan(root, args = []) {
   const changedRaw = readOption(args, '--changed', '');
   const proofField = flag(args, '--proof-field') ? await buildProofField(root, { intent, changedFiles: changedRaw ? changedRaw.split(',') : undefined }) : null;
   const contract = dir ? await readJson(path.join(dir, 'decision-contract.json'), {}) : {};
+  const contractSealed = contract?.status === 'sealed' || Boolean(contract?.sealed_at || contract?.sealed_hash);
   const ambiguity = {
-    required: Boolean(routeContext.clarification_gate || state.ambiguity_gate_required),
-    passed: Boolean(state.ambiguity_gate_passed || state.clarification_passed),
-    status: state.clarification_required ? 'awaiting_answers' : (state.ambiguity_gate_passed ? 'contract_sealed' : undefined),
+    required: Boolean(routeContext.clarification_gate || state.ambiguity_gate_required || contractSealed),
+    passed: Boolean(state.ambiguity_gate_passed || state.clarification_passed || contractSealed),
+    status: state.clarification_required ? 'awaiting_answers' : ((state.ambiguity_gate_passed || contractSealed) ? 'contract_sealed' : undefined),
     contract_hash: contract?.sealed_hash || null
   };
   const planInput = { missionId: id || null, route, task: intent, required: Boolean(routeContext.context7_required || state.context7_required), ambiguity, proofField };
@@ -1719,6 +1723,27 @@ async function selftest() {
   if (trippedStop) throw new Error('selftest failed: compliance loop guard did not terminally trip');
   const loopBlocker = await readJson(path.join(loopMission.dir, 'hard-blocker.json'), null);
   if (loopBlocker?.reason !== 'compliance_loop_guard_tripped') throw new Error('selftest failed: compliance loop guard did not write hard blocker');
+  const clarificationMission = await createMission(tmp, { mode: 'team', prompt: 'visible question gate selftest' });
+  await writeTextAtomic(path.join(clarificationMission.dir, 'questions.md'), '# Questions\n\n1. GOAL_PRECISE: What should be changed?\n');
+  await writeJsonAtomic(path.join(clarificationMission.dir, 'required-answers.schema.json'), { slots: [{ id: 'GOAL_PRECISE', question: 'What should be changed?' }] });
+  const clarificationState = {
+    mission_id: clarificationMission.id,
+    mode: 'TEAM',
+    route_command: '$Team',
+    phase: 'TEAM_CLARIFICATION_AWAITING_ANSWERS',
+    clarification_required: true,
+    implementation_allowed: false,
+    ambiguity_gate_required: true,
+    ambiguity_gate_passed: false,
+    stop_gate: 'clarification-gate'
+  };
+  for (let i = 0; i < 5; i++) {
+    const stop = await evaluateStop(tmp, clarificationState, { last_assistant_message: 'continuing implementation without visible questions' });
+    if (stop?.decision !== 'block' || !String(stop.reason || '').includes('waiting for mandatory ambiguity-removal answers')) throw new Error('selftest failed: clarification gate did not hard-pause without visible questions');
+  }
+  if (await exists(path.join(clarificationMission.dir, 'hard-blocker.json'))) throw new Error('selftest failed: clarification gate used compliance hard-blocker instead of waiting for answers');
+  const visibleQuestionStop = await evaluateStop(tmp, clarificationState, { last_assistant_message: 'Required questions still pending:\n1. GOAL_PRECISE: What should be changed?\n\nUse sks pipeline answer latest answers.json.' });
+  if (visibleQuestionStop?.continue !== true) throw new Error('selftest failed: visible clarification question block did not allow the question-only turn to stop');
   await setCurrent(tmp, loopState);
   const dfixPromptHook = await runProcess(process.execPath, [path.join(packageRoot(), 'bin', 'sks.mjs'), 'hook', 'user-prompt-submit'], {
     cwd: tmp,
@@ -2852,13 +2877,14 @@ async function selftest() {
   if (!harnessReport.forgetting.fixture.passed || !harnessReport.tmux.views.includes('Harness Experiments View') || !harnessReport.reliability.tool_error_taxonomy.includes('Unknown')) throw new Error('selftest failed: harness growth fixture incomplete');
   const proofField = await proofFieldFixture();
   if (!proofField.validation.ok || !validateProofFieldReport(proofField.report).ok) throw new Error('selftest failed: proof field report invalid');
-  if (!proofField.checks.route_cone_selected || !proofField.checks.cli_cone_selected || !proofField.checks.catastrophic_guard_present || !proofField.checks.negative_release_work_recorded || !proofField.checks.outcome_rubric_present || !proofField.checks.adversarial_lenses_present || !proofField.checks.simplicity_score_usable || !proofField.checks.execution_fast_lane_selected) throw new Error('selftest failed: proof field fixture checks incomplete');
+  if (!proofField.checks.route_cone_selected || !proofField.checks.cli_cone_selected || !proofField.checks.catastrophic_guard_present || !proofField.checks.negative_release_work_recorded || !proofField.checks.outcome_rubric_present || !proofField.checks.adversarial_lenses_present || !proofField.checks.route_economy_present || !proofField.checks.simplicity_score_usable || !proofField.checks.execution_fast_lane_selected) throw new Error('selftest failed: proof field fixture checks incomplete');
   if (!speedLanePolicyText().includes('proof_field_fast_lane') || !proofField.report.execution_lane?.skip_when_fast?.includes('planning_debate')) throw new Error('selftest failed: Proof Field speed lane policy missing');
   const fastPipelinePlan = buildPipelinePlan({ route: routePrompt('$Team small CLI help update'), task: 'small CLI help surface update', proofField: proofField.report });
   if (!validatePipelinePlan(fastPipelinePlan).ok || fastPipelinePlan.runtime_lane?.lane !== 'proof_field_fast_lane' || !fastPipelinePlan.skipped_stages.includes('planning_debate') || !fastPipelinePlan.invariants.includes('no_unrequested_fallback_code')) throw new Error('selftest failed: pipeline plan did not encode fast lane stage skips and fallback guard');
   const broadProofField = await buildProofField(tmp, { intent: 'database security route refactor', changedFiles: ['src/core/db-safety.mjs', 'src/core/routes.mjs', 'src/cli/main.mjs', 'README.md'] });
   const broadPipelinePlan = buildPipelinePlan({ route: routePrompt('$Team database security route refactor'), task: 'database security route refactor', proofField: broadProofField });
   if (!validatePipelinePlan(broadPipelinePlan).ok || broadPipelinePlan.runtime_lane?.lane === 'proof_field_fast_lane' || broadPipelinePlan.skipped_stages.includes('planning_debate')) throw new Error('selftest failed: pipeline plan did not fail closed for broad/security work');
+  if (broadPipelinePlan.route_economy?.mode !== 'report_only' || !broadPipelinePlan.route_economy.active_team_triggers?.includes('broad_change_set') || !broadPipelinePlan.route_economy.verification_stage_cache_key) throw new Error('selftest failed: route economy projection missing from pipeline plan');
   const workflowPerf = await runWorkflowPerfBench(tmp, {
     iterations: 2,
     intent: 'small CLI help surface update',

package/src/cli/maintenance-commands.mjs

@@ -529,6 +529,8 @@ export async function perfCommand(sub, args = []) {
     console.log(`Mode: ${report.metrics.decision_mode}`);
     console.log(`Fast lane: ${report.metrics.fast_lane_eligible ? 'yes' : 'no'}`);
     console.log(`Proof Field p95: ${report.metrics.proof_field_build_ms_p95}ms`);
+    console.log(`Contract clarity: ${report.metrics.contract_clarity_score}`);
+    console.log(`Workflow complexity: ${report.metrics.workflow_complexity_band} (${report.metrics.workflow_complexity_score})`);
     console.log(`Proof cones: ${report.metrics.proof_cone_count}`);
     console.log(`Negative work skipped: ${report.metrics.negative_work_skipped_count}`);
     console.log(`Next: ${report.recommendation.next.join('; ')}`);
@@ -569,6 +571,9 @@ export async function proofFieldCommand(sub, args = []) {
   console.log(`Mode: ${report.fast_lane_decision.mode}`);
   console.log(`Eligible: ${report.fast_lane_decision.eligible ? 'yes' : 'no'}`);
   if (report.fast_lane_decision.blockers.length) console.log(`Blockers: ${report.fast_lane_decision.blockers.join(', ')}`);
+  console.log(`Contract clarity: ${report.contract_clarity.score}${report.contract_clarity.ask_recommended ? ' (ask recommended)' : ''}`);
+  console.log(`Workflow complexity: ${report.workflow_complexity.band} (${report.workflow_complexity.score})`);
+  if (report.team_trigger_matrix.active_triggers.length) console.log(`Team triggers: ${report.team_trigger_matrix.active_triggers.join(', ')}`);
   console.log(`Proof cones: ${report.proof_cones.map((cone) => cone.id).join(', ')}`);
   console.log(`Verification: ${report.fast_lane_decision.verification.join('; ')}`);
   console.log(`Report: ${path.relative(root, report.report_path)}`);

package/src/core/fsx.mjs

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 
-export const PACKAGE_VERSION = '0.7.13';
+export const PACKAGE_VERSION = '0.7.16';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 

package/src/core/perf-bench.mjs

@@ -105,6 +105,11 @@ export async function runWorkflowPerfBench(root, opts = {}) {
       verification_count: verification.length,
       negative_work_skipped_count: estimatedSavedWork,
       simplicity_score: Number(proofField?.simplicity_scorecard?.score || 0),
+      contract_clarity_score: Number(proofField?.contract_clarity?.score || 0),
+      workflow_complexity_score: Number(proofField?.workflow_complexity?.score || 0),
+      workflow_complexity_band: proofField?.workflow_complexity?.band || null,
+      team_trigger_count: proofField?.team_trigger_matrix?.active_triggers?.length || 0,
+      verification_stage_cache_key: proofField?.verification_stage_cache?.cache_key || null,
       outcome_criteria_passed: (proofField?.simplicity_scorecard?.criteria || []).filter((item) => item.passed).length,
       proof_field_valid: proofValidation.ok,
       pipeline_plan_valid: planValidation.ok
@@ -129,6 +134,10 @@ export function validateWorkflowPerfReport(report = {}) {
   if (!report.metrics?.execution_lane) issues.push('execution_lane');
   if (!report.metrics?.pipeline_lane) issues.push('pipeline_lane');
   if (!Number.isFinite(Number(report.metrics?.simplicity_score))) issues.push('simplicity_score');
+  if (!Number.isFinite(Number(report.metrics?.contract_clarity_score))) issues.push('contract_clarity_score');
+  if (!Number.isFinite(Number(report.metrics?.workflow_complexity_score))) issues.push('workflow_complexity_score');
+  if (!report.metrics?.workflow_complexity_band) issues.push('workflow_complexity_band');
+  if (!report.metrics?.verification_stage_cache_key) issues.push('verification_stage_cache_key');
   if (!report.proof_field || !validateProofFieldReport(report.proof_field).ok) issues.push('proof_field');
   if (!report.pipeline_plan || !validatePipelinePlan(report.pipeline_plan).ok) issues.push('pipeline_plan');
   if (!report.recommendation?.mode) issues.push('recommendation');

package/src/core/pipeline.mjs

@@ -65,6 +65,7 @@ export function buildPipelinePlan(input = {}) {
   const verification = planVerification(route, proof);
   const skipped = stages.filter((stage) => stage.status === 'skipped').map((stage) => stage.id);
   const kept = stages.filter((stage) => stage.status !== 'skipped' && stage.status !== 'not_applicable').map((stage) => stage.id);
+  const routeEconomy = routeEconomyPlan(proof);
   return {
     schema_version: PIPELINE_PLAN_SCHEMA_VERSION,
     generated_at: nowIso(),
@@ -94,6 +95,7 @@ export function buildPipelinePlan(input = {}) {
     verification,
     invariants: ['no_unrequested_fallback_code', 'listed_verification', 'triwiki_validate_before_final', 'honest_mode'],
     proof_field: proof,
+    route_economy: routeEconomy,
     skill_dream: input.skillDream || { attached: false, reason: 'skill dreaming uses cheap counters and only runs inventory at threshold' },
     next_actions: planNextActions(route, task, ambiguity, lane),
     no_unrequested_fallback_code: true
@@ -113,6 +115,7 @@ export function validatePipelinePlan(plan = {}) {
   if (!plan.runtime_lane?.lane) issues.push('runtime_lane');
   if (!Array.isArray(plan.stages) || !plan.stages.length) issues.push('stages');
   if (!Array.isArray(plan.verification) || !plan.verification.length) issues.push('verification');
+  if (!plan.route_economy?.mode) issues.push('route_economy');
   if (plan.no_unrequested_fallback_code !== true || !plan.invariants?.includes('no_unrequested_fallback_code')) issues.push('fallback_guard');
   if (!plan.next_actions?.length) issues.push('next_actions');
   return { ok: issues.length === 0, issues };
@@ -147,7 +150,37 @@ function normalizeProofField(report) {
     keep: report.execution_lane?.keep || SPEED_LANE_POLICY.always_keep,
     verification: report.execution_lane?.verification || report.fast_lane_decision?.verification || [],
     proof_cones: (report.proof_cones || []).map((cone) => cone.id),
-    source_hash: report.source_hash || null
+    source_hash: report.source_hash || null,
+    contract_clarity: report.contract_clarity || null,
+    workflow_complexity: report.workflow_complexity || null,
+    team_trigger_matrix: report.team_trigger_matrix || null,
+    verification_stage_cache: report.verification_stage_cache || null
+  };
+}
+
+function routeEconomyPlan(proof = {}) {
+  if (!proof.attached) {
+    return {
+      schema_version: 1,
+      mode: 'unavailable',
+      report_only: true,
+      reason: proof.reason || 'Proof Field not attached yet'
+    };
+  }
+  const triggers = proof.team_trigger_matrix?.active_triggers || [];
+  return {
+    schema_version: 1,
+    mode: 'report_only',
+    report_only: true,
+    contract_clarity_score: Number(proof.contract_clarity?.score || 0),
+    contract_clarity_passed: proof.contract_clarity?.passed === true,
+    ask_recommended: proof.contract_clarity?.ask_recommended === true,
+    workflow_complexity_score: Number(proof.workflow_complexity?.score || 0),
+    workflow_complexity_band: proof.workflow_complexity?.band || null,
+    team_trigger_count: triggers.length,
+    active_team_triggers: triggers,
+    verification_stage_cache_key: proof.verification_stage_cache?.cache_key || null,
+    deletion_policy: 'do_not_delete_or_skip_pipeline_stages_until_report_only_metrics_are_calibrated'
   };
 }
 
@@ -920,11 +953,76 @@ function reflectionStopReason(state = {}, status = {}) {
   return `SKS ${route} must run reflection before final. Write .sneakoscope/missions/${id}/${REFLECTION_ARTIFACT}, record real lessons in ${REFLECTION_MEMORY_PATH} when present, refresh/pack and validate TriWiki, then pass .sneakoscope/missions/${id}/${REFLECTION_GATE}.${missing}`;
 }
 
+export async function projectGateStatus(root, state = {}) {
+  const gates = [];
+  const id = state?.mission_id || null;
+  if (clarificationGatePending(state)) {
+    gates.push({
+      id: 'clarification-gate',
+      ok: false,
+      missing: ['explicit_user_answers', 'pipeline_answer'],
+      source: id ? `.sneakoscope/missions/${id}/questions.md` : null
+    });
+  }
+  if (state?.context7_required) {
+    const evidence = await context7Evidence(root, state);
+    gates.push({
+      id: 'context7-evidence',
+      ok: evidence.ok,
+      missing: evidence.ok ? [] : ['resolve-library-id', 'query-docs'],
+      source: id ? `.sneakoscope/missions/${id}/context7-evidence.jsonl` : '.sneakoscope/state/context7-evidence.jsonl'
+    });
+  }
+  if (state?.subagents_required) {
+    const evidence = await subagentEvidence(root, state);
+    gates.push({
+      id: 'subagent-evidence',
+      ok: evidence.ok,
+      missing: evidence.ok ? [] : ['spawn_agent_or_exception_evidence'],
+      source: id ? `.sneakoscope/missions/${id}/subagent-evidence.jsonl` : '.sneakoscope/state/subagent-evidence.jsonl'
+    });
+  }
+  if (id && state?.stop_gate && !['none', 'honest_mode'].includes(state.stop_gate)) {
+    const active = await passedActiveGate(root, state);
+    gates.push({
+      id: active.file || state.stop_gate,
+      ok: active.ok,
+      missing: active.missing || (active.ok ? [] : ['passed']),
+      source: active.file ? `.sneakoscope/missions/${id}/${active.file}` : null
+    });
+  }
+  const reflection = await reflectionGateStatus(root, state);
+  if (reflectionRequiredForState(state)) {
+    gates.push({
+      id: REFLECTION_GATE,
+      ok: reflection.ok,
+      missing: reflection.missing || [],
+      source: id ? `.sneakoscope/missions/${id}/${REFLECTION_GATE}` : null
+    });
+  }
+  const blockers = gates.filter((gate) => !gate.ok).flatMap((gate) => gate.missing.map((item) => `${gate.id}:${item}`));
+  return {
+    schema_version: 1,
+    generated_at: nowIso(),
+    mission_id: id,
+    mode: state?.mode || null,
+    report_only: true,
+    ok: blockers.length === 0,
+    blockers,
+    gates
+  };
+}
+
 export async function evaluateStop(root, state, payload, opts = {}) {
   const last = extractLastMessage(payload);
-  if (state?.clarification_required && String(state.phase || '').includes('CLARIFICATION_AWAITING_ANSWERS')) {
+  if (clarificationGatePending(state)) {
     if (await hasVisibleClarificationQuestionBlock(root, state, last)) return { continue: true };
-    return complianceBlock(root, state, await clarificationStopReason(root, state, 'route'), { gate: 'clarification' });
+    return {
+      decision: 'block',
+      reason: await clarificationStopReason(root, state, 'route'),
+      gate: 'clarification',
+      missing: ['explicit_user_answers', 'pipeline_answer']
+    };
   }
   if (state?.context7_required && !(await hasContext7DocsEvidence(root, state))) {
     return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} requires Context7 evidence before completion. Use Context7 resolve-library-id, then query-docs (or legacy get-library-docs), so SKS can record context7-evidence.jsonl.`, { gate: 'context7-evidence' });
@@ -955,6 +1053,16 @@ export async function evaluateStop(root, state, payload, opts = {}) {
   return null;
 }
 
+function clarificationGatePending(state = {}) {
+  return Boolean(state?.clarification_required && String(state.phase || '').includes('CLARIFICATION_AWAITING_ANSWERS'))
+    || Boolean(
+      state?.mission_id
+      && state.implementation_allowed === false
+      && state.ambiguity_gate_required === true
+      && state.ambiguity_gate_passed !== true
+    );
+}
+
 async function complianceBlock(root, state = {}, reason = '', detail = {}) {
   if (!state?.mission_id) return { decision: 'block', reason };
   const dir = missionDir(root, state.mission_id);

package/src/core/proof-field.mjs

@@ -82,8 +82,12 @@ export async function buildProofField(root, opts = {}) {
   const negativeWork = buildNegativeWorkCache(selectedCones, risk);
   const fastLane = fastLaneDecision({ changedFiles, selectedCones, risk, negativeWork });
   const sourceHash = await sourceDigest(root, changedFiles);
-  const simplicity = outcomeScorecard({ intent, changedFiles, selectedCones, risk, negativeWork, fastLane });
-  const executionLane = executionLaneDecision({ fastLane, simplicity });
+  const contractClarity = contractClarityScore({ intent, changedFiles, selectedCones, risk });
+  const workflowComplexity = workflowComplexityScore({ changedFiles, selectedCones, risk, verification: fastLane.verification });
+  const teamTriggerMatrix = teamTriggerDecision({ 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 });
   return {
     schema_version: PROOF_FIELD_SCHEMA_VERSION,
     generated_at: nowIso(),
@@ -94,6 +98,10 @@ export async function buildProofField(root, opts = {}) {
     invariant_ledger: INVARIANT_LEDGER,
     outcome_rubric: OUTCOME_RUBRIC,
     speed_lane_policy: SPEED_LANE_POLICY,
+    contract_clarity: contractClarity,
+    workflow_complexity: workflowComplexity,
+    team_trigger_matrix: teamTriggerMatrix,
+    verification_stage_cache: verificationStageCache,
     simplicity_scorecard: simplicity,
     execution_lane: executionLane,
     proof_cones: selectedCones,
@@ -120,6 +128,11 @@ export function validateProofFieldReport(report = {}) {
   if (!Array.isArray(report.simplicity_scorecard?.criteria) || report.simplicity_scorecard.criteria.length !== OUTCOME_RUBRIC.length) issues.push('simplicity_criteria');
   if (!report.simplicity_scorecard?.criteria?.every((item) => item.adversarial_lens)) issues.push('simplicity_adversarial_lenses');
   if (!report.speed_lane_policy || Number(report.speed_lane_policy.min_score) !== FAST_LANE_MIN_SCORE) issues.push('speed_lane_policy');
+  if (!Number.isFinite(Number(report.contract_clarity?.score))) issues.push('contract_clarity');
+  if (!Array.isArray(report.contract_clarity?.components) || report.contract_clarity.components.length < 1) 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 (report.verification_stage_cache?.report_only !== true || !report.verification_stage_cache?.cache_key) issues.push('verification_stage_cache');
   if (!report.execution_lane?.lane) issues.push('execution_lane');
   if (report.execution_lane?.lane === SPEED_LANE_POLICY.fast_lane && report.execution_lane?.score < FAST_LANE_MIN_SCORE) issues.push('execution_lane_score');
   if (!Array.isArray(report.proof_cones)) issues.push('proof_cones');
@@ -144,6 +157,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,
       simplicity_score_usable: Number(report.simplicity_scorecard?.score) >= FAST_LANE_MIN_SCORE,
       execution_fast_lane_selected: report.execution_lane?.lane === SPEED_LANE_POLICY.fast_lane
     }
@@ -237,11 +251,120 @@ function fastLaneDecision({ changedFiles, selectedCones, risk, negativeWork }) {
   };
 }
 
-function outcomeScorecard({ intent, changedFiles, selectedCones, risk, negativeWork, fastLane }) {
+function contractClarityScore({ intent, changedFiles, selectedCones, risk }) {
+  const components = [
+    {
+      id: 'goal_fit',
+      floor: 0.7,
+      score: intent ? 1 : 0.25,
+      evidence: intent ? 'intent provided' : 'missing explicit intent'
+    },
+    {
+      id: 'safety_scope_clarity',
+      floor: 0.7,
+      score: risk.flags.unknown_surface ? 0.4 : 1,
+      evidence: risk.flags.unknown_surface ? 'unknown surface present' : `risk flags classified: ${Object.entries(risk.flags).filter(([, value]) => value).map(([key]) => key).join(', ') || 'none'}`
+    },
+    {
+      id: 'acceptance_observability',
+      floor: 0.6,
+      score: /accept|verify|test|done|complete|검증|완료|구현|개선/i.test(intent || '') ? 1 : 0.65,
+      evidence: /accept|verify|test|done|complete|검증|완료|구현|개선/i.test(intent || '') ? 'observable outcome language present' : 'acceptance inferred from proof cones'
+    },
+    {
+      id: 'write_scope_certainty',
+      floor: 0.7,
+      score: changedFiles.length > 0 && changedFiles.length <= 3 ? 1 : (changedFiles.length > 0 ? 0.55 : 0.2),
+      evidence: `${changedFiles.length} changed file(s) in proposed scope`
+    },
+    {
+      id: 'context_confidence',
+      floor: 0.7,
+      score: selectedCones.length > 0 && !risk.flags.unknown_surface ? 1 : 0.45,
+      evidence: `${selectedCones.length} proof cone(s), unknown_surface=${risk.flags.unknown_surface}`
+    }
+  ];
+  const score = Number((components.reduce((sum, item) => sum + item.score, 0) / components.length).toFixed(2));
+  const failed = components.filter((item) => item.score < item.floor).map((item) => item.id);
+  return {
+    schema_version: 1,
+    report_only: true,
+    score,
+    passed: score >= 0.8 && failed.length === 0,
+    ask_recommended: failed.length > 0,
+    failed_floors: failed,
+    components
+  };
+}
+
+function workflowComplexityScore({ changedFiles, selectedCones, risk, verification }) {
+  const surfaces = new Set(selectedCones.flatMap((cone) => cone.surfaces || []));
+  const weighted = {
+    changed_files: Math.min(changedFiles.length, 8) / 8 * 0.3,
+    proof_cones: Math.min(selectedCones.length, 4) / 4 * 0.2,
+    risk_flags: Math.min(risk.score, 4) / 4 * 0.25,
+    verification: Math.min((verification || []).length, 6) / 6 * 0.15,
+    surfaces: Math.min(surfaces.size, 6) / 6 * 0.1
+  };
+  const score = Number(Object.values(weighted).reduce((sum, value) => sum + value, 0).toFixed(2));
+  const band = score >= 0.67 ? 'frontier' : (score >= 0.34 ? 'balanced' : 'focused');
+  return {
+    schema_version: 1,
+    report_only: true,
+    score,
+    band,
+    inputs: {
+      changed_file_count: changedFiles.length,
+      proof_cone_count: selectedCones.length,
+      route_surface_count: surfaces.size,
+      risk_flag_count: risk.score,
+      verification_count: (verification || []).length
+    },
+    weighted
+  };
+}
+
+function teamTriggerDecision({ intent, changedFiles, risk }) {
+  const triggers = [
+    { id: 'explicit_team', active: /\$?team\b/i.test(intent || ''), reason: 'user explicitly selected Team' },
+    { 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' },
+    { id: 'visual_forensic_surface', active: risk.flags.visual_forensic, reason: 'visual forensic risk flag present' },
+    { id: 'unknown_surface', active: risk.flags.unknown_surface, reason: 'unknown proof cone selected' },
+    { id: 'unsupported_claim', active: false, reason: 'only activated by Honest/H-Proof evidence' },
+    { id: 'verification_failed', active: false, reason: 'only activated after verification failure' }
+  ];
+  const active = triggers.filter((trigger) => trigger.active).map((trigger) => trigger.id);
+  return {
+    schema_version: 1,
+    report_only: true,
+    full_team_recommended: active.length > 0,
+    active_triggers: active,
+    triggers
+  };
+}
+
+function verificationStageCachePlan({ sourceHash, changedFiles, verification }) {
+  const stage1 = [...new Set(verification || [])].filter((command) => /packcheck|selftest|commands --json|wiki validate|eval run/i.test(command));
+  const cacheInput = { source_hash: sourceHash || null, changed_files: changedFiles, stage1 };
+  return {
+    schema_version: 1,
+    report_only: true,
+    status: sourceHash ? 'planned' : 'source_hash_missing',
+    cache_key: sha256(JSON.stringify(cacheInput)).slice(0, 16),
+    source_hash: sourceHash || null,
+    stage1_commands: stage1,
+    invalidates_on: ['source_hash_changed', 'command_changed', 'cwd_changed', 'env_changed'],
+    reuse_policy: 'fail_closed'
+  };
+}
+
+function outcomeScorecard({ intent, changedFiles, selectedCones, risk, negativeWork, fastLane, workflowComplexity }) {
   const skipped = negativeWork.filter((item) => item.disposition === 'skip_with_evidence').length;
   const criteria = [
     { id: 'goal_fit', passed: Boolean(intent || changedFiles.length), evidence: intent ? 'intent provided' : 'changed files define scope' },
-    { id: 'minimum_surface', passed: changedFiles.length <= 3 && !risk.flags.unknown_surface, evidence: `${changedFiles.length} changed file(s), ${selectedCones.length} proof cone(s)` },
+    { id: 'minimum_surface', passed: changedFiles.length <= 3 && !risk.flags.unknown_surface, evidence: `${changedFiles.length} changed file(s), ${selectedCones.length} proof cone(s), complexity=${workflowComplexity?.band || 'unknown'}` },
     { id: 'bounded_verification', passed: fastLane.verification.length > 0 && fastLane.verification.length <= 4, evidence: `${fastLane.verification.length} focused verification command(s)` },
     { id: 'escalation_defined', passed: Array.isArray(fastLane.escalate_on) && fastLane.escalate_on.length > 0, evidence: `${fastLane.escalate_on.length} escalation trigger(s)` }
   ].map((criterion) => ({
@@ -258,7 +381,7 @@ function outcomeScorecard({ intent, changedFiles, selectedCones, risk, negativeW
   };
 }
 
-function executionLaneDecision({ fastLane, simplicity }) {
+function executionLaneDecision({ fastLane, simplicity, workflowComplexity, teamTriggerMatrix }) {
   const score = Number(simplicity?.score || 0);
   const fast = Boolean(fastLane?.eligible) && score >= FAST_LANE_MIN_SCORE;
   const lane = fast
@@ -276,7 +399,7 @@ function executionLaneDecision({ fastLane, simplicity }) {
     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}, blockers=${(fastLane?.blockers || []).join(', ') || 'none'}`
+      : `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'}`
   };
 }