leos-agent 6.1.1 → 7.0.0

package/skills/brainstorming/SKILL.md

@@ -7,7 +7,9 @@ description: >
   wide blast radius, hard to reverse, or that introduce new surface need
   genuine, viable alternatives with trade-offs weighed before any code gets
   written. Produces the chosen approach and its trade-offs, sized to the gate,
-  handed off to leo:writing-plans.
+  handed off to leo:writing-plans. Use when choosing an approach before
+  non-trivial code. Do not use for contained reversible tweaks, investigation,
+  or writing the plan itself.
 when_to_use: >
   Before starting non-trivial code: a new feature, a new integration surface,
   a schema or data-model change, anything that's expensive or awkward to

package/skills/debugging/SKILL.md

@@ -5,7 +5,9 @@ description: >
   behavior. Five named phases — Reproduce, Localize, Hypothesize, Prove, Fix —
   each with an exit criterion, so a fix never lands before the cause is
   pinned to file:line. Diagnosis is read-only judge work (investigator); the
-  fix happens separately, at the routed tier.
+  fix happens separately, at the routed tier. Use when a bug, failure, crash,
+  or surprising behavior needs diagnosis. Do not use for planned features,
+  reviewing a diff, or post-fix completion verification.
 when_to_use: >
   Any bug report, failing test, crash, stack trace, or "why does X happen"
   before proposing a fix — used by the investigator agent and by the main
@@ -61,7 +63,7 @@ you, and go again.
 
 After two failures on the same cause (two hypotheses tried and reverted, still
 no Prove), step up one tier rather than retrying at the same one — investigator
-haiku-assist steps to full investigator, investigator itself steps to a
+explore findings feed a full investigator, and investigator itself steps to a
 second, more evidence-fed pass, capped at Opus. A genuine deadlock, or two
 Opus verdicts on the same cause that disagree → `expert`, announced in one
 line ("escalating to expert: <question>") before it's invoked, never silent.

package/skills/delegation/SKILL.md

@@ -4,7 +4,8 @@ description: >
   Operational mechanics for dispatching subagents — a single spawn or a large
   fan-out — the companion to the policy's "Delegate the labor" section.
   Covers brief construction, model/effort pinning, the four-state return
-  contract, and ledger-backed progress tracking for long multi-agent runs.
+  contract, and ledger-backed progress tracking for long multi-agent runs. Use
+  when dispatching any subagent or fan-out. Do not use to choose a task's tier.
 when_to_use: >
   Any time work is routed to a subagent (explore, investigator, executor,
   implementer, reviewer, expert) rather than done inline — single dispatch or
@@ -36,8 +37,8 @@ version needs no follow-up question; the first invites three.
 ## Pin model and effort
 
 Every dispatch pins **model AND effort** from the routing table — opus for
-judges (reviewer, investigator), sonnet for execution (implementer, executor
-on normal work), haiku for mechanical work (executor on boilerplate). expert
+judges (reviewer, investigator), sonnet for normal implementation
+(implementer), haiku for mechanical work (executor). expert
 never appears in a fan-out — one at a time, never fanned. An unpinned call
 silently inherits the session's tier: in an opus session that means every
 executor spawn quietly runs at opus, and a ten-item fan-out burns
@@ -53,7 +54,7 @@ a report that hedges across two of them.
 |---|---|---|
 | `done` | Work finished, matches the brief | Verify against artifacts — see leo:verification — never take the self-report at face value |
 | `concerns` | Finished, but flags something worth a second look | Read the concerns before accepting; they're often the real finding |
-| `needs-context` | Blocked on missing information you can supply | Send the missing piece to the same agent (SendMessage) so it keeps the context it already built; cold re-dispatch only if that agent is gone. Either way **once** — a second needs-context on the same gap means the brief itself is broken, escalate the tier |
+| `needs-context` | Blocked on missing information you can supply | Send the missing piece to the same agent (`SendMessage` on Claude Code, `followup_task` on Codex — elsewhere see the *Follow-up to a live agent* row of your mapping, and where none is established, cold re-dispatch with the context restated is the whole mechanism) so it keeps the context it already built. Either way **once** — a second needs-context on the same gap means the brief itself is broken, escalate the tier |
 | `blocked` | Blocked on something you can't hand over inline | Resolve the blocker, or escalate per the ladder — never a silent same-tier retry |
 
 `needs-context` and `blocked` look similar; the test is whether the missing
