@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-learning-interaction-command.mjs

@@ -0,0 +1,220 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildLearningAdviceModel } from './runtime-learning-advice-model.mjs';
+import { buildLearningRunObservationPreview } from './runtime-learning-run-preview-model.mjs';
+
+// Contract surface marker: tools/vibe-runtime-check/index.mjs validates this file through runtime-entry-size-contracts.
+export function createRuntimeLearningInteractionCommands(deps) {
+  const {
+    ensureRoot,
+    emitJsonEnvelope,
+    learningPresentation,
+    localJsonFileWithinRoot,
+    resolveLocalStateRoot,
+    digestObject,
+    stableStringify,
+    digestExperienceLearningPattern,
+    runtimeExperienceLearningPattern,
+    runtimeExperienceLearningPatternDigestPayload,
+    listLearningObservationFiles,
+    listLearningCandidateInstinctFiles,
+    listLearningPromotionFiles,
+    learningArtifactSummary,
+    learningArtifactAuditEnvelope,
+    learningObservationDescriptor,
+    learningCandidateInstinctDescriptor,
+    learningObservationEnvelope,
+    writeLearningObservation,
+    learningCandidateInstinctEnvelope,
+    writeLearningCandidateInstinct,
+    learningPromotionEnvelope,
+    writeLearningPromotion,
+  } = deps;
+
+function learningAuditEnvelope(root, mode, learningFile = '') {
+  if (mode === 'list') {
+    const observations = listLearningObservationFiles(root).map((fileName) => learningArtifactSummary(root, fileName));
+    const candidateInstincts = listLearningCandidateInstinctFiles(root).map((fileName) => learningArtifactSummary(root, fileName));
+    const promotions = listLearningPromotionFiles(root).map((fileName) => learningArtifactSummary(root, fileName));
+    const artifacts = [...observations, ...candidateInstincts, ...promotions];
+    return {
+      mode: 'learning-list',
+      ok: true,
+      summary: {
+        count: observations.length,
+        observation_count: observations.length,
+        candidate_instinct_count: candidateInstincts.length,
+        promotion_count: promotions.length,
+        failed_count: artifacts.filter((item) => !item.ok).length,
+      },
+      observations,
+      candidate_instincts: candidateInstincts,
+      promotions,
+      quality: [],
+      action: 'read-only learning audit listed local learning sidecars. No skill, prompt, hook, shell, git, worktree, platform API, external network, model, subagent, or business source mutation occurred.',
+    };
+  }
+  return learningArtifactAuditEnvelope(root, mode, learningFile);
+}
+
+function learningAdviceObservationRefs(root, observationFiles) {
+  return [...observationFiles].map((file) => learningObservationDescriptor(root, file)).sort((left, right) => left.file.localeCompare(right.file)).map((descriptor) => ({
+    file: descriptor.file,
+    file_digest: descriptor.file_digest,
+    observation_digest: descriptor.observation_digest,
+    project_id: descriptor.observation.project_id || '',
+    scope: descriptor.observation.scope || '',
+    domain: descriptor.observation.domain || '',
+    signal_count: descriptor.observation.signal_count || 0,
+  }));
+}
+
+function learningAdviceEnvelope(root, { intent = '', observationFiles = [], instinctFile = '' } = {}) {
+  if (observationFiles.length > 0 && instinctFile) throw new Error('learning --advice accepts either --from-observations or --instinct, not both');
+  return buildLearningAdviceModel({
+    intent,
+    observationDigestRefs: learningAdviceObservationRefs(root, observationFiles),
+    instinctDescriptor: instinctFile ? learningCandidateInstinctDescriptor(root, instinctFile) : null,
+    statePresent: fs.existsSync(resolveLocalStateRoot(root)),
+    digestObject,
+  });
+}
+
+function experienceLearningPatternObservationRefs(root, observationFiles) {
+  return [...observationFiles].map((file) => learningObservationDescriptor(root, file)).sort((left, right) => left.file.localeCompare(right.file));
+}
+
+function experienceLearningPatternEnvelope(root, { frictionFile = '', observationFiles = [] } = {}) {
+  const frictionInput = localJsonFileWithinRoot(root, frictionFile, 'learning --experience-pattern --from-friction');
+  const observationRefs = experienceLearningPatternObservationRefs(root, observationFiles);
+  const base = runtimeExperienceLearningPattern({
+    friction: frictionInput.data,
+    observations: observationRefs,
+    source: {
+      friction_file: frictionInput.relative,
+      friction_digest: frictionInput.digest,
+      observation_files: observationRefs.map((item) => item.file),
+      observation_file_digests: observationRefs.map((item) => item.file_digest),
+    },
+  });
+  const pattern = {
+    ...base,
+    experience_pattern_digest: digestExperienceLearningPattern(runtimeExperienceLearningPatternDigestPayload(base)),
+  };
+  return {
+    mode: 'ecc-learning-experience-pattern-gate',
+    ok: pattern.ok,
+    state_present: fs.existsSync(resolveLocalStateRoot(root)),
+    experience_learning_pattern: pattern,
+    safety: { stage: 'Stage 129', ...pattern.boundary_assertions },
+    quality: pattern.experience_pattern_invariants.findings,
+    action: 'experience learning pattern gate was computed read-only from local Stage 126 friction and optional verified Stage 61 observations. It only proposes candidate experience patterns and a manual skill-authoring workflow; no state directory, sidecar, skill, prompt, hook, command execution, automatic promotion, platform API, model, git, MCP, subagent, or business source write occurred.',
+  };
+}
+
+function learningRunObservationPreviewEnvelope(root, runFile) {
+  const source = localJsonFileWithinRoot(root, runFile, 'learning --observe-from-run --from-file');
+  return buildLearningRunObservationPreview({
+    input: source.data,
+    source,
+    rootName: path.basename(root),
+    statePresent: fs.existsSync(resolveLocalStateRoot(root)),
+    digestObject,
+    stableStringify,
+  });
+}
+
+function runLearning(options) {
+  const unsafeLearningRuntimeFlags = options.write || options.scan || options.once || options.fromDispatch || options.dispatchEvent || options.actor || options.approval || options.run || options.autoRun;
+  if (options.learningExperiencePattern && unsafeLearningRuntimeFlags) throw new Error('learning --experience-pattern is read-only and does not accept execution, dispatch, scan, run, write, approval, or agent flags');
+  if (options.learningObserveFromRun && unsafeLearningRuntimeFlags) throw new Error('learning --observe-from-run is read-only and does not accept execution, dispatch, scan, run, write, approval, or agent flags');
+  if (unsafeLearningRuntimeFlags) throw new Error('learning supports local observation, candidate instinct, promotion sidecars, and read-only audit only');
+  ensureRoot(options.root);
+  const modes = [options.learningObserve, options.learningObserveFromRun, options.learningInstincts, options.learningPromote, options.learningAdvice, options.learningExperiencePattern, options.learningList, options.learningShow, options.learningVerify].filter(Boolean);
+  if (modes.length !== 1) throw new Error('learning requires exactly one of --observe, --observe-from-run, --instincts, --promote, --advice, --experience-pattern, --list, --show, or --verify');
+  if (options.methodologyIntent && !options.learningAdvice && !options.learningExperiencePattern) throw new Error('--intent is only supported by learning --advice or learning --experience-pattern');
+  if (options.fromFriction && !options.learningExperiencePattern) throw new Error('--from-friction is only supported by learning --experience-pattern');
+  if (options.fromFile && !options.learningObserve && !options.learningObserveFromRun && !options.learningExperiencePattern) throw new Error('--from-file is only supported by learning --observe or learning --observe-from-run');
+  if (options.learningObservationFiles.length > 0 && !options.learningInstincts && !options.learningAdvice && !options.learningExperiencePattern) throw new Error('--from-observations is only supported by learning --instincts, learning --advice, or learning --experience-pattern');
+  if (options.learningInstinctFile && !options.learningPromote && !options.learningAdvice) throw new Error('--instinct is only supported by learning --promote or learning --advice');
+  if (options.learningExperiencePattern) {
+    if (options.confirm || options.dryRun || options.preflight || options.dispatch || options.dispatchIntent) throw new Error('learning --experience-pattern is read-only and does not accept --confirm, --preview, --preflight, --dispatch, or --dispatch-intent');
+    if (!options.fromFriction) throw new Error('learning --experience-pattern requires --from-friction <local-friction-json>');
+    if (options.fromFile || options.learningInstinctFile) throw new Error('learning --experience-pattern only accepts --from-friction and optional --from-observations');
+    const envelope = experienceLearningPatternEnvelope(options.root, { frictionFile: options.fromFriction, observationFiles: options.learningObservationFiles });
+    if (options.json) emitJsonEnvelope('learning', envelope);
+    else learningPresentation.printExperienceLearningPattern(envelope);
+    return;
+  }
+  if (options.learningAdvice) {
+    if (options.confirm || options.dryRun || options.preflight || options.dispatch || options.dispatchIntent) throw new Error('learning --advice is read-only and does not accept --confirm, --preview, --preflight, --dispatch, or --dispatch-intent');
+    const envelope = learningAdviceEnvelope(options.root, { intent: options.methodologyIntent, observationFiles: options.learningObservationFiles, instinctFile: options.learningInstinctFile });
+    if (options.json) emitJsonEnvelope('learning', envelope);
+    else learningPresentation.printLearningAdvice(envelope);
+    return;
+  }
+  if (options.learningObserveFromRun) {
+    if (options.confirm || options.dryRun || options.preflight || options.dispatch || options.dispatchIntent) throw new Error('learning --observe-from-run is read-only and does not accept --confirm, --preview, --preflight, --dispatch, or --dispatch-intent');
+    if (!options.fromFile) throw new Error('learning --observe-from-run requires --from-file <local-run-or-evidence-json>');
+    const envelope = learningRunObservationPreviewEnvelope(options.root, options.fromFile);
+    if (options.json) emitJsonEnvelope('learning', envelope);
+    else learningPresentation.printLearningRunObservationPreview(envelope);
+    return;
+  }
+  if (options.learningObserve) {
+    if (options.confirm && options.dryRun) throw new Error('learning --observe accepts either --preview or --confirm, not both');
+    if (!options.fromFile) throw new Error('learning --observe requires --from-file <session-evidence-file>');
+    const envelope = learningObservationEnvelope(options.root, { evidenceFile: options.fromFile, persist: options.confirm });
+    if (options.confirm) {
+      const file = writeLearningObservation(options.root, envelope);
+      if (options.json) emitJsonEnvelope('learning', { ...envelope, learning_file: path.basename(file) });
+      else learningPresentation.printLearning(envelope, file);
+      return;
+    }
+    if (options.json) emitJsonEnvelope('learning', envelope);
+    else learningPresentation.printLearning(envelope);
+    return;
+  }
+  if (options.learningInstincts) {
+    if (options.confirm && options.dryRun) throw new Error('learning --instincts accepts either --preview or --confirm, not both');
+    if (options.learningObservationFiles.length === 0) throw new Error('learning --instincts requires --from-observations <learning-observation-file...>');
+    const envelope = learningCandidateInstinctEnvelope(options.root, { observationFiles: options.learningObservationFiles, persist: options.confirm });
+    if (options.confirm) {
+      const file = writeLearningCandidateInstinct(options.root, envelope);
+      if (options.json) emitJsonEnvelope('learning', { ...envelope, learning_file: path.basename(file), candidate_instinct_file: path.basename(file) });
+      else learningPresentation.printLearning(envelope, file);
+      return;
+    }
+    if (options.json) emitJsonEnvelope('learning', envelope);
+    else learningPresentation.printLearning(envelope);
+    return;
+  }
+  if (options.learningPromote) {
+    if (options.confirm && options.dryRun) throw new Error('learning --promote accepts either --preview or --confirm, not both');
+    if (!options.learningInstinctFile) throw new Error('learning --promote requires --instinct <candidate-instinct-file>');
+    const envelope = learningPromotionEnvelope(options.root, { instinctFile: options.learningInstinctFile, persist: options.confirm });
+    if (options.confirm) {
+      const file = writeLearningPromotion(options.root, envelope);
+      if (options.json) emitJsonEnvelope('learning', { ...envelope, learning_file: path.basename(file), learning_promotion_file: path.basename(file) });
+      else learningPresentation.printLearning(envelope, file);
+      return;
+    }
+    if (options.json) emitJsonEnvelope('learning', envelope);
+    else learningPresentation.printLearning(envelope);
+    return;
+  }
+  if (options.confirm || options.dryRun) throw new Error('learning audit is read-only');
+  const mode = options.learningList ? 'list' : options.learningVerify ? 'verify' : 'show';
+  const envelope = learningAuditEnvelope(options.root, mode, options.learningFile);
+  if (options.json) emitJsonEnvelope('learning', envelope);
+  else learningPresentation.printLearning(envelope);
+}
+
+  return {
+    learningAdviceEnvelope,
+    learningAuditEnvelope,
+    learningRunObservationPreviewEnvelope,
+    experienceLearningPatternEnvelope,
+    runLearning,
+  };
+}

