@event4u/agent-config 14.1.0 → 14.4.0

package/agents/templates/.ai-council.yml.example

@@ -207,6 +207,23 @@ cli_call_budget:
   # Warn once usage crosses this fraction of a cap (0..1).
   warn_at: 0.8
 
+# Mid-flight cli -> api fallback. When a CLI call fails partway through a
+# pass, the seat can retry once on that provider's metered api rung instead
+# of being lost. The classes where the CLI provably never reached the
+# provider (missing binary, rejected auth, unsupported CLI, unservable
+# model) fall through unconditionally; a timeout or a 5xx NEVER does, under
+# any setting, because a half-completed call must not be paid for twice.
+#
+# `api_on_quota` is the one BILLING-CLASS decision in that design, which is
+# why it is a key and not a rule. Both quota shapes are safe to retry — the
+# local `cli_call_budget` cap refuses before anything is sent, and a
+# provider plan quota is rejected at the request boundary — so the question
+# is not double spend, it is that an unmetered subscription call becomes a
+# USD one. Off by default; the retry still passes the `cost_budget` gates
+# above. Turn it on if you would rather keep the seat than keep the $0.
+fallback:
+  api_on_quota: false
+
 # Quorum for a council pass to CONCLUDE (road-to-always-on-orchestration
 # Phase 3.3). Default "majority" resolves to ceil(n / 2) enabled members —
 # a SIMPLE majority, deliberately not "more than half": at n=2 that is
@@ -499,6 +516,23 @@ necessity_classifier:
 #
 # See docs/contracts/ai-council-config.md for the trigger lists and the
 # Iron-Law clause.
+# `second_model` — the OPTIONAL local rung between the agent and the
+# council (UOTL Phase 4.1). It exists because the council used to be the
+# only rung before a halt: a medium-impact question stopped the run
+# whenever no council was configured or its quota was gone.
+#
+# Name a provider whose LOCAL CLI runs under subscription auth —
+# anthropic, openai or gemini. That set is narrower than the five
+# providers `members:` accepts, on purpose: xai and perplexity ship
+# community CLI wrappers that consume an API key, so routing a
+# resolution there would spend USD on the rung whose whole point is not
+# to. The rung MUST book against the same `cli_call_budget` counter above
+# — one subscription, one counter. That is an obligation on the rung, not
+# a guard that already exists: nothing reads this key at runtime yet, so
+# setting it declares intent rather than activating a bounded mechanism.
+#
+# The key is REFUSED on high_impact and user_required, not ignored. Those
+# classes reach you, and a silently-dropped key would read as configured.
 decision_resolution:
   enabled: true
   classes:
@@ -511,6 +545,7 @@ decision_resolution:
     medium_impact:
       mode: council
       confidence_threshold: 0.6
+      # second_model: gemini   # uncomment to add the local rung
     high_impact:
       mode: user            # LOCKED — Iron Law
       confidence_threshold: 0.6

package/dist/agent-src/contexts/execution/roadmap-process-loop.md

@@ -277,11 +277,39 @@ For each open step in the working set (scope-bound — see wrapper):
      summary named the members). `high_impact` / `user_required`
      classifications still escalate to the user per
      [`ask-when-uncertain`](../../rules/ask-when-uncertain.md).
+   - **Second-model rung, when the class declares one**
+     (`decision_resolution.classes.<cls>.second_model`, UOTL Phase 4.1)
+     → one local vendor-CLI pass under subscription auth. **The rung is
+     MODEL-CARRIED: the key is declared and schema-validated, and no
+     TypeScript path reads it at runtime** — so "bounded by the
+     `cli_call_budget` counter" is what the rung must respect, never
+     something a booking consumer enforces (`cli_call_budget.ts` declares
+     its consumer set closed at two, and this is not one of them). Stated
+     rather than implied after R2 round 4 finding 4 found the coupling
+     asserted on three surfaces at once. Available
+     to `trivial` / `low_impact` / `medium_impact` only; the config
+     schema REFUSES the key on `high_impact` and `user_required`, so no
+     locked question can reach it.
    - **Council off / not configured** → halt, surface once, wait.
      Resume on next turn. An execution contract cannot enable a
      council that has no configured members — the contract summary
      says so upfront, and in-run ambiguity halts (never silent
      guessing).