@@ -89,10 +90,11 @@ between "agent finished" and "ledger written" is exactly the gap this
 exists to close.
 
 `${CLAUDE_PLUGIN_ROOT}` above is the Claude Code spelling of the plugin root,
-and it is substituted into this text only there. On another harness, read the
-plugin-root form from that harness's appendix in the injected policy (Codex
-uses a real `$PLUGIN_ROOT` env var, Cursor `$CURSOR_PLUGIN_ROOT`) — the path
-after the root is identical everywhere.
+and it is substituted into this text only there. Codex exposes `$PLUGIN_ROOT`
+and Cursor `$CURSOR_PLUGIN_ROOT`. Hermes and OpenCode expose no root variable;
+their injected policy substitutes an absolute payload path into the `state.py`
+and `memory.py` commands, which is the discoverable source to reuse. Do not
+invent an environment variable where the harness exposes none.
 
 For a batch of independent, well-scoped fixes, don't hand-roll this loop —
 the reusable workflow at `${CLAUDE_PLUGIN_ROOT}/workflows/cost-tiered-fix.js`

package/skills/doctor/SKILL.md

@@ -0,0 +1,124 @@
+---
+name: doctor
+description: >
+  Self-check for Leo's own wiring. Reports which harness this is, what each
+  tier name resolves to here, whether the bootstrap is installed, where
+  machine-local state and the memory store live, and which skills shipped
+  versus which this session can actually invoke. Disk facts come from a
+  helper script; the context facts only the running session can answer, and
+  a disagreement between the two columns is the diagnosis. Use when Leo asks
+  about Leo's loading, routing, or skill wiring. Do not use for project health
+  checks, project-code debugging, or unprompted inspection.
+when_to_use: >
+  Leo asks whether the policy loaded, why routing or a skill is misbehaving,
+  or invokes doctor by name after installing, updating, or switching harness.
+  Also the first move when a leo skill cannot be found. NOT a general
+  environment or project health check, NOT for debugging the project's own
+  code (that is leo:debugging), and never run unprompted — it reports on the
+  agent, not on the work.
+---
+
+# doctor
+
+Doctor answers two questions that look like one: what shipped to disk, and what
+reached this session. A skill the harness never registered is indistinguishable
+from a skill that does not exist, right up until the moment you invoke it.
+
+## Run the script
+
+```sh
+python3 "${CLAUDE_PLUGIN_ROOT}/scripts/doctor.py" --harness <name>
+```
+
+Pass `--harness` with the harness you are on — the mapping appendix in your
+context names it in its own heading (`# Hermes mapping` → `hermes`). Detection
+without it relies on a plugin-root variable that Hermes and OpenCode do not
+export, so on those two the script reports `unknown` rather than guessing.
+`unknown` on a harness whose mapping you can plainly read is a missing
+argument, not a fault.
+
+`${CLAUDE_PLUGIN_ROOT}` is the Claude Code spelling. Codex exports
+`$PLUGIN_ROOT` and Cursor `$CURSOR_PLUGIN_ROOT`. On Hermes and OpenCode no
+plugin-root variable exists at all — the injected policy instead substitutes an
+absolute payload path into its `state.py` and `memory.py` commands. Read that
+command path from the policy as the discoverable source. Being unable to locate
+the payload at all is itself the first finding: the harness is not looking where
+the plugin was installed.
+
+Add `--json` when you want the same facts as data.
+
+Doctor validates the bootstrap that actually belongs to the named harness:
+the session hook and manifest for Claude, Codex, and Cursor;
+`config.instructions` in OpenCode's plugin; and Hermes registration plus its
+first-tool-result fallback. It also reports the running Python version against
+the supported 3.9+ floor. Codex hook trust is not provable from disk: review
+the plugin in `/hooks` and confirm it is trusted before treating the on-disk
+hook as active.
+
+## Then answer the three it cannot
+
+A script can prove the hook is installed and that the policy renders. It cannot
+prove the policy arrived. Only you can see your own context.
+
+1. **Did the policy load?** Look for the policy wrapper in your context, and
+   check that the mapping following it names *this* harness. A policy present
+   but carrying another harness's mapping is worse than none, because routing
+   then points at models that do not exist here.
+2. **Which skills are actually invocable?** Compare your own skill list against
+   the script's shipped roster. Mind the naming rule: most harnesses namespace
+   them as `leo:<name>`, while OpenCode has no namespace and requires a
+   skill's frontmatter name to match its directory, so the plugin registers a
+   generated shadow copy with every skill renamed `leo-<name>`. A skill that
+   looks missing on OpenCode may simply be listed as `leo-<name>` rather than
+   `leo:<name>`.
+3. **Is memory present and delivered?** The script reports whether the store
+   exists and whether each native surface received its generated copy. Whether
+   those facts are in front of you right now is something only you can confirm.
+   Report the two separately; they disagree more often than expected. Hermes's
+   projection is opt-in, so doctor reports it explicitly as disabled rather
+   than silently omitting it.
+
+## Reading the report
+
+Every row carries its source — `env`, `disk`, `config`, or `context` — so a
+reader can tell a fact from an inference. Close with one verdict from exactly
+three: **healthy**, **degraded**, or **not loaded**. Never free prose. `not
+loaded` outranks everything else: if the policy did not arrive, nothing else in
+the report describes how this session will actually behave.
+
+**Most breadcrumb logs are history, not a verdict.** Some older logs carry no
+timestamps, and the test suite drives failure paths deliberately, so entries
+can accumulate on a development machine. Quote the newest line if useful, but
+never conclude "the hook failed this session" from history alone. The one
+capability exception is `opencode-skills.log`: its presence means namespaced
+OpenCode skill registration degraded and doctor reports that state until the
+breadcrumb is cleared after the underlying problem is understood.
+
+## Failure modes
+
+| Symptom | Likely cause | Fix |
+|---|---|---|
+| Policy absent, bootstrap installed | the hook fired and failed open | read the newest breadcrumb, then confirm it describes this session before believing it |
+| Policy present, mapping names another harness | detection resolved wrong, usually a stray plugin-root variable exported in an unrelated shell | unset it, restart the session |
+| Harness reported as `unknown` | no `--harness`, and this harness exports no plugin-root variable | degraded until re-run with `--harness <name>` read off your mapping heading; a still-unknown explicit run is invalid wiring |
+| Codex hook is on disk but policy is absent | the new or changed hook may not be trusted | open `/hooks`, review the hook, and explicitly trust it |
+| OpenCode reports `opencode-skills.log` | the namespaced shadow tree failed and no bare-name fallback was registered | inspect the newest breadcrumb, fix the path/permission failure, and restart OpenCode |
+| Shipped roster exceeds what you can invoke | the harness cached an older payload, or the skills directory is not registered | update the plugin; on OpenCode check `opencode debug skill` for each skill's `location` |
+| Skills listed as `leo-<name>` instead of `leo:<name>` | OpenCode, working as designed | invoke them as `leo-<name>`; not a fault |
+| Tier names resolve to models this harness cannot run | mapping and harness disagree | same as row 2 |
+| Machine-local state not writable | the path override points somewhere unwritable | fix or unset it |
+| A skill is genuinely absent from disk | it was never added | see leo:writing-skills |
+
+## Doctor never repairs
+
+It reports, and it names the fix. It does not reinstall, rewrite configuration,
+or delete state — which is what keeps it safe to run at any tier and at any
+moment.
+
+## Works with
+
+- leo:writing-skills — for a skill that turned out to be missing because nobody
+  wrote it yet.
+- leo:memory — doctor reports whether the store exists and reached each surface.
+- leo:verification — this report is a claim like any other: the script ran this
+  turn and its output was read.

