@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-agent-session-start-contract.mjs

@@ -0,0 +1,138 @@
+import {
+  agentBehaviorBoundaryAssertions,
+  agentBehaviorForbiddenActions,
+  normalizeSuperpowersParityProfileName,
+} from './runtime-superpowers-parity-profile-contract.mjs';
+
+const CONTRACT_STAGE = 'Stage 15';
+const CONTRACT_KIND = 'agent-session-start-behavior-contract';
+const EXPECTED_FIRST_SKILL = 'using-vibecoding';
+const EXPECTED_SKILL_PATH = '.vibecoding/skills/using-vibecoding/SKILL.md';
+const STAGE15_BOUNDARY_MARKERS = 'runtime_action auto_execution platform_api external_network model_invocation git_write business_source_write';
+
+export function agentSessionStartBoundaryAssertions() {
+  return {
+    ...agentBehaviorBoundaryAssertions(),
+    agent_session_start_contract_artifact: false,
+    full_skill_injection: false,
+    hidden_execution: false,
+    workflow_start_artifact: false,
+    prompt_mutation: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    subagent_dispatch: false,
+    daemon: false,
+    watcher: false,
+    shell_interception: false,
+    source_merge: false,
+  };
+}
+
+export function buildAgentSessionStartContract({
+  profile = 'vibe-guided',
+  selectedSkill = '',
+  routeReason = '',
+  nextGate = '',
+  entrySummary = {},
+  readiness = {},
+  normalizedIntent = 'unknown',
+  prompt = '',
+  profileSource = 'explicit-or-default',
+  digestObject,
+} = {}) {
+  const normalizedProfile = normalizeSuperpowersParityProfileName(profile);
+  const strict = normalizedProfile === 'superpowers-parity';
+  const boundaryAssertions = agentSessionStartBoundaryAssertions();
+  const forbiddenActions = agentBehaviorForbiddenActions();
+  const contract = {
+    version: 1,
+    stage: CONTRACT_STAGE,
+    contract_kind: CONTRACT_KIND,
+    automation_profile: normalizedProfile,
+    profile_source: profileSource,
+    discipline_level: strict ? 'strict-skill-first-visible-route' : 'lightweight-using-vibecoding-route',
+    prompt: String(prompt || '').trim(),
+    normalized_intent: normalizedIntent,
+    expected_first_skill: EXPECTED_FIRST_SKILL,
+    skill_path: EXPECTED_SKILL_PATH,
+    registry_fallback_to_file_path: true,
+    visible_first_sentence: strict
+      ? `我会先按文件路径读取 \`${EXPECTED_SKILL_PATH}\`，用 \`${EXPECTED_FIRST_SKILL}\` 声明当前 route、验证策略和 stop condition 后再继续。`
+      : `我会先按文件路径读取 \`${EXPECTED_SKILL_PATH}\`，用 \`${EXPECTED_FIRST_SKILL}\` 做轻量分流，并说明可见下一步。`,
+    selected_skill_after_entry: selectedSkill || EXPECTED_FIRST_SKILL,
+    route_reason: routeReason || 'Use Vibecoding entry routing before implementation.',
+    next_gate: nextGate || entrySummary.first_user_decision || 'manual workflow judgment',
+    route_required_before_implementation: true,
+    plan_or_todo_required_when_planning: Boolean(strict || entrySummary.entry_classification === 'planning_needed' || normalizedIntent === 'plan'),
+    validation_strategy_required_before_change: true,
+    stop_conditions: [
+      'goal, scope, acceptance, or validation strategy is missing',
+      'requested action needs source write, command execution, subagent, platform API, or git without explicit scoped permission',
+      'bug or failure lacks reproduction and root-cause evidence',
+      'completion claim lacks fresh verification evidence',
+    ],
+    context_policy: {
+      default_context: 'tiny_context',
+      full_skill_injection: false,
+      load_only_bootstrap_contract_first: true,
+      upgrade_to_balanced_context_when: [
+        'implementation, debugging, or completion verification needs evidence detail',
+        'handoff, stage transition, or risk boundary requires more context',
+      ],
+    },
+    visible_receipt_requirements: {
+      must_name_entry_skill: EXPECTED_FIRST_SKILL,
+      must_show_next_manual_action: true,
+      must_not_claim_skill_execution_from_receipt: true,
+      must_not_claim_command_execution_from_receipt: true,
+    },
+    readiness_summary: {
+      ready_to_start: readiness.ready_to_start === true,
+      required_gate_kinds: readiness.required_gate_kinds || [],
+      readiness_digest: readiness.readiness_digest || '',
+    },
+    entry_summary: {
+      entry_classification: entrySummary.entry_classification || 'unknown',
+      state_gap_is_expected: entrySummary.state_gap_is_expected === true,
+      first_user_decision: entrySummary.first_user_decision || '',
+      readiness_blocker_count: entrySummary.readiness_blocker_count || 0,
+    },
+    forbidden_actions: forbiddenActions,
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  return {
+    ...contract,
+    contract_digest: typeof digestObject === 'function' ? digestObject(contract) : '',
+  };
+}
+
+export function agentSessionStartContractDigestPayload(contract) {
+  return {
+    stage: contract.stage,
+    contract_kind: contract.contract_kind,
+    automation_profile: contract.automation_profile,
+    profile_source: contract.profile_source,
+    discipline_level: contract.discipline_level,
+    expected_first_skill: contract.expected_first_skill,
+    skill_path: contract.skill_path,
+    registry_fallback_to_file_path: contract.registry_fallback_to_file_path,
+    visible_first_sentence: contract.visible_first_sentence,
+    selected_skill_after_entry: contract.selected_skill_after_entry,
+    next_gate: contract.next_gate,
+    route_required_before_implementation: contract.route_required_before_implementation,
+    plan_or_todo_required_when_planning: contract.plan_or_todo_required_when_planning,
+    validation_strategy_required_before_change: contract.validation_strategy_required_before_change,
+    stop_conditions: contract.stop_conditions,
+    context_policy: contract.context_policy,
+    visible_receipt_requirements: contract.visible_receipt_requirements,
+    forbidden_actions: contract.forbidden_actions,
+    boundary_assertions: contract.boundary_assertions,
+  };
+}

package/tools/vibe-runtime/runtime-artifact-ref-validation.mjs

@@ -0,0 +1,281 @@
+import crypto from 'node:crypto';
+
+const traceabilityRefBindings = Object.freeze({
+  requirement_ref: ['product_discovery', 'product_spec'],
+  product_story_ref: ['product_spec'],
+  ui_flow_ref: ['ui_design'],
+  architecture_decision_ref: ['architecture'],
+  scenario_ref: ['scenarios'],
+  product_acceptance_ref: ['product_acceptance'],
+});
+
+const artifactInputSpecs = Object.freeze([
+  ['product_discovery', 'fromProductDiscovery', 'completion ref validation --from-product-discovery'],
+  ['product_spec', 'fromProductSpec', 'completion ref validation --from-product-spec'],
+  ['ui_design', 'fromUiDesign', 'completion ref validation --from-ui-design'],
+  ['architecture', 'fromArchitecture', 'completion ref validation --from-architecture'],
+  ['scenarios', 'fromScenarios', 'completion ref validation --from-scenarios'],
+  ['product_acceptance', 'fromProductAcceptance', 'completion ref validation --from-product-acceptance'],
+  ['traceability', 'fromTraceability', 'completion ref validation --from-traceability'],
+]);
+
+const referenceRegistryKeys = Object.freeze({
+  requirement_refs: 'requirement_ref',
+  product_story_refs: 'product_story_ref',
+  ui_flow_refs: 'ui_flow_ref',
+  architecture_decision_refs: 'architecture_decision_ref',
+  scenario_refs: 'scenario_ref',
+  product_acceptance_refs: 'product_acceptance_ref',
+});
+
+const fallbackRefPatterns = Object.freeze({
+  requirement_ref: /\breq-[A-Za-z0-9._-]+\b/g,
+  product_story_ref: /\bstory-[A-Za-z0-9._-]+\b/g,
+  ui_flow_ref: /\bflow-[A-Za-z0-9._-]+\b/g,
+  architecture_decision_ref: /\badr-[A-Za-z0-9._-]+\b/g,
+  scenario_ref: /(?:^|\n)\s*-\s*id:\s*([A-Za-z0-9._-]+)\s*(?:\n|$)/g,
+  product_acceptance_ref: /\bacceptance-[A-Za-z0-9._-]+\b/g,
+});
+
+export function completionCrossArtifactRefValidation(root, options = {}, { readLocalTextArtifact }) {
+  const sources = readArtifactSources(root, options, readLocalTextArtifact);
+  const traceabilitySource = sources.traceability;
+  if (!traceabilitySource) {
+    return skippedRefValidation('traceability artifact not provided');
+  }
+
+  const index = buildArtifactReferenceIndex(sources);
+  const traceabilityRefs = parseDeliveryTraceabilityRefs(traceabilitySource.text);
+  const validation = validateTraceabilityRefsAgainstIndex(traceabilityRefs, index);
+  const payload = {
+    outcome: validation.missing_refs.length === 0 && validation.unbound_ref_types.length === 0 ? 'pass' : 'blocked',
+    checked_ref_types: Object.keys(traceabilityRefBindings),
+    matched_refs: validation.matched_refs,
+    missing_refs: validation.missing_refs,
+    unbound_ref_types: validation.unbound_ref_types,
+    link_count: traceabilityRefs.links.length,
+    source_index_digests: Object.fromEntries(Object.entries(sources).map(([slot, source]) => [slot, source.digest])),
+    boundary_assertions: {
+      writes: false,
+      command_execution: false,
+      test_execution: false,
+      git: false,
+      git_write: false,
+    },
+  };
+  return {
+    status: 'provided',
+    ok: payload.outcome === 'pass',
+    ref_validation: {
+      ...payload,
+      validation_digest: digestObject(payload),
+    },
+    blocked_reasons: [
+      ...validation.missing_refs.map((item) => `traceability_ref_missing: ${item.ref_type}=${item.ref} not found in ${item.expected_slots.join('|')}`),
+      ...validation.unbound_ref_types.map((item) => `traceability_ref_unbound: ${item.ref_type} has no provided source artifact (${item.expected_slots.join('|')})`),
+    ],
+  };
+}
+
+export function buildArtifactReferenceIndex(sources = {}) {
+  const slots = Object.keys(sources).filter((slot) => slot !== 'traceability');
+  const refs = {};
+  const sourceSlots = {};
+  for (const refType of Object.keys(traceabilityRefBindings)) {
+    refs[refType] = new Map();
+    sourceSlots[refType] = [];
+  }
+
+  for (const slot of slots) {
+    const source = sources[slot];
+    if (!source?.text) continue;
+    const slotRefs = collectRefsFromArtifact(slot, source.text);
+    for (const [refType, values] of Object.entries(slotRefs)) {
+      if (!refs[refType]) continue;
+      if (values.length > 0 && !sourceSlots[refType].includes(slot)) sourceSlots[refType].push(slot);
+      for (const ref of values) {
+        const locations = refs[refType].get(ref) || [];
+        refs[refType].set(ref, [...new Set([...locations, slot])]);
+      }
+    }
+  }
+
+  return { refs, source_slots: sourceSlots };
+}
+
+export function parseDeliveryTraceabilityRefs(text) {
+  const links = parseTraceabilityLinks(text);
+  return {
+    links: links.map((link) => ({
+      id: link.id,
+      refs: Object.fromEntries(Object.keys(traceabilityRefBindings).map((refType) => [refType, scalarValue(link.block, refType)]).filter(([, value]) => Boolean(value))),
+    })),
+  };
+}
+
+export function validateTraceabilityRefsAgainstIndex(traceabilityRefs, index) {
+  const matchedRefs = [];
+  const missingRefs = [];
+  const unboundRefTypes = [];
+
+  for (const link of traceabilityRefs.links) {
+    for (const [refType, ref] of Object.entries(link.refs)) {
+      const expectedSlots = traceabilityRefBindings[refType] || [];
+      const providedSlots = expectedSlots.filter((slot) => (index.source_slots[refType] || []).includes(slot));
+      if (providedSlots.length === 0) {
+        unboundRefTypes.push({ link_id: link.id, ref_type: refType, ref, expected_slots: expectedSlots });
+        continue;
+      }
+      const locations = index.refs[refType]?.get(ref) || [];
+      if (locations.length > 0) {
+        matchedRefs.push({ link_id: link.id, ref_type: refType, ref, locations });
+      } else {
+        missingRefs.push({ link_id: link.id, ref_type: refType, ref, expected_slots: expectedSlots });
+      }
+    }
+  }
+
+  return { matched_refs: matchedRefs, missing_refs: missingRefs, unbound_ref_types: dedupeRefFindings(unboundRefTypes) };
+}
+
+export function scenarioRefsFromArtifactText(text) {
+  return [...new Set(collectRefsFromArtifact('scenarios', text).scenario_ref || [])];
+}
+
+function readArtifactSources(root, options, readLocalTextArtifact) {
+  const sources = {};
+  for (const [slot, optionKey, label] of artifactInputSpecs) {
+    const input = options[optionKey] || '';
+    if (!input) continue;
+    sources[slot] = readLocalTextArtifact(root, input, label);
+  }
+  return sources;
+}
+
+function skippedRefValidation(reason) {
+  return {
+    status: 'skipped',
+    ok: true,
+    ref_validation: {
+      outcome: 'skipped',
+      reason,
+      checked_ref_types: Object.keys(traceabilityRefBindings),
+      matched_refs: [],
+      missing_refs: [],
+      unbound_ref_types: [],
+      link_count: 0,
+      source_index_digests: {},
+      validation_digest: digestObject({ outcome: 'skipped', reason }),
+    },
+    blocked_reasons: [],
+  };
+}
+
+function collectRefsFromArtifact(slot, text) {
+  const refs = parseReferenceRegistry(text);
+  for (const [refType, pattern] of Object.entries(fallbackRefPatterns)) {
+    refs[refType] = [...new Set([...(refs[refType] || []), ...matchesForPattern(pattern, text)])];
+  }
+  if (slot === 'scenarios') refs.scenario_ref = [...new Set([...(refs.scenario_ref || []), ...parseScenarioIds(text)])];
+  return refs;
+}
+
+function parseReferenceRegistry(text) {
+  const section = sectionText(text, 'Reference Registry');
+  const refs = {};
+  const lines = section.split(/\r?\n/);
+  let currentKey = '';
+  for (const line of lines) {
+    const keyMatch = line.match(/^\s*([A-Za-z0-9_]+):\s*(.*?)\s*$/);
+    if (keyMatch) {
+      currentKey = referenceRegistryKeys[keyMatch[1]] || '';
+      if (currentKey) refs[currentKey] = [...(refs[currentKey] || []), ...inlineListValues(keyMatch[2])];
+      continue;
+    }
+    const itemMatch = line.match(/^\s*-\s*([A-Za-z0-9._-]+)\s*$/);
+    if (itemMatch && currentKey) refs[currentKey] = [...(refs[currentKey] || []), itemMatch[1]];
+  }
+  return Object.fromEntries(Object.entries(refs).map(([key, values]) => [key, [...new Set(values.filter(Boolean))]]));
+}
+
+function parseTraceabilityLinks(text) {
+  const lines = text.split(/\r?\n/);
+  const blocks = [];
+  let current = null;
+  for (const line of lines) {
+    const start = line.match(/^\s*-\s+id:\s*(\S.*?)\s*$/);
+    if (start) {
+      if (current) blocks.push(current);
+      current = { id: stripQuotes(start[1]), lines: [line] };
+      continue;
+    }
+    if (current) current.lines.push(line);
+  }
+  if (current) blocks.push(current);
+  return blocks.map((block) => ({ id: block.id, block: block.lines.join('\n') }));
+}
+
+function scalarValue(block, key) {
+  const match = block.match(new RegExp(`(?:^|\\n)\\s*${escapeRegExp(key)}:\\s*(\\S.*?)\\s*(?:\\n|$)`));
+  return stripQuotes(match?.[1] || '');
+}
+
+function sectionText(text, section) {
+  const match = text.match(new RegExp(`^##\\s+${escapeRegExp(section)}\\s*$([\\s\\S]*?)(?=^##\\s+|$)`, 'm'));
+  return match?.[1] || '';
+}
+
+function inlineListValues(value) {
+  const normalized = String(value || '').trim();
+  if (!normalized) return [];
+  if (normalized.startsWith('[') && normalized.endsWith(']')) {
+    return normalized.slice(1, -1).split(',').map(stripQuotes).filter(Boolean);
+  }
+  return [stripQuotes(normalized)].filter(Boolean);
+}
+
+function matchesForPattern(pattern, text) {
+  const values = [];
+  pattern.lastIndex = 0;
+  let match;
+  while ((match = pattern.exec(text))) values.push(stripQuotes(match[1] || match[0]));
+  return values;
+}
+
+function parseScenarioIds(text) {
+  const values = [];
+  const regex = /(?:^|\n)\s*-\s+id:\s*([A-Za-z0-9._-]+)\s*(?:\n|$)/g;
+  let match;
+  while ((match = regex.exec(text))) values.push(stripQuotes(match[1]));
+  return values;
+}
+
+function dedupeRefFindings(findings) {
+  const seen = new Set();
+  return findings.filter((item) => {
+    const key = `${item.link_id}\0${item.ref_type}\0${item.ref}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function stripQuotes(value) {
+  return String(value || '').trim().replace(/^['"]|['"]$/g, '');
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function digestObject(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).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-automatic-verification-gate-contract.mjs

@@ -0,0 +1,134 @@
+const CONTRACT_STAGE = 'stage-4-automatic-verification-gates';
+const CONTRACT_KIND = 'automatic-verification-gate-contract';
+
+const gateOrder = Object.freeze([
+  'stage_runbook_bound',
+  'execution_evidence_bound',
+  'test_evidence_checked',
+  'diff_coverage_checked',
+  'commit_readiness_checked',
+  'freshness_checked',
+  'coverage_checked',
+  'missing_evidence_reported',
+  'failed_evidence_reported',
+  'next_manual_action_recorded',
+]);
+
+const localEvidenceFields = Object.freeze([
+  'stage_runbook',
+  'execution_evidence',
+  'test_evidence',
+  'diff_coverage',
+  'commit_readiness',
+  'freshness',
+  'coverage',
+  'blocked_reasons',
+  'next_manual_action',
+]);
+
+function defaultBoundaryAssertions() {
+  return {
+    evidence_artifact_write: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    validation_execution: false,
+    runtime_action: false,
+    auto_test_run: false,
+    automatic_verification_execution: false,
+    repair_execution: false,
+    formatting_execution: false,
+    code_generation: false,
+    source_write: false,
+    business_source_write: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    push: false,
+    pr: false,
+    merge: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    mcp: false,
+    subagent: false,
+  };
+}
+
+function automaticVerificationGateFindings(contract) {
+  const boundary = contract.boundary_assertions || {};
+  const unexpected = Object.keys(defaultBoundaryAssertions())
+    .filter((key) => boundary[key] !== false)
+    .map((key) => `boundary must remain false: ${key}`);
+  return [
+    ...(contract.stage === CONTRACT_STAGE ? [] : [`stage must be ${CONTRACT_STAGE}`]),
+    ...(contract.contract_kind === CONTRACT_KIND ? [] : [`contract_kind must be ${CONTRACT_KIND}`]),
+    ...(contract.reads_local_evidence_only === true ? [] : ['reads_local_evidence_only must be true']),
+    ...(contract.runtime_runs_checks_by_default === false ? [] : ['runtime_runs_checks_by_default must be false']),
+    ...(contract.completion_claim_requires_evidence === true ? [] : ['completion_claim_requires_evidence must be true']),
+    ...(Array.isArray(contract.blocked_reasons) ? [] : ['blocked_reasons must be an array']),
+    ...(contract.next_manual_action ? [] : ['next_manual_action is required']),
+    ...unexpected,
+  ];
+}
+
+export function buildAutomaticVerificationGateContract({
+  phase = 'verification-gate',
+  stageRunbookBound = false,
+  executionEvidenceBound = false,
+  completionBundleBound = false,
+  evidenceItemCount = 0,
+  missingEvidenceCount = 0,
+  staleEvidenceCount = 0,
+  failedEvidenceCount = 0,
+  unexpectedDiffCount = 0,
+  blockedReasons = [],
+  nextManualAction = 'Add or repair local verification evidence before claiming completion.',
+} = {}) {
+  const normalizedBlockedReasons = [...new Set((blockedReasons || []).map((item) => String(item || '').trim()).filter(Boolean))];
+  const contract = {
+    version: 1,
+    stage: CONTRACT_STAGE,
+    contract_kind: CONTRACT_KIND,
+    phase,
+    local_evidence_fields: localEvidenceFields,
+    gate_order: gateOrder,
+    stage_runbook_bound: Boolean(stageRunbookBound),
+    execution_evidence_bound: Boolean(executionEvidenceBound),
+    completion_bundle_bound: Boolean(completionBundleBound),
+    evidence_item_count: Number.isFinite(evidenceItemCount) ? evidenceItemCount : 0,
+    missing_evidence_count: Number.isFinite(missingEvidenceCount) ? missingEvidenceCount : 0,
+    stale_evidence_count: Number.isFinite(staleEvidenceCount) ? staleEvidenceCount : 0,
+    failed_evidence_count: Number.isFinite(failedEvidenceCount) ? failedEvidenceCount : 0,
+    unexpected_diff_count: Number.isFinite(unexpectedDiffCount) ? unexpectedDiffCount : 0,
+    blocked_reasons: normalizedBlockedReasons,
+    next_manual_action: nextManualAction,
+    reads_local_evidence_only: true,
+    runtime_runs_checks_by_default: false,
+    completion_claim_requires_evidence: true,
+    manual_repair_only: true,
+    writes: false,
+    local_only: true,
+    deterministic: true,
+    boundary_assertions: defaultBoundaryAssertions(),
+  };
+  const findings = automaticVerificationGateFindings(contract);
+  return {
+    ...contract,
+    ready_for_completion_claim: findings.length === 0 && normalizedBlockedReasons.length === 0,
+    gate_pass: findings.length === 0,
+    findings,
+  };
+}
+
+export function automaticVerificationGateContractMarkers() {
+  return {
+    stage: CONTRACT_STAGE,
+    kind: CONTRACT_KIND,
+    local_evidence_fields: localEvidenceFields,
+    gate_order: gateOrder,
+    forbidden_boundaries: Object.keys(defaultBoundaryAssertions()),
+  };
+}

package/tools/vibe-runtime/runtime-automation-boundary-text.mjs

@@ -0,0 +1,7 @@
+export const automationReadinessActionText = 'runtime automation readiness matrix classified fixed local registry capabilities into auto_safe, confirm_required, advice_only, and forbidden categories read-only. No automation plan, one-shot execution, state directory, sidecar, command execution, scheduler, daemon, retry, runtime action, workflow execution, verification command, git, PR, push, merge, tag, platform API, external network, model, worktree, subagent, MCP, or business source mutation occurred.';
+
+export const automationReadinessBoundaryText = 'Boundary: writes=false; automation_readiness_artifact=false; automation_plan_artifact=false; one_shot_execution_artifact=false; command_execution=false; scheduler=false; daemon=false; retry=false; git=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; business_source_write=false';
+
+export const automationStageRunbookActionText = 'sequential-stage-runbook plus runbook-executor-preview dry-run contract was computed read-only from one local plan file, optional Stage 117 executable plan JSON, automation readiness registry digest, autopilot-lab budget contract, and registry. No command execution, check/test execution, source write, plan mutation, runbook artifact write, sidecar write, state directory, git, commit, PR, push, merge, tag, platform API, external network, model, MCP, subagent, scheduler, daemon, retry, worktree, or business source mutation occurred.';
+
+export const automationConfirmedPlanActionText = 'confirmed-one-shot-execution-plan contract was computed read-only from one local plan file, Stage 107 commit readiness, Stage 103 automation readiness, registry, and --confirm-plan. Confirmation means plan contract confirmation only. No action execution, command execution, check/test execution, repair, formatting, code generation, sidecar write, git, commit, PR, push, merge, platform API, external network, model, subagent, MCP, daemon, scheduler, retry, or business source mutation occurred.';