@riddledc/riddle-proof 0.5.0 → 0.5.2

package/runtime/pipelines/riddle-proof-author.lobster

@@ -0,0 +1,28 @@
+name: riddle-proof-author
+# Riddle Proof — Author
+# Consumes recon observation state and turns it into a reusable proof packet.
+# Produces proof_plan, capture_script, and any refined capture inputs.
+# Requires RIDDLE_PROOF_DIR env var set to the runtime directory.
+
+steps:
+
+  - id: check_state
+    command: |
+      python3 << 'PYEOF'
+      import json, os
+      state_file = os.environ.get('RIDDLE_PROOF_STATE_FILE', '/tmp/riddle-proof-state.json')
+      s = json.load(open(state_file))
+      if not s.get('workspace_ready'):
+          raise SystemExit('Workspace not ready. Run riddle-proof-setup first.')
+      if s.get('recon_status') not in ('ready_for_proof_plan', 'completed'):
+          raise SystemExit('Recon has not produced a usable observation packet yet. Run recon first.')
+      print('AUTHOR')
+      print('Proof goal: ' + s.get('change_request', ''))
+      print('Recon summary: ' + (s.get('recon_summary') or '(not run)'))
+      print('Current proof plan status: ' + (s.get('proof_plan_status') or '(unknown)'))
+      PYEOF
+
+  - id: run_author
+    command: |
+      RP="${RIDDLE_PROOF_DIR:-/root/.openclaw/extensions/openclaw-riddle-proof/node_modules/@riddledc/riddle-proof/runtime}"
+      python3 "${RP}/lib/author.py"

package/runtime/pipelines/riddle-proof-implement.lobster

@@ -0,0 +1,26 @@
+name: riddle-proof-implement
+# Riddle Proof — Implement
+# Confirms that real code work exists after recon and before verify.
+# Run after making the code changes on the after worktree.
+# Requires RIDDLE_PROOF_DIR env var set to the runtime directory.
+
+steps:
+
+  - id: check_state
+    command: |
+      python3 << 'PYEOF'
+      import json, os
+      state_file = os.environ.get('RIDDLE_PROOF_STATE_FILE', '/tmp/riddle-proof-state.json')
+      s = json.load(open(state_file))
+      if not s.get('workspace_ready'):
+          raise SystemExit('Workspace not ready. Run riddle-proof-setup first.')
+      print('IMPLEMENT')
+      print('Proof goal: ' + s.get('change_request', ''))
+      print('After worktree: ' + s.get('after_worktree', '') + (' (exists)' if os.path.exists(s.get('after_worktree', '')) else ' (MISSING)'))
+      print('Recon summary: ' + (s.get('recon_summary') or '(not run)'))
+      PYEOF
+
+  - id: run_implement
+    command: |
+      RP="${RIDDLE_PROOF_DIR:-/root/.openclaw/extensions/openclaw-riddle-proof/node_modules/@riddledc/riddle-proof/runtime}"
+      python3 "${RP}/lib/implement.py"

package/runtime/pipelines/riddle-proof-recon.lobster

