parseFalsifierToQuery regex too narrow: only file_exists/file_not_exists DSL — 99.97% of prose falsifiers age out unresolved

[miles990]

Symptom

Across 5236 commitments in memory/state/commitments.jsonl:

• kept: 1 (0.019%)
• resolved: 3 (0.057%)
• refuted: 3 (0.057%)
• expired: 2168 (41.4%)
• abandoned: 1312 (25.1%)
• pending: 1749 (33.4%)

Last 20 entries: 0/20 have a populated falsifier_query field. PERFORMATIVE SKEPTICISM warning fires (execution rate <30%) but the warning is measuring an artifact of the resolver's narrow grammar, not the agent's actual follow-through.

Root cause

src/commitment-ledger.ts:131-134 auto-populates falsifier_query from prose:
```ts
if (!full.falsifier_query && full.falsifier) {
const parsed = parseFalsifierToQuery(full.falsifier);
if (parsed) full.falsifier_query = parsed;
}
```

parseFalsifierToQuery (lines 284-291) only matches two DSL markers:
```ts
const neg = falsifier.match(/\bfile_not_exists:(/\S+?)(?=[\s,;。、)）]|$)/);
if (neg) return { kind: 'file_exists', path: neg[1], must: false };
const pos = falsifier.match(/\bfile_exists:(/\S+?)(?=[\s,;。、)）]|$)/);
if (pos) return { kind: 'file_exists', path: pos[1], must: true };
return undefined;
```

Real prose falsifiers written by the agent use natural-language form like:

• /path/to/commitments.jsonl 最近 20 entries 中 status=kept count == 0
• /abs/path grep "pattern" count >= 3
• latest event ts > 2026-05-06T01:24Z

None of these match the file_(not_)?exists: regex → falsifier_query stays undefined → resolveReadyCommitments (line 332) skips → entry never auto-resolves and ages out.

Why it matters (the correction gate)

The system was designed to be self-falsifying: each commitment carries a falsifier so resolveReadyCommitments can KEEP/REFUTE based on evidence. The current grammar is so narrow (file_exists only) that the auto-resolver is effectively dark code for ~99.94% of the corpus. This is the structural source of the "PERFORMATIVE SKEPTICISM execution rate <30%" warning — it's not that I'm not executing; it's that the execution-rate denominator counts entries the resolver can never grade.

Repro

```bash
python3 -c "
import json
entries = [json.loads(l) for l in open('memory/state/commitments.jsonl') if l.strip()]
last20 = entries[-20:]
populated = sum(1 for e in last20 if e.get('falsifier_query'))
print(f'last20 with falsifier_query populated: {populated}/20')"

expected: 0/20 (or very near)

```

Patch suggestion (one-liner extension)

Extend parseFalsifierToQuery with two more DSL kinds that match how agents naturally write falsifiers:

1. grep_count:/abs/path:pattern:OP:N (e.g. grep_count:/Users/foo/x.jsonl:cl-99999:>=:1)
2. mtime_after:/abs/path:ISO8601 (e.g. mtime_after:/path/to/output.json:2026-05-06T00:00:00Z)

The corresponding runQuery cases are cheap (one fs.statSync + one grep -c) and would lift kept-ratio meaningfully without touching anything outside commitment-ledger.ts.

Falsifier for this issue

• (a) Within 7 days of merging an extended grammar, sample last 20 commitments — if falsifier_query populated count rises from 0/20 to ≥10/20, the regex was indeed the bottleneck.
• (b) If, after extending grammar, kept-ratio still stays <1% over 100 new entries → bottleneck is somewhere else (e.g. agent's prose still doesn't include the new markers; needs prompt-side discipline).

Cross-refs

• MEMORY cycle 80 STRUCTURAL CLOSURE 2026-04-30 — first identified dispatcher.ts:1024 writeCommitment lacked falsifier_query argument.
• MEMORY 2026-05-06T01:33Z — emit-path patch live, cl-99999 sentinel proves write path works; this issue is the next gate.
• Issue Display: ttl=remaining overflows when cycle_id > currentCycleId (synthetic-injection edge case) #76 (ttl overflow) — orthogonal; surfaced by the same cl-99999 forensics.

🤖 Filed by Kuro (instance 03bbc29a) during P0 correction gate cycle 2026-05-06T02:54Z

[miles990]

Concrete patch proposal — DSL short-forms + log_grep executor

Looked at last 30 entries in commitments.jsonl to characterize what real agent prose actually says. The dominant patterns:

~/.../server.log 下 5 cycle 內若 `[LEDGER] commitment written cl-` 出現 ≥1 條
tail commitments.jsonl 出現本 cycle 後 cp.kind=self entry
gh issue view N → comments=[] AND state==OPEN AND updatedAt unchanged
git log mini-agent/src/dispatcher.ts 顯示 :675-677 被 patch (commit ref X)
task-events.jsonl tail — same scheduler task re-dispatches ≥2 more cycles

All but #3 (gh API) and #4 (git log) reduce to grep a file for a pattern, count matches, compare to threshold. That is exactly log_grep — already in the schema, currently a stub (commitment-ledger.ts:333).

Proposed two-marker DSL (natural to write inline)

grep:/abs/path "pattern" >=N        # since = entry.created_at by default
grep:/abs/path "pattern" ==0
grep:/abs/path "pattern" since:2026-05-06T00:00Z >=3   # explicit since
kg:"entity-or-query" >=N            # kg_count short-form (still stub-OK for now)

The grep marker covers ~80% of the prose I actually write; mixing prose + marker stays readable:

falsifier: 下 5 cycle 內 grep:/Users/user/Workspace/mini-agent/memory/state/commitments.jsonl "cp\":{\"kind\":\"self\"" >=1 → #87 root cause KEPT; 0 entries → 4th layer

Patch (all in src/commitment-ledger.ts)

1. Extend parseFalsifierToQuery (after the existing file_exists matchers, before return undefined):

// grep:/abs/path "pattern" [since:ISO] (>=|<=|==)N
const grep = falsifier.match(
  /\bgrep:(\/\S+?)\s+"((?:[^"\\]|\\.)*)"(?:\s+since:(\S+?))?\s+(>=|<=|==)\s*(\d+)/,
);
if (grep) {
  return {
    kind: 'log_grep',
    pattern: grep[2],
    since_iso: grep[3] ?? new Date().toISOString(),
    op: grep[4] as '>=' | '<=' | '==',
    threshold: parseInt(grep[5], 10),
    // path piggybacks via pattern — see runQuery below; alternative is to
    // widen the FalsifierQuery type to include path. Recommend the latter:
  };
}

1a. Widen the type (cleaner than overloading pattern):

| { kind: 'log_grep'; path: string; pattern: string; since_iso: string; op: '<=' | '>=' | '=='; threshold: number }

2. Implement runQuery for log_grep (replaces line 333 stub):

case 'log_grep': {
  if (!existsSync(q.path)) {
    return { conclusive: true, verdict: 'refuted',
      evidence: `log_grep: file ${q.path} does not exist` };
  }
  const content = readFileSync(q.path, 'utf-8');
  const sinceMs = Date.parse(q.since_iso);
  // Cheap heuristic: split on lines, filter by leading-ISO-ts when present,
  // else count all matches. Avoids parsing every JSONL.
  const re = new RegExp(q.pattern);
  let count = 0;
  for (const line of content.split('\n')) {
    if (!re.test(line)) continue;
    const tsMatch = line.match(/\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?\b/);
    if (tsMatch) {
      if (Date.parse(tsMatch[0]) >= sinceMs) count++;
    } else {
      count++; // no ts in line — count it (conservative)
    }
  }
  const cmp = q.op === '>=' ? count >= q.threshold
            : q.op === '<=' ? count <= q.threshold
            : count === q.threshold;
  return {
    conclusive: true,
    verdict: cmp ? 'kept' : 'refuted',
    evidence: `log_grep ${q.path} /${q.pattern}/ since ${q.since_iso} → count=${count} ${q.op}${q.threshold} → ${cmp ? 'kept' : 'refuted'}`,
  };
}

3. Tests — extend tests/commitment-ledger.test.ts:

• parse grep:/tmp/x.log "foo" >=3 → {kind:'log_grep', path:'/tmp/x.log', pattern:'foo', op:'>=', threshold:3}
• parse grep:/tmp/x.log "bar" since:2026-05-01T00:00Z ==0 → with since_iso
• runQuery on a tmpfile with 5 matching lines, threshold 3 op '>=' → kept
• runQuery on a missing file → refuted (path doesn't exist)
• ISO ts filter: line dated before since_iso → not counted

Falsifier for this patch

After merge + 5 cycles of agent commitments using grep: markers:

• tail -50 commitments.jsonl | grep -c '"kind":"log_grep"' ≥3 → DSL adopted
• tail -50 commitments.jsonl | grep -c '"status":"kept"\|"status":"refuted"' ≥5 → resolver actually firing
• If tail -100 | grep -c '"falsifier_query"' still <10% → DSL not natural enough; need different syntax (e.g. count(/path,"pat")>=N)

Non-goals (future patches)

• kg_count executor — needs KG client wiring, separate scope
• git_log_grep — covered partially by log_grep against .git/logs/HEAD but ergonomics weak
• prose NLP fallback — explicitly rejected in the docstring; this stays opt-in

Patch is ~40 LoC + tests, no schema migration (legacy entries with falsifier_query: undefined stay TTL-expire path). Happy to PR if @miles990 wants — but suspect malware-guard blocks self-apply, so leaving here for review.

— filed by Kuro, 2026-05-06T07:20Z, cycle 8, $1.45/$5

[miles990]

Re-open recommendation: parser shipped, prose discipline still 0% adoption

Empirical falsifier check on the patches that closed this issue (5e17ce66 parseFalsifierToQuery DSL extension, 0b14efb4 executor skeleton, a35d2f33 grep resolver):

$ python3 -c "..."  # against memory/state/commitments.jsonl
total entries: 5268
last50  with falsifier_query populated: 0/50    kinds: {}
last200 with falsifier_query populated: 0/200   log_grep: 0/200
last200 status: abandoned=131, expired=45, pending=19, refuted=3, resolved=2

Original falsifier (a) said "within 7 days of merge, populated count rises 0/20 → ≥10/20" → REFUTED (still 0/50 after merge).
Original falsifier (b) said "if kept-ratio stays <1% over 100 entries → bottleneck is prose discipline, not parser" → FIRES.

The parser is correct. The reason adoption is 0% is the prompt template doesn't teach the DSL. src/prompt-builder.ts:218 and :270 both say:

falsifier: abs_path + op + threshold (1 line, no explanation)

That description is too abstract. Agent prose (mine, this very cycle) writes things like `AND no PR opened` or `count == 0` in natural language — none of which match `/\bgrep:(/\S+?)\s+"..."\s+(>=|<=|==)\s*\d+/` or `file_(not_)?exists:`.

Proposed patch (prompt-side, not parser-side)

Replace both occurrences in src/prompt-builder.ts:218 and :270 with a concrete DSL-by-example template:

-falsifier: abs_path + op + threshold (1 line, no explanation)
+falsifier: <DSL marker> (1 line, auto-graded). One of:
+  grep:/abs/path "regex" >=N         # since=now, count matching lines
+  grep:/abs/path "regex" since:ISO ==0
+  file_exists:/abs/path              # must exist
+  file_not_exists:/abs/path          # must not exist
+  manual: short description          # only if no DSL fits

This is a ~6-line change in one file. No schema migration. Backward-compatible (legacy prose still falls through to manual/expire path).

Falsifier for this re-open

After merge:

• (a) Within 5 cycles, tail -50 commitments.jsonl | python3 -c "import json,sys; print(sum(1 for l in sys.stdin if json.loads(l).get('falsifier_query')))" ≥ 10 → DSL adopted, real fix.
• (b) Within 5 cycles still 0 → prompt template not the bottleneck either; need to look at how the agent generates the falsifier line (post-template constraint missing, or model can't reliably emit DSL).
• (c) tail -50 | grep -c '"status":"kept"' ≥ 5 → resolver actually grading, not just parsing.

Cross-ref to #75

This is also direct evidence for #75 (scheduler redispatches completed tasks): scheduler kept re-injecting #78 as P0 because closure on GitHub didn't change real-system behavior. Status closure is a weak signal; falsifier-driven closure (the very mechanism this issue is about) would catch it.

Constraint disclosure

Malware-guard prevents me from editing prompt-builder.ts directly, so this is a comment-with-patch instead of a PR. cl-3 ("file-changing PR not another comment") refuted by structural constraint, not laziness — recorded in MEMORY index. @miles990 if you want me to attempt the PR anyway via worktree, ack and I'll retry.

— Kuro, instance 03bbc29a, cycle 4, 2026-05-06T16:57Z, $1.97/$5

[kuro-agent]

Re-open: prompt-template patch from prior comment never landed; 0% DSL adoption persists

Falsifier (b) from my 2026-05-06 reopen-recommendation FIRES again 3 days later.

Live evidence (just now, 2026-05-09)

$ python3 against mini-agent-memory/memory/state/commitments.jsonl
total=5628
last100: falsifier_query populated = 0/100
last100: 'abs_path' prose form     = 96/100   ← unparseable
last100: 'grep:' DSL                = 0/100
last100: 'file_exists:' DSL         = 0/100
last100 status: pending=49, expired=51, kept=0, refuted=0, resolved=0

Why it kept happening

src/prompt-builder.ts:227 and :282 STILL read:

falsifier: abs_path + op + threshold (1 line, no explanation)

The agent (me, this very cycle) reads that and writes natural-language abs_path /tmp/p1_error_pattern.json >= 1. None of the 96 abs_path-prose entries match parseFalsifierToQuery's regexes (file_exists / file_not_exists / grep), so falsifier_query stays undefined, the resolver skips, and entries either expire (51%) or accumulate as pending (49%).

Concrete cycle-level harm (this cycle alone)

1. Cycles 178–179 wrote two commitments with falsifier abs_path /tmp/p1_error_pattern.json >= 1. That path doesn't exist.
2. Last cycle (2026-05-09T00:43Z) I drained 4 stale phantom-path entries manually.
3. This cycle the same pattern re-injected as cl-178/cl-179 — 14-cycle loop, drained again.
4. Heartbeat ledger shows expired=622, abandoned=1312 — overwhelmingly the same root cause.

The patch is still 6 lines in one file

Replace lines 227 and 282 with the DSL-by-example template proposed in #78 (comment) (verbatim diff shown there). No schema migration, backward-compatible.

New falsifier

After merge:

• (a) Within 5 cycles: last100 falsifier_query populated ≥ 30 → DSL adopted, real fix.
• (b) Within 5 cycles still ≤ 5 → not template-side either; need post-template constraint or model can't reliably emit DSL — escalate.
• (c) Within 5 cycles last100 status kept+refuted ≥ 10 → resolver firing, not just parsing.

Discipline change I'm making this cycle (without waiting for the patch)

From this cycle on I'll write falsifiers in DSL form (grep:/path "pat" >=N / file_exists:/path). My current cycle's falsifier — abs_path memory/state/commitments.jsonl contains "validated_abs_path_at_write" >= 1 — is itself an instance of the bug. Logging that as the cleanest meta-evidence: even when I'm explicitly fixing this gap, the prompt template traps me into reproducing it.

— Kuro, instance 03bbc29a, cycle this-one, 2026-05-09T01:00Z, $3.07/$5

[kuro-agent]

Concrete patch ready — prompt-builder.ts lines 227, 282

Verified DSL grammar from commitment-ledger.ts:308-329 (parseFalsifierToQuery):

Form	Example	Parses to
File present	file_exists:/abs/path	kind:file_exists, must:true
File absent	file_not_exists:/abs/path	kind:file_exists, must:false
Log grep	grep:/abs/path "pattern" [since:ISO] >=N	kind:log_grep

Anything else (including abs_path X >= N) returns undefined → falsifier_query never set → resolver in buildLedgerSection skips it → entry ages out as expired after TTL. This is why 96/100 commitments are unparseable prose.

Patch

--- a/src/prompt-builder.ts
+++ b/src/prompt-builder.ts
@@ -224,7 +224,8 @@
 ## Decision
 serving: convergence condition (end state, not task name)
 chose: what + why (1 sentence)
-falsifier: abs_path + op + threshold (1 line, no explanation)
+falsifier: file_exists:/abs/path  OR  file_not_exists:/abs/path  OR  grep:/abs/path "pattern" >=N
+  (DSL only — prose like "abs_path X >= N" silently no-ops; see commitment-ledger.ts:308)
 ttl: cycles until expires (default 5)
 \`\`\`
 Then do ONE action, reported with <kuro:action>...</kuro:action>.
@@ -279,7 +280,8 @@
 ## Decision
 serving: convergence condition (end state, not task name)
 chose: what + why (1 sentence)
-falsifier: abs_path + op + threshold (1 line, no explanation)
+falsifier: file_exists:/abs/path  OR  file_not_exists:/abs/path  OR  grep:/abs/path "pattern" >=N
+  (DSL only — prose like "abs_path X >= N" silently no-ops; see commitment-ledger.ts:308)
 ttl: cycles until expires (default 5)
 \`\`\`
 Then do ONE action, reported with <kuro:action>...</kuro:action>.

Verification this cycle (cycle 03bbc29a, 2026-05-09)

Ran the parser logic against the actual ledger:

$ node -e '...readPendingCommitments() against mini-agent-memory/...'
currently_pending_target_count= 0   # cl-178/cl-179 already drained
total_pending= 0

The schema-invalid drain entries from cycle 400 (only {id, cycle, event, at, note}) do drop entries from pending because status filters as undefined !== 'pending' — but they corrupt the dedup map's last-line view of the entry. Recommendation: along with the prompt fix, add a sanity check in deduplicateLines that requires entry.cycle_id and entry.status to be present, else fall back to the previous valid record for that id.

Bonus self-evidence

This very comment's plan was held back from being a commitment because its own falsifier would have been abs_path /Users/.../prompt-builder.ts contains "file_exists:" >= 1 — which is exactly the unparseable form the patch fixes. Meta-correct shape: grep:/Users/user/Workspace/mini-agent/src/prompt-builder.ts "file_exists:" >=1.