@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-runtime-automation-methodology-suite.mjs

@@ -0,0 +1,130 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  digestObject,
+  parseJsonOutput,
+  run,
+} from './release-check-runtime.mjs';
+import { runtimeAutomationMethodologySpecs } from './release-check-runtime-automation-methodology-smoke-specs.mjs';
+
+function specMarkerValue(source, markerPath) {
+  return markerPath.split('.').reduce((value, key) => {
+    if (key === 'type') return typeof value;
+    return value?.[key];
+  }, source);
+}
+
+function assertSpecJsonMarkers(source, spec) {
+  assertJsonMarkers(
+    spec.markers.map(([markerPath, expected]) => [markerPath, specMarkerValue(source, markerPath), expected]),
+    spec.label,
+  );
+}
+
+export function runRuntimeAutomationMethodologySmoke(context, options) {
+  const {
+    methodologyTarget,
+    hooksTarget,
+    absoluteMethodologyTarget,
+    absoluteHooksTarget,
+    methodologyHandoffFile,
+  } = context;
+
+  fs.writeFileSync(methodologyHandoffFile, `${JSON.stringify(runtimeAutomationMethodologySpecs.methodologyHandoff, null, 2)}\n`, 'utf8');
+  const methodologyCatalog = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--catalog', '--json', '--root', methodologyTarget], {}, options), runtimeAutomationMethodologySpecs.methodologyCatalogJson.label);
+  assertSpecJsonMarkers(methodologyCatalog, runtimeAutomationMethodologySpecs.methodologyCatalogJson);
+  if (fs.existsSync(path.join(absoluteMethodologyTarget, '.vibecoding-state'))) throw new Error('methodology catalog created unexpected state directory');
+  run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', methodologyHandoffFile, '--root', methodologyTarget], {}, options);
+  const methodologyPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--gate', '--kind', 'completion', '--json', '--root', methodologyTarget], {}, options), runtimeAutomationMethodologySpecs.methodologyPreviewJson.label);
+  assertSpecJsonMarkers(methodologyPreview, runtimeAutomationMethodologySpecs.methodologyPreviewJson);
+  if (fs.existsSync(path.join(absoluteMethodologyTarget, '.vibecoding-state', 'methodology-gates'))) throw new Error('methodology gate preview wrote unexpected gate directory');
+  const methodologyConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--gate', '--kind', 'completion', '--confirm', '--json', '--root', methodologyTarget], {}, options), runtimeAutomationMethodologySpecs.methodologyConfirmJson.label);
+  const methodologyGateFile = methodologyConfirm.methodology_gate_file;
+  assertSpecJsonMarkers(methodologyConfirm, runtimeAutomationMethodologySpecs.methodologyConfirmJson);
+  if (!methodologyGateFile || !fs.existsSync(path.join(absoluteMethodologyTarget, '.vibecoding-state', 'methodology-gates', methodologyGateFile))) throw new Error('methodology gate confirm did not write gate artifact');
+  const methodologyVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--verify', methodologyGateFile, '--json', '--root', methodologyTarget], {}, options), runtimeAutomationMethodologySpecs.methodologyVerifyJson.label);
+  assertSpecJsonMarkers(methodologyVerify, runtimeAutomationMethodologySpecs.methodologyVerifyJson);
+  const methodologyGatePath = path.join(absoluteMethodologyTarget, '.vibecoding-state', 'methodology-gates', methodologyGateFile);
+  const tamperedMethodologyGate = JSON.parse(fs.readFileSync(methodologyGatePath, 'utf8'));
+  tamperedMethodologyGate.methodology_gate.boundary_assertions.git = true;
+  fs.writeFileSync(path.join(absoluteMethodologyTarget, '.vibecoding-state', 'methodology-gates', 'bad-safety.methodology-gate.json'), `${JSON.stringify(tamperedMethodologyGate, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--verify', 'bad-safety.methodology-gate.json', '--root', methodologyTarget], {
+    allowFailure: true,
+    expectOutput: runtimeAutomationMethodologySpecs.tamperedMethodologyVerifyOutput,
+  }, options);
+  fs.rmSync(path.join(absoluteMethodologyTarget, '.vibecoding-state', 'methodology-gates', 'bad-safety.methodology-gate.json'), { force: true });
+  if (!options.keepTmp) fs.rmSync(methodologyHandoffFile, { force: true });
+
+  const hooksCatalog = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'hooks', '--catalog', '--json', '--root', hooksTarget], {}, options), runtimeAutomationMethodologySpecs.hooksCatalogJson.label);
+  assertSpecJsonMarkers(hooksCatalog, runtimeAutomationMethodologySpecs.hooksCatalogJson);
+  if (fs.existsSync(path.join(absoluteHooksTarget, '.vibecoding-state'))) throw new Error('hooks catalog created unexpected state directory');
+  const hooksPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'hooks', '--preview', '--json', '--root', hooksTarget], {}, options), runtimeAutomationMethodologySpecs.hooksPreviewJson.label);
+  assertSpecJsonMarkers(hooksPreview, runtimeAutomationMethodologySpecs.hooksPreviewJson);
+  if (fs.existsSync(path.join(absoluteHooksTarget, '.vibecoding-state'))) throw new Error('hooks preview created unexpected state directory');
+  const hooksConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'hooks', '--preview', '--confirm', '--json', '--root', hooksTarget], {}, options), runtimeAutomationMethodologySpecs.hooksConfirmJson.label);
+  const hookIntentFile = hooksConfirm.hook_intent_file;
+  assertSpecJsonMarkers(hooksConfirm, runtimeAutomationMethodologySpecs.hooksConfirmJson);
+  if (!hookIntentFile || !fs.existsSync(path.join(absoluteHooksTarget, '.vibecoding-state', 'hook-intents', hookIntentFile))) throw new Error('hooks confirm did not write hook intent artifact');
+  const hooksVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'hooks', '--verify', hookIntentFile, '--json', '--root', hooksTarget], {}, options), runtimeAutomationMethodologySpecs.hooksVerifyJson.label);
+  assertSpecJsonMarkers(hooksVerify, runtimeAutomationMethodologySpecs.hooksVerifyJson);
+  const hookIntentPath = path.join(absoluteHooksTarget, '.vibecoding-state', 'hook-intents', hookIntentFile);
+  const tamperedHookIntent = JSON.parse(fs.readFileSync(hookIntentPath, 'utf8'));
+  tamperedHookIntent.hook_intent.subagent_dispatch = true;
+  fs.writeFileSync(path.join(absoluteHooksTarget, '.vibecoding-state', 'hook-intents', 'bad-subagent.hook-intent.json'), `${JSON.stringify(tamperedHookIntent, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'hooks', '--verify', 'bad-subagent.hook-intent.json', '--root', hooksTarget], {
+    allowFailure: true,
+    expectOutput: runtimeAutomationMethodologySpecs.tamperedHookIntentVerifyOutput,
+  }, options);
+  fs.rmSync(path.join(absoluteHooksTarget, '.vibecoding-state', 'hook-intents', 'bad-subagent.hook-intent.json'), { force: true });
+  const resignedBadHookIntent = JSON.parse(fs.readFileSync(hookIntentPath, 'utf8'));
+  resignedBadHookIntent.hook_intent.hook_source = 'external_webhook';
+  resignedBadHookIntent.hook_intent.allowed_followup = ['scheduler-plan-only', 'subagent-dispatch'];
+  const unsignedBadHookIntent = { ...resignedBadHookIntent.hook_intent };
+  delete unsignedBadHookIntent.writes;
+  delete unsignedBadHookIntent.intent_digest;
+  resignedBadHookIntent.hook_intent.intent_digest = digestObject(unsignedBadHookIntent);
+  fs.writeFileSync(path.join(absoluteHooksTarget, '.vibecoding-state', 'hook-intents', 'bad-resigned.hook-intent.json'), `${JSON.stringify(resignedBadHookIntent, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'hooks', '--verify', 'bad-resigned.hook-intent.json', '--root', hooksTarget], {
+    allowFailure: true,
+    expectOutput: runtimeAutomationMethodologySpecs.resignedHookIntentVerifyOutput,
+  }, options);
+  fs.rmSync(path.join(absoluteHooksTarget, '.vibecoding-state', 'hook-intents', 'bad-resigned.hook-intent.json'), { force: true });
+
+  const schedulerHookPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--from-hook', hookIntentFile, '--plan', '--json', '--root', hooksTarget], {}, options), runtimeAutomationMethodologySpecs.schedulerHookPreviewJson.label);
+  assertSpecJsonMarkers(schedulerHookPreview, runtimeAutomationMethodologySpecs.schedulerHookPreviewJson);
+  if (fs.existsSync(path.join(absoluteHooksTarget, '.vibecoding-state', 'scheduler-hook-plans'))) throw new Error('scheduler from-hook preview created unexpected scheduler hook plan directory');
+  const schedulerHookConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--from-hook', hookIntentFile, '--plan', '--confirm', '--json', '--root', hooksTarget], {}, options), runtimeAutomationMethodologySpecs.schedulerHookConfirmJson.label);
+  const schedulerHookPlanFile = schedulerHookConfirm.scheduler_hook_plan_file;
+  assertSpecJsonMarkers(schedulerHookConfirm, runtimeAutomationMethodologySpecs.schedulerHookConfirmJson);
+  if (!schedulerHookPlanFile || !fs.existsSync(path.join(absoluteHooksTarget, '.vibecoding-state', 'scheduler-hook-plans', schedulerHookPlanFile))) throw new Error('scheduler from-hook confirm did not write scheduler hook plan artifact');
+  const schedulerHookVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--verify', schedulerHookPlanFile, '--json', '--root', hooksTarget], {}, options), runtimeAutomationMethodologySpecs.schedulerHookVerifyJson.label);
+  assertSpecJsonMarkers(schedulerHookVerify, runtimeAutomationMethodologySpecs.schedulerHookVerifyJson);
+  const schedulerHookPlanPath = path.join(absoluteHooksTarget, '.vibecoding-state', 'scheduler-hook-plans', schedulerHookPlanFile);
+  const tamperedSchedulerHookPlan = JSON.parse(fs.readFileSync(schedulerHookPlanPath, 'utf8'));
+  tamperedSchedulerHookPlan.scheduler_hook_plan.budget.subagent_dispatch_allowed = true;
+  fs.writeFileSync(path.join(absoluteHooksTarget, '.vibecoding-state', 'scheduler-hook-plans', 'bad-subagent.scheduler-hook-plan.json'), `${JSON.stringify(tamperedSchedulerHookPlan, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--verify', 'bad-subagent.scheduler-hook-plan.json', '--root', hooksTarget], {
+    allowFailure: true,
+    expectOutput: runtimeAutomationMethodologySpecs.tamperedSchedulerHookPlanVerifyOutput,
+  }, options);
+  fs.rmSync(path.join(absoluteHooksTarget, '.vibecoding-state', 'scheduler-hook-plans', 'bad-subagent.scheduler-hook-plan.json'), { force: true });
+  const resignedBadSchedulerHookPlan = JSON.parse(fs.readFileSync(schedulerHookPlanPath, 'utf8'));
+  resignedBadSchedulerHookPlan.scheduler_hook_plan.allowed_followup = ['scheduler-plan-only', 'subagent-dispatch'];
+  resignedBadSchedulerHookPlan.scheduler_hook_plan.budget.max_runs_per_invocation = 1;
+  resignedBadSchedulerHookPlan.scheduler_hook_plan.required_approvals = ['scheduler-hook-plan-review', 'subagent-dispatch-review'];
+  resignedBadSchedulerHookPlan.scheduler_hook_plan.no_subagent_dispatch = false;
+  delete resignedBadSchedulerHookPlan.scheduler_hook_plan.plan_digest;
+  resignedBadSchedulerHookPlan.scheduler_hook_plan.plan_digest = digestObject(resignedBadSchedulerHookPlan.scheduler_hook_plan);
+  fs.writeFileSync(path.join(absoluteHooksTarget, '.vibecoding-state', 'scheduler-hook-plans', 'bad-resigned.scheduler-hook-plan.json'), `${JSON.stringify(resignedBadSchedulerHookPlan, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'scheduler', '--verify', 'bad-resigned.scheduler-hook-plan.json', '--root', hooksTarget], {
+    allowFailure: true,
+    expectOutput: runtimeAutomationMethodologySpecs.resignedSchedulerHookPlanVerifyOutput,
+  }, options);
+  fs.rmSync(path.join(absoluteHooksTarget, '.vibecoding-state', 'scheduler-hook-plans', 'bad-resigned.scheduler-hook-plan.json'), { force: true });
+
+  return {
+    hookIntentFile,
+    schedulerHookPlanFile,
+  };
+}

package/tools/vibe-release-check/release-check-runtime-automation-platform-smoke-helpers.mjs

@@ -0,0 +1,306 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  digestObject,
+  parseJsonOutput,
+  run,
+} from './release-check-runtime.mjs';
+
+export function runPlatformCapabilityArtifactSmoke(context, options) {
+  const { subagentsTarget, absoluteSubagentsTarget } = context;
+
+  const platformCatalog = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--catalog', '--json', '--root', subagentsTarget], {}, options), 'platforms --catalog --json');
+  assertJsonMarkers([
+    ['command', platformCatalog.command, 'platforms'],
+    ['mode', platformCatalog.mode, 'platform-capability-catalog'],
+    ['catalog.stage', platformCatalog.catalog?.stage, 'Stage 41'],
+    ['catalog.default_write', platformCatalog.catalog?.default_write, false],
+  ], 'platforms --catalog --json');
+  const platformPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--probe', 'cursor', '--json', '--root', subagentsTarget], {}, options), 'platforms --probe --json');
+  assertJsonMarkers([
+    ['command', platformPreview.command, 'platforms'],
+    ['mode', platformPreview.mode, 'platform-capability-probe'],
+    ['platform_capability.stage', platformPreview.platform_capability?.stage, 'Stage 41'],
+    ['platform_capability.platform_api', platformPreview.platform_capability?.platform_api, false],
+    ['platform_capability.external_network', platformPreview.platform_capability?.external_network, false],
+    ['platform_capability.session_create', platformPreview.platform_capability?.session_create, false],
+    ['platform_capability.source_merge', platformPreview.platform_capability?.source_merge, false],
+    ['safety.writes', platformPreview.safety?.writes, false],
+  ], 'platforms --probe --json');
+  const platformConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--probe', 'cursor', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'platforms --probe --confirm --json');
+  const platformCapabilityFile = platformConfirm.platform_capability_file;
+  assertJsonMarkers([
+    ['command', platformConfirm.command, 'platforms'],
+    ['mode', platformConfirm.mode, 'platform-capability-probe'],
+    ['platform_capability.platform', platformConfirm.platform_capability?.platform, 'cursor'],
+    ['platform_capability.allowed_followup.0', platformConfirm.platform_capability?.allowed_followup?.[0], 'platform-session-approval-only'],
+    ['safety.platform_capability_artifact', platformConfirm.safety?.platform_capability_artifact, true],
+    ['safety.platform_api', platformConfirm.safety?.platform_api, false],
+    ['safety.session_create', platformConfirm.safety?.session_create, false],
+    ['platform_capability_file.type', typeof platformCapabilityFile, 'string'],
+  ], 'platforms --probe --confirm --json');
+  if (!platformCapabilityFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-capabilities', platformCapabilityFile))) throw new Error('platforms probe did not write capability artifact');
+  const platformVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--verify', platformCapabilityFile, '--json', '--root', subagentsTarget], {}, options), 'platforms --verify --json');
+  assertJsonMarkers([
+    ['command', platformVerify.command, 'platforms'],
+    ['mode', platformVerify.mode, 'platform-capability-verify'],
+    ['verification.ok', platformVerify.verification?.ok, true],
+  ], 'platforms --verify --json');
+  const platformAliasPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-capabilities', 'bad-alias.platform-capability.json');
+  fs.copyFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-capabilities', platformCapabilityFile), platformAliasPath);
+  run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--verify', 'bad-alias.platform-capability.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['platform capability verification failed:', 'Stage 41 platform capability file identity mismatch'],
+  }, options);
+  fs.rmSync(platformAliasPath, { force: true });
+  const resignedBadPlatform = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-capabilities', platformCapabilityFile), 'utf8'));
+  resignedBadPlatform.platform_capability.platform_api = true;
+  resignedBadPlatform.platform_capability.external_network = true;
+  resignedBadPlatform.platform_capability.session_create = true;
+  resignedBadPlatform.platform_capability.source_merge = true;
+  resignedBadPlatform.platform_capability.allowed_followup = ['platform-session-approval-only', 'platform-session-create-only'];
+  delete resignedBadPlatform.platform_capability.capability_digest;
+  resignedBadPlatform.platform_capability.capability_digest = digestObject(resignedBadPlatform.platform_capability);
+  fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-capabilities', 'bad-resigned.platform-capability.json'), `${JSON.stringify(resignedBadPlatform, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'platforms', '--verify', 'bad-resigned.platform-capability.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['platform capability verification failed:', 'platform_capability.platform_api must be false', 'platform_capability.external_network must be false', 'platform_capability.session_create must be false', 'platform_capability.source_merge must be false', 'platform_capability.allowed_followup must equal platform-session-approval-only'],
+  }, options);
+  fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-capabilities', 'bad-resigned.platform-capability.json'), { force: true });
+  const platformTrace = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--build', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'traces --build platform capability --confirm --json');
+  if (!platformTrace.runtime_trace?.source_types?.platform_capabilities) throw new Error('platform capability trace did not include Stage 41 source type');
+
+  return { platformCapabilityFile };
+}
+
+export function runPlatformSessionApprovalSmoke(context, platformCapabilityFile, subagentDispatchFile, options) {
+  const { subagentsTarget, absoluteSubagentsTarget } = context;
+
+  const sessionApprovalPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--session-approval', '--from-dispatch', subagentDispatchFile, '--capability', platformCapabilityFile, '--json', '--root', subagentsTarget], {}, options), 'subagents --session-approval --json');
+  assertJsonMarkers([
+    ['command', sessionApprovalPreview.command, 'subagents'],
+    ['mode', sessionApprovalPreview.mode, 'platform-session-approval'],
+    ['platform_session_approval.stage', sessionApprovalPreview.platform_session_approval?.stage, 'Stage 42'],
+    ['platform_session_approval.session_create', sessionApprovalPreview.platform_session_approval?.session_create, false],
+    ['platform_session_approval.platform_api', sessionApprovalPreview.platform_session_approval?.platform_api, false],
+    ['platform_session_approval.allowed_followup.0', sessionApprovalPreview.platform_session_approval?.allowed_followup?.[0], 'platform-session-create-only'],
+    ['safety.writes', sessionApprovalPreview.safety?.writes, false],
+  ], 'subagents --session-approval --json');
+  const sessionApprovalConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--session-approval', '--from-dispatch', subagentDispatchFile, '--capability', platformCapabilityFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'subagents --session-approval --confirm --json');
+  const sessionApprovalFile = sessionApprovalConfirm.platform_session_approval_file;
+  assertJsonMarkers([
+    ['command', sessionApprovalConfirm.command, 'subagents'],
+    ['mode', sessionApprovalConfirm.mode, 'platform-session-approval'],
+    ['platform_session_approval.approval_status', sessionApprovalConfirm.platform_session_approval?.approval_status, 'approved-session-create-gate-only'],
+    ['platform_session_approval.user_consent_present', sessionApprovalConfirm.platform_session_approval?.user_consent_present, true],
+    ['platform_session_approval.budget.max_sessions', sessionApprovalConfirm.platform_session_approval?.budget?.max_sessions, 1],
+    ['safety.platform_session_approval_artifact', sessionApprovalConfirm.safety?.platform_session_approval_artifact, true],
+    ['safety.session_create', sessionApprovalConfirm.safety?.session_create, false],
+    ['platform_session_approval_file.type', typeof sessionApprovalFile, 'string'],
+  ], 'subagents --session-approval --confirm --json');
+  if (!sessionApprovalFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-approvals', sessionApprovalFile))) throw new Error('session approval did not write platform session approval artifact');
+  const sessionApprovalVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', sessionApprovalFile, '--json', '--root', subagentsTarget], {}, options), 'subagents --verify platform session approval --json');
+  assertJsonMarkers([
+    ['command', sessionApprovalVerify.command, 'subagents'],
+    ['mode', sessionApprovalVerify.mode, 'platform-session-approval-verify'],
+    ['verification.ok', sessionApprovalVerify.verification?.ok, true],
+  ], 'subagents --verify platform session approval --json');
+  const sessionApprovalAliasPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-approvals', 'bad-alias.platform-session-approval.json');
+  fs.copyFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-approvals', sessionApprovalFile), sessionApprovalAliasPath);
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-alias.platform-session-approval.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['platform session approval verification failed:', 'Stage 42 platform session approval file identity mismatch'],
+  }, options);
+  fs.rmSync(sessionApprovalAliasPath, { force: true });
+  const resignedBadSessionApproval = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-approvals', sessionApprovalFile), 'utf8'));
+  resignedBadSessionApproval.platform_session_approval.session_create = true;
+  resignedBadSessionApproval.platform_session_approval.platform_api = true;
+  resignedBadSessionApproval.platform_session_approval.source_merge = true;
+  resignedBadSessionApproval.platform_session_approval.allowed_followup = ['platform-session-create-only', 'source-merge'];
+  delete resignedBadSessionApproval.platform_session_approval.approval_digest;
+  resignedBadSessionApproval.platform_session_approval.approval_digest = digestObject(resignedBadSessionApproval.platform_session_approval);
+  fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-approvals', 'bad-resigned.platform-session-approval.json'), `${JSON.stringify(resignedBadSessionApproval, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-resigned.platform-session-approval.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['platform session approval verification failed:', 'platform_session_approval.allowed_followup must equal platform-session-create-only', 'platform_session_approval.session_create must be false', 'platform_session_approval.platform_api must be false', 'platform_session_approval.source_merge must be false'],
+  }, options);
+  fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-approvals', 'bad-resigned.platform-session-approval.json'), { force: true });
+  const sessionApprovalTrace = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--build', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'traces --build session approval --confirm --json');
+  if (!sessionApprovalTrace.runtime_trace?.source_types?.platform_session_approvals) throw new Error('session approval trace did not include Stage 42 source type');
+
+  return { sessionApprovalFile };
+}
+
+export function runPlatformSessionLifecycleSmoke(context, sessionApprovalFile, options) {
+  const { subagentsTarget, absoluteSubagentsTarget } = context;
+
+  const platformSessionConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--create-session', '--from-approval', sessionApprovalFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'subagents --create-session --confirm --json');
+  const platformSessionFile = platformSessionConfirm.platform_session_file;
+  const platformSessionLeaseFile = platformSessionConfirm.platform_session_lease_file;
+  const platformSessionResultFile = platformSessionConfirm.platform_session_result_file;
+  assertJsonMarkers([
+    ['command', platformSessionConfirm.command, 'subagents'],
+    ['mode', platformSessionConfirm.mode, 'platform-session-create'],
+    ['platform_session.stage', platformSessionConfirm.platform_session?.stage, 'Stage 43'],
+    ['platform_session.session_create', platformSessionConfirm.platform_session?.session_create, true],
+    ['platform_session.platform_api', platformSessionConfirm.platform_session?.platform_api, true],
+    ['platform_session.business_source_write', platformSessionConfirm.platform_session?.business_source_write, false],
+    ['platform_session_result.review_required', platformSessionConfirm.platform_session_result?.review_required, true],
+    ['safety.platform_session_artifact', platformSessionConfirm.safety?.platform_session_artifact, true],
+    ['platform_session_file.type', typeof platformSessionFile, 'string'],
+  ], 'subagents --create-session --confirm --json');
+  if (!platformSessionFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-sessions', platformSessionFile))) throw new Error('create-session did not write platform session artifact');
+  if (!platformSessionLeaseFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-leases', platformSessionLeaseFile))) throw new Error('create-session did not write platform session lease artifact');
+  if (!platformSessionResultFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-results', platformSessionResultFile))) throw new Error('create-session did not write platform session result artifact');
+  const platformSessionVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', platformSessionFile, '--json', '--root', subagentsTarget], {}, options), 'subagents --verify platform session --json');
+  assertJsonMarkers([
+    ['command', platformSessionVerify.command, 'subagents'],
+    ['mode', platformSessionVerify.mode, 'platform-session-verify'],
+    ['verification.ok', platformSessionVerify.verification?.ok, true],
+  ], 'subagents --verify platform session --json');
+  const platformSessionAliasPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-sessions', 'bad-alias.platform-session.json');
+  fs.copyFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-sessions', platformSessionFile), platformSessionAliasPath);
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-alias.platform-session.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['platform session verification failed:', 'Stage 43 platform session file identity mismatch'],
+  }, options);
+  fs.rmSync(platformSessionAliasPath, { force: true });
+  const resignedBadPlatformSession = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-sessions', platformSessionFile), 'utf8'));
+  resignedBadPlatformSession.platform_session.business_source_write = true;
+  resignedBadPlatformSession.platform_session.source_merge = true;
+  resignedBadPlatformSession.platform_session.git = true;
+  resignedBadPlatformSession.platform_session_result.business_source_write = true;
+  delete resignedBadPlatformSession.platform_session.session_digest;
+  resignedBadPlatformSession.platform_session.session_digest = digestObject(resignedBadPlatformSession.platform_session);
+  delete resignedBadPlatformSession.platform_session_result.result_digest;
+  resignedBadPlatformSession.platform_session_result.result_digest = digestObject(resignedBadPlatformSession.platform_session_result);
+  fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-sessions', 'bad-resigned.platform-session.json'), `${JSON.stringify(resignedBadPlatformSession, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-resigned.platform-session.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['platform session verification failed:', 'platform_session.business_source_write must be false', 'platform_session.source_merge must be false', 'platform_session.git must be false'],
+  }, options);
+  fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-sessions', 'bad-resigned.platform-session.json'), { force: true });
+  const platformSessionCancel = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--cancel-session', platformSessionFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'subagents --cancel-session --confirm --json');
+  const platformSessionCancelFile = platformSessionCancel.platform_session_cancel_file;
+  assertJsonMarkers([
+    ['command', platformSessionCancel.command, 'subagents'],
+    ['mode', platformSessionCancel.mode, 'platform-session-cancel'],
+    ['platform_session_cancel.stage', platformSessionCancel.platform_session_cancel?.stage, 'Stage 43'],
+    ['platform_session_cancel.business_source_write', platformSessionCancel.platform_session_cancel?.business_source_write, false],
+    ['safety.platform_session_cancel_artifact', platformSessionCancel.safety?.platform_session_cancel_artifact, true],
+    ['platform_session_cancel_file.type', typeof platformSessionCancelFile, 'string'],
+  ], 'subagents --cancel-session --confirm --json');
+  if (!platformSessionCancelFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-cancellations', platformSessionCancelFile))) throw new Error('cancel-session did not write platform session cancellation artifact');
+  const platformSessionCancelVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', platformSessionCancelFile, '--json', '--root', subagentsTarget], {}, options), 'subagents --verify platform session cancel --json');
+  assertJsonMarkers([
+    ['command', platformSessionCancelVerify.command, 'subagents'],
+    ['mode', platformSessionCancelVerify.mode, 'platform-session-cancel-verify'],
+    ['verification.ok', platformSessionCancelVerify.verification?.ok, true],
+  ], 'subagents --verify platform session cancel --json');
+  const platformSessionCancelAliasPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-cancellations', 'bad-alias.platform-session-cancel.json');
+  fs.copyFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-cancellations', platformSessionCancelFile), platformSessionCancelAliasPath);
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-alias.platform-session-cancel.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['platform session cancel verification failed:', 'Stage 43 platform session cancel file identity mismatch'],
+  }, options);
+  fs.rmSync(platformSessionCancelAliasPath, { force: true });
+  const resignedBadPlatformSessionCancel = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-cancellations', platformSessionCancelFile), 'utf8'));
+  resignedBadPlatformSessionCancel.platform_session_cancel.business_source_write = true;
+  resignedBadPlatformSessionCancel.platform_session_cancel.source_merge = true;
+  resignedBadPlatformSessionCancel.platform_session_cancel.git = true;
+  delete resignedBadPlatformSessionCancel.platform_session_cancel.cancel_digest;
+  resignedBadPlatformSessionCancel.platform_session_cancel.cancel_digest = digestObject(resignedBadPlatformSessionCancel.platform_session_cancel);
+  fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-cancellations', 'bad-resigned.platform-session-cancel.json'), `${JSON.stringify(resignedBadPlatformSessionCancel, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-resigned.platform-session-cancel.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['platform session cancel verification failed:', 'platform_session_cancel.business_source_write must be false', 'platform_session_cancel.source_merge must be false', 'platform_session_cancel.git must be false'],
+  }, options);
+  fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-cancellations', 'bad-resigned.platform-session-cancel.json'), { force: true });
+  const platformSessionTrace = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--build', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'traces --build platform session --confirm --json');
+  const platformSessionSourceTypes = platformSessionTrace.runtime_trace?.source_types || {};
+  if (!platformSessionSourceTypes.platform_sessions || !platformSessionSourceTypes.platform_session_leases || !platformSessionSourceTypes.platform_session_results || !platformSessionSourceTypes.platform_session_cancellations) throw new Error('platform session trace did not include Stage 43 source types');
+
+  return { platformSessionFile, platformSessionResultFile };
+}
+
+export function runPlatformSessionReviewSmoke(context, platformSessionResultFile, options) {
+  const { subagentsTarget, absoluteSubagentsTarget } = context;
+
+  const sessionIntakeConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--ingest-session-result', platformSessionResultFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'subagents --ingest-session-result --confirm --json');
+  const sessionIntakeFile = sessionIntakeConfirm.platform_session_intake_file;
+  assertJsonMarkers([
+    ['command', sessionIntakeConfirm.command, 'subagents'],
+    ['mode', sessionIntakeConfirm.mode, 'platform-session-result-ingestion'],
+    ['platform_session_intake.stage', sessionIntakeConfirm.platform_session_intake?.stage, 'Stage 44'],
+    ['platform_session_intake.allowed_followup.0', sessionIntakeConfirm.platform_session_intake?.allowed_followup?.[0], 'source-change-candidate-only'],
+    ['platform_session_intake.business_source_write', sessionIntakeConfirm.platform_session_intake?.business_source_write, false],
+    ['safety.platform_session_intake_artifact', sessionIntakeConfirm.safety?.platform_session_intake_artifact, true],
+    ['platform_session_intake_file.type', typeof sessionIntakeFile, 'string'],
+  ], 'subagents --ingest-session-result --confirm --json');
+  if (!sessionIntakeFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-intake', sessionIntakeFile))) throw new Error('ingest-session-result did not write platform session intake artifact');
+  const sessionIntakeVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', sessionIntakeFile, '--json', '--root', subagentsTarget], {}, options), 'subagents --verify platform session intake --json');
+  assertJsonMarkers([
+    ['mode', sessionIntakeVerify.mode, 'platform-session-intake-verify'],
+    ['verification.ok', sessionIntakeVerify.verification?.ok, true],
+  ], 'subagents --verify platform session intake --json');
+  const sessionIntakeAliasPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-intake', 'bad-alias.platform-session-intake.json');
+  fs.copyFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-intake', sessionIntakeFile), sessionIntakeAliasPath);
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-alias.platform-session-intake.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['platform session review verification failed:', 'Stage 44 platform session intake file identity mismatch'],
+  }, options);
+  fs.rmSync(sessionIntakeAliasPath, { force: true });
+  const badSessionIntake = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-intake', sessionIntakeFile), 'utf8'));
+  badSessionIntake.platform_session_intake.business_source_write = true;
+  badSessionIntake.platform_session_intake.source_merge = true;
+  badSessionIntake.platform_session_intake.allowed_followup = ['source-change-candidate-only', 'merge'];
+  delete badSessionIntake.platform_session_intake.intake_digest;
+  badSessionIntake.platform_session_intake.intake_digest = digestObject(badSessionIntake.platform_session_intake);
+  fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-intake', 'bad-resigned.platform-session-intake.json'), `${JSON.stringify(badSessionIntake, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-resigned.platform-session-intake.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['platform session review verification failed:', 'platform_session_intake.allowed_followup must equal source-change-candidate-only', 'platform_session_intake.business_source_write must be false', 'platform_session_intake.source_merge must be false'],
+  }, options);
+  fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-intake', 'bad-resigned.platform-session-intake.json'), { force: true });
+  const sessionReviewConfirm = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--review-session-result', sessionIntakeFile, '--confirm', '--json', '--root', subagentsTarget], {}, options), 'subagents --review-session-result --confirm --json');
+  const sessionReviewFile = sessionReviewConfirm.platform_session_review_file;
+  assertJsonMarkers([
+    ['command', sessionReviewConfirm.command, 'subagents'],
+    ['mode', sessionReviewConfirm.mode, 'platform-session-review-gate'],
+    ['platform_session_review.stage', sessionReviewConfirm.platform_session_review?.stage, 'Stage 44'],
+    ['platform_session_review.review_status', sessionReviewConfirm.platform_session_review?.review_status, 'review-gate-passed-source-candidate-required'],
+    ['platform_session_review.business_source_write', sessionReviewConfirm.platform_session_review?.business_source_write, false],
+    ['safety.platform_session_review_artifact', sessionReviewConfirm.safety?.platform_session_review_artifact, true],
+    ['platform_session_review_file.type', typeof sessionReviewFile, 'string'],
+  ], 'subagents --review-session-result --confirm --json');
+  if (!sessionReviewFile || !fs.existsSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-reviews', sessionReviewFile))) throw new Error('review-session-result did not write platform session review artifact');
+  const sessionReviewVerify = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', sessionReviewFile, '--json', '--root', subagentsTarget], {}, options), 'subagents --verify platform session review --json');
+  assertJsonMarkers([
+    ['mode', sessionReviewVerify.mode, 'platform-session-review-verify'],
+    ['verification.ok', sessionReviewVerify.verification?.ok, true],
+  ], 'subagents --verify platform session review --json');
+  const sessionReviewAliasPath = path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-reviews', 'bad-alias.platform-session-review.json');
+  fs.copyFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-reviews', sessionReviewFile), sessionReviewAliasPath);
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-alias.platform-session-review.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['platform session review verification failed:', 'Stage 44 platform session review file identity mismatch'],
+  }, options);
+  fs.rmSync(sessionReviewAliasPath, { force: true });
+  const badSessionReview = JSON.parse(fs.readFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-reviews', sessionReviewFile), 'utf8'));
+  badSessionReview.platform_session_review.git = true;
+  badSessionReview.platform_session_review.source_merge = true;
+  delete badSessionReview.platform_session_review.review_digest;
+  badSessionReview.platform_session_review.review_digest = digestObject(badSessionReview.platform_session_review);
+  fs.writeFileSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-reviews', 'bad-resigned.platform-session-review.json'), `${JSON.stringify(badSessionReview, null, 2)}\n`, 'utf8');
+  run('node', ['tools/vibe-runtime/index.mjs', 'subagents', '--verify', 'bad-resigned.platform-session-review.json', '--root', subagentsTarget], {
+    allowFailure: true,
+    expectOutput: ['platform session review verification failed:', 'platform_session_review.source_merge must be false', 'platform_session_review.git must be false'],
+  }, options);
+  fs.rmSync(path.join(absoluteSubagentsTarget, '.vibecoding-state', 'platform-session-reviews', 'bad-resigned.platform-session-review.json'), { force: true });
+  const platformSessionReviewTrace = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'traces', '--build', '--confirm', '--json', '--root', subagentsTarget], {}, options), 'traces --build platform session review --confirm --json');
+  const platformSessionReviewSourceTypes = platformSessionReviewTrace.runtime_trace?.source_types || {};
+  if (!platformSessionReviewSourceTypes.platform_session_intake || !platformSessionReviewSourceTypes.platform_session_reviews) throw new Error('platform session review trace did not include Stage 44 source types');
+
+  return { sessionIntakeFile, sessionReviewFile };
+}