@@ -0,0 +1,79 @@
+name: riddle-proof-recon
+# Riddle Proof — Recon
+# Recon now owns baseline discovery.
+# Flow: hypothesize -> capture -> observe -> checkpoint for supervising-agent judgment -> bounded retry.
+# Run after setup, before implementation and verify.
+# Requires RIDDLE_PROOF_DIR env var set to the runtime directory.
+
+steps:
+
+  - id: check_state
+    command: |
+      python3 << 'PYEOF'
+      import json, os
+      state_file = os.environ.get('RIDDLE_PROOF_STATE_FILE', '/tmp/riddle-proof-state.json')
+      s = json.load(open(state_file))
+      if not s.get('workspace_ready'):
+          raise SystemExit('Workspace not ready. Run riddle-proof-setup first.')
+      ref = s.get('requested_reference') or s.get('reference', 'both')
+      print('RECON — ' + s.get('mode', 'server').upper() + ' / reference=' + ref)
+      print('Proof goal: ' + s.get('change_request', ''))
+      print('Success criteria: ' + (s.get('success_criteria') or '(none provided)'))
+      print('Verification mode: ' + s.get('verification_mode', 'proof'))
+      print('Proof plan status: ' + s.get('proof_plan_status', 'pending_recon'))
+      print('Server path hint: ' + (s.get('server_path') or '(derive during recon)'))
+      if ref in ('before', 'both'):
+          wt = s.get('before_worktree', '')
+          print('Before worktree: ' + wt + (' (exists)' if os.path.exists(wt) else ' (MISSING)'))
+      print('After worktree: ' + s.get('after_worktree', ''))
+      PYEOF
+
+  - id: run_recon
+    command: |
+      RP="${RIDDLE_PROOF_DIR:-/root/.openclaw/extensions/openclaw-riddle-proof/node_modules/@riddledc/riddle-proof/runtime}"
+      python3 "${RP}/lib/recon.py"
+
+  - id: summarize_recon
+    command: |
+      python3 << 'PYEOF'
+      import json, os
+      state_file = os.environ.get('RIDDLE_PROOF_STATE_FILE', '/tmp/riddle-proof-state.json')
+      s = json.load(open(state_file))
+      r = s.get('recon_results', {})
+      baselines = r.get('baselines', {})
+      hypothesis = r.get('hypothesis', {})
+      print('='*50)
+      print('RECON REVIEW')
+      print('='*50)
+      print('Summary: ' + (s.get('recon_summary') or '(none)'))
+      print('Recon status: ' + (s.get('recon_status') or '(unknown)'))
+      print('Hypothesis path: ' + (hypothesis.get('target_path') or '(none)'))
+      print('Hypothesis source: ' + (hypothesis.get('path_source') or '(none)'))
+      for line in r.get('route_hints', [])[:8]:
+          print('Route hint: ' + line)
+      for line in r.get('keyword_hits', [])[:10]:
+          print('Keyword hit: ' + line)
+      if baselines.get('before'):
+          print('Before baseline: ' + baselines['before'].get('url', '(none)'))
+      if baselines.get('prod'):
+          print('Prod baseline: ' + baselines['prod'].get('url', '(none)'))
+      latest = (r.get('attempt_history') or [])[-1:] 
+      if latest:
+          print('Latest attempt result: ' + latest[0].get('result', '(unknown)'))
+      if s.get('recon_assessment_request') or s.get('recon_decision_request'):
+          req = s.get('recon_assessment_request') or s.get('recon_decision_request', {})
+          print('Recon attempts remaining: ' + str(req.get('attempts_remaining', '(unknown)')))
+
+      print()
+      print('PROOF GOAL: ' + s.get('change_request', ''))
+      print('SUCCESS CRITERIA: ' + (s.get('success_criteria') or '(none provided)'))
+      print()
+      print('REVIEW CHECKLIST:')
+      print('  1. Did recon capture the correct before / prod baseline context?')
+      print('  2. If recon is blocked, what next path or wait selector should the supervising agent try next?')
+      print('  3. Once recon is ready, what exact interaction or state should verify reproduce on the after build?')
+      print('  4. What final capture_script should verify run on the recon-established path?')
+      print('  5. What code work needs to happen before verify?')
+      print()
+      print('Recon should finish with observed baselines and a concrete proof-plan request.')
+      PYEOF

package/runtime/pipelines/riddle-proof-setup.lobster

