@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-retry-command.mjs

@@ -0,0 +1,223 @@
+import { createBoundedAttemptPolicySnapshots } from './runtime-bounded-attempt-policy-model.mjs';
+import { runtimeContractSyncOwner } from './runtime-contract-marker-registry.mjs';
+import { createRuntimeRetryRunGateModel } from './runtime-retry-run-gate-model.mjs';
+
+export const runtimeRetryCommandContractSync = runtimeContractSyncOwner('runtime-retry-command');
+
+export function createRuntimeRetryCommand(deps) {
+  const policySnapshots = createBoundedAttemptPolicySnapshots(deps);
+  const {
+    path,
+    process,
+    jsonSchemaVersion,
+    ensureRoot,
+    writeJsonEnvelope,
+    printList,
+    readJsonArtifact,
+    listStateFiles,
+    fileDigest,
+    retryPackagesDirectory,
+    retryRunsDirectory,
+    retryPackageFilePath,
+    executionFilePath,
+  } = deps;
+
+  function verificationSummaryFromFiles(root, files, directory, label, verifier) {
+    const details = files.map((fileName) => {
+      try {
+        const file = path.join(directory(root), fileName);
+        const artifact = readJsonArtifact(file, label);
+        const verification = verifier(artifact, fileName, file);
+        return { file: fileName, ok: verification.ok, failures: verification.failures || [] };
+      } catch (error) {
+        return { file: fileName, ok: false, failures: [error.message] };
+      }
+    });
+    return {
+      count: details.length,
+      ok_count: details.filter((item) => item.ok).length,
+      failed_count: details.filter((item) => !item.ok).length,
+      details,
+    };
+  }
+
+  function listRetryPackageFiles(root) {
+    return listStateFiles(root, retryPackagesDirectory, '.retry-package.json');
+  }
+  
+  
+  
+  function listRetryRunFiles(root) {
+    return listStateFiles(root, retryRunsDirectory, '.retry-run.json');
+  }
+  
+  
+  
+  function retryHealthSummary(root) {
+    const packageFiles = listRetryPackageFiles(root);
+    const runFiles = listRetryRunFiles(root);
+    const packages = verificationSummaryFromFiles(root, packageFiles, retryPackagesDirectory, 'Retry package', (artifact) => validateRetryPackageArtifact(root, artifact));
+    const runs = verificationSummaryFromFiles(root, runFiles, retryRunsDirectory, 'Retry run', (artifact) => {
+      const failures = [];
+      if (artifact.schema_version !== jsonSchemaVersion) failures.push('schema_version must be 1');
+      if (artifact.command !== 'retry') failures.push('command must be retry');
+      if (artifact.mode !== 'retry-run') failures.push('mode must be retry-run');
+      if (artifact.safety?.stage !== 'Stage 27') failures.push('safety.stage must be Stage 27');
+      if (artifact.safety?.auto_execution !== false) failures.push('safety.auto_execution must be false');
+      if (artifact.safety?.business_source_write !== false) failures.push('safety.business_source_write must be false');
+      return { ok: failures.length === 0, failures };
+    });
+    const duplicateKeys = new Set();
+    const seenKeys = new Set();
+    for (const fileName of runFiles) {
+      try {
+        const run = readJsonArtifact(path.join(retryRunsDirectory(root), fileName), 'Retry run');
+        const key = run.retry_run?.source_idempotency_key || run.retry_run?.source_execution_digest || '';
+        if (!key) continue;
+        if (seenKeys.has(key)) duplicateKeys.add(key);
+        seenKeys.add(key);
+      } catch {
+        duplicateKeys.add(`invalid:${fileName}`);
+      }
+    }
+    const blocked = [...packages.details, ...runs.details].flatMap((item) => item.ok ? [] : item.failures.map((failure) => `${item.file}: ${failure}`));
+    if (duplicateKeys.size > 0) blocked.push('duplicate retry run key detected');
+    return { packages, runs, duplicate_count: duplicateKeys.size, blocked_reasons: blocked };
+  }
+  
+  
+  
+  const { retryPolicySnapshot, retryBudgetSnapshot } = policySnapshots;
+  
+  
+  
+  function validateRetryPackageArtifact(root, retryPackage) {
+    const failures = [];
+    if (retryPackage.schema_version !== jsonSchemaVersion) failures.push('schema_version must be 1');
+    if (retryPackage.mode !== 'retry-package') failures.push('mode must be retry-package');
+    if (!retryPackage.retry_package || typeof retryPackage.retry_package !== 'object') failures.push('retry_package is required');
+    const pkg = retryPackage.retry_package || {};
+    if (!pkg.source_execution_file || !String(pkg.source_execution_file).endsWith('.execution.json')) failures.push('retry_package.source_execution_file must be a .execution.json file');
+    if (!pkg.source_execution_digest) failures.push('retry_package.source_execution_digest is required');
+    if (!pkg.approval_file || !String(pkg.approval_file).endsWith('.approval.json')) failures.push('retry_package.approval_file must be a .approval.json file');
+    if (!pkg.candidate_file || !String(pkg.candidate_file).endsWith('.candidate.json')) failures.push('retry_package.candidate_file must be a .candidate.json file');
+    if (!pkg.idempotency_key) failures.push('retry_package.idempotency_key is required');
+    if (pkg.automatic_retry !== false) failures.push('retry_package.automatic_retry must be false');
+    if (pkg.manual_review_required !== true) failures.push('retry_package.manual_review_required must be true');
+    if (root && pkg.source_execution_file && pkg.source_execution_digest) {
+      try {
+        if (fileDigest(executionFilePath(root, pkg.source_execution_file)) !== pkg.source_execution_digest) failures.push('retry_package.source_execution_digest mismatch');
+      } catch (error) {
+        failures.push(error.message);
+      }
+    }
+    return { ok: failures.length === 0, failures };
+  }
+  
+  
+  
+  const retryRunGate = createRuntimeRetryRunGateModel(deps, {
+    listRetryRunFiles,
+    validateRetryPackageArtifact,
+    retryPolicySnapshot,
+    retryBudgetSnapshot,
+  });
+  const { retryRunPath, retryRunAlreadyApplied, retryGateEnvelope, writeRetryRun } = retryRunGate;
+  
+  
+  
+  function retryPackageAuditEnvelope(root, mode, retryPackageFile = '') {
+    if (mode === 'list') {
+      const packages = listRetryPackageFiles(root).map((fileName) => {
+        try {
+          const retryPackage = readJsonArtifact(path.join(retryPackagesDirectory(root), fileName), 'Retry package');
+          const verification = validateRetryPackageArtifact(root, retryPackage);
+          return { file: fileName, source_execution_file: retryPackage.retry_package?.source_execution_file || '', idempotency_key: retryPackage.retry_package?.idempotency_key || '', verification_ok: verification.ok, verification_failures: verification.failures };
+        } catch (error) {
+          return { file: fileName, source_execution_file: '', idempotency_key: '', verification_ok: false, verification_failures: [error.message] };
+        }
+      });
+      return { mode: 'retry-package-list', ok: true, summary: { count: packages.length, failed_count: packages.filter((item) => !item.verification_ok).length }, packages, quality: [], action: 'read-only retry package audit listed retry packages. No retry occurred.' };
+    }
+    const file = retryPackageFilePath(root, retryPackageFile);
+    const retryPackage = readJsonArtifact(file, 'Retry package');
+    const verification = validateRetryPackageArtifact(root, retryPackage);
+    if (mode === 'verify' && !verification.ok) throw new Error(`retry package verification failed: ${verification.failures.join('; ')}`);
+    return { mode: mode === 'verify' ? 'retry-package-verify' : 'retry-package-show', ok: verification.ok, summary: { file: path.basename(file), source_execution_file: retryPackage.retry_package?.source_execution_file || '', idempotency_key: retryPackage.retry_package?.idempotency_key || '' }, verification, retry_package: retryPackage, quality: verification.failures, action: 'read-only retry package audit inspected one retry package. No retry occurred.' };
+  }
+  
+  
+  
+  function printRetry(envelope, file = '') {
+    console.log('Vibecoding Runtime Bounded Retry');
+    console.log(`Mode: ${envelope.mode}`);
+    console.log(`Status: ${envelope.ok ? 'passed' : 'blocked'}`);
+    console.log(`Source execution: ${envelope.retry_run.source_execution_file || 'none'} [${envelope.retry_run.source_execution_status || 'unknown'}]`);
+    console.log(`Attempts allowed: ${envelope.retry_run.max_retry_attempts}`);
+    if (file) console.log(`Retry run: ${path.relative(process.cwd(), file)}`);
+    if (envelope.quality.length > 0) printList('Blocked reasons', envelope.quality);
+    console.log(`Action: ${envelope.action}`);
+  }
+  
+  
+  
+  function printRetryPackageAudit(envelope) {
+    console.log('Vibecoding Runtime Retry Package Audit');
+    console.log(`Mode: ${envelope.mode.replace('retry-package-', '')}`);
+    if (envelope.mode === 'retry-package-list') {
+      console.log(`Packages: ${envelope.summary.count}; Failed: ${envelope.summary.failed_count}`);
+      for (const item of envelope.packages) console.log(`- ${item.file}: source=${item.source_execution_file || 'none'}; verification=${item.verification_ok ? 'passed' : 'failed'}`);
+    } else {
+      console.log(`File: ${envelope.summary.file}`);
+      console.log(`Source execution: ${envelope.summary.source_execution_file || 'none'}`);
+      console.log(`Verification: ${envelope.verification.ok ? 'passed' : 'failed'}`);
+      if (envelope.verification.failures.length > 0) printList('Verification failures', envelope.verification.failures);
+    }
+    console.log(`Action: ${envelope.action}`);
+  }
+  
+  
+  
+  function runRetry(options) {
+    if (options.write || options.dryRun || options.scan || options.once || options.fromDispatch || options.actor || options.approval || options.autoRun) throw new Error('retry supports package audit and bounded --run only');
+    ensureRoot(options.root);
+    const modes = [options.retryListPackages, options.retryShowPackage, options.retryVerifyPackage, options.retryRunPackage].filter(Boolean);
+    if (modes.length !== 1) throw new Error('retry requires exactly one of --list-packages, --show-package, --verify-package, or --run <retry-package-file>');
+    if (options.retryRunPackage) {
+      const envelope = retryGateEnvelope(options.root, options.retryPackageFile, { persist: options.confirm });
+      if (options.confirm) {
+        const file = writeRetryRun(options.root, envelope);
+        if (options.json) writeJsonEnvelope('retry', { ...envelope, retry_run_file: path.basename(file) });
+        else printRetry(envelope, file);
+        return;
+      }
+      if (options.json) writeJsonEnvelope('retry', envelope);
+      else printRetry(envelope);
+      return;
+    }
+    if (options.confirm) throw new Error('retry --confirm is only supported with --run');
+    const mode = options.retryListPackages ? 'list' : options.retryVerifyPackage ? 'verify' : 'show';
+    const envelope = retryPackageAuditEnvelope(options.root, mode, options.retryPackageFile);
+    if (options.json) writeJsonEnvelope('retry', envelope);
+    else printRetryPackageAudit(envelope);
+  }
+  
+  
+
+  return {
+    listRetryPackageFiles,
+    listRetryRunFiles,
+    retryHealthSummary,
+    retryPolicySnapshot,
+    retryBudgetSnapshot,
+    retryRunPath,
+    retryRunAlreadyApplied,
+    validateRetryPackageArtifact,
+    retryGateEnvelope,
+    writeRetryRun,
+    retryPackageAuditEnvelope,
+    printRetry,
+    printRetryPackageAudit,
+    runRetry,
+  };
+}