package/tools/vibe-release-check/release-check-runtime-automation-platform-suite.mjs

@@ -0,0 +1,30 @@
+import {
+  runPlatformCapabilityArtifactSmoke,
+  runPlatformSessionApprovalSmoke,
+  runPlatformSessionLifecycleSmoke,
+  runPlatformSessionReviewSmoke,
+} from './release-check-runtime-automation-platform-smoke-helpers.mjs';
+
+export function runRuntimeAutomationPlatformSmoke(context, subagentsContext, options) {
+  const { subagentDispatchFile } = subagentsContext;
+
+  const { platformCapabilityFile } = runPlatformCapabilityArtifactSmoke(context, options);
+  const { sessionApprovalFile } = runPlatformSessionApprovalSmoke(context, platformCapabilityFile, subagentDispatchFile, options);
+  const {
+    platformSessionFile,
+    platformSessionResultFile,
+  } = runPlatformSessionLifecycleSmoke(context, sessionApprovalFile, options);
+  const {
+    sessionIntakeFile,
+    sessionReviewFile,
+  } = runPlatformSessionReviewSmoke(context, platformSessionResultFile, options);
+
+  return {
+    platformCapabilityFile,
+    sessionApprovalFile,
+    platformSessionFile,
+    platformSessionResultFile,
+    sessionIntakeFile,
+    sessionReviewFile,
+  };
+}