package/tools/vibe-runtime/runtime-learning-observation-model.mjs

@@ -0,0 +1,124 @@
+const learningObservationScopes = new Set(['project', 'global-candidate']);
+const learningObservationDomains = new Set(['workflow', 'debugging', 'testing', 'code-style', 'governance', 'token-economy']);
+
+export function isLearningObservationScope(value) {
+  return learningObservationScopes.has(value);
+}
+
+export function isLearningObservationDomain(value) {
+  return learningObservationDomains.has(value);
+}
+
+export function normalizeLearningTextList(value, { stableStringify }) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => (typeof item === 'string' ? item : stableStringify(item))).map((item) => item.trim()).filter(Boolean).sort();
+}
+
+export function normalizeLearningScope(value) {
+  const scope = String(value || 'project').trim();
+  if (!isLearningObservationScope(scope)) throw new Error(`learning scope is unsupported: ${scope}`);
+  return scope;
+}
+
+export function normalizeLearningDomain(value) {
+  const domain = String(value || 'workflow').trim();
+  if (!isLearningObservationDomain(domain)) throw new Error(`learning domain is unsupported: ${domain}`);
+  return domain;
+}
+
+export function normalizeLearningConfidenceDelta(value) {
+  const delta = Number(value ?? 0);
+  if (!Number.isFinite(delta)) throw new Error('learning confidence_delta must be a finite number');
+  if (delta < -1 || delta > 1) throw new Error('learning confidence_delta must be between -1 and 1');
+  return Number(delta.toFixed(3));
+}
+
+export function learningSignalsFromEvidence(input, { stableStringify }) {
+  return {
+    user_corrections: normalizeLearningTextList(input.user_corrections || input.corrections, { stableStringify }),
+    failure_fixes: normalizeLearningTextList(input.failure_fixes || input.fixes, { stableStringify }),
+    repeated_workflows: normalizeLearningTextList(input.repeated_workflows || input.workflows, { stableStringify }),
+    preferences: normalizeLearningTextList(input.preferences, { stableStringify }),
+    project_constraints: normalizeLearningTextList(input.project_constraints || input.constraints, { stableStringify }),
+    observations: normalizeLearningTextList(input.observations, { stableStringify }),
+  };
+}
+
+export function learningSignalCount(signals) {
+  return Object.values(signals).reduce((total, items) => total + (Array.isArray(items) ? items.length : 0), 0);
+}
+
+export function learningObservationBoundaryAssertions() {
+  return {
+    skill_mutation: false,
+    prompt_mutation: false,
+    hook_registration: false,
+    shell_interception: false,
+    external_network: false,
+    model_invocation: false,
+    platform_api: false,
+    git: false,
+    worktree: false,
+    business_source_write: false,
+    runtime_action: false,
+    auto_execution: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+  };
+}
+
+export function shortLearningText(value, maxLength = 160) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength - 1).trim()}…`;
+}
+
+export function firstLearningSignal(observation) {
+  const signalOrder = ['user_corrections', 'failure_fixes', 'repeated_workflows', 'preferences', 'project_constraints', 'observations'];
+  for (const signalType of signalOrder) {
+    const values = Array.isArray(observation.signals?.[signalType]) ? observation.signals[signalType] : [];
+    if (values.length > 0) return { signal_type: signalType, signal_text: shortLearningText(values[0]) };
+  }
+  return { signal_type: 'none', signal_text: '' };
+}
+
+export function learningInstinctStatusAndBlocks(descriptors, signal) {
+  const blocked = [];
+  if (descriptors.length === 0) blocked.push('candidate instinct requires at least one observation');
+  if (!signal.signal_text) blocked.push('candidate instinct requires at least one learning signal');
+  const projectIds = new Set(descriptors.map((item) => item.observation.project_id || '').filter(Boolean));
+  if (projectIds.size > 1) blocked.push('candidate instinct requires one project_id');
+  const domains = new Set(descriptors.map((item) => item.observation.domain || '').filter(Boolean));
+  if (domains.size > 1) blocked.push('candidate instinct requires one domain');
+  return { status: blocked.length === 0 ? 'candidate_ready' : 'manual_review_required', blocked_reasons: blocked };
+}
+
+const learningArtifactSummaryBuilders = {
+  'learning-observation': (file, artifact, verification) => ({ file, kind: 'learning-observation', status: artifact.learning_observation?.status || '', scope: artifact.learning_observation?.scope || '', domain: artifact.learning_observation?.domain || '', signal_count: artifact.learning_observation?.signal_count || 0, ok: verification.ok, digest: artifact.learning_observation?.learning_observation_digest || '' }),
+  'candidate-instinct': (file, artifact, verification) => ({ file, kind: 'candidate-instinct', status: artifact.candidate_instinct?.status || '', scope: artifact.candidate_instinct?.scope || '', domain: artifact.candidate_instinct?.domain || '', confidence: artifact.candidate_instinct?.confidence || 0, ok: verification.ok, digest: artifact.candidate_instinct?.candidate_instinct_digest || '' }),
+  'learning-promotion': (file, artifact, verification) => ({ file, kind: 'learning-promotion', status: artifact.learning_promotion?.status || '', scope: artifact.learning_promotion?.scope || '', domain: artifact.learning_promotion?.domain || '', confidence: artifact.learning_promotion?.confidence || 0, ok: verification.ok, digest: artifact.learning_promotion?.learning_promotion_digest || '' }),
+};
+
+const learningArtifactAuditDigestKeys = {
+  'learning-observation': 'observation_digest',
+  'candidate-instinct': 'candidate_instinct_digest',
+  'learning-promotion': 'learning_promotion_digest',
+};
+
+export function learningInvalidArtifactSummary(file, error) {
+  return { file, kind: 'invalid', status: 'invalid', scope: '', domain: '', ok: false, digest: '', error: error.message };
+}
+
+export function learningArtifactSummaryModel(kind, file, artifact, verification) {
+  const build = learningArtifactSummaryBuilders[kind];
+  if (!build) throw new Error(`unsupported learning artifact kind: ${kind}`);
+  return build(file, artifact, verification);
+}
+
+export function learningArtifactAuditSummaryModel(kind, file, artifact) {
+  const summary = learningArtifactSummaryModel(kind, file, artifact, { ok: true });
+  const digestKey = learningArtifactAuditDigestKeys[kind];
+  const { digest, ok, ...auditSummary } = summary;
+  return { ...auditSummary, [digestKey]: digest };
+}

package/tools/vibe-runtime/runtime-learning-presentation.mjs

@@ -0,0 +1,84 @@
+import path from 'node:path';
+import process from 'node:process';
+
+export function createLearningPresentation({ printList }) {
+  function printExperienceLearningPattern(envelope) {
+    const pattern = envelope.experience_learning_pattern;
+    console.log('Vibecoding Runtime Experience Learning Pattern Gate');
+    console.log(`Stage: ${pattern.stage}; Kind: ${pattern.pattern_kind}; pass=${pattern.ok}`);
+    console.log(`Repeat signal: detected=${pattern.repeat_signal.detected}; confidence=${pattern.repeat_signal.confidence}; top_friction=${pattern.repeat_signal.top_friction || 'none'}`);
+    console.log(`Suggested trigger: ${pattern.suggested_instinct_trigger}`);
+    console.log(`Suggested action: ${pattern.suggested_instinct_action}`);
+    printList('Candidate experience patterns', pattern.candidate_experience_patterns.map((item) => `${item.id}: ${item.trigger} -> ${item.action}`));
+    console.log(`Promotion required: ${pattern.promotion_required}; workflow=${pattern.required_workflow.join(' -> ')}`);
+    console.log('Boundary: writes=false; experience_pattern_artifact=false; learning_observation_write=false; candidate_instinct_write=false; learning_promotion_write=false; skill_write=false; writes_formal_skills=false; writes_agents_md=false; writes_claude_md=false; prompt_mutation=false; hook_registration=false; command_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; automatic_promotion=false; agent_first_delegation=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+    console.log(`Experience pattern digest: ${pattern.experience_pattern_digest}`);
+    if (envelope.quality.length > 0) printList('Blocked reasons', envelope.quality);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printLearningAdvice(envelope) {
+    const advice = envelope.learning_advice;
+    console.log('Vibecoding Runtime Learning Advice');
+    console.log(`Stage: ${advice.stage}; Intent: ${advice.intent}; Advice: ${advice.advice_kind}`);
+    console.log(`Next step: ${advice.recommended_next_learning_step}`);
+    console.log(`Recommended command: ${advice.recommended_command}`);
+    if (advice.observation_digest_refs.length > 0) console.log(`Observations: ${advice.observation_digest_refs.length}`);
+    if (advice.candidate_instinct_digest) console.log(`Candidate instinct digest: ${advice.candidate_instinct_digest}`);
+    console.log(`Promotion boundary: ${advice.promotion_boundary.promotion_target}; automatic_promotion=false; writes_formal_skills=false`);
+    console.log(`Advice digest: ${advice.advice_digest}`);
+    if (envelope.quality.length > 0) printList('Notes', envelope.quality);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printLearningRunObservationPreview(envelope) {
+    const observation = envelope.learning_observation_preview;
+    const candidate = envelope.candidate_instinct_preview;
+    console.log('Vibecoding Runtime Learning Run Observation Preview');
+    console.log(`Source: ${envelope.source.file}; input=${envelope.source.input_kind}`);
+    console.log(`Observation: ${observation.status}; domain=${observation.domain}; signals=${observation.signal_count}`);
+    console.log(`Candidate: ${candidate.status}; confidence=${candidate.confidence}`);
+    console.log('Boundary: writes=false; learning_observation_artifact=false; candidate_instinct_artifact=false; automatic_promotion=false; writes_formal_skills=false; skill_mutation=false; prompt_mutation=false; hook_registration=false; git=false; worktree=false; subagent=false; business_source_write=false');
+    console.log(`Observation digest: ${observation.learning_observation_preview_digest}`);
+    console.log(`Candidate digest: ${candidate.candidate_instinct_preview_digest}`);
+    if (envelope.quality.length > 0) printList('Blocked reasons', envelope.quality);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printLearning(envelope, file = '') {
+    console.log('Vibecoding Runtime Learning Ledger');
+    console.log(`Mode: ${envelope.mode.replace('learning-', '')}`);
+    if (envelope.learning_observation) {
+      console.log(`Status: ${envelope.learning_observation.status}; Scope: ${envelope.learning_observation.scope}; Domain: ${envelope.learning_observation.domain}`);
+      console.log(`Signals: ${envelope.learning_observation.signal_count}; Digest: ${envelope.learning_observation.learning_observation_digest}`);
+      if (file) console.log(`Learning observation: ${path.relative(process.cwd(), file)}`);
+    } else if (envelope.candidate_instinct) {
+      console.log(`Status: ${envelope.candidate_instinct.status}; Scope: ${envelope.candidate_instinct.scope}; Domain: ${envelope.candidate_instinct.domain}`);
+      console.log(`Confidence: ${envelope.candidate_instinct.confidence}; Digest: ${envelope.candidate_instinct.candidate_instinct_digest}`);
+      if (file) console.log(`Candidate instinct: ${path.relative(process.cwd(), file)}`);
+    } else if (envelope.learning_promotion) {
+      console.log(`Status: ${envelope.learning_promotion.status}; Scope: ${envelope.learning_promotion.scope}; Domain: ${envelope.learning_promotion.domain}`);
+      console.log(`Confidence: ${envelope.learning_promotion.confidence}; Digest: ${envelope.learning_promotion.learning_promotion_digest}`);
+      if (file) console.log(`Learning promotion: ${path.relative(process.cwd(), file)}`);
+    } else if (envelope.mode === 'learning-list') {
+      console.log(`Observations: ${envelope.summary.observation_count}; Candidate instincts: ${envelope.summary.candidate_instinct_count}; Promotions: ${envelope.summary.promotion_count}; Failed: ${envelope.summary.failed_count}`);
+      for (const observation of envelope.observations) console.log(`- ${observation.file}: ${observation.domain}/${observation.scope}; signals=${observation.signal_count}; verification=${observation.ok ? 'passed' : 'failed'}`);
+      for (const instinct of envelope.candidate_instincts) console.log(`- ${instinct.file}: ${instinct.domain}/${instinct.scope}; confidence=${instinct.confidence}; verification=${instinct.ok ? 'passed' : 'failed'}`);
+      for (const promotion of envelope.promotions) console.log(`- ${promotion.file}: ${promotion.domain}/${promotion.scope}; confidence=${promotion.confidence}; verification=${promotion.ok ? 'passed' : 'failed'}`);
+    } else {
+      console.log(`File: ${envelope.summary.file}`);
+      console.log(`Kind: ${envelope.summary.kind || 'learning-observation'}; Status: ${envelope.summary.status}; Scope: ${envelope.summary.scope}; Domain: ${envelope.summary.domain}`);
+      console.log(`Verification: ${envelope.verification.ok ? 'passed' : 'failed'}`);
+      if (envelope.verification.failures.length > 0) printList('Verification failures', envelope.verification.failures);
+    }
+    if (envelope.quality?.length > 0) printList('Blocked reasons', envelope.quality);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  return {
+    printExperienceLearningPattern,
+    printLearningAdvice,
+    printLearningRunObservationPreview,
+    printLearning,
+  };
+}

package/tools/vibe-runtime/runtime-learning-run-preview-model.mjs

@@ -0,0 +1,184 @@
+import {
+  firstLearningSignal,
+  learningObservationBoundaryAssertions,
+  learningSignalCount,
+  learningSignalsFromEvidence,
+  normalizeLearningConfidenceDelta,
+  normalizeLearningDomain,
+  normalizeLearningScope,
+} from './runtime-learning-observation-model.mjs';
+import { learningAdviceBoundaryAssertions } from './runtime-learning-advice-model.mjs';
+
+const previewSignalFields = Object.freeze([
+  'user_corrections',
+  'failure_fixes',
+  'repeated_workflows',
+  'preferences',
+  'project_constraints',
+  'observations',
+]);
+
+function asArray(value) {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+function nestedArray(input, path) {
+  const value = path.reduce((current, key) => current?.[key], input);
+  return asArray(value);
+}
+
+function compactList(items) {
+  return items.map((item) => String(item || '').trim()).filter(Boolean);
+}
+
+function inferDomain(input) {
+  const command = String(input.command || input.mode || '').toLowerCase();
+  if (/token/.test(command)) return 'token-economy';
+  if (/test|verification|eval/.test(command)) return 'testing';
+  if (/debug|fail|error/.test(command)) return 'debugging';
+  if (/governance|automation/.test(command)) return 'governance';
+  return 'workflow';
+}
+
+function inferredObservations(input) {
+  return compactList([
+    input.action,
+    input.summary?.text,
+    input.summary?.status,
+    input.mode ? `mode=${input.mode}` : '',
+    input.command ? `command=${input.command}` : '',
+    Object.prototype.hasOwnProperty.call(input, 'ok') ? `ok=${Boolean(input.ok)}` : '',
+    ...nestedArray(input, ['quality']),
+    ...nestedArray(input, ['blocked_reasons']),
+    ...nestedArray(input, ['verification', 'failures']),
+  ]);
+}
+
+function previewEvidence(input) {
+  const evidence = Object.fromEntries(previewSignalFields.map((field) => [field, asArray(input[field])]));
+  return {
+    ...input,
+    ...evidence,
+    observations: [...evidence.observations, ...inferredObservations(input)],
+  };
+}
+
+function buildObservationPreview({ input, source, rootName, digestObject, stableStringify }) {
+  const evidence = previewEvidence(input);
+  const signals = learningSignalsFromEvidence(evidence, { stableStringify });
+  const signalCount = learningSignalCount(signals);
+  const excerpt = String(input.evidence_excerpt || input.excerpt || input.action || '').trim();
+  const payload = {
+    version: 1,
+    stage: 'Stage 61',
+    preview_kind: 'learning-observation-preview',
+    artifact_kind: 'learning-observation',
+    status: signalCount > 0 ? 'observation_recorded' : 'manual_required',
+    source_file: source.relative,
+    source_digest: source.digest,
+    project_id: String(input.project_id || rootName || 'local-project').trim(),
+    scope: normalizeLearningScope(input.scope),
+    domain: normalizeLearningDomain(input.domain || inferDomain(input)),
+    confidence_delta: normalizeLearningConfidenceDelta(input.confidence_delta),
+    evidence_excerpt_digest: digestObject({ source_digest: source.digest, excerpt: excerpt || stableStringify(signals) }),
+    signals,
+    signals_digest: digestObject(signals),
+    signal_count: signalCount,
+    candidate_only: true,
+    promotion_required: true,
+    allowed_followup: ['candidate_instinct_preview', 'manual_review', 'vibe-writing-skills'],
+    blocked_reasons: signalCount > 0 ? [] : ['local input did not contain any learning signal'],
+    boundary_assertions: learningObservationBoundaryAssertions(),
+    writes: false,
+    local_only: true,
+    no_skill_mutation: true,
+    no_prompt_mutation: true,
+    no_cross_project_share: true,
+  };
+  return { ...payload, learning_observation_preview_digest: digestObject(payload) };
+}
+
+function buildCandidatePreview(observation, digestObject) {
+  const signal = firstLearningSignal(observation);
+  const ready = observation.signal_count > 0 && Boolean(signal.signal_text);
+  const confidence = Number(Math.max(0, Math.min(1, 0.5 + Number(observation.confidence_delta || 0) / 2)).toFixed(3));
+  const payload = {
+    version: 1,
+    stage: 'Stage 62',
+    preview_kind: 'candidate-instinct-preview',
+    artifact_kind: 'candidate-instinct',
+    status: ready ? 'candidate_ready' : 'manual_review_required',
+    project_id: observation.project_id,
+    scope: observation.scope,
+    domain: observation.domain,
+    atomic: true,
+    one_trigger: true,
+    one_action: true,
+    trigger: ready ? `domain=${observation.domain}; signal=${signal.signal_type}; when ${signal.signal_text}` : `domain=${observation.domain}; signal=none; manual review required`,
+    action: ready ? `Prefer the project-scoped learned response: ${signal.signal_text}` : 'Review local learning signals manually before creating formal guidance.',
+    confidence,
+    evidence_backed: observation.signal_count > 0,
+    source_observation: {
+      source_file: observation.source_file,
+      source_digest: observation.source_digest,
+      observation_digest: observation.learning_observation_preview_digest,
+      signal_count: observation.signal_count,
+    },
+    blocked_reasons: ready ? [] : ['candidate preview requires at least one learning signal'],
+    promotion_required: true,
+    automatic_promotion: false,
+    writes_formal_skills: false,
+    writes_agents_md: false,
+    writes_claude_md: false,
+    formal_skill_mutation: false,
+    skill_mutation: false,
+    prompt_mutation: false,
+    hook_registration: false,
+    shell_interception: false,
+    cross_project_share: false,
+    allowed_followup: ['learning_promotion_preview', 'manual_review', 'vibe-writing-skills'],
+    boundary_assertions: learningObservationBoundaryAssertions(),
+    writes: false,
+    local_only: true,
+    no_skill_mutation: true,
+    no_prompt_mutation: true,
+    no_cross_project_share: true,
+  };
+  return { ...payload, candidate_instinct_preview_digest: digestObject(payload) };
+}
+
+export function buildLearningRunObservationPreview({ input, source, rootName, statePresent = false, digestObject, stableStringify }) {
+  const observation = buildObservationPreview({ input, source, rootName, digestObject, stableStringify });
+  const candidate = buildCandidatePreview(observation, digestObject);
+  const adviceBoundary = learningAdviceBoundaryAssertions();
+  return {
+    mode: 'learning-run-observation-preview',
+    ok: observation.status === 'observation_recorded',
+    state_present: Boolean(statePresent),
+    source: { file: source.relative, digest: source.digest, input_kind: String(input.mode || input.command || 'local-json') },
+    learning_observation_preview: observation,
+    candidate_instinct_preview: candidate,
+    promotion_boundary: {
+      promotion_target: 'manual-skill-authoring',
+      required_workflow: ['vibe-writing-skills', 'vibe-writing-plans', 'vibe-test-driven-development', 'vibe-review'],
+      human_approval_required: true,
+      automatic_promotion: false,
+      writes_formal_skills: false,
+      writes_agents_md: false,
+      writes_claude_md: false,
+    },
+    safety: {
+      stage: 'Stage 61/62 preview',
+      writes: false,
+      learning_observation_artifact: false,
+      candidate_instinct_artifact: false,
+      learning_promotion_artifact: false,
+      state_directory_created: false,
+      ...learningObservationBoundaryAssertions(),
+      ...adviceBoundary,
+    },
+    quality: [...observation.blocked_reasons, ...candidate.blocked_reasons],
+    action: 'learning observation and candidate instinct were previewed read-only from one local JSON input. No state directory, learning sidecar, formal skill, prompt, hook, shell, git, worktree, platform API, external network, model, subagent, MCP, daemon, or business source mutation occurred.',
+  };
+}