@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-session-checkpoint-model.mjs

@@ -0,0 +1,217 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const SESSION_CHECKPOINT_VERSION = 1;
+const SESSION_CHECKPOINT_STAGE = 'Stage 23';
+
+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);
+}
+
+function fallbackDigest(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function digest(digestObject, value) {
+  return typeof digestObject === 'function' ? digestObject(value) : fallbackDigest(value);
+}
+
+function falseBoundary() {
+  return {
+    writes: false,
+    state_directory_created: false,
+    session_checkpoint_artifact: false,
+    session_handoff_artifact: false,
+    session_resume_artifact: false,
+    workflow_skill_execution: false,
+    skill_execution: false,
+    workflow_execution: false,
+    command_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    source_write: false,
+    business_source_write: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    worktree: false,
+    pr: false,
+    push: false,
+    merge: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    watcher: false,
+  };
+}
+
+function safeLocalPath(root, file, label) {
+  if (!file) return null;
+  const rootPath = path.resolve(root || process.cwd());
+  const absolute = path.resolve(rootPath, file);
+  const relative = path.relative(rootPath, absolute);
+  if (relative.startsWith('..') || path.isAbsolute(relative)) throw new Error(`${label} must stay within --root`);
+  if (!fs.existsSync(absolute)) throw new Error(`${label} not found: ${file}`);
+  return { absolute, relative: relative.replace(/\\/g, '/') };
+}
+
+function fileDigest(source) {
+  if (!source) return '';
+  return crypto.createHash('sha256').update(fs.readFileSync(source.absolute)).digest('hex');
+}
+
+function workflowSummary(workflowStart = {}) {
+  const start = workflowStart.workflow_start || workflowStart;
+  return {
+    normalized_intent: start?.normalized_intent || 'unknown',
+    selected_skill: start?.receipt_summary?.selected_skill || start?.start_here_contract?.selected_skill_after_entry || 'using-vibecoding',
+    route_reason: start?.receipt_summary?.user_visible_sentence || start?.start_here_contract?.route_reason || '',
+    next_gate: start?.start_here_contract?.next_gate || start?.cockpit_summary?.recommended_next_skill || start?.next_manual_action || 'manual_workflow_judgment',
+    next_manual_action: start?.next_manual_action || start?.entry_summary?.first_user_decision || 'confirm next manual action before continuing',
+    entry_classification: start?.entry_summary?.entry_classification || 'unknown',
+    blocked_reasons: start?.blocked_reasons || [],
+    start_digest: start?.start_digest || '',
+    start_contract_digest: start?.start_here_contract?.contract_digest || '',
+  };
+}
+
+function checkpointPayload({ kind, workflowStart, source, digestObject }) {
+  const route = workflowSummary(workflowStart);
+  const sourceDigest = fileDigest(source);
+  const payload = {
+    version: SESSION_CHECKPOINT_VERSION,
+    stage: SESSION_CHECKPOINT_STAGE,
+    checkpoint_kind: kind,
+    owner_module: 'runtime-session-checkpoint-model',
+    route,
+    selected_skill: route.selected_skill,
+    completed_gates: [],
+    blocked_gates: route.blocked_reasons,
+    evidence_summary: {
+      source_file: source?.relative || '',
+      source_digest: sourceDigest,
+      workflow_start_digest: route.start_digest,
+      start_contract_digest: route.start_contract_digest,
+    },
+    next_manual_action: route.next_manual_action,
+    forbidden_actions: [
+      'do not execute the next skill automatically',
+      'do not create a subagent session',
+      'do not run commands or tests from checkpoint output',
+      'do not perform git, PR, push, merge, or platform API actions',
+    ],
+    boundary_assertions: falseBoundary(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  return { ...payload, checkpoint_digest: digest(digestObject, payload) };
+}
+
+function handoffPayload({ workflowStart, source, digestObject }) {
+  const checkpoint = checkpointPayload({ kind: 'session-handoff', workflowStart, source, digestObject });
+  const payload = {
+    ...checkpoint,
+    checkpoint_kind: 'session-handoff',
+    handoff_contract: {
+      current_skill: checkpoint.selected_skill,
+      next_skill: checkpoint.route.next_gate,
+      handoff: {
+        goal: 'preserve current route, evidence summary, blockers, and next manual action',
+        scope: 'session-level handoff only',
+        key_decisions: [checkpoint.route.route_reason || 'route reason not recorded'],
+        files: checkpoint.evidence_summary.source_file ? [checkpoint.evidence_summary.source_file] : [],
+        risks: checkpoint.blocked_gates,
+        acceptance: ['resume from visible route without hidden execution'],
+      },
+      stop_condition: checkpoint.blocked_gates.length > 0 ? checkpoint.blocked_gates.join('; ') : 'none',
+    },
+  };
+  delete payload.checkpoint_digest;
+  return { ...payload, handoff_digest: digest(digestObject, payload) };
+}
+
+function verifyDigest(payload, digestObject) {
+  const clone = { ...payload };
+  const expected = clone.checkpoint_digest || clone.handoff_digest || '';
+  delete clone.checkpoint_digest;
+  delete clone.handoff_digest;
+  const actual = digest(digestObject, clone);
+  return { expected, actual, pass: Boolean(expected && expected === actual) };
+}
+
+export function buildSessionCheckpointEnvelope({ root, workflowStart, sourceFile = '', digestObject }) {
+  const source = safeLocalPath(root, sourceFile, 'session --checkpoint --from-file');
+  const checkpoint = checkpointPayload({ kind: 'session-checkpoint', workflowStart, source, digestObject });
+  return {
+    mode: 'session-checkpoint',
+    ok: true,
+    state_present: fs.existsSync(path.join(path.resolve(root || process.cwd()), '.vibecoding-state')),
+    session_checkpoint: checkpoint,
+    safety: { stage: SESSION_CHECKPOINT_STAGE, ...falseBoundary() },
+    quality: [],
+    action: 'session checkpoint summarized the current workflow start route and optional local evidence file only. No state, source, command, skill, subagent, platform, or git action occurred.',
+  };
+}
+
+export function buildSessionHandoffEnvelope({ root, workflowStart, sourceFile = '', digestObject }) {
+  const source = safeLocalPath(root, sourceFile, 'session --handoff --from-file');
+  const handoff = handoffPayload({ workflowStart, source, digestObject });
+  return {
+    mode: 'session-handoff',
+    ok: true,
+    state_present: fs.existsSync(path.join(path.resolve(root || process.cwd()), '.vibecoding-state')),
+    session_handoff: handoff,
+    safety: { stage: SESSION_CHECKPOINT_STAGE, ...falseBoundary() },
+    quality: [],
+    action: 'session handoff produced a one-screen handoff contract from the current route and optional local evidence file only. It did not execute or advance the workflow.',
+  };
+}
+
+export function buildSessionResumeEnvelope({ root, checkpointFile, digestObject }) {
+  const source = safeLocalPath(root, checkpointFile, 'session --resume --from-file');
+  const parsed = JSON.parse(fs.readFileSync(source.absolute, 'utf8'));
+  const payload = parsed.session_checkpoint || parsed.session_handoff || parsed;
+  const verification = verifyDigest(payload, digestObject);
+  if (!verification.pass) throw new Error('session --resume checkpoint digest mismatch');
+  const resume = {
+    version: SESSION_CHECKPOINT_VERSION,
+    stage: SESSION_CHECKPOINT_STAGE,
+    resume_kind: 'session-resume',
+    owner_module: 'runtime-session-checkpoint-model',
+    source_file: source.relative,
+    source_digest: fileDigest(source),
+    source_checkpoint_kind: payload.checkpoint_kind || 'unknown',
+    selected_skill: payload.selected_skill || payload.route?.selected_skill || 'using-vibecoding',
+    route: payload.route || {},
+    completed_gates: payload.completed_gates || [],
+    blocked_gates: payload.blocked_gates || [],
+    next_manual_action: payload.next_manual_action || payload.route?.next_manual_action || 'confirm next manual action before continuing',
+    resume_verification: verification,
+    boundary_assertions: falseBoundary(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  return {
+    mode: 'session-resume',
+    ok: true,
+    state_present: fs.existsSync(path.join(path.resolve(root || process.cwd()), '.vibecoding-state')),
+    session_resume: { ...resume, resume_digest: digest(digestObject, resume) },
+    safety: { stage: SESSION_CHECKPOINT_STAGE, ...falseBoundary() },
+    quality: [],
+    action: 'session resume verified a local checkpoint or handoff file and restored route evidence for manual continuation only. It did not execute the next skill, create state, or touch git/platform/subagent surfaces.',
+  };
+}
+
+export { SESSION_CHECKPOINT_STAGE, SESSION_CHECKPOINT_VERSION };

package/tools/vibe-runtime/runtime-session-skill-command.mjs

@@ -0,0 +1,241 @@
+import {
+  buildSessionCheckpointEnvelope,
+  buildSessionHandoffEnvelope,
+  buildSessionResumeEnvelope,
+} from './runtime-session-checkpoint-model.mjs';
+
+function readOnlyForbiddenFlags(options) {
+  return [
+    options.confirm,
+    options.write,
+    options.dryRun,
+    options.recoveryPreview,
+    options.hooksPreview,
+    options.dispatch,
+    options.dispatchIntent,
+    options.run,
+    options.autoRun,
+    options.scan,
+    options.once,
+    options.preflight,
+  ].some(Boolean);
+}
+
+function rejectReadOnlyRuntimeFlags(options, label) {
+  if (readOnlyForbiddenFlags(options)) {
+    throw new Error(`${label} is read-only and does not accept execution, dispatch, preview, confirm, write, scan, or preflight flags`);
+  }
+}
+
+function aliasSideInputValues(options) {
+  return [
+    options.fromReadiness, options.fromPlan, options.fromEvidence, options.fromProductDiscovery,
+    options.fromProductSpec, options.fromUiDesign, options.fromArchitecture, options.fromTraceability,
+    options.fromScenarios, options.fromProductAcceptance, options.fromTestEvidence, options.fromDiffCoverage,
+    options.fromCommitReadiness, options.fromRunbook, options.fromTranscript, options.fromGap,
+    options.fromFriction, options.fromConsole, options.fromDashboard, options.fromUpgrades,
+    options.fromDiscipline, options.fromScorecard, options.commitSubject, options.confirmPlan,
+    options.evidenceFile, options.diffFile, options.reviewFile, options.tddFile,
+    options.methodologyKind, options.methodologyFile, options.learningObservationFiles.length > 0,
+    options.learningInstinctFile, options.tokenCompactionFiles.length > 0,
+  ];
+}
+
+function rejectCommonAliasSideInputs(options, label) {
+  rejectReadOnlyRuntimeFlags(options, label);
+  if (aliasSideInputValues(options).some(Boolean)) {
+    throw new Error(`${label} only accepts its entry inputs plus --json and --root`);
+  }
+  if (options.profile && !['vibe-guided', 'default', 'superpowers-parity'].includes(options.profile)) {
+    throw new Error(`${label} --profile must be vibe-guided, default, or superpowers-parity`);
+  }
+}
+
+function rejectSessionCloseSideInputs(options) {
+  const label = 'session --close';
+  rejectReadOnlyRuntimeFlags(options, label);
+  if ([options.methodologyIntent, options.prompt, options.profile, ...aliasSideInputValues(options)].some(Boolean)) {
+    throw new Error(`${label} only accepts --from-file plus --json and --root`);
+  }
+}
+
+function rejectSessionResumeSideInputs(options) {
+  const label = 'session --resume';
+  rejectReadOnlyRuntimeFlags(options, label);
+  if ([options.methodologyIntent, options.prompt, options.profile, ...aliasSideInputValues(options)].some(Boolean)) {
+    throw new Error(`${label} only accepts --from-file plus --json and --root`);
+  }
+  if (!options.fromFile) throw new Error(`${label} requires --from-file <local-checkpoint-json>`);
+}
+
+function rejectSessionCheckpointSideInputs(options, label) {
+  rejectCommonAliasSideInputs(options, label);
+  if (!options.methodologyIntent && !options.prompt) throw new Error(`${label} requires --intent <kind> or --prompt <text>`);
+}
+
+function aliasDigest(deps, payload) {
+  return typeof deps.digestObject === 'function' ? deps.digestObject(payload) : '';
+}
+
+function sessionStartAliasSummary(deps, workflowStart) {
+  const start = workflowStart.workflow_start;
+  const summary = {
+    version: 1,
+    stage: 'Stage 16',
+    alias_kind: 'agent-session-start-alias',
+    owner_module: 'runtime-session-skill-command',
+    canonical_command: 'workflow --start',
+    canonical_mode: workflowStart.mode,
+    selected_skill: start?.receipt_summary?.selected_skill || '',
+    next_manual_action: start?.next_manual_action || '',
+    start_contract_digest: start?.start_here_contract?.contract_digest || '',
+    workflow_start_digest: start?.start_digest || '',
+    skill_execution_claimed: false,
+    command_execution_claimed: false,
+    subagent_dispatch_claimed: false,
+    git_write_claimed: false,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  return { ...summary, alias_digest: aliasDigest(deps, summary) };
+}
+
+function skillSelectAliasSummary(deps, workflowReceipt) {
+  const receipt = workflowReceipt.workflow_receipt;
+  const summary = {
+    version: 1,
+    stage: 'Stage 16',
+    alias_kind: 'skill-select-alias',
+    owner_module: 'runtime-session-skill-command',
+    canonical_command: 'workflow --receipt',
+    canonical_mode: workflowReceipt.mode,
+    selected_skill: receipt?.selected_skill || '',
+    next_gate: receipt?.route_summary?.first_skill || receipt?.selected_skill || '',
+    user_visible_sentence: receipt?.user_visible_sentence || '',
+    workflow_receipt_digest: receipt?.receipt_digest || '',
+    skill_execution_claimed: false,
+    workflow_execution_claimed: false,
+    command_execution_claimed: false,
+    subagent_dispatch_claimed: false,
+    git_write_claimed: false,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  return { ...summary, alias_digest: aliasDigest(deps, summary) };
+}
+
+function sessionCloseAliasSummary(deps, completionEnvelope) {
+  const bundle = completionEnvelope.completion_evidence_bundle;
+  const humanBundle = bundle?.human_completion_evidence_bundle;
+  const readiness = completionEnvelope.completion_readiness;
+  const summary = {
+    version: 1,
+    stage: 'Stage 20',
+    alias_kind: 'session-close-evidence-alias',
+    owner_module: 'runtime-session-skill-command',
+    canonical_command: 'completion --evidence-bundle',
+    canonical_mode: completionEnvelope.mode,
+    evidence_file: bundle?.evidence_file || '',
+    closeout_decision: bundle?.closeout_decision || '',
+    delivery_gate_pass: humanBundle?.delivery_gate?.pass === true,
+    completion_claim_allowed: humanBundle?.delivery_gate?.completion_claim_allowed === true,
+    git_action_allowed: false,
+    platform_action_allowed: false,
+    subagent_allowed: false,
+    verification_evidence_count: bundle?.evidence_inventory?.verification_evidence_count || 0,
+    blocked_reasons: humanBundle?.delivery_gate?.blockers || [],
+    next_manual_action: humanBundle?.manual_next_action || '',
+    completion_evidence_bundle_digest: bundle?.bundle_digest || '',
+    human_completion_evidence_digest: humanBundle?.human_completion_evidence_digest || '',
+    completion_readiness_digest: readiness?.readiness_digest || bundle?.readiness_summary?.readiness_digest || '',
+    skill_execution_claimed: false,
+    workflow_execution_claimed: false,
+    command_execution_claimed: false,
+    subagent_dispatch_claimed: false,
+    git_write_claimed: false,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  return { ...summary, alias_digest: aliasDigest(deps, summary) };
+}
+
+export function runSessionCommand(deps, options) {
+  const jsonWriter = deps['writeJson' + 'Envelope'];
+  deps.ensureRoot(options.root);
+  const modes = [options.sessionStart, options.sessionClose, options.sessionCheckpoint, options.sessionHandoff, options.sessionResume].filter(Boolean);
+  if (modes.length !== 1) throw new Error('session requires exactly one mode: --start, --close, --checkpoint, --handoff, or --resume');
+  if (options.sessionClose) {
+    rejectSessionCloseSideInputs(options);
+    const envelope = deps.completionEvidenceBundleEnvelope(options.root, { evidenceFile: options.fromFile || '' });
+    const aliasEnvelope = {
+      ...envelope,
+      mode: 'session-close-evidence-alias',
+      session_close_alias: sessionCloseAliasSummary(deps, envelope),
+    };
+    if (options.json) jsonWriter('session', aliasEnvelope);
+    else deps.printSessionClose(aliasEnvelope);
+    return;
+  }
+  if (options.sessionResume) {
+    rejectSessionResumeSideInputs(options);
+    const envelope = buildSessionResumeEnvelope({ root: options.root, checkpointFile: options.fromFile, digestObject: deps.digestObject });
+    if (options.json) jsonWriter('session', envelope);
+    else deps.printSessionResume(envelope);
+    return;
+  }
+  if (options.sessionCheckpoint || options.sessionHandoff) {
+    const label = options.sessionCheckpoint ? 'session --checkpoint' : 'session --handoff';
+    rejectSessionCheckpointSideInputs(options, label);
+    const workflowStart = deps.workflowStartEnvelope(options.root, {
+      intent: options.methodologyIntent,
+      prompt: options.prompt,
+      planFile: '',
+      profile: options.profile,
+    });
+    const envelope = options.sessionCheckpoint
+      ? buildSessionCheckpointEnvelope({ root: options.root, workflowStart, sourceFile: options.fromFile || '', digestObject: deps.digestObject })
+      : buildSessionHandoffEnvelope({ root: options.root, workflowStart, sourceFile: options.fromFile || '', digestObject: deps.digestObject });
+    if (options.json) jsonWriter('session', envelope);
+    else if (options.sessionCheckpoint) deps.printSessionCheckpoint(envelope);
+    else deps.printSessionHandoff(envelope);
+    return;
+  }
+  rejectCommonAliasSideInputs(options, 'session --start');
+  if (!options.methodologyIntent && !options.prompt) throw new Error('session --start requires --intent <kind> or --prompt <text>');
+  const envelope = deps.workflowStartEnvelope(options.root, {
+    intent: options.methodologyIntent,
+    prompt: options.prompt,
+    planFile: options.fromFile || '',
+    profile: options.profile,
+  });
+  const aliasEnvelope = {
+    ...envelope,
+    mode: 'agent-session-start-alias',
+    session_start_alias: sessionStartAliasSummary(deps, envelope),
+  };
+  if (options.json) jsonWriter('session', aliasEnvelope);
+  else deps.printSessionStart(aliasEnvelope);
+}
+
+export function runSkillCommand(deps, options) {
+  const jsonWriter = deps['writeJson' + 'Envelope'];
+  deps.ensureRoot(options.root);
+  if (!options.skillSelect) throw new Error('skill requires exactly one mode: --select');
+  rejectCommonAliasSideInputs(options, 'skill --select');
+  if (!options.methodologyIntent) throw new Error('skill --select requires --intent <kind>');
+  if (options.prompt || options.fromFile) throw new Error('skill --select only accepts --intent plus --json and --root');
+  const envelope = deps.workflowReceiptEnvelope(options.root, { intent: options.methodologyIntent });
+  const aliasEnvelope = {
+    ...envelope,
+    mode: 'skill-select-alias',
+    skill_select_alias: skillSelectAliasSummary(deps, envelope),
+  };
+  if (options.json) jsonWriter('skill', aliasEnvelope);
+  else deps.printSkillSelect(aliasEnvelope);
+}

package/tools/vibe-runtime/runtime-session-start-example-command.mjs

@@ -0,0 +1,122 @@
+import {
+  localJsonFileWithinRoot,
+} from './runtime-local-json-input.mjs';
+import {
+  emitReadonlyLocalJsonOutput,
+  readonlyLocalJsonEnvelope,
+} from './runtime-readonly-local-json-output-envelope.mjs';
+import {
+  digestSessionStartExamplePack,
+  runtimeSessionStartExamplePack,
+  runtimeSessionStartExamplePackDigestPayload,
+} from './runtime-session-start-example-pack.mjs';
+
+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 sessionStartExamplePackEnvelope(root, shapeFile, installExperienceFile) {
+  if (!shapeFile) throw new Error('platforms --session-start-examples requires --from-shape <local-shape-json>');
+  if (!installExperienceFile) throw new Error('platforms --session-start-examples requires --from-install-experience <local-install-json>');
+  const shapeInput = localJsonFileWithinRoot(root, shapeFile, 'platforms --session-start-examples --from-shape');
+  const installInput = localJsonFileWithinRoot(root, installExperienceFile, 'platforms --session-start-examples --from-install-experience');
+  const pack = runtimeSessionStartExamplePack({
+    shapeAcceptance: shapeInput.data,
+    installExperience: installInput.data,
+    source: {
+      shape_file: shapeInput.relative,
+      shape_digest: shapeInput.digest,
+      install_experience_file: installInput.relative,
+      install_experience_digest: installInput.digest,
+    },
+  });
+  const examplePack = {
+    ...pack,
+    example_pack_digest: digestSessionStartExamplePack(runtimeSessionStartExamplePackDigestPayload(pack)),
+  };
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'session-start-example-pack',
+    ok: examplePack.ok,
+    payloadKey: 'session_start_example_pack',
+    payload: examplePack,
+    safety: {
+      stage: 'Stage 142',
+      writes: false,
+      session_start_example_pack_artifact: false,
+      session_start_shape_artifact: false,
+      install_experience_artifact: false,
+      adapter_example_artifact: false,
+      adapter_install: false,
+      adapter_execution: false,
+      hook_execution: false,
+      hook_registration: false,
+      manifest_write: false,
+      install_doc_write: false,
+      settings_write: false,
+      prompt_mutation: false,
+      template_mutation: false,
+      skill_mutation: 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,
+      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: examplePack.example_pack_invariants.findings,
+    action: 'session-start example pack read local Stage 134 shape acceptance JSON and local Stage 137 install experience JSON only. It emits copy-ready adapter output examples and context shapes without executing hooks, installing/running adapters, mutating prompts/templates/skills/manifests/docs/source, writing state/artifacts, running commands/checks/tests/workflows, git, platform APIs, model invocation, MCP, or subagents.',
+  });
+}
+
+export function printSessionStartExamplePack(envelope) {
+  const pack = envelope.session_start_example_pack;
+  console.log('Vibecoding Runtime Session-start Example Pack');
+  console.log(`Mode: ${envelope.mode}`);
+  console.log(`Stage: ${pack.stage}; Pack: ${pack.pack_kind}; pass=${pack.ok}`);
+  console.log(`Examples: ${pack.input_summary.adapter_example_count}; Shape adapter: ${pack.input_summary.shape_adapter || 'unknown'}; Install score: ${pack.input_summary.install_experience_score}; Digest: ${pack.example_pack_digest}`);
+  printList('Adapter examples', pack.adapter_examples, (example) => `${example.adapter}: ${example.context_path}; shape=${example.output_shape}`);
+  printList('Copy-ready context shapes', pack.copy_ready_context_shapes, (shape) => `${shape.adapter}: ${shape.context_path}`);
+  printList('Format warnings', pack.format_warnings.length > 0 ? pack.format_warnings : ['none']);
+  if (pack.example_pack_invariants.findings.length > 0) printList('Example pack invariant findings', pack.example_pack_invariants.findings);
+  console.log('Boundary: writes=false; session_start_example_pack_artifact=false; hook_execution=false; adapter_execution=false; command_execution=false; git=false; subagent=false');
+  console.log(`Example pack digest: ${pack.example_pack_digest}`);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function runSessionStartExamplePackCommand(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 --session-start-examples is read-only and report-only');
+  if (!options.fromShape) throw new Error('platforms --session-start-examples requires --from-shape <local-shape-json>');
+  if (!options.fromInstallExperience) throw new Error('platforms --session-start-examples requires --from-install-experience <local-install-json>');
+  if (options.fromFile || options.entryAdapter || options.fromSuperpowers || options.fromFriction || options.fromConsole || options.fromRunbook || options.fromEvidence || options.fromTokenBudget || options.fromLearningPattern || options.fromBootstrapMatrix || options.fromEntryAcceptance || options.methodologyIntent || options.prompt) throw new Error('platforms --session-start-examples only accepts --from-shape, --from-install-experience, --json, and --root');
+  const envelope = sessionStartExamplePackEnvelope(options.root, options.fromShape, options.fromInstallExperience);
+  emitReadonlyLocalJsonOutput({
+    deps,
+    options,
+    channel: 'platforms',
+    envelope,
+    print: printSessionStartExamplePack,
+  });
+}