+   - **No self-adversarial fallback.** With neither a council nor a
+     second-model rung available, the ambiguity halt STANDS. The gap is
+     never filled by the agent arguing both sides of the question to
+     itself: a monologue produces a verdict with no independent
+     observer, which is the failure
+     [`evaluator-independence`](../../rules/evaluator-independence.md)
+     exists over, and reads as convergence to whoever finds it later.
+     Halting costs one turn; a manufactured verdict costs the trust in
+     every other verdict the run produced.
+   - **A resolution taken WITHOUT contacting the user is recorded** —
+     `agent-config decision:memo write --run <id> …` (question, chosen
+     option, reasoning, resolver, confidence). The run's PR description
+     links the directory. Not a gate: the memo is what makes an
+     autonomous resolution reviewable after the fact, which is the
+     condition under which it is legitimate at all.
 5. **Atomic flip — same reply, every step.**
    Flip the checkbox in `agents/roadmaps/<file>.md`: `[x]` done ·
    `[~]` partial · `[-]` skipped. **Non-skippable, non-batchable**
@@ -345,20 +373,56 @@ For each open step in the working set (scope-bound — see wrapper):
    file is the source of truth between regens.
 7. Run quality pipeline if cadence is `per_step`.
 
+### 5d. Resuming a run whose previous session died
+
+A session above the recycle threshold and inside a running contract leaves a
+**deterministic checkpoint** at
+`agents/runtime/state/checkpoints/<run>.json` — open / done / parked counts,
+the next open step, and the commit the tree was on. Every field is recomputed
+from the roadmap on disk rather than summarised, which is what makes the next
+line possible.
+
+```
+A RESUMED RUN RE-VERIFIES THE CHECKPOINT BEFORE ACTING ON IT.
+RESUME BY EVIDENCE, NEVER BY BOOKKEEPING.
+```
+
+The first act of a resumed run is to look its checkpoint up **by roadmap slug**
+— `latestCheckpointFor(repoRoot, slug)` — and then `verifyCheckpoint` it against
+the current tree. The slug, not the run id: a relaunched session has a NEW
+session id, so the run-id-keyed `readCheckpoint` cannot find the checkpoint the
+DYING session wrote, and this instruction named an unreachable path until the
+R2 review's finding 7. The slug is the one key a resumed run holds by
+definition, because claiming the same roadmap is what makes it a resume.
+
+The per-field report then names WHICH claim went stale, which is what a bare
+"stale/fresh" verdict cannot. **A disagreement is not an error**: work landing
+between the checkpoint and the resume is the normal case (a human committed, a
+sibling worktree moved, the dying session finished a step it never recorded),
+and the `actual` column is what to resume from. Treating progress as corruption
+would refuse every healthy resume.
+
+`agent-config run:supervise --once` reports which runs died with open steps
+left. It never merges, pushes, or closes anything — that boundary is a named
+rejection, not a missing feature.
+
 ### Halt conditions
 
 - Hard-Floor trigger ([`non-destructive-by-default`](../../rules/non-destructive-by-default.md))
 - Security-sensitive path ([`security-sensitive-stop`](../../rules/security-sensitive-stop.md))
 - Step reveals work outside the roadmap's scope
 - Test failure or quality red on `per_step`