@@ -0,0 +1,141 @@
+name: riddle-proof-setup
+# Riddle Proof — Setup
+# Creates worktrees, installs deps, validates args.
+# Run once before recon/verify/ship.
+# Requires RIDDLE_PROOF_DIR env var set to the runtime directory.
+
+args:
+  repo:
+    default: ""
+  branch:
+    default: ""
+  change_request:
+    default: ""
+  commit_message:
+    default: ""
+  prod_url:
+    default: ""
+  capture_script:
+    default: ""
+    description: "Optional during setup. Add it before recon/verify once the proof target is clear."
+  success_criteria:
+    default: ""
+    description: "Plain-English definition of what counts as fixed"
+  assertions_json:
+    default: ""
+    description: "Optional JSON object/array of checks to satisfy"
+  verification_mode:
+    default: "proof"
+    description: "proof, visual, interaction, render, data, or custom label"
+  reference:
+    default: "both"
+    description: "What to compare against: prod, before, or both"
+  base_branch:
+    default: "main"
+    description: "Target branch for PR base"
+  before_ref:
+    default: ""
+    description: "Detached baseline ref for before preview; defaults to origin/<base_branch>"
+  allow_static_preview_fallback:
+    default: "false"
+    description: "Allow server mode to fall back to static preview; keep false for routed/interactive apps"
+  context:
+    default: ""
+  reviewer:
+    default: "davisdiehl"
+  mode:
+    default: "server"
+    description: "static or server"
+  build_command:
+    default: "npm run build"
+  build_output:
+    default: "build"
+    description: "Build output directory (static mode only)"
+  server_image:
+    default: "node:20-slim"
+  server_command:
+    default: "npm start"
+  server_port:
+    default: "3000"
+  server_path:
+    default: ""
+  use_auth:
+    default: ""
+    description: "Set to 'true' to auto-fetch Cognito auth tokens"
+  auth_localStorage_json:
+    default: ""
+    description: "JSON object of localStorage entries to inject before page load"
+  auth_cookies_json:
+    default: ""
+    description: "JSON object or array of cookies to inject before page load"
+  auth_headers_json:
+    default: ""
+    description: "JSON object of request headers to use during proof capture"
+  color_scheme:
+    default: ""
+    description: "Browser color scheme: 'dark' or 'light' (applied before page load)"
+  wait_for_selector:
+    default: ""
+    description: "CSS selector to wait for before capturing screenshot"
+  discord_channel:
+    default: ""
+  discord_thread_id:
+    default: ""
+  discord_message_id:
+    default: ""
+  discord_source_url:
+    default: ""
+
+steps:
+
+  - id: preflight
+    command: |
+      python3 << 'PYEOF'
+      import json, os
+      raw_server_path = """${server_path}""".strip()
+      args = {
+          'mode': """${mode}""".strip() or 'server',
+          'reference': """${reference}""".strip() or 'both',
+          'repo': """${repo}""".strip(),
+          'branch': """${branch}""".strip(),
+          'change_request': """${change_request}""".strip(),
+          'commit_message': """${commit_message}""".strip(),
+          'prod_url': """${prod_url}""".strip(),
+          'capture_script': """${capture_script}""".strip(),
+          'success_criteria': """${success_criteria}""".strip(),
+          'assertions_json': """${assertions_json}""".strip(),
+          'verification_mode': """${verification_mode}""".strip() or 'proof',
+          'context': """${context}""".strip(),
+          'reviewer': """${reviewer}""".strip() or 'davisdiehl',
+          'base_branch': """${base_branch}""".strip() or 'main',
+          'before_ref': """${before_ref}""".strip(),
+          'allow_static_preview_fallback': """${allow_static_preview_fallback}""".strip(),
+          'build_command': """${build_command}""".strip() or 'npm run build',
+          'build_output': """${build_output}""".strip() or 'build',
+          'server_image': """${server_image}""".strip() or 'node:20-slim',
+          'server_command': """${server_command}""".strip() or 'npm start',
+          'server_port': """${server_port}""".strip() or '3000',
+          'server_path': raw_server_path,
+          'server_path_source': 'user' if raw_server_path else '',
+          'use_auth': """${use_auth}""".strip(),
+          'auth_localStorage_json': """${auth_localStorage_json}""".strip(),
+          'auth_cookies_json': """${auth_cookies_json}""".strip(),
+          'auth_headers_json': """${auth_headers_json}""".strip(),
+          'color_scheme': """${color_scheme}""".strip(),
+          'wait_for_selector': """${wait_for_selector}""".strip(),
+          'discord_channel': """${discord_channel}""".strip(),
+          'discord_thread_id': """${discord_thread_id}""".strip(),
+          'discord_message_id': """${discord_message_id}""".strip(),
+          'discord_source_url': """${discord_source_url}""".strip(),
+      }
+      args_file = os.environ.get('RIDDLE_PROOF_ARGS_FILE', '/tmp/riddle-proof-args.json')
+      with open(args_file, 'w') as f:
+          json.dump(args, f, indent=2)
+      PYEOF
+      RP="${RIDDLE_PROOF_DIR:-/root/.openclaw/extensions/openclaw-riddle-proof/node_modules/@riddledc/riddle-proof/runtime}"
+      python3 "${RP}/lib/preflight.py"
+
+  - id: setup
+    command: |
+      RP="${RIDDLE_PROOF_DIR:-/root/.openclaw/extensions/openclaw-riddle-proof/node_modules/@riddledc/riddle-proof/runtime}"
+      python3 "${RP}/lib/setup.py"

package/runtime/pipelines/riddle-proof-ship.lobster

@@ -0,0 +1,36 @@
+name: riddle-proof-ship
+# Riddle Proof — Ship
+# Commits, creates PR, posts proof artifacts, waits for CI, marks ready.
+# Cleans up worktrees and preview sites.
+# Requires RIDDLE_PROOF_DIR env var set to the runtime directory.
+
+steps:
+
+  - id: check_state
+    command: |
+      python3 << 'PYEOF'
+      import json, os
+      state_file = os.environ.get('RIDDLE_PROOF_STATE_FILE', '/tmp/riddle-proof-state.json')
+      s = json.load(open(state_file))
+      if not s.get('after_cdn'):
+          raise SystemExit('No after evidence. Run verify first.')
+      print('SHIP')
+      print('  Proof goal: ' + s.get('change_request', ''))
+      print('  Commit: ' + s.get('commit_message', ''))
+      print('  Before: ' + s.get('before_cdn', '(none)'))
+      print('  After:  ' + s.get('after_cdn', ''))
+      print('  Assertion status: ' + s.get('assertion_status', 'unknown'))
+      mr = s.get('merge_recommendation', '')
+      if mr:
+          print('  Merge recommendation: ' + mr)
+      pr = s.get('pr_url', '')
+      if pr:
+          print('  PR: ' + pr + ' (will update)')
+      else:
+          print('  PR: will create draft')
+      PYEOF
+
+  - id: ship
+    command: |
+      RP="${RIDDLE_PROOF_DIR:-/root/.openclaw/extensions/openclaw-riddle-proof/node_modules/@riddledc/riddle-proof/runtime}"
+      python3 "${RP}/lib/ship.py"