package/skills/executing-plans/SKILL.md

@@ -5,7 +5,8 @@ description: >
   with a check at every batch boundary, plan-intent-wins-on-architecture /
   reality-wins-on-mechanics arbitration, and one fix-then-re-review cycle
   before stopping to report. Used by the implementer agent, or the main loop
-  when it executes a plan directly.
+  when it executes a plan directly. Use when a written plan is about to become
+  code. Do not use for open-ended work without a plan or for reviewing a diff.
 when_to_use: >
   A written plan (from planner, an issue, or Leo's own outline) is about to
   be turned into code. NOT for open-ended implementation with no plan

package/skills/finishing-a-branch/SKILL.md

@@ -6,7 +6,9 @@ description: >
   a closed set of next steps — merge / PR / keep / discard — routes the
   chosen path through the right ordering (land the work before removing the
   worktree, remove the worktree before deleting the branch), and leaves the
-  repo clean.
+  repo clean. Use when reviewed implementation on a branch/worktree needs a
+  terminal disposition. Do not use to manage a worktree mid-task or replace
+  the review cycle.
 when_to_use: >
   A branch or worktree has reached "implementation done" and Leo needs to
   decide what happens to it. Fires after execute-then-review completes, or
@@ -71,7 +73,7 @@ Per option:
 | Option | Sequence |
 |---|---|
 | merge | merge locally or `gh pr merge` → remove worktree (`leo:worktrees`) → delete local branch |
-| PR | push branch → open PR → **stop** (worktree and branch stay; nothing is unmerged yet) |
+| PR | push branch → open PR → **stop** (worktree and branch stay; nothing is merged yet.) |
 | keep | do nothing destructive; leave worktree and branch as-is |
 | discard | typed confirmation (below) → remove worktree (`leo:worktrees`) → force-delete branch |
 

package/skills/freshness/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: freshness
+description: >
+  Currency gate for code written against anything outside this repository.
+  Before a library call, CLI flag, endpoint field, or vendor number is
+  committed to, its shape is confirmed against a source that reflects the
+  version this project actually runs — the installed package, the lockfile
+  pin, or documentation fetched this turn. Each check is recorded by symbol
+  and source in the report. Use when writing, reviewing, or asserting a
+  third-party surface. Do not use for first-party code, pinned standard
+  libraries, or as a substitute for verification.
+when_to_use: >
+  About to write, review, or assert the shape of a third-party surface — an
+  import path, an argument list, a config key, an HTTP field, an auth
+  scheme, a model id, a price, a deprecation claim. NOT for first-party code
+  in this workspace (read it instead), NOT for the standard library of a
+  pinned runtime, and NOT a substitute for running anything — leo:verification
+  still governs the completion claim built on top of it.
+---
+
+# freshness
+
+A third-party surface you have not read this session is a guess, however
+familiar it feels. Recall of a library is a snapshot of some arbitrary past
+version; it is not a snapshot of the one pinned in this lockfile. The cost is
+a call that reads perfectly and does not exist.
+
+Recall is not a source. The package installed on disk is.
+
+## When it fires
+
+A closed list of five.
+
+1. **A symbol you did not read this session** — a function, method, class,
+   decorator, flag, or config key belonging to something not defined in this
+   working tree.
+2. **A version-sensitive call shape** — argument order, keyword names, return
+   type, or import path for a dependency whose installed version you have not
+   confirmed.
+3. **A service contract** — endpoint path, request or response field, auth
+   scheme, pagination rule, error code.
+4. **A vendor-schedule fact** — a model id, context window, price, rate limit,
+   or regional availability. These move on someone else's calendar.
+5. **A deprecation or removal claim** — "that was dropped in v3" is an
+   assertion about a moving target and needs the same check as a signature.
+
+Outside these five, write the code.
+
+## What counts as a source
+
+Two different questions — which to reach for, and which one wins.
+
+**Lookup order.** Cheapest first; stop at the first that answers.
+
+1. A documentation tool the harness exposes for that vendor (Context7 and
+   the like) — one call, cheap.
+2. Official documentation fetched this turn — cheap.
+3. The lockfile pin plus that version's changelog — a narrow read.
+4. The installed package read on disk — `node_modules`, `site-packages`,
+   `vendor` — expensive; grep for the specific symbol, never read whole
+   files.
+
+Rungs 1 and 2 answer for whichever version they happen to describe, which is
+not always yours. Note the version each one reports and compare it to the pin;
+a cheap answer that cannot say which version it describes has not answered.
+
+**Authority.** When two sources disagree, the installed package wins — it
+is the version that will execute. A cheap source that contradicts it is
+wrong.
+
+Not sources: your recollection; an older file in this repo calling the same API,
+which may be the stale thing you are about to copy; a blog post; a search
+snippet you did not open.
+
+## When it doesn't — Exemptions
+
+A closed, named list. Outside it the default holds — no free pass by analogy.
+
+1. **First-party code** — defined in this repo or a sibling package in the same
+   workspace. Read it; a fetch would answer a question the tree already answers.
+2. **Standard library at a pinned runtime** — those shapes do not move between
+   two runs of the same interpreter.
+3. **Already checked this session** — one check per symbol. Cite the earlier
+   check rather than repeating it.
+4. **Covered by a red-to-green run against the real dependency** — a
+   leo:test-first cycle that exercises the actual library is this check, and its
+   transition is the record. Do not manufacture weaker evidence beside it.
+5. **No fetch capability in this session** — offline, or no docs tool reachable.
+   Then the claim is reported as unchecked and this exemption is named.
+
+A skip must name its exemption in the report — "skipped freshness: first-party,
+read src/auth/session.ts". An unnamed skip is an unchecked claim.
+
+## Recording the check
+
+One line per check, in the done report:
+
+```
+checked <symbol> against <source> (<version>)
+```
+
+The version in parentheses is what makes it auditable — a reviewer compares it
+to the lockfile without rerunning anything.
+
+## Self-talk to catch
+
+- "I've used this library for years" — across how many major versions, and
+  which one is pinned here?
+- "The docs will only confirm what I know" — then it costs nothing, and the
+  case where they do not is the entire reason for the step.
+- "Another file here calls it this way" — that file may be what you are about
+  to propagate.
+- "The typechecker will catch it" — a typechecker reads installed stubs, the
+  authority source. Say so and cite it, rather than skipping and hoping.
+- "It's one argument" — argument names are exactly what moves between majors.
+
+## Reviewable finding
+
+An unchecked third-party surface with no named exemption is a finding:
+blocking when the call sits on the path the task was about, non-blocking
+otherwise.
+
+## Works with
+
+- leo:verification — that gate proves the code you wrote runs; this one governs
+  whether the API you wrote it against exists. A green test against a mocked
+  dependency satisfies that skill and not this one.
+- leo:test-first — exemption 4; a red-to-green run against the real dependency
+  has already done this work.
+- leo:debugging — when Localize follows a path into a dependency, this says
+  which copy of it to read.

package/skills/memory/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: memory
+description: >
+  Durable cross-harness facts, one per file, in a store that outlives the
+  session and every plugin update. Covers what earns a place in the store,
+  how a fact is written and revised, how to read one before acting on it,
+  and when to throw one away. The store is canonical; each harness's own
+  memory surface receives a generated copy of the global facts. Use when a
+  durable preference, repo rule, decision, or machine quirk surfaces. Do not
+  use for current-task state or facts already recorded in the repository.
+when_to_use: >
+  A fact surfaces that will still be true next month — a stated preference,
+  a repo rule the code does not spell out, a settled decision, a machine
+  quirk that cost you a detour. Also when a remembered fact turns out wrong
+  and has to be revised or dropped. NOT for anything scoped to the current
+  task (branch names, what is failing right now — that is machine-local
+  JSON state), and NOT for material the repository already records.
+---
+
+# memory
+
+One fact per file, written the moment it is learned. A fact you intend to
+record at the end of the session is a fact you will lose, because the end of
+the session is exactly where context runs out.
+
+The store is the only place you write. Each harness's native memory file
+receives a generated copy of the global facts, so a preference learned on one
+harness is in front of you on the next one. Those copies are derived — editing
+one changes nothing and is overwritten on the next write.
+
+## What earns a place
+
+All three must hold. Miss one and it is not a memory.
+
+1. **It is durable.** Still true a month from now. Not the branch you are on,
+   not the test that is failing, not where you are in the current task.
+2. **It is not cheaply re-derivable.** You could not recover it from one grep
+   or one file read in the repo you are already sitting in.
+3. **It fits one of the five types below.** There is no sixth type, and that
+   closed set is the whole gate.
+
+## The five types
+
+1. **preference** — Leo said how he wants something done, and it outlives this
+   task. *"Squash-merge, never a merge commit."*
+2. **convention** — a rule of this repo the code does not state, usually
+   learned the hard way. *"The adapters directory is generated; hand edits are
+   swept on the next render."*
+3. **environment** — a machine or tooling fact that cost a detour to establish.
+   Never a credential.
+4. **decision** — a settled choice and its one-line reason, where reopening it
+   would cost a conversation.
+5. **person** — who owns or decides what, and how to reach them about it.
+
+## When it doesn't — Exemptions
+
+A closed, named list. Outside it the default holds — no free pass by analogy.
+
+1. **Task state** — anything true only until this task ends. Branch names, PR
+   numbers, what you are about to do next. That belongs in machine-local JSON
+   via `${CLAUDE_PLUGIN_ROOT}/scripts/state.py`, not here. (`${CLAUDE_PLUGIN_ROOT}`
+   is the Claude Code spelling of the plugin root and is not substituted into
+   this text; leo:delegation's ledger section gives the per-harness forms.)
+2. **Re-readable facts** — anything one search away in the working tree. The
+   repository is not something to memorize.
+3. **Your own conclusions** — an analysis, a diagnosis, a plan. A memory
+   records what Leo or the world asserted, not your reasoning about it.
+4. **Restatements of policy** — anything already in leo:using-leo or another
+   leo skill. Two copies of one rule drift apart, and the copy wins by being
+   nearer to hand.
+5. **Secrets** — tokens, keys, passwords, private URLs. Never, under any type:
+   the store is plain text on disk.
+6. **One-off corrections** — Leo redirecting you inside this task. Only a
+   correction he generalizes becomes a preference.
+
+## Rate discipline
+
+Automatic capture without a brake becomes a log, and nobody trusts a log.
+
+- At most **three** unprompted writes in a session. Reaching for a fourth means
+  you are recording activity, not learning facts — consolidate instead.
+- Announce every write in one line: `remembered: <title> (preference)`. A store
+  that grows invisibly is a store Leo cannot audit.
+- Check the scope before writing. A fact that restates one already there is a
+  revision of that file, never a second file beside it.
+
+## Procedure
+
+Write, with the body on standard input:
+
+```sh
+python3 "${CLAUDE_PLUGIN_ROOT}/scripts/memory.py" write global preference "Squash merge"
+```
+
+Repo-scoped facts take an explicit key — the working directory is never
+guessed, because a worktree would attribute the fact to the wrong project:
+
+```sh
+python3 "${CLAUDE_PLUGIN_ROOT}/scripts/memory.py" write repo convention "Generated adapters" --repo owner/name
+```
+
+Writing the same title again revises that file in place and keeps its original
+creation date only when both title and type match exactly. A slug collision with
+a different title or type receives the next `-N` suffix; a corrupt occupied
+slot is never overwritten. `list` shows what is stored; `read <ref>` returns
+one fact whole.
+
+Leo-owned memory directories use mode `0700`; fact files and the generated
+`index.json` and `MEMORY.md` use `0600`. A newly generated projection is also
+private, while an existing user-owned projection target retains the mode the
+user chose.
+
+## Read path
+
+1. The index arrives in context on every harness whose mapping says so. Each
+   line is a pointer, not the fact — the one-line hook is lossy by design.
+2. Read the file before you rely on it.
+3. **What you can see beats what you remember.** When a stored fact disagrees
+   with the repository in front of you, the repository is right. Use the
+   observation, then revise the memory. Never act on a fact you just watched
+   fail.
+
+## Forget path
+
+Three triggers, and no others: Leo says it is wrong or has changed; you
+observed it to be false; or its subject no longer exists.
+
+```sh
+python3 "${CLAUDE_PLUGIN_ROOT}/scripts/memory.py" forget global/squash-merge
+```
+
+Forgetting moves the file aside rather than destroying it, so a wrong call is
+recoverable. A superseded fact is a revision, not a forget followed by a write.
+Suspicion that something looks stale is not grounds to drop it — that needs an
+assertion or an observation.
+
+## Self-talk to catch
+
+- "I'll write this down once the task settles" — the task ending is what takes
+  the fact with it.
+- "This is worth keeping, roughly" — name its type, or it does not go in.
+- "The memory says the flag is called that" — the memory says what was true
+  when someone wrote it; check the flag.
+- "Leo corrected me, that's a preference" — inside one task it is a
+  correction; only a generalization is a preference.
+
+## Works with
+
+- leo:using-leo — draws the line this skill sits on: per-task JSON state on one
+  side, durable facts on the other.
+- leo:doctor — reports whether the store exists and whether each harness
+  actually received its copy.
+- leo:verification — a stored fact is not evidence. Claims still need a fresh
+  command run this turn.