@riddledc/riddle-proof 0.5.22 → 0.5.24

package/dist/{chunk-PJ3RTT5D.js → chunk-46355FJD.js}

@@ -89,8 +89,20 @@ function loadRunState(input) {
     state_path: statePath
   });
 }
+function isProtectedFinalStatus(status) {
+  return status === "ready_to_ship" || status === "shipped" || status === "completed";
+}
+function shouldPreserveFinalizedRunState(filePath, incoming) {
+  const existing = readJson(filePath);
+  if (!existing?.finalized || !isProtectedFinalStatus(existing.status)) return false;
+  if (!incoming.finalized) return true;
+  if (existing.status === incoming.status) return false;
+  return !(existing.status === "ready_to_ship" && incoming.status === "shipped");
+}
 function persist(state) {
-  if (state.state_path) writeJson(state.state_path, state);
+  if (!state.state_path) return;
+  if (shouldPreserveFinalizedRunState(state.state_path, state)) return;
+  writeJson(state.state_path, state);
 }
 function recordEvent(state, event) {
   appendRunEvent(state, event);
@@ -124,6 +136,16 @@ function fullRiddleState(result, state) {
 function workdirFromState(state) {
   return nonEmptyString(state?.after_worktree) || nonEmptyString(state?.worktree_path) || null;
 }
+function parseGitStatusPaths(status) {
+  return status.split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean).map((line) => {
+    let item = line.length > 3 ? line.slice(3) : line;
+    if (item.includes(" -> ")) item = item.split(" -> ").pop() || item;
+    return item.trim();
+  }).filter(Boolean);
+}
+function isToolNoisePath(filePath) {
+  return filePath === ".codex" || filePath.startsWith(".codex/") || filePath === ".oc-smoke" || filePath.startsWith(".oc-smoke/");
+}
 function hasGitDiff(workdir) {
   if (!workdir || !existsSync(workdir)) return false;
   try {
@@ -132,7 +154,7 @@ function hasGitDiff(workdir) {
       encoding: "utf-8",
       timeout: 1e4
     });
-    return status.trim().length > 0;
+    return parseGitStatusPaths(status).some((filePath) => !isToolNoisePath(filePath));
   } catch {
     return false;
   }
@@ -315,6 +337,7 @@ function engineFailureBlocker(result, checkpoint) {
 }
 function terminalResult(state, status, result, summary, raw = {}) {
   setRunStatus(state, status);
+  if (isProtectedFinalStatus(status)) state.finalized = true;
   const metadata = normalizeTerminalMetadata({
     riddleState: result ? fullRiddleState(result, state) : null,
     engineResult: result

package/dist/engine-harness.cjs

@@ -3091,8 +3091,20 @@ function loadRunState(input) {
     state_path: statePath
   });
 }
+function isProtectedFinalStatus(status) {
+  return status === "ready_to_ship" || status === "shipped" || status === "completed";
+}
+function shouldPreserveFinalizedRunState(filePath, incoming) {
+  const existing = readJson(filePath);
+  if (!existing?.finalized || !isProtectedFinalStatus(existing.status)) return false;
+  if (!incoming.finalized) return true;
+  if (existing.status === incoming.status) return false;
+  return !(existing.status === "ready_to_ship" && incoming.status === "shipped");
+}
 function persist(state) {
-  if (state.state_path) writeJson(state.state_path, state);
+  if (!state.state_path) return;
+  if (shouldPreserveFinalizedRunState(state.state_path, state)) return;
+  writeJson(state.state_path, state);
 }
 function recordEvent(state, event) {
   appendRunEvent(state, event);
@@ -3126,6 +3138,16 @@ function fullRiddleState(result, state) {
 function workdirFromState(state) {
   return nonEmptyString(state?.after_worktree) || nonEmptyString(state?.worktree_path) || null;
 }
+function parseGitStatusPaths(status) {
+  return status.split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean).map((line) => {
+    let item = line.length > 3 ? line.slice(3) : line;
+    if (item.includes(" -> ")) item = item.split(" -> ").pop() || item;
+    return item.trim();
+  }).filter(Boolean);
+}
+function isToolNoisePath(filePath) {
+  return filePath === ".codex" || filePath.startsWith(".codex/") || filePath === ".oc-smoke" || filePath.startsWith(".oc-smoke/");
+}
 function hasGitDiff(workdir) {
   if (!workdir || !(0, import_node_fs3.existsSync)(workdir)) return false;
   try {
@@ -3134,7 +3156,7 @@ function hasGitDiff(workdir) {
       encoding: "utf-8",
       timeout: 1e4
     });
-    return status.trim().length > 0;
+    return parseGitStatusPaths(status).some((filePath) => !isToolNoisePath(filePath));
   } catch {
     return false;
   }
@@ -3317,6 +3339,7 @@ function engineFailureBlocker(result, checkpoint) {
 }
 function terminalResult(state, status, result, summary, raw = {}) {
   setRunStatus(state, status);
+  if (isProtectedFinalStatus(status)) state.finalized = true;
   const metadata = normalizeTerminalMetadata({
     riddleState: result ? fullRiddleState(result, state) : null,
     engineResult: result

package/dist/engine-harness.js

@@ -2,7 +2,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-PJ3RTT5D.js";
+} from "./chunk-46355FJD.js";
 import "./chunk-7ZJAUEUN.js";
 import "./chunk-TMMKRKY5.js";
 export {

package/dist/index.cjs

@@ -3647,8 +3647,20 @@ function loadRunState(input) {
     state_path: statePath
   });
 }
+function isProtectedFinalStatus(status) {
+  return status === "ready_to_ship" || status === "shipped" || status === "completed";
+}
+function shouldPreserveFinalizedRunState(filePath, incoming) {
+  const existing = readJson(filePath);
+  if (!existing?.finalized || !isProtectedFinalStatus(existing.status)) return false;
+  if (!incoming.finalized) return true;
+  if (existing.status === incoming.status) return false;
+  return !(existing.status === "ready_to_ship" && incoming.status === "shipped");
+}
 function persist(state) {
-  if (state.state_path) writeJson(state.state_path, state);
+  if (!state.state_path) return;
+  if (shouldPreserveFinalizedRunState(state.state_path, state)) return;
+  writeJson(state.state_path, state);
 }
 function recordEvent(state, event) {
   appendRunEvent(state, event);
@@ -3682,6 +3694,16 @@ function fullRiddleState(result, state) {
 function workdirFromState(state) {
   return nonEmptyString(state?.after_worktree) || nonEmptyString(state?.worktree_path) || null;
 }
+function parseGitStatusPaths(status) {
+  return status.split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean).map((line) => {
+    let item = line.length > 3 ? line.slice(3) : line;
+    if (item.includes(" -> ")) item = item.split(" -> ").pop() || item;
+    return item.trim();
+  }).filter(Boolean);
+}
+function isToolNoisePath(filePath) {
+  return filePath === ".codex" || filePath.startsWith(".codex/") || filePath === ".oc-smoke" || filePath.startsWith(".oc-smoke/");
+}
 function hasGitDiff(workdir) {
   if (!workdir || !(0, import_node_fs3.existsSync)(workdir)) return false;
   try {
@@ -3690,7 +3712,7 @@ function hasGitDiff(workdir) {
       encoding: "utf-8",
       timeout: 1e4
     });
-    return status.trim().length > 0;
+    return parseGitStatusPaths(status).some((filePath) => !isToolNoisePath(filePath));
   } catch {
     return false;
   }
@@ -3873,6 +3895,7 @@ function engineFailureBlocker(result, checkpoint) {
 }
 function terminalResult(state, status, result, summary, raw = {}) {
   setRunStatus(state, status);
+  if (isProtectedFinalStatus(status)) state.finalized = true;
   const metadata = normalizeTerminalMetadata({
     riddleState: result ? fullRiddleState(result, state) : null,
     engineResult: result

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-PJ3RTT5D.js";
+} from "./chunk-46355FJD.js";
 import {
   runRiddleProof
 } from "./chunk-F6VFKS7K.js";

package/package.json

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

package/runtime/lib/implement.py

@@ -9,6 +9,8 @@ import json, os, sys
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from util import load_state, save_state, git, shell_quote
 
+TOOL_NOISE_PATHS = ('.codex', '.oc-smoke')
+
 
 def unique_nonempty(items):
     seen = set()
@@ -37,6 +39,15 @@ def parse_status_paths(lines):
     return unique_nonempty(paths)
 
 
+def is_tool_noise_path(path):
+    text = str(path or '').strip()
+    return any(text == prefix or text.startswith(prefix + '/') for prefix in TOOL_NOISE_PATHS)
+
+
+def material_paths(paths):
+    return [path for path in unique_nonempty(paths) if not is_tool_noise_path(path)]
+
+
 s = load_state()
 after_dir = (s.get('after_worktree') or '').strip()
 if not after_dir or not os.path.exists(after_dir):
@@ -45,7 +56,9 @@ if not after_dir or not os.path.exists(after_dir):
 base_branch = s.get('base_branch', 'main')
 base_ref = (s.get('before_ref') or '').strip() or ('origin/' + base_branch)
 dirty = [ln for ln in git('git status --short', after_dir).stdout.splitlines() if ln.strip()]
-dirty_paths = parse_status_paths(dirty)
+dirty_paths_all = parse_status_paths(dirty)
+dirty_paths = material_paths(dirty_paths_all)
+ignored_dirty_paths = [path for path in dirty_paths_all if is_tool_noise_path(path)]
 
 diff_probes = []
 
@@ -70,7 +83,9 @@ if diff_result.returncode != 0:
 if diff_result.returncode != 0 and not committed:
     fallback, committed = run_diff_probe('head_parent', 'git diff --name-only HEAD~1 HEAD')
 
-changed = unique_nonempty(dirty_paths + committed)
+committed_material = material_paths(committed)
+ignored_committed_paths = [path for path in committed if is_tool_noise_path(path)]
+changed = unique_nonempty(dirty_paths + committed_material)
 authored = bool((s.get('capture_script') or '').strip()) and bool((s.get('proof_plan') or '').strip())
 
 detection = {
@@ -81,9 +96,13 @@ detection = {
     'base_ref_requested': base_ref,
     'dirty_status_lines': dirty[:20],
     'dirty_paths': dirty_paths[:20],
+    'ignored_dirty_paths': ignored_dirty_paths[:20],
     'dirty_path_count': len(dirty_paths),
-    'committed_paths': committed[:20],
-    'committed_path_count': len(committed),
+    'dirty_path_count_including_noise': len(dirty_paths_all),
+    'committed_paths': committed_material[:20],
+    'ignored_committed_paths': ignored_committed_paths[:20],
+    'committed_path_count': len(committed_material),
+    'committed_path_count_including_noise': len(committed),
     'changed_paths': changed[:20],
     'changed_path_count': len(changed),
     'diff_probes': diff_probes[:6],

package/runtime/tests/recon_verify_smoke.py

@@ -637,6 +637,7 @@ def run_implement_records_detection_when_changes_missing():
         })
         write_state(state_path, state)
         os.environ['RIDDLE_PROOF_STATE_FILE'] = str(state_path)
+        load_module('util', UTIL_PATH)
 
         try:
             load_module('implement_changes_missing_state', IMPLEMENT_PATH)
@@ -673,6 +674,56 @@ def run_implement_records_detection_when_changes_missing():
         shutil.rmtree(tempdir, ignore_errors=True)
 
 
+def run_implement_ignores_tool_noise_when_detecting_changes():
+    tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-implement-noise-'))
+    state_path = tempdir / 'state.json'
+    previous_state_file = os.environ.get('RIDDLE_PROOF_STATE_FILE')
+    try:
+        state = base_state(tempdir, reference='before')
+        after_dir = Path(state['after_worktree'])
+        init_git_repo(after_dir)
+        codex_dir = after_dir / '.codex'
+        codex_dir.mkdir(parents=True, exist_ok=True)
+        (codex_dir / 'session.json').write_text('{}\n')
+        state.update({
+            'recon_status': 'ready_for_proof_plan',
+            'author_status': 'ready',
+            'proof_plan_status': 'ready',
+            'proof_plan': 'Capture the pricing CTA after the implementation is applied.',
+            'capture_script': "await page.waitForSelector('[data-testid=pricing-cta]'); await saveScreenshot('after-proof');",
+        })
+        write_state(state_path, state)
+        os.environ['RIDDLE_PROOF_STATE_FILE'] = str(state_path)
+        load_module('util', UTIL_PATH)
+
+        try:
+            load_module('implement_ignores_tool_noise', IMPLEMENT_PATH)
+        except SystemExit as exc:
+            assert 'No implementation detected on the after worktree.' in str(exc), exc
+        else:
+            raise AssertionError('implement stage should have halted when only tool noise changed')
+
+        after_state = json.loads(state_path.read_text())
+        detection = after_state['implementation_detection']
+        assert detection['outcome'] == 'no_changes_detected'
+        assert detection['diff_detected'] is False
+        assert detection['dirty_path_count'] == 0
+        assert detection['dirty_path_count_including_noise'] >= 1
+        assert any(str(path).startswith('.codex') for path in detection['ignored_dirty_paths'])
+        assert detection['changed_path_count'] == 0
+        assert after_state['changed_files'] == []
+        return {
+            'ok': True,
+            'ignored_dirty_paths': detection['ignored_dirty_paths'],
+        }
+    finally:
+        if previous_state_file is None:
+            os.environ.pop('RIDDLE_PROOF_STATE_FILE', None)
+        else:
+            os.environ['RIDDLE_PROOF_STATE_FILE'] = previous_state_file
+        shutil.rmtree(tempdir, ignore_errors=True)
+
+
 def run_recon_then_author_request():
     tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-supervisor-request-'))
     state_path = tempdir / 'state.json'
@@ -1481,6 +1532,7 @@ if __name__ == '__main__':
         'apply_auth_context': run_apply_auth_context_passes_supported_auth_payloads(),
         'run_project_build_retries_after_clean_failure': run_project_build_retries_after_clean_failure(),
         'implement_records_detection_when_changes_missing': run_implement_records_detection_when_changes_missing(),
+        'implement_ignores_tool_noise_when_detecting_changes': run_implement_ignores_tool_noise_when_detecting_changes(),
         'verify_quality_ignores_proof_telemetry_console_text': run_verify_quality_ignores_proof_telemetry_console_text(),
         'recon_then_author_request': run_recon_then_author_request(),
         'recon_preserves_query_route': run_recon_preserves_query_route(),