package/tools/vibe-runtime/runtime-retry-run-gate-model.mjs

@@ -0,0 +1,151 @@
+export function createRuntimeRetryRunGateModel(deps, collaborators) {
+  const {
+    fs,
+    path,
+    jsonSchemaVersion,
+    workflowPath,
+    writeStateArtifact,
+    readJsonArtifact,
+    fileDigest,
+    retryRunsDirectory,
+    retryPackageFilePath,
+    executionFilePath,
+    readExecutionFile,
+    approvalFilePath,
+    candidateFilePath,
+    validateApprovalArtifact,
+    validateCandidateArtifact,
+    executionPolicySnapshot,
+    runtimeActionCatalogDigest,
+    approvalLifecycleCurrentState,
+    activeSchedulerLease,
+    autoRunLockFilePath,
+  } = deps;
+  const {
+    listRetryRunFiles,
+    validateRetryPackageArtifact,
+    retryPolicySnapshot,
+    retryBudgetSnapshot,
+  } = collaborators;
+
+  function retryRunPath(root) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return path.join(retryRunsDirectory(root), `${timestamp}.retry-run.json`);
+  }
+
+  function retryRunAlreadyApplied(root, sourceExecutionDigest, idempotencyKey) {
+    return listRetryRunFiles(root).some((fileName) => {
+      try {
+        const run = readJsonArtifact(path.join(retryRunsDirectory(root), fileName), 'Retry run');
+        return run.retry_run?.source_execution_digest === sourceExecutionDigest
+          || (idempotencyKey && run.retry_run?.source_idempotency_key === idempotencyKey);
+      } catch {
+        return false;
+      }
+    });
+  }
+
+  function retryGateEnvelope(root, retryPackageFile, { persist = false } = {}) {
+    const retryPath = retryPackageFilePath(root, retryPackageFile);
+    const retryPackage = readJsonArtifact(retryPath, 'Retry package');
+    const packageVerification = validateRetryPackageArtifact(root, retryPackage);
+    const pkg = retryPackage.retry_package || {};
+    const policy = retryPolicySnapshot();
+    const budget = retryBudgetSnapshot();
+    const blocked = [...packageVerification.failures];
+    let sourceExecution = null;
+    let sourceStatus = '';
+    let approval = null;
+    let candidate = null;
+    let approvalDigest = '';
+    let candidateDigest = '';
+
+    if (packageVerification.ok) {
+      sourceExecution = readExecutionFile(executionFilePath(root, pkg.source_execution_file));
+      sourceStatus = sourceExecution.execution?.status || sourceExecution.status || '';
+      if (!['failed', 'timed_out'].includes(sourceStatus)) blocked.push('source execution is not failed or timed_out');
+      if (sourceExecution.execution?.idempotency_key && sourceExecution.execution.idempotency_key !== pkg.idempotency_key) blocked.push('source execution idempotency mismatch');
+      approval = readJsonArtifact(approvalFilePath(root, pkg.approval_file), 'Approval');
+      candidate = readJsonArtifact(candidateFilePath(root, pkg.candidate_file), 'Candidate');
+      approvalDigest = fileDigest(approvalFilePath(root, pkg.approval_file));
+      candidateDigest = fileDigest(candidateFilePath(root, pkg.candidate_file));
+      const approvalVerification = validateApprovalArtifact(approval);
+      const candidateVerification = validateCandidateArtifact(candidate);
+      blocked.push(...approvalVerification.failures, ...candidateVerification.failures);
+      if (approval.approval?.candidate_file !== pkg.candidate_file) blocked.push('approval candidate file mismatch');
+      if (approval.approval?.candidate_digest !== candidateDigest) blocked.push('approval candidate digest mismatch');
+      if (approval.approval?.idempotency_key !== pkg.idempotency_key) blocked.push('approval idempotency mismatch');
+      if (candidate.candidate?.idempotency_key !== pkg.idempotency_key) blocked.push('candidate idempotency mismatch');
+      if (approval.approval?.policy_digest !== executionPolicySnapshot().policy_digest) blocked.push('approval policy digest mismatch');
+      if (approval.approval?.runtime_action_catalog?.catalog_digest !== runtimeActionCatalogDigest()) blocked.push('approval runtime action catalog digest mismatch');
+      if (candidate.candidate?.runtime_action_catalog?.catalog_digest !== runtimeActionCatalogDigest()) blocked.push('candidate runtime action catalog digest mismatch');
+      const lifecycle = approvalLifecycleCurrentState(root, pkg.approval_file);
+      blocked.push(...lifecycle.blocked_reasons);
+      if (activeSchedulerLease(root)) blocked.push('active scheduler lease blocks retry');
+      if (fs.existsSync(autoRunLockFilePath(root, pkg.idempotency_key))) blocked.push('active auto-run lock blocks retry');
+      if (retryRunAlreadyApplied(root, pkg.source_execution_digest, pkg.idempotency_key)) blocked.push('retry package was already applied');
+    }
+
+    const ok = blocked.length === 0;
+    return {
+      mode: persist ? 'retry-run' : 'retry-preview',
+      ok,
+      state_present: fs.existsSync(workflowPath(root)),
+      retry_run: {
+        writes: Boolean(persist),
+        retry_package_file: String(retryPackageFile),
+        retry_package_digest: fileDigest(retryPath),
+        source_execution_file: pkg.source_execution_file || '',
+        source_execution_digest: pkg.source_execution_digest || '',
+        source_execution_status: sourceStatus,
+        source_idempotency_key: pkg.idempotency_key || '',
+        candidate_file: pkg.candidate_file || '',
+        candidate_digest: candidateDigest,
+        approval_file: pkg.approval_file || '',
+        approval_digest: approvalDigest,
+        retry_policy_digest: policy.retry_policy_digest,
+        retry_budget_digest: budget.retry_budget_digest,
+        execution_policy_digest: executionPolicySnapshot().policy_digest,
+        action_catalog_digest: runtimeActionCatalogDigest(),
+        max_retry_attempts: budget.max_retry_attempts,
+        attempted: Boolean(persist && ok),
+        result_status: persist && ok ? 'succeeded' : 'blocked',
+        external_delivery: false,
+      },
+      retry_package: retryPackage,
+      retry_policy: policy,
+      retry_budget: budget,
+      safety: {
+        stage: 'Stage 27',
+        writes: Boolean(persist),
+        retry_run_artifact: Boolean(persist),
+        bounded_retry: true,
+        max_retry_attempts: 1,
+        runtime_action: Boolean(persist && ok),
+        auto_execution: false,
+        platform_api: false,
+        skill_execution: false,
+        business_source_write: false,
+        source_mutation: false,
+        subagent: false,
+        mcp: false,
+        daemon: false,
+        git: false,
+        worktree: false,
+      },
+      verification: { ok, failures: blocked },
+      quality: blocked,
+      action: persist
+        ? 'bounded retry gate wrote one retry-run audit. No workflow skill, platform API, subagent, MCP, daemon, git, worktree, or business source write occurred.'
+        : 'bounded retry was previewed read-only. No files were written and no retry occurred.',
+    };
+  }
+
+  function writeRetryRun(root, envelope) {
+    if (!envelope.ok) throw new Error(`retry gate failed: ${envelope.quality.join('; ')}`);
+    const file = retryRunPath(root);
+    return writeStateArtifact(path.dirname(file), path.basename(file), { schema_version: jsonSchemaVersion, command: 'retry', ...envelope });
+  }
+
+  return { retryRunPath, retryRunAlreadyApplied, retryGateEnvelope, writeRetryRun };
+}