-- Council off + true ambiguity — under an **accepted execution
-  contract** ([§ 3](#3-pre-scan--execution-contract-or-commit-step-ask))
-  this halt exists only when no council is configured: the contract
-  auto-enables council for the run, so in-run open questions resolve
-  silently (`high_impact` / `user_required` classifications still
-  escalate per [`ask-when-uncertain`](../../rules/ask-when-uncertain.md));
-  with no council configured, true ambiguity halts — never silent
-  guessing.
+- Council off, no second-model rung, and true ambiguity — under an
+  **accepted execution contract**
+  ([§ 3](#3-pre-scan--execution-contract-or-commit-step-ask)) this halt
+  exists only when neither rung is available: the contract auto-enables
+  council for the run, so in-run open questions resolve silently
+  (`high_impact` / `user_required` classifications still escalate per
+  [`ask-when-uncertain`](../../rules/ask-when-uncertain.md)); with a
+  class-declared `second_model` the local rung runs first. With neither,
+  true ambiguity halts — never silent guessing, and never a
+  self-adversarial monologue in place of the missing observer (the
+  open-question handling in § 5 states that rung by rung).
 
 An accepted execution contract **never lifts a Hard Floor** or any of
 the other halts above — it removes redundant *asks* (git shape,
@@ -438,10 +502,17 @@ The loop MUST:
    five choices: follow-up (draft), follow-up (ready + blocked),
    keep-in-archive (intentional drop), restore to `[ ]`, convert
    to `[-]` cancelled.
-3. Wait for the user. The autonomous mandate (`/work`,
-   `/roadmap:process-full`, "decide for me") does **not** lift this
-   gate — Iron Law 3 calls it "the canonical lost-information failure
-   mode this rule exists to prevent."
+3. **Route by the preservation test**, per
+   [`roadmap-progress-sync § Who resolves it`](../../rules/roadmap-progress-sync.md):
+   a disposition that keeps the criterion ALIVE in the active estate
+   (fix now · carry item + blocker into a follow-up created in the SAME
+   change · merge into existing active work · restore to `[ ]`) may be
+   resolved by the council, recorded at the item. A disposition that
+   drops, weakens or permanently accepts the loss of it — cancel to
+   `[-]`, keep-in-archive, scope cut — reaches the **user**, and the
+   autonomous mandate (`/work`, `/roadmap:process-full`, "decide for
+   me") does **not** lift that half. In doubt: user. A council verdict
+   naming a follow-up that does not exist yet fails closed to the user.
 4. On picks 1 / 2 → run the "Spawn follow-up from deferred items"
    procedure in [`roadmap-management`](../../skills/roadmap-management/SKILL.md).
    On picks 3 / 4 / 5 → apply the change, re-evaluate the decision

package/dist/agent-src/rules/roadmap-progress-sync.md

@@ -46,12 +46,56 @@ IS A RULE VIOLATION, NOT AN OVERSIGHT.
 
 ```
 A ROADMAP WITH `[~]` DEFERRED ITEMS NEVER AUTO-ARCHIVES SILENTLY.
-SURFACE EVERY DEFERRED STEP. ASK THE USER WHAT HAPPENS TO THE PLAN.
+SURFACE EVERY DEFERRED STEP. RESOLVE IT — VIA THE COUNCIL WHERE THE
+DISPOSITION PRESERVES THE ITEM, VIA THE USER WHERE IT DOES NOT.
 A SILENT ARCHIVE THAT BURIES PLANNED-FOR-LATER WORK
 IS A RULE VIOLATION, NOT A CONVENIENCE.
 ```
 
-Closure check fires (`count_open == 0` and `count_deferred > 0`) → enumerate every `[~]` step, present the numbered-options resolution menu (per [`user-interaction`](user-interaction.md)), and only after the user resolves the deferrals does the `git mv` to `archive/` run. Full option menu + migration mechanics: guideline + [`roadmap-management`](../skills/roadmap-management/SKILL.md).
+Closure check fires (`count_open == 0` and `count_deferred > 0`) → enumerate every `[~]` step, present the numbered-options resolution menu (per [`user-interaction`](user-interaction.md)), and only after the deferrals are resolved does the `git mv` to `archive/` run. Full option menu + migration mechanics: guideline + [`roadmap-management`](../skills/roadmap-management/SKILL.md).
+
+### Who resolves it — the preservation test
+
+```
+THE COUNCIL MAY RESOLVE A `[~]` ONLY WHERE THE CHOSEN DISPOSITION KEEPS THE
+ITEM ALIVE IN THE ACTIVE ESTATE. ANYTHING THAT DROPS, WEAKENS, OR PERMANENTLY
+ACCEPTS THE LOSS OF IT REACHES THE USER — ALWAYS, AND NO MANDATE LIFTS THAT.
+IN DOUBT, IT IS A USER DECISION. THE COUNCIL ADVISES ON HOW AND WHEN;
+THE OWNER DECIDES WHETHER.
+```
+
+One question decides the route, and it is answerable from the option itself
+rather than from judgement: **does this disposition keep the criterion active
+in the estate?**
+
+| Disposition | Route |
+|---|---|
+| Fix the blocker now, in this change or its own PR | council |
+| Carry item **and** blocker into a named follow-up roadmap created in the SAME change and estate-ratchet compliant | council |
+| Merge the item into existing active work that already covers it | council |
+| Restore to `[ ]` in this roadmap | council |
+| Convert to `[-]` cancelled | **user** |
+| Weaken the criterion, cut its scope, or accept the breakage permanently | **user** |
+| Keep-in-archive (an intentional drop) | **user** |
+| The item carries a `high_impact` / `user_required` classification | **user** |
+
+- **"Immediately active" is not a promise.** A follow-up counts only if created
+  in the same change and estate-ratchet compliant. A verdict naming a roadmap
+  that does not exist yet **fails closed to the user**.
+- **Recorded, or it did not happen.** At the item: criterion verbatim ·
+  blocker id · every option · verdict + one-sentence rationale · dissent ·
+  destination when carried · what closes it. A verdict with no record is a
+  silent drop wearing a procedure.
+- **The residual hole, stated not papered over.** Both authoring seats named
+  it in their own strongest counter: a carried follow-up can still become an
+  indefinite deferral, so this test bounds *who decides*, not *whether the work
+  happens*. Only fix-now discharges it. A carried item untouched at the next
+  task boundary is raised again per [`active-remediation`](active-remediation.md).
+- **Why it changed.** Adopted 2026-08-19, unanimous 2/2 council (blind peer
+  review). The prior text — *"Wait for the user"* — handed back a fully
+  analysed choice with four costed options, the low-value interruption
+  [`no-cheap-questions`](no-cheap-questions.md) forbids. The gate protects the
+  item, not the maintainer's attention.
 
 ## Later disposition — blocked-for-later roadmaps are parked, never left active
 
@@ -95,9 +139,9 @@ Before sending any reply that landed roadmap work:
 4. Did `count_open` reach 0?
    - **No (real open work remains)** → continue normally.
    - **Yes + `count_deferred == 0`** → the roadmap is **complete**. Archive it — `git mv` to `archive/` + migrate inbound refs + regen, same reply — or let the next `/create-pr` § 1c sweep do it deterministically. Either way it must never be pushed to the trunk unarchived (§ PR-gate; the `--check` backstop enforces it).
-   - **Yes + `count_deferred > 0`** → STOP. Run the Iron Law 3 deferred-resolution flow (surface items + numbered options + wait). Archive only after resolution.
+   - **Yes + `count_deferred > 0`** → STOP. Run the Iron Law 3 deferred-resolution flow: surface every item, apply the preservation test above, and resolve — council where the disposition keeps the item alive, user where it does not. Archive only after resolution, and only with the resolution recorded at the item.
 
-Any "no" at step 2 → reply is incomplete. Do not send. A skipped step 3 regen is fine when cadence permits — checkbox truth lives in the markdown file. Skipping the deferred-resolution gate at step 4 is **never** acceptable; it is the canonical "lost-information" failure mode this rule exists to prevent.
+Any "no" at step 2 → reply is incomplete. Do not send. A skipped step 3 regen is fine when cadence permits — checkbox truth lives in the markdown file. Skipping the deferred-resolution gate at step 4 is **never** acceptable; it is the canonical "lost-information" failure mode this rule exists to prevent. Note what the council path does and does not change here: it changes WHO resolves a preserving disposition, never whether the gate runs, never whether the resolution is recorded, and never the user's ownership of a drop.
 
 Body migrated to `guideline:agent-infra/roadmap-progress-mechanics` (per P4 of `road-to-kernel-and-router.md`) — glyph semantics, regen cadence, deferred-resolution menu, later-disposition procedure, PR-gate prose, plus the long-form failure-mode catalog, Copilot fallback, and hook + CI defence-in-depth.
 Trigger-set above activates this routing on demand, independent of the discipline profile (ADR-110).

package/dist/agent-src/scripts/resume_probe.ts

@@ -16,14 +16,19 @@
  *
  * ## What it can and cannot decide, stated plainly
  *
- * A resume condition is prose. Two shapes are machine-decidable and the rest
- * are not, so the verdict set has three values rather than two:
+ * A resume condition is prose. TWO shapes are machine-decidable — a roadmap
+ * reference, and a single repo-relative file path under an existence predicate
+ * — and the rest are not, so the verdict set has three values rather than two:
  *
  *   - `fired`       — every roadmap the condition names has archived, or the
- *                     named step in a still-active roadmap is ticked.
+ *                     named step in a still-active roadmap is ticked; or the
+ *                     single path it names under `exists` is there.
  *   - `unmet`       — at least one named roadmap is still active with the
- *                     named step (or the whole file) still open.
- *   - `undecidable` — the condition names no roadmap this tree can resolve.
+ *                     named step (or the whole file) still open; or the single
+ *                     path it names under `exists` is absent.
+ *   - `undecidable` — the condition names neither, names both (a conjunction
+ *                     this probe can only half-weigh), names two of either, or
+ *                     states a predicate other than existence over its path.
  *
  * `undecidable` is reported as its own count and never folded into "nothing
  * fired". A probe that reads 44 files, understands 12 of them and announces
@@ -84,6 +89,31 @@ const COMPOUND_RE = /\bboth\b|\band\b|\([1-9]\)|\([a-e]\)|`[ \t]*\+|\+[ \t]*`/i;
 const FIELD_LABEL_RE = /\*\*[^*]+:\*\*/;
 /** A roadmap slug as written in prose, with or without the `.md` suffix. */
 const ROADMAP_REF_RE = /\broad-to-[a-z0-9][a-z0-9-]*\b/g;
+
+/**
+ * A repo-relative path named inside backticks — the second decidable form.
+ *
+ * `PARK-PROBEABLE` (`road-to-estate-drawdown` Phase 2) means the resume
+ * condition can be tested by a script, and until this existed the probe could
+ * decide exactly one phrasing: a roadmap slug. Measured 2026-08-19 on the live
+ * estate, 42 of 44 park notes were `undecidable`, and the batch-1 sweep could
+ * only add six more — a verdict whose name promised a probe that did not read
+ * the conditions it was producing.
+ *
+ * Deliberately narrow in three ways, because a false FIRED un-parks live work:
+ * the path must be **inside backticks** (prose that merely contains a slash is
+ * not a condition), it must start at a **known top-level repo directory** and
+ * end in a **file extension**, and the clause must name **exactly one** — two
+ * paths are a conjunction this function cannot weigh, and `COMPOUND_RE` does
+ * not catch a comma.
+ *
+ * The extension requirement is what keeps a *directory* out. `agents/evidence/`
+ * exists in every checkout, so "recorded under `agents/evidence/`" is not a
+ * condition a probe can decide — and since `_exists` tests `isFile()`, matching
+ * it would have reported "does not exist" about a directory that does. A
+ * directory-shaped condition stays `undecidable`, which is the honest verdict.
+ */
+const REPO_PATH_RE = /`((?:agents|docs|src|tests|internal|scripts|evals|\.github)\/[A-Za-z0-9._\-/]*[A-Za-z0-9_\-]\.[A-Za-z0-9]{2,5})`/g;
 /**
  * A step reference: `P2.1`, `Phase 2.1`, or a bare `2.1`.
  *
@@ -231,6 +261,37 @@ function _blankFencedCode(text: string): string {
     );
 }
 
+/**
+ * The head of `s` up to its first sentence terminator OUTSIDE backticks.
+ *
+ * A naive character-class scan that stops at any dot cuts inside `foo.md` or
+ * inside a step id like `3.3`, which truncates the clause mid-span and hides
+ * the very path or step the condition names. Measured 2026-08-19: three of the six park notes written by
+ * `road-to-estate-drawdown` Phase 2 batch 1 lost their backticked path this
+ * way, and the probe then reported "names no roadmap this tree can resolve"
+ * about a condition that named a file.
+ */
+function _sentenceHead(s: string): string {
+    // An ODD backtick count means the span never closes, and toggling on it
+    // would leave `inCode` stuck true for the whole remainder — the commentary
+    // paragraph then becomes the clause, and a path mentioned only in that
+    // commentary could decide the verdict. Fall back to the plain scan, which
+    // cuts at the first terminator and is the conservative direction.
+    const balanced = (s.match(/`/g) ?? []).length % 2 === 0;
+    let inCode = false;
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i] as string;
+        if (ch === '`' && balanced) {
+            inCode = !inCode;
+            continue;
+        }
+        if (!inCode && (ch === '.' || ch === '—' || ch === '–')) {
+            return s.slice(0, i);
+        }
+    }
+    return s;
+}
+
 /**
  * The condition CLAUSE inside the condition text.
  *
@@ -260,13 +321,63 @@ function conditionClause(condition: string): string {
             // (`**Resume when** that pruning lands`), so take the span plus the
             // remainder of its sentence — up to an em dash or a full stop.
             const after = condition.slice(m.index + m[0].length);
-            const tail = /^[^—–.]*/.exec(after)?.[0] ?? '';
-            return `${span}${tail}`;
+            return `${span}${_sentenceHead(after)}`;
         }
     }
     return condition;
 }
 
+/**
+ * The clause's predicate is EXISTENCE, not some property of the file's content.
+ *
+ * Without this the path branch would answer a question the condition did not
+ * ask. Measured 2026-08-19 while writing it: `road-to-catalogue-host-fit` waits
+ * until `agents/evidence/metrics/skill-catalogue.jsonl` *holds at least 20
+ * observations*; the file exists today with 7 lines, so an existence test would
+ * have reported FIRED and un-parked a roadmap whose bar is 13 observations away.
+ * A content bar is decidable — by `capture_skill_catalogue --cadence` — but not
+ * by this probe, and `undecidable` is the honest verdict for it.
+ *
+ * The predicate is bound POSITIONALLY to the path rather than tested as a word
+ * anywhere in the clause, because word-presence is not a predicate: `\`x.md\` no
+ * longer exists` would have reported FIRED while the file was still there, and
+ * `blocked until a workaround exists, see \`docs/x.md\`` would have paired the
+ * word with a path it does not govern. Both shapes are regression tests.
+ *
+ * KNOWN LIMIT, stated rather than papered over: this probe reads the condition
+ * AFTER `_truncateAtNextField`, so a content bar an author moves into a sibling
+ * bolded field is invisible to it and the note decides as bare existence. That
+ * is an authoring bypass no check here can see — the guard is that a resume
+ * condition states its whole bar inside the condition, and it is model-carried.
+ */
+const EXISTENCE_PREDICATE_RE = /`(?:agents|docs|src|tests|internal|scripts|evals|\.github)\/[A-Za-z0-9._\-/]+`[ \t]*(?:currently[ \t]+)?exists\b/i;
+
+/**
+ * The single repo-relative path a condition names, or `null`.
+ *
+ * `null` for zero paths (nothing to test) and for two or more (a conjunction
+ * this probe cannot weigh — reporting FIRED on the first would be the
+ * partial-match resume the compound guard already refuses).
+ */
+function referencedPath(condition: string): string | null {
+    if (!EXISTENCE_PREDICATE_RE.test(condition)) {
+        return null;
+    }
+    const paths = _pathsIn(condition);
+    return paths.length === 1 ? (paths[0] as string) : null;
+}
+
+/** Every distinct repo-relative file path a clause names, predicate or not. */
+function _pathsIn(condition: string): string[] {
+    REPO_PATH_RE.lastIndex = 0;
+    const found = new Set<string>();
+    let m: RegExpExecArray | null;
+    while ((m = REPO_PATH_RE.exec(condition)) !== null) {
+        found.add(m[1] as string);
+    }
+    return [...found].sort();
+}
+
 /** Roadmap slugs named by the condition, minus the parked file's own slug. */
 function referencedRoadmaps(condition: string, ownSlug: string): string[] {
     const out = new Set<string>();
@@ -310,7 +421,10 @@ function stepIsDone(text: string, stepId: string): boolean | null {
  * tree rather than the live estate — a probe whose only test is the live tree
  * stops testing anything the day the live tree changes.
  */
-function probeLater(roadmapRoot: string): ResumeFinding[] {
+function probeLater(roadmapRoot: string, repoRootArg?: string): ResumeFinding[] {
+    // Defaults to the repo that owns `agents/roadmaps/`. Passed explicitly by
+    // the tests, whose fixture tree IS the roadmap root and has no repo above it.
+    const repoRoot = repoRootArg ?? path.resolve(roadmapRoot, '..', '..');
     const laterDir = path.join(roadmapRoot, 'later');
     let entries: string[];
     try {
@@ -353,13 +467,43 @@ function probeLater(roadmapRoot: string): ResumeFinding[] {
             continue;
         }
         const refs = referencedRoadmaps(clause, ownSlug);
+        // A clause naming a roadmap AND a path is a conjunction, and deciding it
+        // on the roadmap half alone is the partial-match resume `COMPOUND_RE`
+        // already refuses for two roadmaps. `COMPOUND_RE` does not close it —
+        // a comma joins the two without an `and`, which is the same hole the
+        // two-paths rule in `referencedPath` exists for. Refused symmetrically.
+        if (refs.length > 0 && _pathsIn(clause).length > 0) {
+            findings.push({
+                file: `later/${name}`,
+                condition,
+                refs,
+                verdict: 'undecidable',
+                why: 'names a roadmap and a repo path — a conjunction the probe can only half-weigh',
+            });
+            continue;
+        }
         if (refs.length === 0) {
+            // Second decidable form: a single repo-relative path. `exists` is
+            // the whole test — the condition says the artefact will appear, so
+            // its appearance IS the firing, and no content check is implied.
+            const rel = referencedPath(clause);
+            if (rel !== null) {
+                const there = _exists(path.join(repoRoot, rel));
+                findings.push({
+                    file: `later/${name}`,
+                    condition,
+                    refs,
+                    verdict: there ? 'fired' : 'unmet',
+                    why: there ? `${rel} exists` : `${rel} does not exist`,
+                });
+                continue;
+            }
             findings.push({
                 file: `later/${name}`,
                 condition,
                 refs,
                 verdict: 'undecidable',
-                why: 'the condition names no roadmap this tree can resolve',
+                why: 'the condition names no roadmap or repo path this tree can resolve',
             });
             continue;
         }
@@ -414,6 +558,7 @@ export {
     conditionClause,
     extractCondition,
     probeLater,
+    referencedPath,
     referencedRoadmaps,
     roadmapDisposition,
     stepIsDone,