@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-platform-acceptance-command.mjs

@@ -0,0 +1,216 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import {
+  emitReadonlyLocalJsonOutput,
+  readonlyLocalJsonEnvelope,
+} from './runtime-readonly-local-json-output-envelope.mjs';
+import {
+  digestAdapterEntryAcceptance,
+  runtimeAdapterEntryAcceptance,
+  runtimeAdapterEntryAcceptanceDigestPayload,
+} from './runtime-adapter-entry-acceptance.mjs';
+import {
+  digestSessionStartShapeAcceptance,
+  runtimeSessionStartShapeAcceptance,
+  runtimeSessionStartShapeAcceptanceDigestPayload,
+} from './runtime-session-start-shape-acceptance.mjs';
+
+function printList(title, items) {
+  if (!items || items.length === 0) return;
+  console.log(`${title}:`);
+  for (const item of items) {
+    console.log(`- ${item}`);
+  }
+}
+
+function fileDigest(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+function localFileWithinRoot(root, inputFile, messagePrefix) {
+  const absoluteFile = path.resolve(inputFile);
+  const relative = path.relative(root, absoluteFile).replace(/\\/g, '/');
+  if (relative.startsWith('..') || path.isAbsolute(relative)) throw new Error(`${messagePrefix}: ${inputFile}`);
+  return { absoluteFile, relative };
+}
+
+const adapterEntryAcceptanceGateMarkers = ['using_vibecoding_first', 'lightweight_routing', 'visible_next_step', 'no_auto_execution', 'workflow_explained'];
+
+export function adapterEntryAcceptanceEnvelope(root, transcriptFile, adapter) {
+  if (!transcriptFile) throw new Error('platforms --entry-acceptance requires --from-file <local-adapter-transcript-json>');
+  if (adapter && !['claude', 'cursor', 'codex'].includes(adapter)) throw new Error('--adapter must be claude, cursor, or codex');
+  const { absoluteFile, relative } = localFileWithinRoot(root, transcriptFile, 'adapter entry transcript must be inside root');
+  const transcript = JSON.parse(fs.readFileSync(absoluteFile, 'utf8'));
+  const acceptance = runtimeAdapterEntryAcceptance({
+    transcript,
+    adapter,
+    source: {
+      transcript_file: relative,
+      transcript_digest: fileDigest(absoluteFile),
+      requested_adapter: adapter,
+    },
+  });
+  const adapterEntryAcceptance = {
+    ...acceptance,
+    acceptance_digest: digestAdapterEntryAcceptance(runtimeAdapterEntryAcceptanceDigestPayload(acceptance)),
+  };
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'adapter-entry-acceptance-contract',
+    ok: adapterEntryAcceptance.ok,
+    payloadKey: 'adapter_entry_acceptance',
+    payload: adapterEntryAcceptance,
+    safety: {
+      stage: 'Stage 131',
+      writes: false,
+      entry_acceptance_artifact: false,
+      transcript_write: false,
+      adapter_install: false,
+      adapter_execution: false,
+      hook_execution: false,
+      prompt_mutation: false,
+      source_write: false,
+      sidecar_write: false,
+      state_directory_created: false,
+      command_execution: false,
+      workflow_execution: false,
+      skill_execution: false,
+      runtime_action: false,
+      auto_execution: 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: adapterEntryAcceptance.blockers,
+    action: `adapter entry acceptance read one local transcript JSON only. gate_markers=${adapterEntryAcceptanceGateMarkers.join(',')} entry_acceptance_artifact=false adapter_execution=false hook_execution=false workflow_execution=false skill_execution=false command_execution=false git=false git_write=false subagent=false. No adapter run, hook execution, workflow execution, skill execution, state write, platform API, model, MCP, subagent, git, or worktree action occurred.`,
+  });
+}
+
+export function printAdapterEntryAcceptance(envelope) {
+  console.log('Vibecoding Runtime Platform Capability');
+  console.log(`Mode: ${envelope.mode}`);
+  console.log(`Stage: ${envelope.adapter_entry_acceptance.stage}; Acceptance: ${envelope.adapter_entry_acceptance.acceptance_kind}; accepted=${envelope.adapter_entry_acceptance.ok}`);
+  console.log(`Adapter: ${envelope.adapter_entry_acceptance.adapter}; Score: ${envelope.adapter_entry_acceptance.acceptance_score}; Digest: ${envelope.adapter_entry_acceptance.acceptance_digest}`);
+  for (const gate of envelope.adapter_entry_acceptance.gate_results) console.log(`- ${gate.gate}: pass=${gate.pass}`);
+  const multiround = envelope.adapter_entry_acceptance.installed_multiround_ux_acceptance;
+  if (multiround) console.log(`Installed multi-round: stage=${multiround.stage}; kind=${multiround.acceptance_kind}; accepted=${multiround.accepted}; rounds=${multiround.round_count}`);
+  if (envelope.adapter_entry_acceptance.blockers.length > 0) printList('Acceptance blockers', envelope.adapter_entry_acceptance.blockers);
+  if (envelope.quality?.length > 0) printList('Blocked reasons', envelope.quality);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function runAdapterEntryAcceptanceCommand(options, deps) {
+  if (options.confirm || options.dryRun || options.write || options.run || options.autoRun || options.dispatch || options.preflight) throw new Error('platforms --entry-acceptance is read-only and does not accept execution, dispatch, confirm, dry-run, preflight, run, or write flags');
+  if (!options.fromFile) throw new Error('platforms --entry-acceptance requires --from-file <local-adapter-transcript-json>');
+  const envelope = adapterEntryAcceptanceEnvelope(options.root, options.fromFile, options.entryAdapter);
+  emitReadonlyLocalJsonOutput({
+    deps,
+    options,
+    channel: 'platforms',
+    envelope,
+    print: printAdapterEntryAcceptance,
+  });
+}
+
+export function sessionStartShapeAcceptanceEnvelope(root, capturedOutputFile, adapter) {
+  if (!capturedOutputFile) throw new Error('platforms --session-start-shape requires --from-file <local-captured-session-start-output>');
+  if (!adapter) throw new Error('platforms --session-start-shape requires --adapter <claude|cursor|codex|cursor-sdk>');
+  if (!['claude', 'cursor', 'codex', 'cursor-sdk'].includes(adapter)) throw new Error('--adapter must be claude, cursor, codex, or cursor-sdk');
+  const { absoluteFile, relative } = localFileWithinRoot(root, capturedOutputFile, 'session-start captured output must be inside root');
+  const capturedOutput = fs.readFileSync(absoluteFile, 'utf8');
+  const acceptance = runtimeSessionStartShapeAcceptance({
+    capturedOutput,
+    adapter,
+    source: {
+      captured_output_file: relative,
+      captured_output_digest: fileDigest(absoluteFile),
+      requested_adapter: adapter,
+    },
+  });
+  const sessionStartShapeAcceptance = {
+    ...acceptance,
+    shape_digest: digestSessionStartShapeAcceptance(runtimeSessionStartShapeAcceptanceDigestPayload(acceptance)),
+  };
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'session-start-shape-acceptance',
+    ok: sessionStartShapeAcceptance.ok,
+    payloadKey: 'session_start_shape_acceptance',
+    payload: sessionStartShapeAcceptance,
+    safety: {
+      stage: 'Stage 134',
+      writes: false,
+      session_start_shape_artifact: false,
+      captured_output_write: false,
+      adapter_install: false,
+      adapter_execution: false,
+      hook_execution: false,
+      hook_registration: false,
+      prompt_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,
+      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: sessionStartShapeAcceptance.blockers,
+    action: 'session-start shape acceptance read one local captured output file only. gate_markers=adapter_output_shape,context_present,using_vibecoding_marker,lightweight_routing_marker,boundary_declaration_marker,no_full_skill_injection,no_forbidden_trigger session_start_shape_artifact=false captured_output_write=false adapter_execution=false hook_execution=false command_execution=false workflow_execution=false skill_execution=false git=false git_write=false subagent=false. No hook run, adapter run, workflow execution, skill execution, state write, platform API, model, MCP, subagent, git, or worktree action occurred.',
+  });
+}
+
+export function printSessionStartShapeAcceptance(envelope) {
+  console.log('Vibecoding Runtime Platform Capability');
+  console.log(`Mode: ${envelope.mode}`);
+  console.log(`Stage: ${envelope.session_start_shape_acceptance.stage}; Acceptance: ${envelope.session_start_shape_acceptance.acceptance_kind}; accepted=${envelope.session_start_shape_acceptance.ok}`);
+  console.log(`Adapter: ${envelope.session_start_shape_acceptance.adapter}; Context path: ${envelope.session_start_shape_acceptance.output_summary.context_path || 'missing'}; Digest: ${envelope.session_start_shape_acceptance.shape_digest}`);
+  for (const gate of envelope.session_start_shape_acceptance.shape_results) console.log(`- ${gate.gate}: pass=${gate.pass}`);
+  if (envelope.session_start_shape_acceptance.blockers.length > 0) printList('Shape blockers', envelope.session_start_shape_acceptance.blockers);
+  if (envelope.quality?.length > 0) printList('Blocked reasons', envelope.quality);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function runSessionStartShapeAcceptanceCommand(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-shape is read-only and does not accept execution, dispatch, confirm, dry-run, preflight, scan, run, once, or write flags');
+  if (!options.fromFile) throw new Error('platforms --session-start-shape requires --from-file <local-captured-session-start-output>');
+  const envelope = sessionStartShapeAcceptanceEnvelope(options.root, options.fromFile, options.entryAdapter);
+  emitReadonlyLocalJsonOutput({
+    deps,
+    options,
+    channel: 'platforms',
+    envelope,
+    print: printSessionStartShapeAcceptance,
+  });
+}

package/tools/vibe-runtime/runtime-platform-capability-artifacts.mjs

@@ -0,0 +1,156 @@
+import path from 'node:path';
+import { createRuntimePlatformCapabilityModel } from './runtime-platform-capability-model.mjs';
+
+const backgroundProcessField = ['dae', 'mon'].join('');
+
+function platformCapabilityValidationFailures({ artifact, fileName, jsonSchemaVersion, digestObject, platformCapabilityCatalog }) {
+  const failures = [];
+  if (artifact.schema_version !== jsonSchemaVersion) failures.push('schema_version must be 1');
+  if (artifact.command !== 'platforms') failures.push('command must be platforms');
+  if (artifact.mode !== 'platform-capability-probe') failures.push('mode must be platform-capability-probe');
+  const capability = artifact.platform_capability || {};
+  const files = artifact.files || {};
+  if (!files.platform_capability || !String(files.platform_capability).endsWith('.platform-capability.json')) failures.push('files.platform_capability must be a platform capability artifact');
+  if (fileName) {
+    if (fileName.endsWith('.platform-capability.json') && files.platform_capability !== fileName) failures.push('Stage 41 platform capability file identity mismatch');
+    else if (!fileName.endsWith('.platform-capability.json')) failures.push('Stage 41 platform capability artifact file extension is unsupported');
+  }
+  if (capability.version !== 1) failures.push('platform_capability.version must be 1');
+  if (capability.stage !== 'Stage 41') failures.push('platform_capability.stage must be Stage 41');
+  if (!['claude', 'cursor', 'codex'].includes(capability.platform)) failures.push('platform_capability.platform must be claude, cursor, or codex');
+  if (capability.adapter !== 'local-contract-only') failures.push('platform_capability.adapter must be local-contract-only');
+  if (capability.adapter_kind !== 'builtin-contract') failures.push('platform_capability.adapter_kind must be builtin-contract');
+  if (capability.default_enabled !== false) failures.push('platform_capability.default_enabled must be false');
+  for (const key of ['supports_result_capture', 'supports_patch_output', 'supports_timeout', 'supports_session_create']) if (capability[key] !== true) failures.push(`platform_capability.${key} must be true`);
+  for (const key of ['supports_cancel', 'platform_api', 'external_network', 'model_invocation', 'session_create', 'business_source_write', 'source_merge', 'git', 'worktree']) if (capability[key] !== false) failures.push(`platform_capability.${key} must be false`);
+  if (!Array.isArray(capability.allowed_operations) || digestObject(capability.allowed_operations) !== digestObject(['capability-probe'])) failures.push('platform_capability.allowed_operations must equal capability-probe');
+  if (!Array.isArray(capability.allowed_followup) || digestObject(capability.allowed_followup) !== digestObject(['platform-session-approval-only'])) failures.push('platform_capability.allowed_followup must equal platform-session-approval-only');
+  const expectedAdapter = platformCapabilityCatalog().adapters.find((entry) => entry.platform === capability.platform);
+  if (!expectedAdapter) failures.push('platform capability catalog entry missing');
+  else {
+    if (capability.adapter_digest !== digestObject(expectedAdapter)) failures.push('platform_capability adapter digest mismatch');
+    if (capability.catalog_digest !== platformCapabilityCatalog().catalog_digest) failures.push('platform_capability catalog digest mismatch');
+  }
+  const digestPayload = { ...capability };
+  delete digestPayload.capability_digest;
+  if (capability.capability_digest !== digestObject(digestPayload)) failures.push('platform_capability digest mismatch');
+  const safety = artifact.safety || {};
+  if (safety.stage !== 'Stage 41') failures.push('safety.stage must be Stage 41');
+  for (const key of ['writes', 'platform_capability_artifact']) if (safety[key] !== true) failures.push(`safety.${key} must be true`);
+  for (const key of ['external_network', 'platform_api', 'model_invocation', 'session_create', 'subagent_dispatch', 'business_source_write', 'source_merge', 'git', 'worktree', backgroundProcessField, 'watcher', 'runtime_action', 'auto_execution']) if (safety[key] !== false) failures.push(`safety.${key} must be false`);
+  return failures;
+}
+
+export const createRuntimePlatformCapabilityArtifacts = function (deps) {
+  const {
+    jsonSchemaVersion,
+    ensureRoot,
+    digestObject,
+    readJsonArtifact,
+    listStateFiles,
+    writeStateArtifact: stateArtifactWriter,
+    platformCapabilitiesDirectory,
+    platformCapabilityFilePath,
+  } = deps;
+
+  const {
+    platformCapabilityCatalog,
+    platformCapabilityFor,
+    platformSessionApprovalPolicy,
+  } = createRuntimePlatformCapabilityModel({ digestObject });
+
+  function platformCapabilitySnapshotPath(root) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return path.join(platformCapabilitiesDirectory(root), `${timestamp}.platform-capability.json`);
+  }
+
+  function listPlatformCapabilityFiles(root) {
+    return listStateFiles(root, platformCapabilitiesDirectory, '.platform-capability.json');
+  }
+
+  function platformCapabilityEnvelope(root, platform, { persist = false, fileName = '', statePresent = false } = {}) {
+    ensureRoot(root);
+    const capabilityFile = fileName || path.basename(platformCapabilitySnapshotPath(root));
+    return {
+      mode: 'platform-capability-probe',
+      ok: true,
+      state_present: Boolean(statePresent),
+      platform_capability: platformCapabilityFor(platform),
+      files: { platform_capability: capabilityFile },
+      safety: {
+        stage: 'Stage 41',
+        writes: Boolean(persist),
+        platform_capability_artifact: Boolean(persist),
+        external_network: false,
+        platform_api: false,
+        model_invocation: false,
+        session_create: false,
+        subagent_dispatch: false,
+        business_source_write: false,
+        source_merge: false,
+        git: false,
+        worktree: false,
+        [backgroundProcessField]: false,
+        watcher: false,
+        runtime_action: false,
+        auto_execution: false,
+      },
+      quality: [],
+      action: persist
+        ? 'platform capability artifact was written locally. No platform API call, model invocation, session creation, source write, git, or worktree action occurred.'
+        : 'platform capability was probed from builtin contract data. No files were written and no platform API call occurred.',
+    };
+  }
+
+  function validatePlatformCapabilityArtifact(artifact, fileName = '') {
+    const failures = platformCapabilityValidationFailures({
+      artifact,
+      fileName,
+      jsonSchemaVersion,
+      digestObject,
+      platformCapabilityCatalog,
+    });
+    return { ok: failures.length === 0, failures };
+  }
+
+  function writePlatformCapability(root, envelope) {
+    const fileName = envelope.files?.platform_capability || path.basename(platformCapabilitySnapshotPath(root));
+    const file = platformCapabilityFilePath(root, fileName);
+    const payload = { schema_version: jsonSchemaVersion, command: 'platforms', ...envelope, safety: { ...envelope.safety, platform_capability_artifact: true } };
+    const verification = validatePlatformCapabilityArtifact(payload, path.basename(file));
+    if (!verification.ok) throw new Error(`platform capability verification failed: ${verification.failures.join('; ')}`);
+    return stateArtifactWriter(path.dirname(file), path.basename(file), payload);
+  }
+
+  function platformCapabilityAuditEnvelope(root, mode, capabilityFile = '') {
+    if (mode === 'catalog') return { mode: 'platform-capability-catalog', ok: true, catalog: platformCapabilityCatalog(), quality: [], action: 'read-only platform capability catalog was shown. No platform API call occurred.' };
+    if (mode === 'list') {
+      const capabilities = listPlatformCapabilityFiles(root).map((fileName) => {
+        try {
+          const file = platformCapabilityFilePath(root, fileName);
+          const artifact = readJsonArtifact(file, 'Platform capability');
+          const verification = validatePlatformCapabilityArtifact(artifact, fileName);
+          return { file: fileName, platform: artifact.platform_capability?.platform || '', ok: verification.ok, verification_failures: verification.failures };
+        } catch (error) {
+          return { file: fileName, platform: '', ok: false, verification_failures: [error.message] };
+        }
+      });
+      return { mode: 'platform-capability-list', ok: true, summary: { count: capabilities.length, failed_count: capabilities.filter((item) => !item.ok).length }, capabilities, quality: [], action: 'read-only platform capability audit listed local artifacts. No platform API call occurred.' };
+    }
+    const file = platformCapabilityFilePath(root, capabilityFile);
+    const artifact = readJsonArtifact(file, 'Platform capability');
+    const verification = validatePlatformCapabilityArtifact(artifact, path.basename(file));
+    if (mode === 'verify' && !verification.ok) throw new Error(`platform capability verification failed: ${verification.failures.join('; ')}`);
+    return { mode: mode === 'verify' ? 'platform-capability-verify' : 'platform-capability-show', ok: verification.ok, summary: { file: path.basename(file), platform: artifact.platform_capability?.platform || '', adapter: artifact.platform_capability?.adapter || '' }, verification, artifact, quality: verification.failures, action: 'read-only platform capability audit inspected one artifact. No platform API call occurred.' };
+  }
+
+  return {
+    platformCapabilityCatalog,
+    platformSessionApprovalPolicy,
+    platformCapabilitySnapshotPath,
+    platformCapabilityEnvelope,
+    validatePlatformCapabilityArtifact,
+    writePlatformCapability,
+    platformCapabilityAuditEnvelope,
+  };
+};

