@riddledc/riddle-proof 0.5.3 → 0.5.5

package/dist/{chunk-MLJJIKTP.js → chunk-GC7C2NRA.js}

@@ -296,6 +296,20 @@ function requirePayload(action, payload, state, result) {
   }
   return null;
 }
+function engineFailureBlocker(result, checkpoint) {
+  if (result.ok !== false) return null;
+  if (!checkpoint.endsWith("_failed") && !checkpoint.endsWith("_blocked")) return null;
+  return {
+    code: checkpoint,
+    checkpoint,
+    message: result.summary || `Riddle Proof engine stopped at ${checkpoint}.`,
+    details: compactRecord({
+      error: result.error,
+      approval: result.approval,
+      checkpointContract: result.checkpointContract || null
+    })
+  };
+}
 function terminalResult(state, status, result, summary, raw = {}) {
   setRunStatus(state, status);
   const metadata = normalizeTerminalMetadata({
@@ -453,6 +467,10 @@ async function routeCheckpoint(request, state, result, agent, input) {
       terminal: terminalResult(state, "completed", result, result.summary || "Riddle Proof engine completed.")
     };
   }
+  const failureBlocker = engineFailureBlocker(result, checkpoint);
+  if (failureBlocker) {
+    return { blocker: failureBlocker };
+  }
   if ([
     "recon_human_escalation",
     "verify_human_escalation",

package/dist/engine-harness.cjs

@@ -3266,6 +3266,20 @@ function requirePayload(action, payload, state, result) {
   }
   return null;
 }
+function engineFailureBlocker(result, checkpoint) {
+  if (result.ok !== false) return null;
+  if (!checkpoint.endsWith("_failed") && !checkpoint.endsWith("_blocked")) return null;
+  return {
+    code: checkpoint,
+    checkpoint,
+    message: result.summary || `Riddle Proof engine stopped at ${checkpoint}.`,
+    details: compactRecord({
+      error: result.error,
+      approval: result.approval,
+      checkpointContract: result.checkpointContract || null
+    })
+  };
+}
 function terminalResult(state, status, result, summary, raw = {}) {
   setRunStatus(state, status);
   const metadata = normalizeTerminalMetadata({
@@ -3423,6 +3437,10 @@ async function routeCheckpoint(request, state, result, agent, input) {
       terminal: terminalResult(state, "completed", result, result.summary || "Riddle Proof engine completed.")
     };
   }
+  const failureBlocker = engineFailureBlocker(result, checkpoint);
+  if (failureBlocker) {
+    return { blocker: failureBlocker };
+  }
   if ([
     "recon_human_escalation",
     "verify_human_escalation",

package/dist/engine-harness.js

@@ -2,7 +2,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-MLJJIKTP.js";
+} from "./chunk-GC7C2NRA.js";
 import "./chunk-GVPCSXN7.js";
 import "./chunk-TMMKRKY5.js";
 export {

package/dist/index.cjs

@@ -3825,6 +3825,20 @@ function requirePayload(action, payload, state, result) {
   }
   return null;
 }
+function engineFailureBlocker(result, checkpoint) {
+  if (result.ok !== false) return null;
+  if (!checkpoint.endsWith("_failed") && !checkpoint.endsWith("_blocked")) return null;
+  return {
+    code: checkpoint,
+    checkpoint,
+    message: result.summary || `Riddle Proof engine stopped at ${checkpoint}.`,
+    details: compactRecord({
+      error: result.error,
+      approval: result.approval,
+      checkpointContract: result.checkpointContract || null
+    })
+  };
+}
 function terminalResult(state, status, result, summary, raw = {}) {
   setRunStatus(state, status);
   const metadata = normalizeTerminalMetadata({
@@ -3982,6 +3996,10 @@ async function routeCheckpoint(request, state, result, agent, input) {
       terminal: terminalResult(state, "completed", result, result.summary || "Riddle Proof engine completed.")
     };
   }
+  const failureBlocker = engineFailureBlocker(result, checkpoint);
+  if (failureBlocker) {
+    return { blocker: failureBlocker };
+  }
   if ([
     "recon_human_escalation",
     "verify_human_escalation",

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-MLJJIKTP.js";
+} from "./chunk-GC7C2NRA.js";
 import {
   runRiddleProof
 } from "./chunk-VSEKLCNU.js";

package/lib/workspace-core.mjs

@@ -318,6 +318,11 @@ function writeDepsManifest(projectDir, fingerprint, installCmd) {
   writeFileSync(manifestPath, JSON.stringify({ fingerprint, install_cmd: installCmd }, null, 2));
 }
 
+function dependencyInstallTimeoutMs() {
+  const parsed = Number.parseInt(process.env.RIDDLE_PROOF_INSTALL_TIMEOUT_MS || "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 600000;
+}
+
 export function ensureDeps({ projectDir, reuseFrom = "" } = {}) {
   const fingerprint = computeDependencyFingerprint(projectDir);
   if (!fingerprint) return "no_package_json";
@@ -341,7 +346,7 @@ export function ensureDeps({ projectDir, reuseFrom = "" } = {}) {
 
   const installCmd = detectInstallCommand(projectDir);
   if (!installCmd) return "no_install_command";
-  const installResult = runSafe(`${installCmd} 2>&1 | tail -5`, projectDir, 300000);
+  const installResult = runSafe(`${installCmd} 2>&1 | tail -5`, projectDir, dependencyInstallTimeoutMs());
   if (!installResult.ok) {
     throw new Error(`dependency install failed in ${projectDir}: ${installResult.output.slice(0, 300)}`);
   }
@@ -380,6 +385,9 @@ async function main() {
     case "ensure-deps":
       ok({ status: ensureDeps(payload) });
       return;
+    case "dependency-fingerprint":
+      ok({ fingerprint: computeDependencyFingerprint(payload.projectDir) });
+      return;
     default:
       throw new Error(`Unsupported command: ${command}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "Reusable Riddle Proof contracts and helpers for evidence-backed agent changes.",
   "license": "MIT",
   "author": "RiddleDC",

package/runtime/lib/setup.py

@@ -6,7 +6,7 @@ workspace root by default:
   <workspace>/.riddle-proof-worktrees/riddle-proof-<run_id>-after
 """
 
-import json, subprocess as sp, os, sys, shutil
+import json, subprocess as sp, os, sys, shutil, time
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from util import load_state, save_state, git, shell_quote
 
@@ -37,6 +37,15 @@ SKILLS_ROOT = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__fil
 WORKSPACE_CORE = os.path.join(SKILLS_ROOT, 'lib', 'workspace-core.mjs')
 
 
+def dependency_timeout_seconds():
+    raw = os.environ.get('RIDDLE_PROOF_INSTALL_TIMEOUT_MS', '').strip()
+    try:
+        millis = int(raw)
+    except Exception:
+        millis = 600000
+    return max(660, int((millis + 999) / 1000) + 30)
+
+
 def workspace_core(command, payload, timeout=180):
     if not os.path.exists(WORKSPACE_CORE):
         raise SystemExit('workspace core helper missing: ' + WORKSPACE_CORE)
@@ -64,10 +73,89 @@ def ensure_deps(project_dir, reuse_from=''):
     payload = {'projectDir': project_dir}
     if reuse_from:
         payload['reuseFrom'] = reuse_from
-    result = workspace_core('ensure-deps', payload, timeout=300)
+    result = workspace_core('ensure-deps', payload, timeout=dependency_timeout_seconds())
     return result.get('status', '')
 
 
+def dependency_fingerprint(project_dir):
+    if not project_dir:
+        return ''
+    result = workspace_core('dependency-fingerprint', {'projectDir': project_dir}, timeout=30)
+    return result.get('fingerprint', '') or ''
+
+
+def record_setup_phase(phase, status='running', summary=''):
+    global s
+    ts = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
+    try:
+        current = load_state()
+    except Exception:
+        current = dict(s)
+    runtime_step = current.get('current_runtime_step') if isinstance(current.get('current_runtime_step'), dict) else {}
+    if not runtime_step:
+        runtime_step = {
+            'step': 'setup',
+            'action': 'run',
+            'status': 'running',
+            'started_at': ts,
+            'workflow_file': 'riddle-proof-setup.lobster',
+        }
+    runtime_step['phase'] = phase
+    runtime_step['phase_status'] = status
+    if status == 'running':
+        runtime_step['phase_started_at'] = ts
+        runtime_step.pop('phase_finished_at', None)
+    else:
+        runtime_step['phase_finished_at'] = ts
+    if summary:
+        runtime_step['summary'] = summary
+    current['current_runtime_step'] = runtime_step
+    events = current.get('runtime_events') if isinstance(current.get('runtime_events'), list) else []
+    events.append({
+        'ts': ts,
+        'kind': 'workflow.phase.' + ('started' if status == 'running' else 'finished'),
+        'step': 'setup',
+        'phase': phase,
+        'summary': summary or (phase + ' ' + status),
+        'details': {'status': status},
+    })
+    current['runtime_events'] = events[-100:]
+    current['runtime_updated_at'] = ts
+    save_state(current)
+    for key in ('current_runtime_step', 'runtime_events', 'runtime_updated_at'):
+        if key in current:
+            s[key] = current[key]
+
+
+def ensure_deps_phase(phase, project_dir, reuse_from='', summary=''):
+    record_setup_phase(phase, 'running', summary)
+    try:
+        status = ensure_deps(project_dir, reuse_from=reuse_from)
+    except BaseException as exc:
+        record_setup_phase(phase, 'failed', str(exc)[:300])
+        raise
+    record_setup_phase(phase, 'completed', status or 'no dependency install needed')
+    return status
+
+
+def dependencies_match(left_dir, right_dir):
+    left = dependency_fingerprint(left_dir)
+    right = dependency_fingerprint(right_dir)
+    return bool(left and right and left == right)
+
+
+def compatible_reuse_source(source_dir, target_dirs):
+    if not source_dir:
+        return ''
+    source = dependency_fingerprint(source_dir)
+    if not source:
+        return ''
+    for target_dir in target_dirs:
+        if target_dir and dependency_fingerprint(target_dir) == source:
+            return source_dir
+    return ''
+
+
 def resolve_worktree_root(repo_dir):
     configured = (s.get('worktree_root') or os.environ.get('RIDDLE_PROOF_WORKTREE_ROOT') or '').strip()
     if configured:
@@ -338,17 +426,36 @@ print('After worktree: ' + AFTER_DIR + ' (' + AFTER_WORKTREE_BRANCH + ' -> ' + b
 apply_repo_profile(AFTER_DIR)
 save_state(s)
 
+target_dependency_dirs = [AFTER_DIR]
+if reference in ('before', 'both'):
+    target_dependency_dirs.append(BEFORE_DIR)
+
 reuse_source = repo_dir if os.path.exists(os.path.join(repo_dir, 'package.json')) else ''
-shared_status = ensure_deps(reuse_source) if reuse_source else ''
-if shared_status:
-    print('Shared deps status: ' + shared_status)
+shared_reuse_source = compatible_reuse_source(reuse_source, target_dependency_dirs)
+shared_status = ''
+if shared_reuse_source:
+    shared_status = ensure_deps_phase('shared_deps', shared_reuse_source, summary='Ensuring shared repository dependencies.')
+    if shared_status:
+        print('Shared deps status: ' + shared_status)
+elif reuse_source:
+    record_setup_phase(
+        'shared_deps',
+        'completed',
+        'skipped: active workspace dependencies differ from proof worktrees',
+    )
+    print('Shared deps skipped: active workspace dependencies differ from proof worktrees')
 
 before_dep_status = ''
 if reference in ('before', 'both'):
-    before_dep_status = ensure_deps(BEFORE_DIR, reuse_from=reuse_source)
+    before_dep_status = ensure_deps_phase('before_deps', BEFORE_DIR, reuse_from=shared_reuse_source, summary='Ensuring before-worktree dependencies.')
     print('Before deps status: ' + before_dep_status)
 
-after_dep_status = ensure_deps(AFTER_DIR, reuse_from=reuse_source)
+after_reuse_source = ''
+if before_dep_status and dependencies_match(BEFORE_DIR, AFTER_DIR):
+    after_reuse_source = BEFORE_DIR
+elif shared_reuse_source:
+    after_reuse_source = shared_reuse_source
+after_dep_status = ensure_deps_phase('after_deps', AFTER_DIR, reuse_from=after_reuse_source, summary='Ensuring after-worktree dependencies.')
 print('After deps status: ' + after_dep_status)
 
 # Patch Next.js config in after worktree if needed