@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-adapter-packaging-consistency-command.mjs

@@ -0,0 +1,131 @@
+import {
+  localJsonFileWithinRoot,
+} from './runtime-local-json-input.mjs';
+import {
+  emitReadonlyLocalJsonOutput,
+  readonlyLocalJsonEnvelope,
+} from './runtime-readonly-local-json-output-envelope.mjs';
+import {
+  digestAdapterPackagingConsistency,
+  runtimeAdapterPackagingConsistency,
+  runtimeAdapterPackagingConsistencyDigestPayload,
+} from './runtime-adapter-packaging-consistency.mjs';
+
+export const adapterPackagingConsistencyCommandContractSync = {
+  runtime_check_owner: 'tools/vibe-runtime-check/index.mjs',
+  release_check_owner: 'tools/vibe-release-check',
+};
+
+function printList(title, items, format = (item) => String(item)) {
+  if (!items || items.length === 0) return;
+  console.log(`${title}:`);
+  for (const item of items) console.log(`- ${format(item)}`);
+}
+
+export function adapterPackagingConsistencyEnvelope(root, bootstrapMatrixFile, sessionExamplesFile) {
+  if (!bootstrapMatrixFile) throw new Error('platforms --adapter-packaging-consistency requires --from-bootstrap-matrix <local-bootstrap-json>');
+  if (!sessionExamplesFile) throw new Error('platforms --adapter-packaging-consistency requires --from-session-examples <local-session-examples-json>');
+  const bootstrapInput = localJsonFileWithinRoot(root, bootstrapMatrixFile, 'platforms --adapter-packaging-consistency --from-bootstrap-matrix');
+  const examplesInput = localJsonFileWithinRoot(root, sessionExamplesFile, 'platforms --adapter-packaging-consistency --from-session-examples');
+  const checklist = runtimeAdapterPackagingConsistency({
+    bootstrapMatrix: bootstrapInput.data,
+    sessionExamples: examplesInput.data,
+    source: {
+      bootstrap_matrix_file: bootstrapInput.relative,
+      bootstrap_matrix_digest: bootstrapInput.digest,
+      session_examples_file: examplesInput.relative,
+      session_examples_digest: examplesInput.digest,
+    },
+  });
+  const adapterPackagingConsistency = {
+    ...checklist,
+    consistency_digest: digestAdapterPackagingConsistency(runtimeAdapterPackagingConsistencyDigestPayload(checklist)),
+  };
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'adapter-packaging-consistency-checklist',
+    ok: adapterPackagingConsistency.ok,
+    payloadKey: 'adapter_packaging_consistency',
+    payload: adapterPackagingConsistency,
+    safety: {
+      stage: 'Stage 148',
+      writes: false,
+      adapter_packaging_consistency_artifact: false,
+      bootstrap_matrix_artifact: false,
+      session_start_example_pack_artifact: false,
+      adapter_row_artifact: false,
+      fix_note_artifact: false,
+      adapter_install: false,
+      adapter_execution: false,
+      hook_execution: false,
+      hook_registration: false,
+      manifest_write: false,
+      plugin_manifest_write: false,
+      install_doc_write: false,
+      settings_write: false,
+      source_write: false,
+      sidecar_write: false,
+      state_directory_created: false,
+      command_execution: false,
+      check_execution: false,
+      test_execution: false,
+      workflow_execution: false,
+      skill_execution: false,
+      runtime_action: false,
+      auto_execution: false,
+      repair_execution: false,
+      auto_fix: false,
+      prompt_mutation: false,
+      template_mutation: false,
+      skill_mutation: false,
+      full_skill_injection: false,
+      platform_api: false,
+      external_network: false,
+      model_invocation: false,
+      subagent: false,
+      mcp: false,
+      daemon: false,
+      git: false,
+      git_write: false,
+      git_add: false,
+      commit: false,
+      pr: false,
+      push: false,
+      merge: false,
+      tag: false,
+      worktree: false,
+      business_source_write: false,
+    },
+    quality: adapterPackagingConsistency.consistency_invariants.findings,
+    action: 'adapter packaging consistency read local Stage 122 bootstrap matrix JSON and local Stage 142 session-start examples JSON only. It emits adapter rows, missing install markers, and copy-ready fix notes without installing adapters, executing hooks/adapters/commands/checks/tests/workflows, mutating manifests/docs/source/prompts/templates/skills, writing state/artifacts, git, platform APIs, model invocation, MCP, or subagents.',
+  });
+}
+
+export function printAdapterPackagingConsistency(envelope) {
+  const checklist = envelope.adapter_packaging_consistency;
+  console.log('Vibecoding Runtime Adapter Packaging Consistency');
+  console.log(`Mode: ${envelope.mode}`);
+  console.log(`Stage: ${checklist.stage}; Kind: ${checklist.consistency_kind}; pass=${checklist.ok}`);
+  console.log(`Adapters: ${checklist.input_summary.adapter_row_count}; Missing install markers: ${checklist.input_summary.missing_install_marker_count}; Fix notes: ${checklist.input_summary.copy_ready_fix_note_count}; Digest: ${checklist.consistency_digest}`);
+  printList('Adapter rows', checklist.adapter_rows, (row) => `${row.adapter}: bootstrap=${row.bootstrap_pass}; example=${row.session_example_present}; context=${row.context_path || 'missing'}; consistent=${row.packaging_consistent}`);
+  printList('Missing install markers', checklist.missing_install_markers.length > 0 ? checklist.missing_install_markers : ['none'], (item) => typeof item === 'string' ? item : `${item.adapter}: ${item.marker}`);
+  printList('Copy-ready fix notes', checklist.copy_ready_fix_notes.length > 0 ? checklist.copy_ready_fix_notes : ['none'], (item) => typeof item === 'string' ? item : `${item.adapter}: ${item.note}`);
+  if (checklist.consistency_invariants.findings.length > 0) printList('Consistency invariant findings', checklist.consistency_invariants.findings);
+  console.log('Boundary: writes=false; adapter_packaging_consistency_artifact=false; bootstrap_matrix_artifact=false; session_start_example_pack_artifact=false; adapter_row_artifact=false; fix_note_artifact=false; adapter_install=false; hook_execution=false; adapter_execution=false; manifest_write=false; plugin_manifest_write=false; install_doc_write=false; command_execution=false; git=false; subagent=false');
+  console.log(`Consistency digest: ${checklist.consistency_digest}`);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function runAdapterPackagingConsistencyCommand(options, deps) {
+  if (options.confirm || options.dryRun || options.write || options.run || options.autoRun || options.dispatch || options.dispatchIntent || options.scan || options.once || options.preflight) throw new Error('platforms --adapter-packaging-consistency is read-only and checklist-only');
+  if (!options.fromBootstrapMatrix) throw new Error('platforms --adapter-packaging-consistency requires --from-bootstrap-matrix <local-bootstrap-json>');
+  if (!options.fromSessionExamples) throw new Error('platforms --adapter-packaging-consistency requires --from-session-examples <local-session-examples-json>');
+  if (options.fromFile || options.entryAdapter || options.fromSuperpowers || options.fromFriction || options.fromConsole || options.fromRunbook || options.fromEvidence || options.fromTokenBudget || options.fromLearningPattern || options.fromShape || options.fromInstallExperience || options.fromEntryAcceptance || options.fromComparison || options.fromDashboard || options.methodologyIntent || options.prompt) throw new Error('platforms --adapter-packaging-consistency only accepts --from-bootstrap-matrix, --from-session-examples, --json, and --root');
+  const envelope = adapterPackagingConsistencyEnvelope(options.root, options.fromBootstrapMatrix, options.fromSessionExamples);
+  emitReadonlyLocalJsonOutput({
+    deps,
+    options,
+    channel: 'platforms',
+    envelope,
+    print: printAdapterPackagingConsistency,
+  });
+}

package/tools/vibe-runtime/runtime-adapter-packaging-consistency.mjs

@@ -0,0 +1,253 @@
+import crypto from 'node:crypto';
+
+const adapterPackagingConsistencyStage = 'Stage 148';
+const adapterPackagingConsistencyKind = 'adapter-packaging-consistency-checklist';
+const baselineAdapters = ['claude', 'cursor', 'codex'];
+const requiredInstallMarkers = ['using-vibecoding', 'session-start', '不会注入完整 skill', '写 `.vibecoding-state/`', 'subagent', 'git', 'worktree'];
+
+export function runtimeAdapterPackagingConsistency({ bootstrapMatrix = {}, sessionExamples = {}, source = {} } = {}) {
+  const bootstrap = unwrapBootstrapMatrix(bootstrapMatrix);
+  const examples = unwrapSessionExamples(sessionExamples);
+  const adapterRows = adapterOrder(bootstrap, examples).map((adapter) => adapterConsistencyRow(adapter, bootstrap, examples));
+  const missingInstallMarkers = adapterRows.flatMap((row) => row.missing_install_markers.map((marker) => ({ adapter: row.adapter, marker })));
+  const copyReadyFixNotes = copyReadyFixNoteList(adapterRows);
+  const core = {
+    version: 1,
+    stage: adapterPackagingConsistencyStage,
+    consistency_kind: adapterPackagingConsistencyKind,
+    source_bindings: sourceBindingSummary(source, bootstrap, examples),
+    input_summary: inputSummary(bootstrap, examples, adapterRows),
+    adapter_rows: adapterRows,
+    missing_install_markers: missingInstallMarkers,
+    copy_ready_fix_notes: copyReadyFixNotes,
+    consistency_digest_basis: {
+      bootstrap_matrix_digest: stringValue(bootstrap.matrix_digest),
+      session_examples_digest: stringValue(examples.example_pack_digest),
+    },
+    boundary_assertions: runtimeAdapterPackagingConsistencyBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeAdapterPackagingConsistencyInvariants(core);
+  const checklist = {
+    ...core,
+    ok: invariants.pass,
+    consistency_invariants: invariants,
+  };
+  return {
+    ...checklist,
+    consistency_digest: digestAdapterPackagingConsistency(runtimeAdapterPackagingConsistencyDigestPayload(checklist)),
+  };
+}
+
+export function runtimeAdapterPackagingConsistencyDigestPayload(checklist) {
+  return {
+    stage: checklist.stage,
+    consistency_kind: checklist.consistency_kind,
+    source_bindings: checklist.source_bindings,
+    input_summary: checklist.input_summary,
+    adapter_rows: checklist.adapter_rows,
+    missing_install_markers: checklist.missing_install_markers,
+    copy_ready_fix_notes: checklist.copy_ready_fix_notes,
+    consistency_digest_basis: checklist.consistency_digest_basis,
+    boundary_assertions: checklist.boundary_assertions,
+    consistency_invariants: checklist.consistency_invariants,
+  };
+}
+
+export function runtimeAdapterPackagingConsistencyBoundaryAssertions() {
+  return {
+    adapter_packaging_consistency_artifact: false,
+    bootstrap_matrix_artifact: false,
+    session_start_example_pack_artifact: false,
+    adapter_row_artifact: false,
+    fix_note_artifact: false,
+    adapter_install: false,
+    adapter_execution: false,
+    hook_execution: false,
+    hook_registration: false,
+    manifest_write: false,
+    plugin_manifest_write: false,
+    install_doc_write: false,
+    settings_write: false,
+    source_write: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    repair_execution: false,
+    auto_fix: false,
+    prompt_mutation: false,
+    template_mutation: false,
+    skill_mutation: false,
+    full_skill_injection: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    git: false,
+    git_write: false,
+    git_add: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeAdapterPackagingConsistencyInvariants(checklist) {
+  const unsafeBoundaries = Object.entries(checklist.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingForbidden = Object.keys(runtimeAdapterPackagingConsistencyBoundaryAssertions())
+    .filter((key) => checklist.boundary_assertions?.[key] !== false);
+  const adapters = (checklist.adapter_rows || []).map((row) => row.adapter);
+  const duplicateAdapters = adapters.filter((adapter, index, items) => items.indexOf(adapter) !== index);
+  const findings = [
+    ...(checklist.stage === adapterPackagingConsistencyStage ? [] : [`stage must be ${adapterPackagingConsistencyStage}`]),
+    ...(checklist.consistency_kind === adapterPackagingConsistencyKind ? [] : [`consistency_kind must be ${adapterPackagingConsistencyKind}`]),
+    ...(checklist.source_bindings?.bootstrap_matrix_file ? [] : ['bootstrap matrix file binding is required']),
+    ...(checklist.source_bindings?.bootstrap_matrix_digest ? [] : ['bootstrap matrix digest binding is required']),
+    ...(checklist.source_bindings?.session_examples_file ? [] : ['session examples file binding is required']),
+    ...(checklist.source_bindings?.session_examples_digest ? [] : ['session examples digest binding is required']),
+    ...(checklist.input_summary?.bootstrap_stage === 'Stage 122' ? [] : ['bootstrap input must be Stage 122 evidence']),
+    ...(checklist.input_summary?.session_examples_stage === 'Stage 142' ? [] : ['session examples input must be Stage 142 evidence']),
+    ...(Array.isArray(checklist.adapter_rows) && checklist.adapter_rows.length >= 3 ? [] : ['adapter_rows must include at least claude, cursor, and codex']),
+    ...baselineAdapters.filter((adapter) => !adapters.includes(adapter)).map((adapter) => `missing baseline adapter row: ${adapter}`),
+    ...duplicateAdapters.map((adapter) => `duplicate adapter row: ${adapter}`),
+    ...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`),
+    ...missingForbidden.map((key) => `forbidden boundary missing or not false: ${key}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: ['source_bindings', 'stage_122_bootstrap_matrix', 'stage_142_session_examples', 'adapter_row_coverage', 'install_marker_visibility', 'copy_ready_fix_notes', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestAdapterPackagingConsistency(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function unwrapBootstrapMatrix(input) {
+  return objectValue(input.adapter_bootstrap_matrix || input.bootstrap_matrix || input);
+}
+
+function unwrapSessionExamples(input) {
+  return objectValue(input.session_start_example_pack || input.example_pack || input);
+}
+
+function sourceBindingSummary(source, bootstrap, examples) {
+  return {
+    bootstrap_matrix_file: stringValue(source.bootstrap_matrix_file),
+    bootstrap_matrix_digest: stringValue(source.bootstrap_matrix_digest),
+    session_examples_file: stringValue(source.session_examples_file),
+    session_examples_digest: stringValue(source.session_examples_digest),
+    bootstrap_stage: stringValue(bootstrap.stage),
+    session_examples_stage: stringValue(examples.stage),
+    bootstrap_artifact_digest: stringValue(bootstrap.matrix_digest),
+    session_examples_artifact_digest: stringValue(examples.example_pack_digest),
+  };
+}
+
+function inputSummary(bootstrap, examples, rows) {
+  return {
+    bootstrap_stage: stringValue(bootstrap.stage),
+    bootstrap_kind: stringValue(bootstrap.matrix_kind),
+    bootstrap_ok: bootstrap.ok === true,
+    session_examples_stage: stringValue(examples.stage),
+    session_examples_kind: stringValue(examples.pack_kind),
+    session_examples_ok: examples.ok === true,
+    bootstrap_adapter_count: listValue(bootstrap.adapter_rows).length,
+    session_example_count: listValue(examples.adapter_examples).length,
+    adapter_row_count: rows.length,
+    missing_install_marker_count: rows.reduce((sum, row) => sum + row.missing_install_markers.length, 0),
+    copy_ready_fix_note_count: rows.reduce((sum, row) => sum + row.copy_ready_fix_notes.length, 0),
+  };
+}
+
+function adapterOrder(bootstrap, examples) {
+  const bootstrapAdapters = listValue(bootstrap.adapter_rows).map((row) => stringValue(row.adapter)).filter(Boolean);
+  const exampleAdapters = listValue(examples.adapter_examples).map((row) => stringValue(row.adapter)).filter(Boolean);
+  return unique([...baselineAdapters, ...bootstrapAdapters, ...exampleAdapters]);
+}
+
+function adapterConsistencyRow(adapter, bootstrap, examples) {
+  const bootstrapRow = listValue(bootstrap.adapter_rows).find((row) => stringValue(row.adapter) === adapter) || {};
+  const exampleRow = listValue(examples.adapter_examples).find((row) => stringValue(row.adapter) === adapter) || {};
+  const contextShape = listValue(examples.copy_ready_context_shapes).find((row) => stringValue(row.adapter) === adapter) || {};
+  const missingMarkers = installMarkerFindings(adapter, bootstrapRow);
+  const fixNotes = rowFixNotes(adapter, bootstrapRow, exampleRow, contextShape, missingMarkers);
+  return {
+    adapter,
+    bootstrap_present: Object.keys(bootstrapRow).length > 0,
+    bootstrap_pass: bootstrapRow.pass === true,
+    session_example_present: Object.keys(exampleRow).length > 0,
+    context_shape_present: Object.keys(contextShape).length > 0,
+    entry_file: stringValue(bootstrapRow.entry_file),
+    expected_entry_file: stringValue(bootstrapRow.expected_entry_file),
+    context_path: stringValue(exampleRow.context_path || contextShape.context_path),
+    output_shape: stringValue(exampleRow.output_shape),
+    runtime_bridge_mode: stringValue(bootstrapRow.runtime_bridge?.mode),
+    bootstrap_command: stringValue(bootstrapRow.bootstrap_policy?.command),
+    missing_install_markers: missingMarkers,
+    copy_ready_fix_notes: fixNotes,
+    packaging_consistent: Object.keys(bootstrapRow).length > 0 && bootstrapRow.pass === true && Object.keys(exampleRow).length > 0 && Object.keys(contextShape).length > 0 && missingMarkers.length === 0,
+  };
+}
+
+function installMarkerFindings(adapter, bootstrapRow) {
+  if (!bootstrapRow || Object.keys(bootstrapRow).length === 0) return requiredInstallMarkers.map((marker) => `bootstrap row missing; cannot confirm install marker: ${marker}`);
+  const gate = listValue(bootstrapRow.gates).find((item) => stringValue(item.gate) === 'install_doc_bootstrap_gate');
+  const findings = listValue(gate?.findings).map(stringValue).filter(Boolean);
+  if (findings.length > 0) return findings.map((finding) => finding.replace(/^install\.md missing marker:\s*/, ''));
+  return [];
+}
+
+function rowFixNotes(adapter, bootstrapRow, exampleRow, contextShape, missingMarkers) {
+  return [
+    ...(Object.keys(bootstrapRow).length > 0 ? [] : [`Add ${adapter} to the Stage 122 bootstrap matrix before claiming adapter packaging consistency.`]),
+    ...(bootstrapRow.pass === true ? [] : [`Resolve ${adapter} Stage 122 bootstrap blockers before packaging closeout.`]),
+    ...(Object.keys(exampleRow).length > 0 ? [] : [`Add a Stage 142 session-start example for ${adapter}.`]),
+    ...(Object.keys(contextShape).length > 0 ? [] : [`Add a copy-ready context shape for ${adapter}.`]),
+    ...missingMarkers.map((marker) => `Document ${adapter} install marker: ${marker}`),
+  ];
+}
+
+function copyReadyFixNoteList(rows) {
+  return rows.flatMap((row) => row.copy_ready_fix_notes.map((note) => ({ adapter: row.adapter, note })));
+}
+
+function unique(items) {
+  return [...new Set(items.filter(Boolean))];
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function listValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function stringValue(value) {
+  return typeof value === 'string' ? value : value == null ? '' : String(value);
+}
+
+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-advice-hub-model.mjs

@@ -0,0 +1,175 @@
+export function adviceHubBoundaryAssertions() {
+  return {
+    sidecar_write: false,
+    skill_execution: false,
+    command_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    external_network: false,
+    model_invocation: false,
+    platform_api: false,
+    git: false,
+    worktree: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    shell_interception: false,
+    business_source_write: false,
+    source_merge: false,
+  };
+}
+
+export function normalizeAdviceHubIntent(intent) {
+  const value = String(intent || '').trim().toLowerCase().replace(/_/g, '-');
+  const known = new Set(['feature', 'bug', 'review', 'closeout', 'release', 'status', 'verification', 'learning', 'token']);
+  return known.has(value) ? value : 'unknown';
+}
+
+export function adviceHubLaneMapping(intent) {
+  const mappings = {
+    feature: { primary_lane: 'entry', entry: 'feature', tokens: 'feature', learning: 'project-constraint', governance: 'closeout' },
+    bug: { primary_lane: 'entry', entry: 'debug', tokens: 'debug', learning: 'failure-fix', governance: 'closeout' },
+    review: { primary_lane: 'governance', entry: 'review', tokens: 'review', learning: 'review', governance: 'review' },
+    closeout: { primary_lane: 'governance', entry: 'completion', tokens: 'completion', learning: 'review', governance: 'closeout' },
+    release: { primary_lane: 'governance', entry: 'completion', tokens: 'verification', learning: 'review', governance: 'release' },
+    status: { primary_lane: 'tokens', entry: 'feature', tokens: 'status', learning: 'review', governance: 'compatibility' },
+    verification: { primary_lane: 'tokens', entry: 'completion', tokens: 'verification', learning: 'review', governance: 'closeout' },
+    learning: { primary_lane: 'learning', entry: 'feature', tokens: 'context', learning: 'correction', governance: 'closeout' },
+    token: { primary_lane: 'tokens', entry: 'feature', tokens: 'status', learning: 'review', governance: 'closeout' },
+    unknown: { primary_lane: 'entry', entry: 'unknown', tokens: 'unknown', learning: 'unknown', governance: 'unknown' },
+  };
+  return mappings[intent] || mappings.unknown;
+}
+
+function adviceHubLaneRecommendation(lane, envelope) {
+  if (lane === 'entry') {
+    const advice = envelope.entry_advice;
+    return {
+      lane,
+      stage: advice.stage,
+      advice_kind: advice.advice_kind,
+      intent: advice.intent,
+      recommended_layer: advice.recommended_layer,
+      recommended_command: `entry --advice --intent ${advice.intent} --json`,
+      first_skill: advice.first_skill,
+      selected_workflow: advice.selected_workflow,
+      manual_action: advice.manual_action,
+      verification_hint: advice.verification_hint,
+      advice_digest: advice.advice_digest,
+    };
+  }
+  if (lane === 'tokens') {
+    const advice = envelope.token_advice;
+    return {
+      lane,
+      stage: advice.stage,
+      advice_kind: advice.advice_kind,
+      intent: advice.intent,
+      recommended_profile: advice.recommended_profile,
+      recommended_command: advice.command ? `tokens --advice --command ${advice.command} --json` : `tokens --advice --intent ${advice.intent} --json`,
+      recommended_compactors: advice.recommended_compactors.map((item) => item.id),
+      recommended_rewrites: advice.recommended_rewrites.map((item) => ({ command: item.command, suggested_command: item.suggested_command, changed: item.changed })),
+      manual_action: advice.manual_action,
+      verification_hint: advice.verification_hint,
+      advice_digest: advice.advice_digest,
+    };
+  }
+  if (lane === 'learning') {
+    const advice = envelope.learning_advice;
+    return {
+      lane,
+      stage: advice.stage,
+      advice_kind: advice.advice_kind,
+      intent: advice.intent,
+      recommended_next_learning_step: advice.recommended_next_learning_step,
+      recommended_command: advice.recommended_command,
+      manual_action: advice.manual_action,
+      verification_hint: advice.verification_hint,
+      advice_digest: advice.advice_digest,
+    };
+  }
+  const advice = envelope.governance_advice;
+  return {
+    lane,
+    stage: advice.stage,
+    advice_kind: advice.advice_kind,
+    intent: advice.intent,
+    recommended_next_governance_step: advice.recommended_next_governance_step,
+    recommended_command: advice.recommended_command,
+    manual_action: advice.manual_action,
+    verification_hint: advice.verification_hint,
+    advice_digest: advice.advice_digest,
+  };
+}
+
+export function buildAdviceHubModel({ intent = '', entryEnvelope, tokenEnvelope, learningEnvelope, governanceEnvelope, statePresent = false, digestObject } = {}) {
+  const inputIntent = String(intent || '').trim();
+  const normalizedIntent = normalizeAdviceHubIntent(inputIntent);
+  const laneMapping = adviceHubLaneMapping(normalizedIntent);
+  const laneRecommendations = {
+    entry: adviceHubLaneRecommendation('entry', entryEnvelope),
+    tokens: adviceHubLaneRecommendation('tokens', tokenEnvelope),
+    learning: adviceHubLaneRecommendation('learning', learningEnvelope),
+    governance: adviceHubLaneRecommendation('governance', governanceEnvelope),
+  };
+  const primaryLane = laneMapping.primary_lane;
+  const primary = laneRecommendations[primaryLane];
+  const boundaryAssertions = adviceHubBoundaryAssertions();
+  const laneDigests = {
+    entry: laneRecommendations.entry.advice_digest,
+    tokens: laneRecommendations.tokens.advice_digest,
+    learning: laneRecommendations.learning.advice_digest,
+    governance: laneRecommendations.governance.advice_digest,
+  };
+  const quality = [
+    ...entryEnvelope.quality.map((item) => `entry: ${item}`),
+    ...tokenEnvelope.quality.map((item) => `tokens: ${item}`),
+    ...learningEnvelope.quality.map((item) => `learning: ${item}`),
+    ...governanceEnvelope.quality.map((item) => `governance: ${item}`),
+  ];
+  if (inputIntent && normalizedIntent === 'unknown') quality.push('unknown unified advice intent; using four-lane fallback advice');
+  const advice = {
+    version: 1,
+    stage: 'Stage 83',
+    advice_kind: 'unified-runtime-advice-hub',
+    input_intent: inputIntent,
+    normalized_intent: normalizedIntent,
+    primary_lane: primaryLane,
+    primary_recommendation: {
+      lane: primary.lane,
+      stage: primary.stage,
+      advice_kind: primary.advice_kind,
+      recommended_command: primary.recommended_command,
+      manual_action: primary.manual_action,
+      verification_hint: primary.verification_hint,
+      advice_digest: primary.advice_digest,
+    },
+    lane_recommendations: laneRecommendations,
+    manual_action: `Start with the ${primaryLane} lane recommendation, then use the other lanes as bounded context only.`,
+    verification_hint: 'This hub is read-only aggregation. Verify concrete effects with the selected lane command before writing any sidecar or source change.',
+    boundary_assertions: boundaryAssertions,
+    lane_digests: laneDigests,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+  };
+  return {
+    mode: 'unified-runtime-advice-hub',
+    ok: true,
+    state_present: Boolean(statePresent),
+    advice_hub: { ...advice, advice_digest: digestObject(advice) },
+    safety: {
+      stage: 'Stage 83',
+      writes: false,
+      advice_hub_artifact: false,
+      state_directory_created: false,
+      ...boundaryAssertions,
+    },
+    quality,
+    action: 'unified advice hub was computed read-only from Stage 78 entry, Stage 79 token, Stage 80 learning, and Stage 81 governance advice envelopes. No state directory, sidecar, command execution, runtime action, PR, push, merge, tag, platform API, external network, model, git, worktree, subagent, MCP, daemon, shell interception, or business source mutation occurred.',
+  };
+}