package/runtime/pipelines/riddle-proof-verify.lobster

@@ -0,0 +1,74 @@
+name: riddle-proof-verify
+# Riddle Proof — Verify
+# Reuses recon-established baselines and captures the after-proof.
+# Run after recon and after code changes are on the branch.
+# Re-run as many times as needed until the proof is strong.
+# Requires RIDDLE_PROOF_DIR env var set to the runtime directory.
+
+steps:
+
+  - id: check_state
+    command: |
+      python3 << 'PYEOF'
+      import json, os
+      state_file = os.environ.get('RIDDLE_PROOF_STATE_FILE', '/tmp/riddle-proof-state.json')
+      s = json.load(open(state_file))
+      if not s.get('workspace_ready'):
+          raise SystemExit('Workspace not ready. Run riddle-proof-setup first.')
+      if s.get('implementation_status') not in ('changes_detected', 'completed'):
+          raise SystemExit('Implementation not recorded. Run riddle-proof-implement after making code changes.')
+      print('VERIFY — ' + s.get('mode', 'server').upper())
+      print('Proof goal: ' + s.get('change_request', ''))
+      print('Success criteria: ' + (s.get('success_criteria') or '(none provided)'))
+      print('Verification mode: ' + s.get('verification_mode', 'proof'))
+      print('Reference: ' + (s.get('requested_reference') or s.get('reference', 'both')))
+      print('Proof plan status: ' + s.get('proof_plan_status', 'unknown'))
+      print('Before baseline: ' + s.get('before_cdn', '(missing)'))
+      if s.get('prod_cdn'):
+          print('Prod baseline: ' + s.get('prod_cdn'))
+      after_dir = s.get('after_worktree', '')
+      print('After worktree: ' + after_dir + (' (exists)' if os.path.exists(after_dir) else ' (MISSING)'))
+      PYEOF
+
+  - id: run_verify
+    command: |
+      RP="${RIDDLE_PROOF_DIR:-/root/.openclaw/extensions/openclaw-riddle-proof/node_modules/@riddledc/riddle-proof/runtime}"
+      python3 "${RP}/lib/verify.py"
+
+  - id: present_evidence
+    command: |
+      python3 << 'PYEOF'
+      import json, os
+      state_file = os.environ.get('RIDDLE_PROOF_STATE_FILE', '/tmp/riddle-proof-state.json')
+      s = json.load(open(state_file))
+      print('='*50)
+      print('RIDDLE PROOF — EVIDENCE')
+      print('='*50)
+      print('PROOF GOAL: ' + s.get('change_request', ''))
+      print('SUCCESS CRITERIA: ' + (s.get('success_criteria') or '(none provided)'))
+      print('MODE: ' + s.get('verification_mode', 'proof'))
+      print()
+      print('BEFORE (RECON): ' + s.get('before_cdn', '(none)'))
+      if s.get('prod_cdn'):
+          print('PROD (RECON):   ' + s.get('prod_cdn'))
+      print('AFTER:          ' + s.get('after_cdn', '(none)'))
+      print()
+      print('PROOF SUMMARY:')
+      print(s.get('proof_summary', '(not generated)'))
+      print()
+      print('VERIFY STATUS: ' + s.get('verify_status', 'unknown'))
+      print('ASSERTION STATUS: ' + s.get('assertion_status', 'unknown'))
+      mr = s.get('merge_recommendation', '')
+      if mr:
+          print('MERGE RECOMMENDATION: ' + mr)
+      pa = s.get('proof_assessment') or {}
+      if pa.get('decision'):
+          print('PROOF ASSESSMENT: ' + pa.get('decision'))
+      next_stage = (s.get('verify_decision_request') or {}).get('continue_with_stage') or (s.get('verify_decision_request') or {}).get('recommended_stage')
+      if next_stage:
+          print('NEXT INTERNAL STAGE: ' + str(next_stage))
+      print()
+      print('Review the full proof bundle.')
+      print('  - Use continue_from_checkpoint when the internal next stage looks right.')
+      print('  - Only escalate to the human if the workflow is not converging.')
+      PYEOF