@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-superpowers-gap-matrix.mjs

@@ -0,0 +1,307 @@
+import crypto from 'node:crypto';
+
+const superpowersGapStage = 'Stage 115';
+const superpowersGapKind = 'superpowers-gap-matrix';
+
+const dimensionDefinitions = [
+  {
+    id: 'entry_ux',
+    label: 'Entry UX',
+    superpowers_markers: ['session-start', 'You have superpowers', 'using-superpowers', '1% chance'],
+    vibecoding_markers: ['workflow --start', 'using-vibecoding', '受控 agent 沙盒', '轻量入口'],
+    superpowers_strength: 'Full session-start injection makes skill discipline visible immediately.',
+    vibecoding_strength: 'Lightweight entry contract keeps startup bounded and avoids full-skill context inflation.',
+    gap: 'Vibecoding should expose a stronger one-screen entry UX without injecting the full workflow skill by default.',
+    recommended_stage: 'Stage 116',
+  },
+  {
+    id: 'skill_trigger_discipline',
+    label: 'Skill trigger discipline',
+    superpowers_markers: ['ABSOLUTELY MUST', 'Invoke relevant or requested skills BEFORE', 'Red Flags'],
+    vibecoding_markers: ['轻量分流', '不要声称已使用某个 skill', 'workflow --receipt'],
+    superpowers_strength: 'Aggressive trigger discipline prevents agents from skipping process.',
+    vibecoding_strength: 'Explicit receipt and route contracts can prove what was recommended without falsely claiming skill execution.',
+    gap: 'Vibecoding needs a clearer contract for progressive trigger strength by task risk.',
+    recommended_stage: 'Stage 116',
+  },
+  {
+    id: 'planning_quality',
+    label: 'Planning quality',
+    superpowers_markers: ['Exact file paths', 'No Placeholders', 'Task Structure', 'Expected:'],
+    vibecoding_markers: ['planner --action-manifest', 'planner --lint', 'docs_expectations', 'code_expectations'],
+    superpowers_strength: 'Plan prose is highly actionable and forces test, file, and commit details.',
+    vibecoding_strength: 'Plan manifests are deterministic and digest-bound.',
+    gap: 'Vibecoding should score plan executability directly, including placeholders, expected output, rollback, and stop conditions.',
+    recommended_stage: 'Stage 117',
+  },
+  {
+    id: 'tdd_enforcement',
+    label: 'TDD enforcement',
+    superpowers_markers: ['NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST', 'RED', 'GREEN', 'REFACTOR'],
+    vibecoding_markers: ['verification --tdd-trace', 'TDD trace', 'RED-GREEN-REFACTOR', 'test_execution=false'],
+    superpowers_strength: 'Strong behavioral mandate forces RED-GREEN-REFACTOR before implementation claims.',
+    vibecoding_strength: 'TDD trace contract can bind local evidence without running tests in runtime.',
+    gap: 'TDD evidence should become part of a broader runbook/evidence binder for stage progression.',
+    recommended_stage: 'Stage 119',
+  },
+  {
+    id: 'execution_loop',
+    label: 'Execution loop',
+    superpowers_markers: ['fresh subagent per task', 'Continuous execution', 'progress ledger', 'review package'],
+    vibecoding_markers: ['automation --one-shot-plan', 'workflow --close-loop', 'execution_authorized=false', 'automation readiness'],
+    superpowers_strength: 'Subagent-driven execution gives a strong autonomous loop when the platform supports it.',
+    vibecoding_strength: 'Execution boundaries remain explicit and local; no hidden session or model dispatch occurs.',
+    gap: 'Vibecoding should create a deterministic sequential stage runbook before allowing any agent-driven local execution.',
+    recommended_stage: 'Stage 118',
+  },
+  {
+    id: 'review_loop',
+    label: 'Review loop',
+    superpowers_markers: ['task reviewer', 'spec compliance', 'code quality', 'final whole-branch review'],
+    vibecoding_markers: ['review --intake', 'review --resolution', 'review_intake_digest', 'review_resolution_digest'],
+    superpowers_strength: 'Per-task and final review are central to execution, not an afterthought.',
+    vibecoding_strength: 'Review intake/resolution envelopes bind local review feedback and repair evidence without platform calls.',
+    gap: 'Review status should be tied into execution evidence and staged commit readiness.',
+    recommended_stage: 'Stage 119',
+  },
+  {
+    id: 'verification_gate',
+    label: 'Verification gate',
+    superpowers_markers: ['Evidence before claims', 'NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE', 'RUN', 'READ'],
+    vibecoding_markers: ['verification --evidence-intake', 'completion --readiness', 'freshness_findings', 'gate_coverage'],
+    superpowers_strength: 'Fresh verification is framed as an honesty gate before any completion claim.',
+    vibecoding_strength: 'Evidence intake and completion readiness can make verification machine-checkable.',
+    gap: 'Actual command evidence should bind to each runbook stage before moving forward.',
+    recommended_stage: 'Stage 119',
+  },
+  {
+    id: 'commit_closeout',
+    label: 'Commit closeout',
+    superpowers_markers: ['finishing-a-development-branch', 'Verify Tests', 'Present Options', 'git commit'],
+    vibecoding_markers: ['release --commit-readiness', 'release --commit-guard', 'commit_execution_authorized=false', 'workflow --close-loop'],
+    superpowers_strength: 'Closeout flow integrates test verification, branch state, and user choice.',
+    vibecoding_strength: 'Commit guard/readiness keeps git action separated from runtime advice.',
+    gap: 'Vibecoding needs per-stage commit readiness that references runbook and evidence, while keeping runtime git=false.',
+    recommended_stage: 'Stage 120',
+  },
+  {
+    id: 'install_bootstrap',
+    label: 'Install bootstrap',
+    superpowers_markers: ['Quickstart', 'plugin marketplace', 'session-start hook', 'additionalContext'],
+    vibecoding_markers: ['node bin/vibe.mjs', 'managed block', 'hooks/', 'injectsFullSkill=false'],
+    superpowers_strength: 'Marketplace and hook bootstrap produce a nearly automatic first-run experience.',
+    vibecoding_strength: 'Install is explicit, no-dependency, and preserves business-project root cleanliness.',
+    gap: 'Vibecoding should keep improving entry UX while preserving lightweight installed layout.',
+    recommended_stage: 'Stage 116',
+  },
+  {
+    id: 'contract_governance',
+    label: 'Contract governance',
+    superpowers_markers: ['workflow', 'skill', 'review', 'verification'],
+    vibecoding_markers: ['runtime-capability-registry', 'boundary_assertions', 'registry_version', 'digest'],
+    superpowers_strength: 'Workflow expectations are strongly documented in skills.',
+    vibecoding_strength: 'Runtime contracts are registry-backed, digest-bound, and release-check verified.',
+    gap: 'Vibecoding should use the gap matrix itself to drive stage planning and regression checks.',
+    recommended_stage: 'Stage 115',
+  },
+];
+
+export function runtimeSuperpowersGapMatrix({ superpowersSources = [], vibecodingSources = [], registry = {} } = {}) {
+  const boundaryAssertions = runtimeSuperpowersGapBoundaryAssertions();
+  const sourceSummary = summarizeSources(superpowersSources, vibecodingSources);
+  const dimensions = dimensionDefinitions.map((definition) => dimensionAssessment(definition, superpowersSources, vibecodingSources));
+  const priorityGaps = dimensions
+    .filter((dimension) => dimension.priority !== 'low')
+    .map((dimension) => ({ id: dimension.id, priority: dimension.priority, recommended_stage: dimension.recommended_stage, gap: dimension.gap }));
+  const recommendedStageSequence = [...new Set(dimensions.map((dimension) => dimension.recommended_stage))]
+    .filter(Boolean)
+    .sort((left, right) => Number(left.replace(/\D/g, '')) - Number(right.replace(/\D/g, '')));
+  const matrix = {
+    version: 1,
+    stage: superpowersGapStage,
+    gap_kind: superpowersGapKind,
+    comparison_target: 'fork/superpowers',
+    source_summary: sourceSummary,
+    registry_binding: {
+      registry_stage: registry.registry_stage || '',
+      registry_kind: registry.registry_kind || '',
+      registry_version: registry.registry_version || 0,
+    },
+    dimensions,
+    vibecoding_advantages: [
+      'deterministic local envelopes with stable digests',
+      'explicit boundary assertions for execution, git, platform, model, MCP, and subagent actions',
+      'runtime registry and release-check coverage for capability drift',
+      'human-friendly aliases without full-skill context injection',
+      'local evidence intake, diff coverage, review resolution, and TDD trace contracts',
+    ],
+    superpowers_advantages: [
+      'strong startup skill discipline and behavior-shaping language',
+      'highly actionable plan prose with exact paths, tests, expected output, and commits',
+      'subagent-driven execution loop with task review and final review',
+      'strong TDD and verification-before-completion norms',
+      'marketplace-oriented installation and session-start bootstrap experience',
+    ],
+    priority_gaps: priorityGaps,
+    recommended_stage_sequence: recommendedStageSequence,
+    next_manual_action: 'Implement the recommended stages in order, starting with Stage 116 entry UX, while preserving local deterministic runtime boundaries.',
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeSuperpowersGapInvariants(matrix);
+  return {
+    ...matrix,
+    gap_matrix_invariants: invariants,
+    manual_action: invariants.pass ? matrix.next_manual_action : 'Fix source coverage or boundary gaps before using this comparison to plan later stages.',
+  };
+}
+
+export function runtimeSuperpowersGapInvariants(matrix) {
+  const dimensionIds = matrix.dimensions.map((dimension) => dimension.id);
+  const missingDimensions = dimensionDefinitions.map((dimension) => dimension.id).filter((id) => !dimensionIds.includes(id));
+  const duplicateDimensions = dimensionIds.filter((id, index, ids) => ids.indexOf(id) !== index);
+  const writableBoundaries = Object.entries(matrix.boundary_assertions || {}).filter(([, value]) => value !== false).map(([key]) => key);
+  const missingForbidden = ['command_execution', 'skill_execution', 'subagent', 'mcp', 'platform_api', 'external_network', 'model_invocation', 'git', 'git_write', 'pr', 'push', 'merge', 'business_source_write', 'state_directory_created']
+    .filter((key) => matrix.boundary_assertions?.[key] !== false);
+  const findings = [
+    ...(matrix.stage === superpowersGapStage ? [] : ['stage must be Stage 115']),
+    ...(matrix.gap_kind === superpowersGapKind ? [] : ['gap_kind must be superpowers-gap-matrix']),
+    ...(matrix.source_summary?.superpowers?.present_files > 0 ? [] : ['superpowers source files must be present']),
+    ...(matrix.source_summary?.vibecoding?.present_files > 0 ? [] : ['vibecoding source files must be present']),
+    ...(matrix.registry_binding?.registry_version >= 13 ? [] : ['registry version must be at least 13 before Stage 115']),
+    ...missingDimensions.map((id) => `missing comparison dimension: ${id}`),
+    ...duplicateDimensions.map((id) => `duplicate comparison dimension: ${id}`),
+    ...writableBoundaries.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_coverage', 'dimension_coverage', 'registry_binding', 'read_only_boundaries'],
+    findings,
+  };
+}
+
+export function runtimeSuperpowersGapDigestPayload(matrix) {
+  return {
+    stage: matrix.stage,
+    gap_kind: matrix.gap_kind,
+    comparison_target: matrix.comparison_target,
+    source_summary: matrix.source_summary,
+    registry_binding: matrix.registry_binding,
+    dimensions: matrix.dimensions,
+    vibecoding_advantages: matrix.vibecoding_advantages,
+    superpowers_advantages: matrix.superpowers_advantages,
+    priority_gaps: matrix.priority_gaps,
+    recommended_stage_sequence: matrix.recommended_stage_sequence,
+    boundary_assertions: matrix.boundary_assertions,
+    gap_matrix_invariants: matrix.gap_matrix_invariants,
+  };
+}
+
+export function digestSuperpowersGapMatrix(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function dimensionAssessment(definition, superpowersSources, vibecodingSources) {
+  const superpowersEvidence = evidenceForMarkers(superpowersSources, definition.superpowers_markers);
+  const vibecodingEvidence = evidenceForMarkers(vibecodingSources, definition.vibecoding_markers);
+  const superpowersScore = scoreEvidence(superpowersEvidence, definition.superpowers_markers.length);
+  const vibecodingScore = scoreEvidence(vibecodingEvidence, definition.vibecoding_markers.length);
+  const delta = superpowersScore - vibecodingScore;
+  const priority = delta >= 25 ? 'high' : delta >= 10 ? 'medium' : 'low';
+  return {
+    id: definition.id,
+    label: definition.label,
+    superpowers_score: superpowersScore,
+    vibecoding_score: vibecodingScore,
+    priority,
+    superpowers_strength: definition.superpowers_strength,
+    vibecoding_strength: definition.vibecoding_strength,
+    gap: definition.gap,
+    recommended_stage: definition.recommended_stage,
+    superpowers_evidence: superpowersEvidence,
+    vibecoding_evidence: vibecodingEvidence,
+  };
+}
+
+function evidenceForMarkers(sources, markers) {
+  return markers.map((marker) => {
+    const hits = sources.filter((source) => source.present && source.marker_hits?.includes(marker));
+    return {
+      marker,
+      present: hits.length > 0,
+      files: hits.map((source) => source.file).slice(0, 6),
+    };
+  });
+}
+
+function scoreEvidence(evidence, total) {
+  if (!total) return 0;
+  return Math.round((evidence.filter((item) => item.present).length / total) * 100);
+}
+
+function summarizeSources(superpowersSources, vibecodingSources) {
+  return {
+    superpowers: sourceFamilySummary(superpowersSources),
+    vibecoding: sourceFamilySummary(vibecodingSources),
+    source_digest: digestSuperpowersGapMatrix({ superpowers: compactSources(superpowersSources), vibecoding: compactSources(vibecodingSources) }),
+  };
+}
+
+function sourceFamilySummary(sources) {
+  return {
+    files: sources.length,
+    present_files: sources.filter((source) => source.present).length,
+    missing_files: sources.filter((source) => !source.present).map((source) => source.file),
+    digest: digestSuperpowersGapMatrix(compactSources(sources)),
+  };
+}
+
+function compactSources(sources) {
+  return sources.map((source) => ({ file: source.file, present: Boolean(source.present), digest: source.digest || '', marker_hits: source.marker_hits || [] }));
+}
+
+function runtimeSuperpowersGapBoundaryAssertions() {
+  return {
+    superpowers_gap_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    source_write: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    workflow_execution: false,
+    auto_execution: false,
+    scheduler: false,
+    daemon: false,
+    retry: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    history_rewrite: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}

package/tools/vibe-runtime/runtime-superpowers-parity-command.mjs

@@ -0,0 +1,102 @@
+import {
+  ensureRoot,
+  localJsonFileWithinRoot,
+} from './runtime-local-json-input.mjs';
+import {
+  emitReadonlyLocalJsonOutput,
+  readonlyLocalJsonEnvelope,
+} from './runtime-readonly-local-json-output-envelope.mjs';
+import {
+  digestSuperpowersParityScorecard,
+  runtimeSuperpowersParityScorecard,
+  runtimeSuperpowersParityScorecardDigestPayload,
+} from './runtime-superpowers-parity-scorecard.mjs';
+
+function printList(title, items) {
+  if (!items || items.length === 0) return;
+  console.log(`${title}:`);
+  for (const item of items) {
+    console.log(`- ${item}`);
+  }
+}
+
+export function superpowersParityScorecardEnvelope(root, { comparisonFile = '', entryDisciplineFile = '', installExperienceFile = '', upgradesFile = '' } = {}) {
+  ensureRoot(root);
+  if (!comparisonFile) throw new Error('governance --superpowers-parity-scorecard requires --from-comparison <local-comparison-json>');
+  if (!entryDisciplineFile) throw new Error('governance --superpowers-parity-scorecard requires --from-entry-discipline <local-discipline-json>');
+  if (!installExperienceFile) throw new Error('governance --superpowers-parity-scorecard requires --from-install-experience <local-install-json>');
+  if (!upgradesFile) throw new Error('governance --superpowers-parity-scorecard requires --from-upgrades <local-upgrades-json>');
+  const comparisonInput = localJsonFileWithinRoot(root, comparisonFile, 'governance --superpowers-parity-scorecard --from-comparison');
+  const entryDisciplineInput = localJsonFileWithinRoot(root, entryDisciplineFile, 'governance --superpowers-parity-scorecard --from-entry-discipline');
+  const installInput = localJsonFileWithinRoot(root, installExperienceFile, 'governance --superpowers-parity-scorecard --from-install-experience');
+  const upgradesInput = localJsonFileWithinRoot(root, upgradesFile, 'governance --superpowers-parity-scorecard --from-upgrades');
+  const base = runtimeSuperpowersParityScorecard({
+    comparison: comparisonInput.data,
+    entryDiscipline: entryDisciplineInput.data,
+    installExperience: installInput.data,
+    upgrades: upgradesInput.data,
+    source: {
+      comparison_file: comparisonInput.relative,
+      comparison_digest: comparisonInput.digest,
+      entry_discipline_file: entryDisciplineInput.relative,
+      entry_discipline_digest: entryDisciplineInput.digest,
+      install_experience_file: installInput.relative,
+      install_experience_digest: installInput.digest,
+      upgrades_file: upgradesInput.relative,
+      upgrades_digest: upgradesInput.digest,
+    },
+  });
+  const scorecard = {
+    ...base,
+    parity_digest: digestSuperpowersParityScorecard(runtimeSuperpowersParityScorecardDigestPayload(base)),
+  };
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'superpowers-parity-scorecard-v2',
+    ok: scorecard.ok,
+    payloadKey: 'superpowers_parity_scorecard',
+    payload: scorecard,
+    safety: { stage: 'Stage 140', ...scorecard.boundary_assertions },
+    quality: scorecard.parity_invariants.findings,
+    action: 'Superpowers parity scorecard was computed read-only from local Stage 133 comparison JSON, local Stage 135 entry discipline JSON, local Stage 137 install experience JSON, and local Stage 139 upgrade prioritizer JSON. It only explains absorbed advantages, remaining gaps, do-not-cross boundaries, and the next-cycle bet; no scorecard artifact, state directory, sidecar, command, check, smoke, test, eval, agent session, workflow skill execution, runtime action, repair, prompt mutation, hook registration, full skill injection, git, commit, push, PR, merge, platform API, external network, model, MCP, subagent, worktree, or business source write occurred.',
+  });
+}
+
+export function printSuperpowersParityScorecard(envelope) {
+  const scorecard = envelope.superpowers_parity_scorecard;
+  console.log('Vibecoding Runtime Superpowers Parity Scorecard v2');
+  console.log(`Stage: ${scorecard.stage}; Kind: ${scorecard.scorecard_kind}; pass=${scorecard.ok}`);
+  console.log(`Inputs: comparison=${scorecard.input_summary.comparison_stage}; entry=${scorecard.input_summary.entry_discipline_stage}; install=${scorecard.input_summary.install_experience_stage}; upgrades=${scorecard.input_summary.upgrades_stage}`);
+  console.log(`Parity score: ${scorecard.parity_score}`);
+  for (const axis of scorecard.parity_axes) console.log(`- ${axis.id}: score=${axis.axis_score}; status=${axis.status}; source=${axis.evidence_source}`);
+  printList('Vibecoding leads', scorecard.vibecoding_leads.map((item) => `${item.id}: ${item.evidence}`));
+  printList('Remaining gaps', scorecard.remaining_gaps.map((item) => `${item.axis_id}: score=${item.axis_score}; ${item.next_action}`));
+  printList('Do not cross boundaries', scorecard.do_not_cross_boundaries.map((item) => `${item.id}: ${item.boundary}`));
+  console.log(`Next cycle bet: ${scorecard.next_cycle_bet.target_stage}; ${scorecard.next_cycle_bet.candidate_id}; weakest_axis=${scorecard.next_cycle_bet.weakest_axis}`);
+  console.log('Boundary: writes=false; parity_scorecard_artifact=false; scorecard_artifact=false; comparison_artifact=false; entry_discipline_artifact=false; install_experience_artifact=false; upgrades_artifact=false; source_write=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; smoke_execution=false; test_execution=false; eval_execution=false; agent_session_execution=false; verification_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_execution=false; repair_execution=false; prompt_mutation=false; hook_registration=false; full_skill_injection=false; dynamic_tool_execution=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; git=false; git_write=false; git_add=false; commit=false; pr=false; push=false; merge=false; business_source_write=false');
+  console.log(`Parity digest: ${scorecard.parity_digest}`);
+  if (envelope.quality.length > 0) printList('Findings', envelope.quality);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function runSuperpowersParityScorecardCommand(options, deps) {
+  if (options.governanceReport) throw new Error('governance --superpowers-parity-scorecard does not accept --report');
+  if (options.confirm || options.dryRun || options.write || options.preflight || options.dispatch || options.dispatchIntent || options.scan || options.once || options.run || options.autoRun || options.fromDispatch || options.dispatchEvent || options.actor || options.approval) throw new Error('governance --superpowers-parity-scorecard is read-only and scorecard-only');
+  if (!options.fromComparison) throw new Error('governance --superpowers-parity-scorecard requires --from-comparison <local-comparison-json>');
+  if (!options.fromEntryDiscipline) throw new Error('governance --superpowers-parity-scorecard requires --from-entry-discipline <local-discipline-json>');
+  if (!options.fromInstallExperience) throw new Error('governance --superpowers-parity-scorecard requires --from-install-experience <local-install-json>');
+  if (!options.fromUpgrades) throw new Error('governance --superpowers-parity-scorecard requires --from-upgrades <local-upgrades-json>');
+  if (options.fromFile || options.fromSuperpowers || options.fromReadiness || options.fromFriction || options.fromConsole || options.fromTokenBudget || options.fromLearningPattern || options.fromRunbook || options.fromEvidence || options.fromExecutablePlan || options.fromPlan || options.fromBootstrapMatrix || options.fromEntryAcceptance || options.fromDashboard || options.selectedStage || options.task || options.commitSubject || options.confirmPlan || options.methodologyIntent || options.methodologyKind || options.learningObservationFiles.length > 0 || options.learningInstinctFile || options.tokenCompactionFiles.length > 0 || options.prompt) throw new Error('governance --superpowers-parity-scorecard only accepts --from-comparison, --from-entry-discipline, --from-install-experience, --from-upgrades, --json, and --root');
+  const envelope = superpowersParityScorecardEnvelope(options.root, {
+    comparisonFile: options.fromComparison,
+    entryDisciplineFile: options.fromEntryDiscipline,
+    installExperienceFile: options.fromInstallExperience,
+    upgradesFile: options.fromUpgrades,
+  });
+  emitReadonlyLocalJsonOutput({
+    deps,
+    options,
+    channel: 'governance',
+    envelope,
+    print: printSuperpowersParityScorecard,
+  });
+}

package/tools/vibe-runtime/runtime-superpowers-parity-profile-contract.mjs

@@ -0,0 +1,183 @@
+const VIBE_GUIDED_PROFILE = 'vibe-guided';
+const LEGACY_DEFAULT_PROFILE = 'default';
+const SUPERPOWERS_PARITY_PROFILE = 'superpowers-parity';
+
+const PROFILE_NAMES = Object.freeze([VIBE_GUIDED_PROFILE, SUPERPOWERS_PARITY_PROFILE]);
+const COMPATIBLE_PROFILE_NAMES = Object.freeze([VIBE_GUIDED_PROFILE, LEGACY_DEFAULT_PROFILE, SUPERPOWERS_PARITY_PROFILE]);
+
+const PROFILE_POLICIES = Object.freeze({
+  [VIBE_GUIDED_PROFILE]: Object.freeze({
+    entry_discipline: 'lightweight-routing',
+    skill_first: false,
+    continuous_next_gate: false,
+    handoff_pressure: 'as-needed',
+    evidence_pressure: 'minimum-necessary',
+    manual_progression: true,
+  }),
+  [SUPERPOWERS_PARITY_PROFILE]: Object.freeze({
+    entry_discipline: 'skill-first-visible-routing',
+    skill_first: true,
+    continuous_next_gate: true,
+    handoff_pressure: 'plan-brief-review-evidence',
+    evidence_pressure: 'strategy-before-change-and-proof-before-closeout',
+    manual_progression: true,
+  }),
+});
+
+const FORBIDDEN_ACTIONS = Object.freeze([
+  'hidden workflow execution',
+  'real subagent session creation',
+  'platform API access',
+  'business source write without explicit scoped permission',
+  'git worktree mutation',
+  'commit, push, PR, or merge',
+  'external network or model call',
+]);
+
+const BOUNDARY_ASSERTIONS = Object.freeze({
+  writes: false,
+  state_directory_created: false,
+  profile_artifact: false,
+  workflow_execution: false,
+  skill_execution: false,
+  command_execution: false,
+  runtime_action: false,
+  auto_execution: false,
+  sidecar_write: false,
+  source_write: false,
+  business_source_write: false,
+  git: false,
+  git_write: false,
+  worktree: false,
+  commit: false,
+  pr: false,
+  push: false,
+  merge: false,
+  platform_api: false,
+  external_network: false,
+  model_invocation: false,
+  subagent: false,
+  mcp: false,
+});
+
+export function vibeGuidedProfileName() {
+  return VIBE_GUIDED_PROFILE;
+}
+
+export function legacyDefaultProfileName() {
+  return LEGACY_DEFAULT_PROFILE;
+}
+
+export function normalizeSuperpowersParityProfileName(profile = VIBE_GUIDED_PROFILE) {
+  if (profile === SUPERPOWERS_PARITY_PROFILE) return SUPERPOWERS_PARITY_PROFILE;
+  return VIBE_GUIDED_PROFILE;
+}
+
+export function compatibleSuperpowersParityProfileNames() {
+  return [...COMPATIBLE_PROFILE_NAMES];
+}
+
+export function agentBehaviorForbiddenActions() {
+  return [...FORBIDDEN_ACTIONS];
+}
+
+export function agentBehaviorBoundaryAssertions() {
+  return { ...BOUNDARY_ASSERTIONS };
+}
+
+export function superpowersParityProfileBoundaryAssertions() {
+  return agentBehaviorBoundaryAssertions();
+}
+
+export function buildSuperpowersParitySkillFirstReceiptModel({
+  profile = VIBE_GUIDED_PROFILE,
+  selectedSkill = '',
+  routeReason = '',
+  nextGate = '',
+  mustNotDoYet = [],
+  digestObject,
+} = {}) {
+  const normalizedProfile = normalizeSuperpowersParityProfileName(profile);
+  const summary = {
+    version: 1,
+    profile: normalizedProfile,
+    receipt_kind: normalizedProfile === SUPERPOWERS_PARITY_PROFILE ? 'skill-first-visible-receipt' : 'lightweight-visible-receipt',
+    selected_skill: selectedSkill || 'using-vibecoding',
+    route_reason: routeReason || (normalizedProfile === SUPERPOWERS_PARITY_PROFILE
+      ? 'superpowers-parity requires visible using-vibecoding routing before implementation.'
+      : 'vibe-guided keeps lightweight using-vibecoding routing.'),
+    next_gate: nextGate || 'manual workflow judgment',
+    must_not_do_yet: mustNotDoYet.length > 0 ? mustNotDoYet : FORBIDDEN_ACTIONS,
+    skill_execution_claimed: false,
+    workflow_execution_claimed: false,
+    boundary_assertions: superpowersParityProfileBoundaryAssertions(),
+    writes: false,
+    local_only: true,
+    deterministic: true,
+  };
+  return {
+    ...summary,
+    receipt_digest: typeof digestObject === 'function' ? digestObject(summary) : '',
+  };
+}
+
+export function buildSuperpowersParityWorkflowStartProfileSummary({
+  profile = VIBE_GUIDED_PROFILE,
+  selectedSkill = '',
+  routeReason = '',
+  nextGate = '',
+  digestObject,
+} = {}) {
+  const normalizedProfile = normalizeSuperpowersParityProfileName(profile);
+  if (normalizedProfile !== SUPERPOWERS_PARITY_PROFILE) return null;
+  const profileContract = buildSuperpowersParityProfileContractModel({ profile: normalizedProfile, digestObject });
+  const skillFirstReceipt = buildSuperpowersParitySkillFirstReceiptModel({
+    profile: normalizedProfile,
+    selectedSkill,
+    routeReason,
+    nextGate,
+    mustNotDoYet: ['do not claim the skill was executed by this receipt', ...profileContract.forbidden_actions],
+    digestObject,
+  });
+  return {
+    profile: profileContract.profile,
+    policy: profileContract.policy,
+    approval_required_before: profileContract.approval_required_before,
+    forbidden_actions: profileContract.forbidden_actions,
+    skill_first_receipt: {
+      selected_skill: skillFirstReceipt.selected_skill,
+      route_reason: skillFirstReceipt.route_reason,
+      next_gate: skillFirstReceipt.next_gate,
+      must_not_do_yet: skillFirstReceipt.must_not_do_yet,
+      skill_execution_claimed: skillFirstReceipt.skill_execution_claimed,
+      workflow_execution_claimed: skillFirstReceipt.workflow_execution_claimed,
+      receipt_digest: skillFirstReceipt.receipt_digest,
+    },
+    profile_digest: profileContract.profile_digest,
+  };
+}
+
+export function buildSuperpowersParityProfileContractModel({ profile = VIBE_GUIDED_PROFILE, digestObject } = {}) {
+  const normalizedProfile = normalizeSuperpowersParityProfileName(profile);
+  const policy = PROFILE_POLICIES[normalizedProfile];
+  const summary = {
+    version: 1,
+    profile: normalizedProfile,
+    known_profiles: PROFILE_NAMES,
+    compatible_profile_aliases: { [LEGACY_DEFAULT_PROFILE]: VIBE_GUIDED_PROFILE },
+    policy,
+    forbidden_actions: FORBIDDEN_ACTIONS,
+    approval_required_before: ['subagent', 'source_write', 'git_write', 'platform_api'],
+    vibe_guided_profile_selected: normalizedProfile === VIBE_GUIDED_PROFILE,
+    default_profile_remains_lightweight: normalizedProfile === VIBE_GUIDED_PROFILE,
+    parity_profile_selected: normalizedProfile === SUPERPOWERS_PARITY_PROFILE,
+    boundary_assertions: superpowersParityProfileBoundaryAssertions(),
+    writes: false,
+    local_only: true,
+    deterministic: true,
+  };
+  return {
+    ...summary,
+    profile_digest: typeof digestObject === 'function' ? digestObject(summary) : '',
+  };
+}