@riddledc/riddle-proof 0.5.3 → 0.5.4

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)}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "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,64 @@ 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 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 resolve_worktree_root(repo_dir):
     configured = (s.get('worktree_root') or os.environ.get('RIDDLE_PROOF_WORKTREE_ROOT') or '').strip()
     if configured:
@@ -339,16 +402,16 @@ apply_repo_profile(AFTER_DIR)
 save_state(s)
 
 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 ''
+shared_status = ensure_deps_phase('shared_deps', reuse_source, summary='Ensuring shared repository dependencies.') if reuse_source else ''
 if shared_status:
     print('Shared deps status: ' + shared_status)
 
 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=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_dep_status = ensure_deps_phase('after_deps', AFTER_DIR, reuse_from=reuse_source, summary='Ensuring after-worktree dependencies.')
 print('After deps status: ' + after_dep_status)
 
 # Patch Next.js config in after worktree if needed