@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-self-test-gate-profile.mjs

@@ -0,0 +1,225 @@
+import crypto from 'node:crypto';
+
+const selfTestGateProfileStage = 'Stage 106';
+const selfTestGateProfileKind = 'self-test-gate-profile';
+
+export function runtimeSelfTestGateProfile({ planActionManifest = {}, registry = {}, registryDigest = '' } = {}) {
+  const boundaryAssertions = runtimeSelfTestGateProfileBoundaryAssertions();
+  const checkExpectations = planActionManifest.check_expectations || [];
+  const gateItems = checkExpectations.map((item, index) => selfTestGateItem(item, index));
+  const coverage = coverageSummary(gateItems);
+  const profile = {
+    version: 1,
+    stage: selfTestGateProfileStage,
+    profile_kind: selfTestGateProfileKind,
+    source_bindings: {
+      plan_action_manifest_stage: planActionManifest.stage || '',
+      plan_action_manifest_digest: planActionManifest.plan_action_manifest_digest || '',
+      registry_stage: registry.registry_stage || '',
+      registry_kind: registry.registry_kind || '',
+      registry_version: registry.registry_version || 0,
+      registry_digest: registryDigest,
+    },
+    gate_items: gateItems,
+    gate_categories: ['syntax', 'runtime_contract', 'release_contract', 'diff_hygiene', 'manual_verification'],
+    coverage,
+    evidence_requirements: evidenceRequirements(gateItems),
+    recommended_order: recommendedOrder(gateItems),
+    next_manual_action: nextManualAction(gateItems),
+    allowed_followup: ['Stage 107 commit readiness envelope', 'Stage 108 confirmed one-shot execution plan'],
+    forbidden_actions: [
+      'check execution',
+      'test execution',
+      'repair execution',
+      'formatting or code generation',
+      'sidecar or .vibecoding-state write',
+      'git commit/push/PR/merge/tag',
+      'platform API, external network, model, MCP, or subagent invocation',
+      'treating recommended checks as completed evidence',
+    ],
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeSelfTestGateProfileInvariants(profile);
+  return {
+    ...profile,
+    profile_invariants: invariants,
+    manual_action: invariants.pass
+      ? 'Self-test gate profile is ready. Use it as a deterministic checklist; Stage 106 did not run checks.'
+      : 'Fix the listed self-test gate profile gaps before using this profile for commit readiness.',
+  };
+}
+
+export function runtimeSelfTestGateProfileInvariants(profile) {
+  const gateItems = profile.gate_items || [];
+  const missingSourceBindings = ['plan_action_manifest_digest', 'registry_digest']
+    .filter((key) => !profile.source_bindings?.[key]);
+  const incompleteGates = gateItems
+    .filter((item) => !item.id || !item.category || !item.command || item.execution_authorized !== false || item.status !== 'planned_not_run')
+    .map((item) => item.id || item.command || 'unknown');
+  const executableGates = gateItems
+    .filter((item) => item.execution_authorized !== false)
+    .map((item) => item.id || item.command || 'unknown');
+  const writableBoundaries = Object.entries(profile.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const forbiddenMissing = ['command_execution', 'test_execution', 'repair_execution', 'git', 'push', 'pr', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write']
+    .filter((key) => profile.boundary_assertions?.[key] !== false);
+  const findings = [
+    ...(gateItems.length === 0 ? ['gate_items must not be empty'] : []),
+    ...missingSourceBindings.map((item) => `missing source binding: ${item}`),
+    ...incompleteGates.map((item) => `incomplete or executable gate item: ${item}`),
+    ...executableGates.map((item) => `execution must not be authorized: ${item}`),
+    ...writableBoundaries.map((item) => `boundary assertion must remain false: ${item}`),
+    ...forbiddenMissing.map((item) => `forbidden boundary missing or not false: ${item}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: [
+      'plan_action_manifest_binding',
+      'gate_item_schema',
+      'planned_not_run_status',
+      'execution_authorized_false',
+      'read_only_boundary_assertions',
+    ],
+    findings,
+  };
+}
+
+export function runtimeSelfTestGateProfileBoundaryAssertions() {
+  return {
+    self_test_gate_profile_artifact: false,
+    test_result_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    test_execution: false,
+    verification_execution: false,
+    repair_execution: false,
+    formatting_execution: false,
+    code_generation: false,
+    runtime_action: false,
+    workflow_execution: false,
+    scheduler: false,
+    daemon: false,
+    retry: false,
+    git: false,
+    git_write: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeSelfTestGateProfileDigestPayload(profile) {
+  return {
+    stage: profile.stage,
+    profile_kind: profile.profile_kind,
+    source_bindings: profile.source_bindings,
+    gate_items: profile.gate_items,
+    gate_categories: profile.gate_categories,
+    coverage: profile.coverage,
+    evidence_requirements: profile.evidence_requirements,
+    recommended_order: profile.recommended_order,
+    next_manual_action: profile.next_manual_action,
+    allowed_followup: profile.allowed_followup,
+    forbidden_actions: profile.forbidden_actions,
+    boundary_assertions: profile.boundary_assertions,
+    profile_invariants: profile.profile_invariants,
+  };
+}
+
+export function digestSelfTestGateProfile(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function selfTestGateItem(item, index) {
+  const command = String(item.command || '').trim() || `manual verification ${index + 1}`;
+  const category = classifyCommand(command);
+  return {
+    id: `stage106-gate-${String(index + 1).padStart(2, '0')}-${category}`,
+    category,
+    command,
+    evidence_required: item.evidence_required || evidenceForCategory(category),
+    source_check_expectation_id: item.id || '',
+    status: 'planned_not_run',
+    execution_authorized: false,
+    stop_conditions: stopConditionsForCategory(category),
+  };
+}
+
+function classifyCommand(command) {
+  if (/node\s+--check|tsc|eslint|syntax/i.test(command)) return 'syntax';
+  if (/vibe-runtime-check|runtime-check/i.test(command)) return 'runtime_contract';
+  if (/vibe-release-check|release-check/i.test(command)) return 'release_contract';
+  if (/git\s+diff\s+--check|diff --check/i.test(command)) return 'diff_hygiene';
+  return 'manual_verification';
+}
+
+function coverageSummary(gateItems) {
+  const categories = Object.fromEntries(['syntax', 'runtime_contract', 'release_contract', 'diff_hygiene', 'manual_verification'].map((key) => [key, 0]));
+  for (const item of gateItems) categories[item.category] = (categories[item.category] || 0) + 1;
+  return {
+    gate_count: gateItems.length,
+    categories,
+    has_syntax_gate: categories.syntax > 0,
+    has_runtime_contract_gate: categories.runtime_contract > 0,
+    has_release_contract_gate: categories.release_contract > 0,
+    has_diff_hygiene_gate: categories.diff_hygiene > 0,
+  };
+}
+
+function evidenceRequirements(gateItems) {
+  return gateItems.map((item) => ({
+    gate_id: item.id,
+    category: item.category,
+    required_evidence: item.evidence_required,
+    completion_claim_allowed_without_evidence: false,
+  }));
+}
+
+function recommendedOrder(gateItems) {
+  const order = ['syntax', 'runtime_contract', 'release_contract', 'diff_hygiene', 'manual_verification'];
+  return [...gateItems].sort((left, right) => order.indexOf(left.category) - order.indexOf(right.category)).map((item) => item.id);
+}
+
+function nextManualAction(gateItems) {
+  if (gateItems.length === 0) return 'Add check_expectations in Stage 105 before deriving a self-test gate profile.';
+  return 'Run the recommended checks manually if needed, capture evidence, then use Stage 107 commit readiness envelope.';
+}
+
+function evidenceForCategory(category) {
+  const table = {
+    syntax: 'fresh syntax/type/lint output or explicit blocked reason',
+    runtime_contract: 'fresh runtime-check output or explicit blocked reason',
+    release_contract: 'fresh release-check output or explicit blocked reason',
+    diff_hygiene: 'fresh git diff --check output or explicit blocked reason',
+    manual_verification: 'manual verification note tied to changed scope',
+  };
+  return table[category] || table.manual_verification;
+}
+
+function stopConditionsForCategory(category) {
+  return [
+    'command would write outside the sandbox or accepted scope',
+    'check requires network/platform/model/subagent access',
+    `missing evidence for ${category}`,
+  ];
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+  if (value && typeof value === 'object') return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  return JSON.stringify(value);
+}

package/tools/vibe-runtime/runtime-sequential-stage-runbook.mjs

@@ -0,0 +1,406 @@
+import crypto from 'node:crypto';
+
+const sequentialStageRunbookStage = 'Stage 118';
+const sequentialStageRunbookKind = 'sequential-stage-runbook';
+
+export function runtimeSequentialStageRunbook({ sourcePlan = {}, executablePlan = null, registry = {}, registryDigest = '' } = {}) {
+  const text = String(sourcePlan.text || '');
+  const boundaryAssertions = runtimeSequentialStageRunbookBoundaryAssertions();
+  const sourceStages = deriveStageSequence(text, executablePlan);
+  const stageSequence = sourceStages.map((stage, index) => buildRunbookStage(stage, index, sourceStages));
+  const stageOrderGate = buildStageOrderGate(stageSequence);
+  const blockedReasons = blockedReasonsFor(stageSequence, stageOrderGate, executablePlan);
+  const runbook = {
+    version: 1,
+    stage: sequentialStageRunbookStage,
+    runbook_kind: sequentialStageRunbookKind,
+    source_plan: {
+      file: sourcePlan.file || '',
+      digest: sourcePlan.digest || '',
+      line_count: Number(sourcePlan.line_count || 0),
+    },
+    source_bindings: {
+      executable_plan_stage: executablePlan?.stage || '',
+      executable_plan_kind: executablePlan?.contract_kind || '',
+      executable_plan_digest: executablePlan?.executable_plan_digest || '',
+      executable_plan_quality_pass: executablePlan?.plan_quality_pass === true,
+      registry_stage: registry.registry_stage || '',
+      registry_kind: registry.registry_kind || '',
+      registry_version: registry.registry_version || 0,
+      registry_digest: registryDigest,
+    },
+    stage_sequence: stageSequence,
+    stage_order_gate: stageOrderGate,
+    execution_order: stageSequence.map((item) => item.stage_id),
+    evidence_required: [...new Set(stageSequence.flatMap((item) => item.evidence_required))],
+    blocked_reasons: blockedReasons,
+    ready_for_evidence_binding: blockedReasons.length === 0 && stageSequence.length > 0,
+    next_manual_action: nextManualAction(blockedReasons, stageSequence),
+    allowed_followup: ['Stage 119 execution evidence binder', 'manual runbook refinement before Stage 119'],
+    forbidden_actions: [
+      'stage execution or command execution',
+      'test/check execution',
+      'source write or plan mutation',
+      'runbook artifact or sidecar write',
+      'git commit/push/PR/merge/tag',
+      'platform API, external network, model, MCP, or subagent invocation',
+    ],
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeSequentialStageRunbookInvariants(runbook);
+  return {
+    ...runbook,
+    runbook_invariants: invariants,
+    manual_action: invariants.pass
+      ? 'Sequential stage runbook is ready as a read-only control-plane contract. Stage 118 did not execute commands, write artifacts, or mutate git/source state.'
+      : 'Fix the listed runbook gaps before binding Stage 119 execution evidence.',
+  };
+}
+
+export function runtimeSequentialStageRunbookInvariants(runbook) {
+  const missingSourceBindings = ['source_plan.digest', 'source_bindings.registry_digest']
+    .filter((key) => !getPath(runbook, key));
+  const missingFields = ['stage_sequence', 'stage_order_gate', 'execution_order', 'evidence_required', 'blocked_reasons']
+    .filter((field) => runbook[field] === undefined || runbook[field] === null);
+  const incompleteStages = (runbook.stage_sequence || [])
+    .filter((item) => !item.stage_id || !Array.isArray(item.files_to_change) || !Array.isArray(item.validation_commands) || !Array.isArray(item.evidence_required) || !item.commit_subject || !Array.isArray(item.stop_if) || item.execution_authorized !== false || item.actions_executed !== false)
+    .map((item) => item.stage_id || item.title || 'unknown');
+  const orderMismatch = (runbook.stage_sequence || [])
+    .map((item) => item.stage_id)
+    .some((stageId, index) => stageId !== runbook.execution_order?.[index]);
+  const stageOrderGateFindings = runbook.stage_order_gate?.pass === true ? [] : ['stage_order_gate must pass before Stage 119 evidence binding'];
+  const incompleteOrderGates = (runbook.stage_order_gate?.per_stage_gates || [])
+    .filter((item) => item.execution_authorized !== false || item.command_execution_authorized !== false || item.git_write_authorized !== false || !item.commit_condition || !Array.isArray(item.input_required) || !Array.isArray(item.mutex_conflicts))
+    .map((item) => item.stage_id || 'unknown');
+  const writableBoundaries = Object.entries(runbook.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const forbiddenMissing = ['stage_runbook_artifact', 'sidecar_write', 'state_directory_created', 'source_write', 'plan_mutation', 'command_execution', 'check_execution', 'test_execution', 'runtime_action', 'git', 'git_write', 'commit', 'push', 'pr', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write']
+    .filter((key) => runbook.boundary_assertions?.[key] !== false);
+  const preview = runbook.runbook_executor_preview;
+  const previewFindings = preview ? [
+    ...(preview.stage === 'stage-9-runbook-executor-preview' ? [] : ['runbook_executor_preview stage must be stage-9-runbook-executor-preview']),
+    ...(preview.contract_kind === 'runbook-executor-preview-dry-run-contract' ? [] : ['runbook_executor_preview contract kind must be runbook-executor-preview-dry-run-contract']),
+    ...(preview.runbook_executor_preview_invariants?.pass === true ? [] : ['runbook_executor_preview invariants must pass']),
+    ...(preview.ready_for_runtime_action === false ? [] : ['runbook_executor_preview must not authorize runtime action']),
+    ...(preview.boundary_assertions?.command_execution === false ? [] : ['runbook_executor_preview command boundary must remain false']),
+    ...(preview.boundary_assertions?.source_write === false ? [] : ['runbook_executor_preview source boundary must remain false']),
+    ...(preview.boundary_assertions?.git_write === false ? [] : ['runbook_executor_preview git boundary must remain false']),
+  ] : [];
+  const findings = [
+    ...(runbook.stage === sequentialStageRunbookStage ? [] : ['stage must be Stage 118']),
+    ...(runbook.runbook_kind === sequentialStageRunbookKind ? [] : ['runbook_kind must be sequential-stage-runbook']),
+    ...missingSourceBindings.map((item) => `missing source binding: ${item}`),
+    ...missingFields.map((item) => `missing required field: ${item}`),
+    ...(runbook.stage_sequence?.length > 0 ? [] : ['stage_sequence must not be empty']),
+    ...(orderMismatch ? ['execution_order must mirror stage_sequence order'] : []),
+    ...incompleteStages.map((item) => `incomplete or executable runbook stage: ${item}`),
+    ...stageOrderGateFindings,
+    ...previewFindings,
+    ...incompleteOrderGates.map((item) => `incomplete or executable stage order gate: ${item}`),
+    ...writableBoundaries.map((item) => `boundary assertion must remain false: ${item}`),
+    ...forbiddenMissing.map((item) => `forbidden boundary missing or not false: ${item}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: [
+      'source_plan_binding',
+      'optional_executable_plan_binding',
+      'stage_sequence_schema',
+      'stage_order_gate_schema',
+      'execution_order_schema',
+      'evidence_required_schema',
+      'execution_authorized_false',
+      'read_only_boundary_assertions',
+    ],
+    findings,
+  };
+}
+
+export function runtimeSequentialStageRunbookBoundaryAssertions() {
+  return {
+    stage_runbook_artifact: false,
+    runbook_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    source_write: false,
+    plan_mutation: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    repair_execution: false,
+    formatting_execution: false,
+    code_generation: false,
+    action_item_execution: false,
+    runtime_action: false,
+    workflow_execution: false,
+    auto_execution: false,
+    scheduler: false,
+    daemon: false,
+    retry: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeSequentialStageRunbookDigestPayload(runbook) {
+  return {
+    stage: runbook.stage,
+    runbook_kind: runbook.runbook_kind,
+    source_plan: runbook.source_plan,
+    source_bindings: runbook.source_bindings,
+    stage_sequence: runbook.stage_sequence,
+    stage_order_gate: runbook.stage_order_gate,
+    execution_order: runbook.execution_order,
+    evidence_required: runbook.evidence_required,
+    runbook_executor_preview: runbook.runbook_executor_preview ? {
+      stage: runbook.runbook_executor_preview.stage,
+      contract_kind: runbook.runbook_executor_preview.contract_kind,
+      preview_mode: runbook.runbook_executor_preview.preview_mode,
+      source_bindings: runbook.runbook_executor_preview.source_bindings,
+      task_budget_preview: runbook.runbook_executor_preview.task_budget_preview,
+      ordered_steps: runbook.runbook_executor_preview.ordered_steps,
+      required_gates: runbook.runbook_executor_preview.required_gates,
+      allowed_actions: runbook.runbook_executor_preview.allowed_actions,
+      blocked_actions: runbook.runbook_executor_preview.blocked_actions,
+      expected_evidence: runbook.runbook_executor_preview.expected_evidence,
+      blocked_reasons: runbook.runbook_executor_preview.blocked_reasons,
+      preview_gate: runbook.runbook_executor_preview.preview_gate,
+      boundary_assertions: runbook.runbook_executor_preview.boundary_assertions,
+      runbook_executor_preview_invariants: runbook.runbook_executor_preview.runbook_executor_preview_invariants,
+      runbook_executor_preview_digest: runbook.runbook_executor_preview.runbook_executor_preview_digest,
+    } : null,
+    blocked_reasons: runbook.blocked_reasons,
+    ready_for_evidence_binding: runbook.ready_for_evidence_binding,
+    allowed_followup: runbook.allowed_followup,
+    forbidden_actions: runbook.forbidden_actions,
+    boundary_assertions: runbook.boundary_assertions,
+    runbook_invariants: runbook.runbook_invariants,
+  };
+}
+
+export function digestSequentialStageRunbook(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function deriveStageSequence(text, executablePlan) {
+  const fromExecutable = Array.isArray(executablePlan?.task_readiness)
+    ? executablePlan.task_readiness.map((item) => ({
+      title: item.title || item.id || 'unnamed executable task',
+      files: item.files_to_change || [],
+      commands: item.verification_commands || [],
+      evidence: evidenceForTask(item),
+      commitSubjects: item.commit_subject_hints || [],
+      stopIf: item.stop_conditions || [],
+      source: 'executable_plan.task_readiness',
+    }))
+    : [];
+  if (fromExecutable.length > 0) return fromExecutable.slice(0, 30);
+
+  const lines = String(text || '').split(/\r?\n/);
+  const globalFiles = extractPaths(text).slice(0, 12);
+  const globalCommands = extractCommands(text).slice(0, 10);
+  const globalEvidence = extractEvidenceRequirements(lines);
+  const globalCommitSubjects = extractCommitSubjects(text);
+  const globalStopIf = extractStopConditions(lines);
+  const actionLines = lines
+    .map((line, index) => ({ line: line.trim(), index }))
+    .filter((item) => /^[-*]\s+\[[ xX]\]\s+.+|^[-*]\s+(Stage\s+\d+|Task\b|Implement\b|Update\b|Validate\b|Run\b|Create\b|Bind\b|Commit\b|Stop\b).+/i.test(item.line));
+  return actionLines.slice(0, 30).map((item) => ({
+    title: item.line.replace(/^[-*]\s+(?:\[[ xX]\]\s+)?/, ''),
+    files: extractPaths(item.line).length > 0 ? extractPaths(item.line) : globalFiles,
+    commands: globalCommands,
+    evidence: globalEvidence,
+    commitSubjects: globalCommitSubjects,
+    stopIf: globalStopIf,
+    source: `source_plan.line:${item.index + 1}`,
+  }));
+}
+
+function buildRunbookStage(stage, index, allStages) {
+  const stageNumber = extractStageNumber(stage.title) || String(index + 1).padStart(2, '0');
+  const files = dedupe(stage.files || []).slice(0, 20);
+  const commands = dedupe(stage.commands || []).slice(0, 12);
+  const evidence = dedupe([...(stage.evidence || []), ...commands.map((command) => `exit_code=0 and output marker for: ${command}`)]).slice(0, 20);
+  const stopIf = dedupe([
+    ...(stage.stopIf || []),
+    'required evidence is missing, stale, or failed',
+    'stage would require runtime command execution or source mutation',
+    'stage would require git push, PR, merge, platform API, model, MCP, or subagent access',
+  ]).slice(0, 20);
+  return {
+    stage_id: `stage118-runbook-${String(index + 1).padStart(2, '0')}-${slug(stageNumber)}`,
+    source: stage.source || '',
+    title: stage.title || `Stage ${stageNumber}`,
+    sequence_index: index + 1,
+    files_to_change: files,
+    validation_commands: commands,
+    evidence_required: evidence,
+    commit_subject: (stage.commitSubjects || [])[0] || `stage ${stageNumber} local commit subject required`,
+    stop_if: stopIf,
+    depends_on: index === 0 ? [] : [`stage118-runbook-${String(index).padStart(2, '0')}-${slug(extractStageNumber(allStages[index - 1]?.title) || String(index).padStart(2, '0'))}`],
+    next_stage: index + 1 < allStages.length ? `stage118-runbook-${String(index + 2).padStart(2, '0')}-${slug(extractStageNumber(allStages[index + 1]?.title) || String(index + 2).padStart(2, '0'))}` : 'Stage 119 execution evidence binder',
+    execution_authorized: false,
+    actions_executed: false,
+    command_execution_authorized: false,
+    git_write_authorized: false,
+  };
+}
+
+function overlaps(left, right) {
+  const rightSet = new Set(right || []);
+  return (left || []).some((item) => rightSet.has(item));
+}
+
+function buildStageOrderGate(stageSequence) {
+  const perStageGates = stageSequence.map((stage, index) => {
+    const inputRequired = dedupe([
+      'accepted executable plan or local plan section',
+      ...(index === 0 ? ['clean stage baseline'] : [`previous stage completed: ${stage.depends_on[0]}`]),
+      ...stage.files_to_change.map((file) => `file scope: ${file}`),
+    ]).slice(0, 20);
+    const mutexConflicts = stageSequence
+      .filter((candidate) => candidate.stage_id !== stage.stage_id && overlaps(stage.files_to_change, candidate.files_to_change))
+      .map((candidate) => candidate.stage_id);
+    const gateGaps = [
+      ...(inputRequired.length > 0 ? [] : ['input_required']),
+      ...(stage.files_to_change.length > 0 ? [] : ['files_to_change']),
+      ...(stage.validation_commands.length > 0 ? [] : ['validation_commands']),
+      ...(stage.evidence_required.length > 0 ? [] : ['evidence_required']),
+      ...(stage.stop_if.length > 0 ? [] : ['stop_if']),
+      ...(stage.commit_subject ? [] : ['commit_subject']),
+    ];
+    return {
+      stage_id: stage.stage_id,
+      sequence_index: stage.sequence_index,
+      input_required: inputRequired,
+      dependencies: stage.depends_on,
+      dependency_gate: index === 0 ? 'root_stage' : 'previous_stage_must_pass_evidence_and_commit_readiness',
+      mutex_group: `files:${stage.files_to_change.slice().sort().join('|') || 'none'}`,
+      mutex_conflicts: mutexConflicts,
+      conflict_policy: mutexConflicts.length > 0 ? 'serialize_overlapping_file_scopes_before_execution' : 'no_conflict_detected',
+      commit_condition: {
+        subject: stage.commit_subject,
+        require_validation_evidence: stage.validation_commands.length > 0,
+        require_stage_evidence: stage.evidence_required.length > 0,
+        commit_execution_authorized: false,
+      },
+      stop_if: stage.stop_if,
+      pass: gateGaps.length === 0,
+      blocking_gaps: gateGaps,
+      execution_authorized: false,
+      command_execution_authorized: false,
+      git_write_authorized: false,
+    };
+  });
+  const blocked = perStageGates
+    .filter((gate) => !gate.pass)
+    .map((gate) => `stage order gate gap: ${gate.stage_id}: ${gate.blocking_gaps.join(', ')}`);
+  return {
+    gate_kind: 'sequential-stage-order-gate',
+    pass: perStageGates.length > 0 && blocked.length === 0,
+    per_stage_gates: perStageGates,
+    blocked_reasons: blocked,
+    order_is_sequential: true,
+    auto_execution: false,
+    command_execution: false,
+    git_write: false,
+  };
+}
+
+function blockedReasonsFor(stageSequence, stageOrderGate, executablePlan) {
+  const reasons = [];
+  if (stageSequence.length === 0) reasons.push('missing stage_sequence');
+  for (const stage of stageSequence) {
+    if (stage.files_to_change.length === 0) reasons.push(`stage missing files_to_change: ${stage.stage_id}`);
+    if (stage.validation_commands.length === 0) reasons.push(`stage missing validation_commands: ${stage.stage_id}`);
+    if (stage.evidence_required.length === 0) reasons.push(`stage missing evidence_required: ${stage.stage_id}`);
+    if (!stage.commit_subject) reasons.push(`stage missing commit_subject: ${stage.stage_id}`);
+  }
+  if (executablePlan && executablePlan.plan_quality_pass !== true) reasons.push('source executable plan did not pass quality gate');
+  if (Array.isArray(stageOrderGate?.blocked_reasons)) reasons.push(...stageOrderGate.blocked_reasons);
+  return dedupe(reasons).slice(0, 40);
+}
+
+function nextManualAction(blockedReasons, stageSequence) {
+  if (blockedReasons.length > 0) return `Refine the runbook inputs before Stage 119. First blocker: ${blockedReasons[0]}`;
+  return `Review ${stageSequence.length} planned stage(s), then collect local execution evidence for Stage 119. Stage 118 did not run commands or write artifacts.`;
+}
+
+function evidenceForTask(item) {
+  const markers = item.expected_output_markers || [];
+  const base = ['command exit_code=0 evidence', 'fresh validation output summary'];
+  return dedupe([...base, ...markers.map((marker) => `expected output marker: ${marker}`)]);
+}
+
+function extractPaths(text) {
+  const matches = String(text || '').match(/(?:[A-Za-z]:[\\/])?(?:[\w.-]+[\\/])+(?:[\w.-]+\.(?:mjs|js|ts|tsx|jsx|json|md|yml|yaml|toml|txt|css|html)|[\w.-]+)/g) || [];
+  return dedupe(matches.map((item) => item.replace(/\\/g, '/')).filter((item) => !item.startsWith('http')).filter((item) => /\.(?:mjs|js|ts|tsx|jsx|json|md|yml|yaml|toml|txt|css|html)$/i.test(item)));
+}
+
+function extractCommands(text) {
+  const fencedCommands = [...String(text || '').matchAll(/`([^`]*(?:node|npm|pnpm|yarn|git|pytest|python|tsc|eslint|vitest|jest|powershell)[^`]*)`/gi)].map((match) => match[1].trim());
+  const lineCommands = [...String(text || '').matchAll(/(?:^|\n)\s*(?:[-*]\s*)?((?:node|npm|pnpm|yarn|git|pytest|python|tsc|eslint|vitest|jest|powershell)\s+[^\n`]+)/gi)].map((match) => match[1].trim());
+  return dedupe([...fencedCommands, ...lineCommands].map((item) => item.trim())).slice(0, 30);
+}
+
+function extractCommitSubjects(text) {
+  const explicit = [...String(text || '').matchAll(/(?:commit|提交)(?:\s+(?:subject|message)|\s*信息)?\s*[:：]\s*[`"“]?([^`"”\n]+)/gi)].map((match) => match[1].trim());
+  const conventional = String(text || '').match(/\b(?:feat|fix|docs|test|refactor|chore|perf)\([^\n)]+\):\s*[^\n]+/g) || [];
+  return dedupe([...explicit, ...conventional].map((item) => item.trim())).slice(0, 10);
+}
+
+function extractEvidenceRequirements(lines) {
+  const matches = lines
+    .map((line) => line.trim().replace(/^[-*]\s+/, ''))
+    .filter((line) => /evidence|required evidence|output marker|expected output|exit_code|验证证据|证据|输出|结果/i.test(line));
+  return dedupe(matches).slice(0, 20);
+}
+
+function extractStopConditions(lines) {
+  const matches = lines
+    .map((line) => line.trim().replace(/^[-*]\s+/, ''))
+    .filter((line) => /rollback|stop if|stop condition|blocked|fail|失败|阻塞|停止|回滚|不要|不得|out of scope/i.test(line));
+  return dedupe(matches).slice(0, 20);
+}
+
+function extractStageNumber(value) {
+  const match = String(value || '').match(/Stage\s*(\d+)/i);
+  return match ? `Stage ${match[1]}` : '';
+}
+
+function slug(value) {
+  return String(value || 'stage').toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40) || 'stage';
+}
+
+function dedupe(items) {
+  return [...new Set((items || []).filter(Boolean).map((item) => String(item).trim()).filter(Boolean))];
+}
+
+function getPath(value, dotted) {
+  return dotted.split('.').reduce((current, key) => current?.[key], value);
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}