@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-source-merge-command.mjs

@@ -0,0 +1,160 @@
+import { runtimeContractSyncOwner } from './runtime-contract-marker-registry.mjs';
+import { emitReadonlyLocalJsonOutput } from './runtime-readonly-local-json-output-envelope.mjs';
+
+export const runtimeSourceMergeCommandContractSync = runtimeContractSyncOwner('runtime-source-merge-command');
+
+export function createRuntimeSourceMergeCommand(deps) {
+  const {
+    path,
+    process,
+    ensureRoot,
+    printList,
+    readJsonArtifact,
+    fileDigest,
+    listStateFiles,
+    sourceChangeCandidatesDirectory,
+    sourceSandboxRunsDirectory,
+    sourceVerificationsDirectory,
+    mergeReadinessDirectory,
+    mergeApprovalsDirectory,
+    mergeAppliesDirectory,
+    sourceChangeCandidateFilePath,
+    sourceSandboxRunFilePath,
+    sourceVerificationFilePath,
+    mergeReadinessFilePath,
+    mergeApprovalFilePath,
+    mergeApplyFilePath,
+    sourceChangeCandidateEnvelope,
+    sourceVerificationEnvelope,
+    mergeReadinessEnvelope,
+    validateSourceChangeCandidateArtifact,
+    validateSourceSandboxRunArtifact,
+    validateSourceVerificationArtifact,
+    validateMergeReadinessArtifact,
+    validateMergeApprovalArtifact,
+    validateMergeApplyArtifact,
+  } = deps;
+
+  function listSourceChangeCandidateFiles(root) {
+    return listStateFiles(root, sourceChangeCandidatesDirectory, '.source-change-candidate.json');
+  }
+
+  function listSourceSandboxRunFiles(root) {
+    return listStateFiles(root, sourceSandboxRunsDirectory, '.source-sandbox-run.json');
+  }
+
+  function listSourceVerificationFiles(root) {
+    return listStateFiles(root, sourceVerificationsDirectory, '.source-verification.json');
+  }
+
+  function sourceAuditEnvelope(root, mode, fileName = '') {
+    if (mode === 'list') {
+      const candidates = listSourceChangeCandidateFiles(root).map((name) => ({ kind: 'source-change-candidate', file: name }));
+      const sandboxes = listSourceSandboxRunFiles(root).map((name) => ({ kind: 'source-sandbox-run', file: name }));
+      const verifications = listSourceVerificationFiles(root).map((name) => ({ kind: 'source-verification', file: name }));
+      return { mode: 'source-artifact-list', ok: true, artifacts: [...candidates, ...sandboxes, ...verifications], summary: { count: candidates.length + sandboxes.length + verifications.length, candidate_count: candidates.length, sandbox_count: sandboxes.length, verification_count: verifications.length }, quality: [], action: 'read-only source artifact audit listed candidate, sandbox, and verification sidecars. No source was written.' };
+    }
+    const kind = fileName.endsWith('.source-change-candidate.json') ? 'candidate' : fileName.endsWith('.source-sandbox-run.json') ? 'sandbox' : 'verification';
+    const file = kind === 'candidate' ? sourceChangeCandidateFilePath(root, fileName) : kind === 'sandbox' ? sourceSandboxRunFilePath(root, fileName) : sourceVerificationFilePath(root, fileName);
+    const artifact = readJsonArtifact(file, kind === 'candidate' ? 'Source change candidate' : kind === 'sandbox' ? 'Source sandbox run' : 'Source verification');
+    const verification = kind === 'candidate' ? validateSourceChangeCandidateArtifact(root, artifact, path.basename(file)) : kind === 'sandbox' ? validateSourceSandboxRunArtifact(root, artifact, path.basename(file)) : validateSourceVerificationArtifact(root, artifact, path.basename(file));
+    if (mode === 'verify' && !verification.ok) throw new Error(`source artifact verification failed: ${verification.failures.join('; ')}`);
+    const modeName = kind === 'candidate' ? 'source-change-candidate' : kind === 'sandbox' ? 'source-sandbox-run' : 'source-verification';
+    return { mode: mode === 'verify' ? `${modeName}-verify` : `${modeName}-show`, ok: verification.ok, summary: { file: path.basename(file), status: artifact.source_change_candidate?.candidate_status || artifact.source_sandbox_run?.sandbox_status || artifact.source_verification?.verification_status || '' }, verification, artifact, quality: verification.failures, action: 'read-only source artifact audit inspected one sidecar. No source was written.' };
+  }
+
+  function printSourceArtifact(envelope, file = '') {
+    console.log('Vibecoding Runtime Source Artifact');
+    console.log(`Mode: ${envelope.mode}`);
+    const detail = envelope.source_change_candidate || envelope.source_sandbox_run || envelope.source_verification || envelope.summary || {};
+    console.log(`Status: ${detail.candidate_status || detail.sandbox_status || detail.verification_status || 'listed'}`);
+    if (file) console.log(`Artifact: ${path.relative(process.cwd(), file)}`);
+    if (envelope.quality?.length > 0) printList('Quality', envelope.quality);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function runSourceReadOnly(options) {
+    ensureRoot(options.root);
+    if (options.sourceCandidate) {
+      const envelope = sourceChangeCandidateEnvelope(options.root, options.sourceFile, { persist: false, artifactFile: '' });
+      emitReadonlyLocalJsonOutput({ deps, options, channel: 'source', envelope, print: printSourceArtifact });
+      return;
+    }
+    if (options.sourceVerifyChange) {
+      const envelope = sourceVerificationEnvelope(options.root, options.sourceFile, { persist: false, artifactFile: '' });
+      emitReadonlyLocalJsonOutput({ deps, options, channel: 'source', envelope, print: printSourceArtifact });
+      return;
+    }
+    if (options.confirm) throw new Error('source audit does not support --confirm');
+    const mode = options.sourceList ? 'list' : options.sourceVerify ? 'verify' : 'show';
+    const envelope = sourceAuditEnvelope(options.root, mode, options.sourceFile);
+    emitReadonlyLocalJsonOutput({ deps, options, channel: 'source', envelope, print: printSourceArtifact });
+  }
+
+  function listMergeReadinessFiles(root) {
+    return listStateFiles(root, mergeReadinessDirectory, '.merge-readiness.json');
+  }
+
+  function listMergeApprovalFiles(root) {
+    return listStateFiles(root, mergeApprovalsDirectory, '.merge-approval.json');
+  }
+
+  function listMergeApplyFiles(root) {
+    return listStateFiles(root, mergeAppliesDirectory, '.merge-apply.json');
+  }
+
+  function mergeAuditEnvelope(root, mode, fileName = '') {
+    if (mode === 'list') {
+      const readiness = listMergeReadinessFiles(root).map((name) => ({ kind: 'merge-readiness', file: name }));
+      const approvals = listMergeApprovalFiles(root).map((name) => ({ kind: 'merge-approval', file: name }));
+      const applies = listMergeApplyFiles(root).map((name) => ({ kind: 'merge-apply', file: name }));
+      return { mode: 'merge-artifact-list', ok: true, artifacts: [...readiness, ...approvals, ...applies], summary: { count: readiness.length + approvals.length + applies.length, readiness_count: readiness.length, approval_count: approvals.length, apply_count: applies.length }, quality: [], action: 'read-only merge artifact audit listed readiness, approval, and apply sidecars. No merge occurred.' };
+    }
+    const isReadiness = fileName.endsWith('.merge-readiness.json');
+    const isApply = fileName.endsWith('.merge-apply.json');
+    const file = isReadiness ? mergeReadinessFilePath(root, fileName) : isApply ? mergeApplyFilePath(root, fileName) : mergeApprovalFilePath(root, fileName);
+    const artifact = readJsonArtifact(file, isReadiness ? 'Merge readiness' : isApply ? 'Merge apply' : 'Merge approval');
+    const verification = isReadiness ? validateMergeReadinessArtifact(root, artifact, path.basename(file)) : isApply ? validateMergeApplyArtifact(root, artifact, path.basename(file)) : validateMergeApprovalArtifact(root, artifact, path.basename(file));
+    if (mode === 'verify' && !verification.ok) throw new Error(`merge artifact verification failed: ${verification.failures.join('; ')}`);
+    const modeName = isReadiness ? 'merge-readiness' : isApply ? 'merge-apply' : 'merge-approval';
+    return { mode: mode === 'verify' ? `${modeName}-verify` : `${modeName}-show`, ok: verification.ok, summary: { file: path.basename(file), status: artifact.merge_readiness?.readiness_status || artifact.merge_approval?.approval_status || artifact.merge_apply?.apply_status || '' }, verification, artifact, quality: verification.failures, action: 'read-only merge artifact audit inspected one sidecar. No merge occurred.' };
+  }
+
+  function printMergeArtifact(envelope, file = '') {
+    console.log('Vibecoding Runtime Merge Artifact');
+    console.log(`Mode: ${envelope.mode}`);
+    const detail = envelope.merge_readiness || envelope.merge_approval || envelope.merge_apply || envelope.summary || {};
+    console.log(`Status: ${detail.readiness_status || detail.approval_status || detail.apply_status || 'listed'}`);
+    if (file) console.log(`Artifact: ${path.relative(process.cwd(), file)}`);
+    if (envelope.quality?.length > 0) printList('Quality', envelope.quality);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function runMergeReadOnly(options) {
+    ensureRoot(options.root);
+    if (options.mergeReadiness) {
+      const envelope = mergeReadinessEnvelope(options.root, options.mergeFile, { persist: false, artifactFile: '' });
+      emitReadonlyLocalJsonOutput({ deps, options, channel: 'merge', envelope, print: printMergeArtifact });
+      return;
+    }
+    if (options.confirm) throw new Error('merge audit does not support --confirm');
+    const mode = options.mergeList ? 'list' : options.mergeVerify ? 'verify' : 'show';
+    const envelope = mergeAuditEnvelope(options.root, mode, options.mergeFile);
+    emitReadonlyLocalJsonOutput({ deps, options, channel: 'merge', envelope, print: printMergeArtifact });
+  }
+
+  return {
+    listSourceChangeCandidateFiles,
+    listSourceSandboxRunFiles,
+    listSourceVerificationFiles,
+    sourceAuditEnvelope,
+    printSourceArtifact,
+    runSourceReadOnly,
+    listMergeReadinessFiles,
+    listMergeApprovalFiles,
+    listMergeApplyFiles,
+    mergeAuditEnvelope,
+    printMergeArtifact,
+    runMergeReadOnly,
+  };
+}

package/tools/vibe-runtime/runtime-source-merge-entry-command.mjs

@@ -0,0 +1,153 @@
+export function createRuntimeSourceMergeEntryCommands({
+  path,
+  ensureRoot,
+  writeJsonEnvelope,
+  printSourceArtifact,
+  printMergeArtifact,
+  runtimeSourceMergeCommand,
+  sourcePatchPlanEnvelope,
+  sourceChangeCandidateSnapshotPath,
+  sourceSandboxRunSnapshotPath,
+  sourceVerificationSnapshotPath,
+  sourceChangeCandidateEnvelope,
+  sourceSandboxRunEnvelope,
+  sourceVerificationEnvelope,
+  writeSourceChangeCandidate,
+  writeSourceSandboxRun,
+  writeSourceVerification,
+  mergeReadinessSnapshotPath,
+  mergeApprovalSnapshotPath,
+  mergeApplySnapshotPath,
+  mergeReadinessEnvelope,
+  mergeApprovalEnvelope,
+  mergeApplyEnvelope,
+  writeMergeReadiness,
+  writeMergeApproval,
+  writeMergeApply,
+}) {
+  function runMerge(options) {
+    ensureRoot(options.root);
+    if (options.mergeReadiness && !options.confirm) return runtimeSourceMergeCommand().runMergeReadOnly(options);
+    if (options.mergeReadiness) {
+      const readinessFile = options.confirm ? path.basename(mergeReadinessSnapshotPath(options.root)) : '';
+      const envelope = mergeReadinessEnvelope(options.root, options.mergeFile, { persist: options.confirm, artifactFile: readinessFile });
+      if (options.confirm) {
+        const file = writeMergeReadiness(options.root, envelope);
+        if (options.json) writeJsonEnvelope('merge', { ...envelope, merge_readiness_file: path.basename(file) });
+        else printMergeArtifact(envelope, file);
+        return;
+      }
+      if (options.json) writeJsonEnvelope('merge', envelope);
+      else printMergeArtifact(envelope);
+      return;
+    }
+    if (options.mergeApprove) {
+      if (!options.confirm) throw new Error('merge --approve requires --confirm');
+      const approvalFile = path.basename(mergeApprovalSnapshotPath(options.root));
+      const envelope = mergeApprovalEnvelope(options.root, options.mergeFile, { persist: true, artifactFile: approvalFile });
+      const file = writeMergeApproval(options.root, envelope);
+      if (options.json) writeJsonEnvelope('merge', { ...envelope, merge_approval_file: path.basename(file) });
+      else printMergeArtifact(envelope, file);
+      return;
+    }
+    if (options.mergeApply) {
+      if (!options.confirm) throw new Error('merge --apply requires --confirm');
+      const applyFile = path.basename(mergeApplySnapshotPath(options.root));
+      const envelope = mergeApplyEnvelope(options.root, options.mergeFile, { persist: true, artifactFile: applyFile });
+      const file = writeMergeApply(options.root, envelope);
+      if (options.json) writeJsonEnvelope('merge', { ...envelope, merge_apply_file: path.basename(file) });
+      else printMergeArtifact(envelope, file);
+      return;
+    }
+    if (options.confirm) throw new Error('merge audit does not support --confirm');
+    return runtimeSourceMergeCommand().runMergeReadOnly(options);
+  }
+
+  function runSource(options) {
+    ensureRoot(options.root);
+    if (options.sourcePatchPlan) {
+      if (options.confirm) throw new Error('source --patch-plan is read-only and does not support --confirm');
+      const envelope = sourcePatchPlanEnvelope(options.root, options.fromTask);
+      if (options.json) writeJsonEnvelope('source', envelope);
+      else printSourceArtifact(envelope);
+      return;
+    }
+    if (options.sourceCandidate && !options.confirm) return runtimeSourceMergeCommand().runSourceReadOnly(options);
+    if (options.sourceVerifyChange && !options.confirm) return runtimeSourceMergeCommand().runSourceReadOnly(options);
+    if (options.sourceCandidate) {
+      const candidateFile = options.confirm ? path.basename(sourceChangeCandidateSnapshotPath(options.root)) : '';
+      const envelope = sourceChangeCandidateEnvelope(options.root, options.sourceFile, { persist: options.confirm, artifactFile: candidateFile });
+      if (options.confirm) {
+        const file = writeSourceChangeCandidate(options.root, envelope);
+        if (options.json) writeJsonEnvelope('source', { ...envelope, source_change_candidate_file: path.basename(file) });
+        else printSourceArtifact(envelope, file);
+        return;
+      }
+      if (options.json) writeJsonEnvelope('source', envelope);
+      else printSourceArtifact(envelope);
+      return;
+    }
+    if (options.sourceApplySandbox) {
+      if (!options.confirm) throw new Error('source --apply-sandbox requires --confirm');
+      const sandboxFile = path.basename(sourceSandboxRunSnapshotPath(options.root));
+      const envelope = sourceSandboxRunEnvelope(options.root, options.sourceFile, { persist: true, artifactFile: sandboxFile });
+      const file = writeSourceSandboxRun(options.root, envelope);
+      if (options.json) writeJsonEnvelope('source', { ...envelope, source_sandbox_run_file: path.basename(file) });
+      else printSourceArtifact(envelope, file);
+      return;
+    }
+    if (options.sourceApplyToWorktree) {
+      if (!options.confirm) throw new Error('source --apply-to-worktree requires --confirm');
+      if (!options.approval) throw new Error('source --apply-to-worktree requires --approval');
+      const applyFile = path.basename(mergeApplySnapshotPath(options.root));
+      const envelope = mergeApplyEnvelope(options.root, options.approval, { persist: true, artifactFile: applyFile });
+      const file = writeMergeApply(options.root, envelope);
+      const sourceEnvelope = {
+        mode: 'source-apply-to-worktree',
+        ok: true,
+        state_present: envelope.state_present,
+        source_apply_to_worktree: {
+          stage: 'P9',
+          approval_file: options.approval,
+          approval_required: true,
+          human_confirmed: true,
+          delegated_apply: 'merge --apply',
+          merge_apply_file: path.basename(file),
+          applied_files: envelope.merge_apply.applied_files,
+          rollback_guidance: 'Use the recorded before_file_digests, after_file_digests, marker_digest, and applied_files from the merge apply artifact to review or revert the allowlisted marker change manually.',
+          post_apply_test_evidence_required: true,
+          git: false,
+          commit: false,
+          push: false,
+          pr: false,
+        },
+        merge_apply: envelope.merge_apply,
+        merge_approval: envelope.merge_approval,
+        files: { ...envelope.files, merge_apply: path.basename(file) },
+        safety: { ...envelope.safety, source_apply_to_worktree_alias: true, human_confirmed_apply: true },
+        quality: envelope.quality,
+        action: 'source apply-to-worktree used the existing Stage 48 controlled apply gate. Only the allowlisted local marker and merge apply artifact were written; no git, commit, push, PR, daemon, or watcher occurred.',
+      };
+      if (options.json) writeJsonEnvelope('source', sourceEnvelope);
+      else printSourceArtifact(sourceEnvelope, file);
+      return;
+    }
+    if (options.sourceVerifyChange) {
+      const verificationFile = options.confirm ? path.basename(sourceVerificationSnapshotPath(options.root)) : '';
+      const envelope = sourceVerificationEnvelope(options.root, options.sourceFile, { persist: options.confirm, artifactFile: verificationFile });
+      if (options.confirm) {
+        const file = writeSourceVerification(options.root, envelope);
+        if (options.json) writeJsonEnvelope('source', { ...envelope, source_verification_file: path.basename(file) });
+        else printSourceArtifact(envelope, file);
+        return;
+      }
+      if (options.json) writeJsonEnvelope('source', envelope);
+      else printSourceArtifact(envelope);
+      return;
+    }
+    if (options.confirm) throw new Error('source audit does not support --confirm');
+    return runtimeSourceMergeCommand().runSourceReadOnly(options);
+  }
+
+  return { runMerge, runSource };
+}

package/tools/vibe-runtime/runtime-source-patch-plan-model.mjs

@@ -0,0 +1,119 @@
+import { createPatchQueuePreviewContract } from './runtime-patch-queue-contract.mjs';
+
+export function createSourcePatchPlanEnvelope(deps) {
+  const {
+    fs,
+    path,
+    ensureRoot,
+    workflowPath,
+    fileDigest,
+    digestObject,
+  } = deps;
+
+  function sourcePatchPlanEnvelope(root, taskFile) {
+    ensureRoot(root);
+    const taskPath = resolveSourceTaskFile(root, taskFile);
+    const task = readSourcePatchPlanTask(taskPath);
+    const files = extractSourcePatchPlanFiles(task);
+    const taskRelativePath = path.relative(root, taskPath).replace(/\\/g, '/');
+    const taskDigest = fileDigest(taskPath);
+    const patchQueuePreview = createPatchQueuePreviewContract({
+      task,
+      taskFile: taskRelativePath,
+      fileDigest: taskDigest,
+      digestObject,
+    });
+    const core = {
+      version: 1,
+      stage: 'P9',
+      plan_kind: 'sandbox-patch-plan',
+      created_at: new Date().toISOString(),
+      task_file: taskRelativePath,
+      task_digest: taskDigest,
+      task_summary: task.summary,
+      path_allowlist: files,
+      backup_required: true,
+      diff_artifact_required: true,
+      rollback_guidance_required: true,
+      post_apply_test_evidence_required: true,
+      approval_required: true,
+      sandbox_required: true,
+      writes: false,
+      state_directory_created: false,
+      main_worktree_write: false,
+      business_source_write: false,
+      source_merge: false,
+      git: false,
+      worktree: false,
+      auto_apply: false,
+      allowed_followup: ['source-sandbox-apply-only', 'source-apply-to-worktree-after-approval-only'],
+    };
+    return {
+      mode: 'source-patch-plan',
+      ok: true,
+      state_present: fs.existsSync(workflowPath(root)),
+      source_patch_plan: { ...core, plan_digest: digestObject(core) },
+      patch_queue_preview: patchQueuePreview,
+      source_apply_gate: patchQueuePreview.items[0].source_apply_gate,
+      safety: { ...sourcePatchPlanSafety(), patch_queue_preview: true, source_apply_gate: true, source_apply: false },
+      quality: [
+        ...(files.length === 0 ? ['task artifact did not declare a path allowlist; manual scoping is required before apply'] : []),
+        ...patchQueuePreview.items[0].blocked_reasons,
+      ],
+      action: 'source patch plan and patch queue preview were evaluated read-only. No sandbox, worktree, git, state, or business source write occurred.',
+    };
+  }
+
+  function resolveSourceTaskFile(root, taskFile) {
+    const raw = String(taskFile || '').trim();
+    if (!raw) throw new Error('source --patch-plan requires --from-task');
+    const taskPath = path.resolve(root, raw);
+    const relative = path.relative(root, taskPath);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) throw new Error('source --patch-plan task file must stay inside --root');
+    if (!fs.existsSync(taskPath) || fs.statSync(taskPath).isDirectory()) throw new Error('source --patch-plan task file not found');
+    return taskPath;
+  }
+
+  function readSourcePatchPlanTask(taskPath) {
+    const text = fs.readFileSync(taskPath, 'utf8');
+    try {
+      const parsed = JSON.parse(text);
+      return { parsed, summary: String(parsed.title || parsed.id || parsed.task_id || path.basename(taskPath)).slice(0, 160) };
+    } catch {
+      const firstLine = text.split(/\r?\n/).find((line) => line.trim()) || path.basename(taskPath);
+      return { parsed: null, summary: firstLine.replace(/^#+\s*/, '').slice(0, 160) };
+    }
+  }
+
+  function extractSourcePatchPlanFiles(task) {
+    const parsed = task.parsed;
+    const rawFiles = Array.isArray(parsed?.files) ? parsed.files : Array.isArray(parsed?.task?.files) ? parsed.task.files : [];
+    const rawAllowlist = [parsed?.allowed_paths, parsed?.allowedFiles, parsed?.path_allowlist]
+      .find((value) => Array.isArray(value)) || [];
+    return [...rawFiles, ...rawAllowlist]
+      .map((item) => typeof item === 'string' ? item : item?.path)
+      .filter((item) => typeof item === 'string' && item.trim())
+      .map((item) => item.replace(/\\/g, '/'))
+      .filter((item) => !path.isAbsolute(item) && !item.includes('..'));
+  }
+
+  return sourcePatchPlanEnvelope;
+}
+
+function sourcePatchPlanSafety() {
+  return {
+    stage: 'P9',
+    writes: false,
+    patch_plan_artifact: false,
+    sandbox_only: true,
+    approval_required: true,
+    main_worktree_write: false,
+    business_source_write: false,
+    source_merge: false,
+    git: false,
+    worktree: false,
+    daemon: false,
+    watcher: false,
+    auto_execution: false,
+  };
+}