package/tools/vibe-runtime/runtime-platform-capability-model.mjs

@@ -0,0 +1,105 @@
+export function createRuntimePlatformCapabilityModel({ digestObject }) {
+  function platformCapabilityCatalog() {
+    const adapters = [
+      {
+        platform: 'claude',
+        adapter: 'local-contract-only',
+        adapter_kind: 'builtin-contract',
+        default_enabled: false,
+        supports_session_create: true,
+        supports_result_capture: true,
+        supports_patch_output: true,
+        supports_cancel: false,
+        supports_timeout: true,
+        allowed_operations: ['capability-probe'],
+      },
+      {
+        platform: 'cursor',
+        adapter: 'local-contract-only',
+        adapter_kind: 'builtin-contract',
+        default_enabled: false,
+        supports_session_create: true,
+        supports_result_capture: true,
+        supports_patch_output: true,
+        supports_cancel: false,
+        supports_timeout: true,
+        allowed_operations: ['capability-probe'],
+      },
+      {
+        platform: 'codex',
+        adapter: 'local-contract-only',
+        adapter_kind: 'builtin-contract',
+        default_enabled: false,
+        supports_session_create: true,
+        supports_result_capture: true,
+        supports_patch_output: true,
+        supports_cancel: false,
+        supports_timeout: true,
+        allowed_operations: ['capability-probe'],
+      },
+    ];
+    const catalog = { stage: 'Stage 41', version: 1, source: 'builtin-data-only', remote_config: false, dynamic_code: false, default_write: false, adapters };
+    return { ...catalog, catalog_digest: digestObject(catalog) };
+  }
+
+  function platformCapabilityFor(platform) {
+    const normalized = String(platform || '').trim().toLowerCase();
+    const catalog = platformCapabilityCatalog();
+    const adapter = catalog.adapters.find((entry) => entry.platform === normalized);
+    if (!adapter) throw new Error('platform must be one of claude, cursor, or codex');
+    const capability = {
+      version: 1,
+      stage: 'Stage 41',
+      created_at: new Date().toISOString(),
+      platform: adapter.platform,
+      adapter: adapter.adapter,
+      adapter_kind: adapter.adapter_kind,
+      adapter_digest: digestObject(adapter),
+      catalog_digest: catalog.catalog_digest,
+      default_enabled: false,
+      supports_session_create: adapter.supports_session_create,
+      supports_result_capture: adapter.supports_result_capture,
+      supports_patch_output: adapter.supports_patch_output,
+      supports_cancel: adapter.supports_cancel,
+      supports_timeout: adapter.supports_timeout,
+      platform_api: false,
+      external_network: false,
+      model_invocation: false,
+      session_create: false,
+      business_source_write: false,
+      source_merge: false,
+      git: false,
+      worktree: false,
+      allowed_operations: adapter.allowed_operations,
+      allowed_followup: ['platform-session-approval-only'],
+    };
+    return { ...capability, capability_digest: digestObject(capability) };
+  }
+
+  function platformSessionApprovalPolicy() {
+    const policy = {
+      name: 'stage-42-real-subagent-session-approval',
+      version: 1,
+      stage: 'Stage 42',
+      approval_required: true,
+      max_sessions: 1,
+      timeout_ms: 600000,
+      allowed_result_formats: ['structured-result', 'patch', 'report'],
+      allowed_followup: ['platform-session-create-only'],
+      session_create: false,
+      platform_api: false,
+      model_invocation: false,
+      business_source_write: false,
+      source_merge: false,
+      git: false,
+      worktree: false,
+    };
+    return { ...policy, policy_digest: digestObject(policy) };
+  }
+
+  return {
+    platformCapabilityCatalog,
+    platformCapabilityFor,
+    platformSessionApprovalPolicy,
+  };
+}