package/tools/vibe-release-check/release-check-runtime-automation-smoke-fixtures.mjs

@@ -0,0 +1,53 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  repoRoot,
+  tmpRoot,
+} from './release-check-runtime.mjs';
+
+export function buildRuntimeAutomationFixtureContext(options) {
+  const target = '.tmp/vibe-runtime-automation';
+  const methodologyTarget = '.tmp/vibe-runtime-methodology';
+  const hooksTarget = '.tmp/vibe-runtime-hooks';
+  const subagentsTarget = '.tmp/vibe-runtime-subagents';
+  const absoluteTarget = path.join(repoRoot, target);
+  const absoluteMethodologyTarget = path.join(repoRoot, methodologyTarget);
+  const absoluteHooksTarget = path.join(repoRoot, hooksTarget);
+  const absoluteSubagentsTarget = path.join(repoRoot, subagentsTarget);
+  const methodologyHandoffFile = path.join(tmpRoot, 'runtime-methodology-handoff.json');
+  const subagentsHandoffFile = path.join(tmpRoot, 'runtime-subagents-handoff.json');
+
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  fs.rmSync(absoluteMethodologyTarget, { recursive: true, force: true });
+  fs.rmSync(absoluteHooksTarget, { recursive: true, force: true });
+  fs.rmSync(absoluteSubagentsTarget, { recursive: true, force: true });
+  fs.mkdirSync(tmpRoot, { recursive: true });
+  fs.mkdirSync(absoluteTarget, { recursive: true });
+  fs.mkdirSync(absoluteMethodologyTarget, { recursive: true });
+  fs.mkdirSync(absoluteHooksTarget, { recursive: true });
+  fs.mkdirSync(absoluteSubagentsTarget, { recursive: true });
+
+  const cleanup = () => {
+    if (options.keepTmp) return;
+    fs.rmSync(absoluteTarget, { recursive: true, force: true });
+    fs.rmSync(absoluteMethodologyTarget, { recursive: true, force: true });
+    fs.rmSync(absoluteHooksTarget, { recursive: true, force: true });
+    fs.rmSync(absoluteSubagentsTarget, { recursive: true, force: true });
+    fs.rmSync(methodologyHandoffFile, { force: true });
+    fs.rmSync(subagentsHandoffFile, { force: true });
+  };
+
+  return {
+    target,
+    methodologyTarget,
+    hooksTarget,
+    subagentsTarget,
+    absoluteTarget,
+    absoluteMethodologyTarget,
+    absoluteHooksTarget,
+    absoluteSubagentsTarget,
+    methodologyHandoffFile,
+    subagentsHandoffFile,
+    cleanup,
+  };
+}