@antoneeo/kb-agentic-skill 1.6.0 → 1.8.0

package/CHANGELOG.md

@@ -2,6 +2,81 @@
 
 Every significant change to this skill is recorded here.
 
+## [1.8.0] - 2026-08-28
+
+F-041 -- the mid-session drift field report, both items.
+
+### Added
+- **`check` notes an unwired or dead session-orientation hook.** `init` wires the
+  hook at init time only; pre-F-036 and agent-bootstrapped projects never got it,
+  silently. `check` now prints, right after its summary line, a one-line `[note]` when no hook is detectable
+  in `.claude/settings.json` / `.claude/settings.local.json` / `.codex/hooks.json`,
+  and a distinct note when a hook is wired but its validator does not resolve
+  (any-resolves aggregation across entries; BOM-tolerant reads; fail-open on
+  malformed config). Informational only: never the exit code, never a `validate`
+  warning -- CI stays green because the wired hook legitimately lives in the
+  git-ignored local settings file.
+- **`remind` -- an opt-in per-turn one-line reminder (UserPromptSubmit).** orient
+  fires once; mid-session drift had no mechanical guard. One constant, zero-read
+  line re-arms the kb minimum (triage levels, the topics/INDEX.md recall trigger,
+  the capture moment) at every prompt. Never wired by `init`, never a default:
+  ENFORCEMENT par.4 documents the snippet and the ~50 tokens/prompt cost.
+
+## [1.7.0] - 2026-08-28
+
+F-040 — the capture moment (second-brain unit 2): the day's decisions reach the
+ledger before they evaporate.
+
+### Added
+- **`SKILL.md` §The Capture Moment.** At a user-signed closing (phase 5 of a governed
+  unit, or any closing signal in an un-governed session), ONE sweep question carrying
+  its own inline search result: "today I recorded [...] — any other decisions from
+  today?". Scoped to TODAY, so it reaches decisions taken outside the session — facts
+  only the practitioner owns. A scheduled elicitation (the phase-3 round's family),
+  not a blocking question. The sweep is idempotent: a decision already noted at
+  phase 4 is verified, never re-captured. Channeling with explicit provenance
+  (elicited → ELICITED, synthesis → DERIVED, RULING only when resolving a contested
+  set per reconciliation §2); capture never creates topics (`unplaced.md` is never a
+  decision park); a no-topic decision is noted NOW with the placement declared as the
+  next kb unit. Declared residual: an unsignaled end captures nothing — the phase-4
+  note-when-said duty is the protection for sessions that never close.
+- **Notes recency in the kb `orient`.** Whenever `corpus/notes/` exists: `newest
+  note: N days old` (or `no notes yet`), dated from note frontmatter `date:` with
+  mtime as fallback — named limit: mtime lies after clone/worktree, and the line
+  measures notes recency, not full ledger freshness. A missed capture is visible at
+  the next session's start.
+- **`test_kb_capture.py`** — kb-only battery module (doctrine anchors + the five
+  recency states), outside the shared x3 manifest.
+- Eval scenarios `capture_channels_the_days_decisions.md` and
+  `capture_stays_silent_with_nothing_to_record.md` (the negative branch: "niente"
+  writes nothing).
+
+F-039 — the recall reflex (second-brain unit 1): the graph is read when answering,
+not only written when distilling.
+
+### Added
+- **`SKILL.md` §Topic Recall — the answer-side consult.** Whenever a reply would
+  assert facts about the project's domain, the topic index is scanned and the descent
+  (`taxonomy.md` §6, new) runs in answer mode — plausibility of coverage is judged ON
+  the scanned index, never before it. Four declared verdicts (claims cited / node
+  matched no claims, surfacing `gaps:` / no coverage / index absent + regenerate),
+  emitted only when the recall ran; never faked. Once per topic per session.
+- **The anti-echo re-touch rule.** A DERIVED claim that grounds a decision has its
+  chain walked to non-DERIVED ground (GIVEN artifact, ELICITED or RULING note) and
+  that ground cited; an unresolvable ground marks the claim unverified for
+  decision-grounding — surfaced, never silently cited. IMPORTED grounding a decision
+  is named as un-re-ratified foreign authority.
+- **By construction: kb `orient` appends the topic router.** The overlay special-cases
+  `orient` (raw argv forwarded to the spine, never re-parsed) and appends the top of
+  `topics/INDEX.md` — or `index absent (N node files)` with the regenerate command —
+  so every session opens with the graph in sight. Fails open; spine untouched.
+- **`test_kb_recall.py`** — new kb-only battery module (doctrine anchors + orient
+  interception), deliberately outside the shared x3 manifest.
+- **`run_behavioral.py` fenced-block seeding** — a scenario setup entry ending in `|`
+  takes its file body from the following fenced block (common-dedented), so claims
+  tables and frontmatter'd nodes can be seeded; one-line entries unchanged.
+- Eval scenario `recall_descends_before_answering.md`.
+
 ## [1.6.0] - 2026-08-26
 
 F-038 — the gated rung: truthful log vocabulary and a mandated ask, no grant memory.

package/README.md

@@ -20,6 +20,10 @@ Two axes are kept apart on purpose — **abstraction** (a topic made of topics:
 
 5. **Escalation in one batch at the end of the run**, in legal form (the claims, the reopenable sources, the dates, why the machine cannot decide). Ingestion never stops to interrogate you.
 
+6. **Recall — the graph is read when answering, not only written when distilling.** Whenever a reply would assert facts about the project's domain, the agent scans the topic index and descends before answering from model memory — plausibility of coverage is judged ON the scanned index, never before it. Answers cite claim ids; a superseded claim is never cited without its successor; the verdict is declared only when the recall ran (`kb: <slug> → N claims cited`, a matched node with no claims surfaces its `gaps:`, and a missing index is reported as index-absent — not as a missing graph — with the regenerate command). When a DERIVED claim grounds a decision, its chain is walked to non-DERIVED ground (the given artifact or the elicited/ruled note) and that ground is cited — re-reading the agent's own synthesis is the echo chamber this rule exists to break. By construction, not exhortation: the kb `orient` opens every session with the topic router in sight.
+
+7. **Capture — the day's decisions reach the ledger before they evaporate.** At a user-signed closing ("chiudiamo"), one sweep question — carrying its own inline result: "today I recorded X and Y — any other decisions from today?" — reaches even the decisions taken outside the session, which no transcript search could find. What surfaces lands on the existing rails (an elicited dated note, an L1 claim row) with explicit provenance; the sweep is idempotent (nothing captured twice), never creates topics, and stays silent when no one signed off. The kb `orient` shows notes recency at every session start — dated from note frontmatter, because file mtimes lie after a clone or worktree — so a missed capture is visible the next morning.
+
 Deliberately absent: any per-node coverage or completion state. `gaps:` says what a node lacks; nothing collects it into a dashboard. A **source** does record how far it has been read, but on its own sidecar and nowhere else — the corpus index prints that fact for every artifact, including the finished ones, because a list of only what is behind is the dashboard this method refuses.
 
 ## Key features
@@ -78,7 +82,11 @@ it: a repo that vendors it gets a repo-relative command in the shared `.claude/s
 (portable — commit it); otherwise the path is machine-specific and goes to the git-ignored
 `.claude/settings.local.json`, and each teammate runs `init` once. Re-running `init` never
 duplicates the hook, and a hook whose validator no longer resolves is reported as **broken**
-with the correction rather than counted as installed.
+with the correction rather than counted as installed. Since F-041, `check` also
+prints a one-line note when a project has no orientation hook wired (or a dead
+one), and an opt-in per-turn reminder exists for long sessions: `sdlc_check.py
+remind`, one constant line via UserPromptSubmit -- documented in `ENFORCEMENT.md`
+par.4, never wired by default.
 
 ## The family: three lenses, one spine
 

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "kb-agentic-skill",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Knowledge-Base & Document-First protocol with risk triage, Vision governance, signal distillation and optional devPNT integration.",
   "author": "Antonio Pinto (https://github.com/Antoneeo)"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antoneeo/kb-agentic-skill",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Knowledge-Base & Document-First protocol for Claude Code, Gemini CLI, Google Antigravity and Codex with risk triage, Vision governance, signal distillation and optional devPNT integration.",
   "keywords": [
     "claude-code",

package/skills/kb-agentic-skill/ENFORCEMENT.md

@@ -86,6 +86,20 @@ that cannot be placed in a command safely, or a settings file it cannot write. `
 prints which case applied, per client — a silent skip is what let "documented default
 that nobody installs" survive in the first place.
 
+**Older and agent-bootstrapped projects are silently unwired -- `check` now tells you (F-041).**
+`init` wires the hook at init time only: a project initialized before F-036, or whose
+docs root was bootstrapped by the agent (which runs `index`, never `init`), never
+received it retroactively -- and until F-041 nothing said so. `check` now prints, right after its summary line, a
+one-line `[note]` when no orientation hook is detectable (`.claude/settings.json`,
+`.claude/settings.local.json`, `.codex/hooks.json`), and a DISTINCT note when a hook is
+wired but the validator it names does not resolve (the wired-and-DEAD state below --
+silence there would bless the worst of the three states). The notes are informational
+only: never the exit code, never a `validate` warning -- CI (`validate --strict`) does
+not see them, because the wired hook legitimately lives in the git-ignored
+`settings.local.json`. Known residuals, accepted as honest: a client with no hook
+mechanism (Gemini today) keeps the note -- read it as the manual-reads reminder; a
+`.codex/hooks.json` wired in a shape other than the documented one keeps it too.
+
 **Which settings file, and why it is not always the shared one.** The command names a
 validator, and where that validator lives decides where the hook may be written:
 
@@ -133,6 +147,38 @@ Gemini CLI — wire the same command into its startup-hook mechanism if present;
 - **Hybrid/devPNT projects**: add `--hybrid` — the hook then appends a one-line pointer to run `devpnt_mcp_get_bootstrap` for the Master Plan / Knowledge Layer and does not replicate them; the filesystem orientation (router + handoff + README) still emits.
 - Like the CI gate (§2), if you copied `sdlc_check.py` into the repo, the hook references that copy — keep it current when you update the skill.
 
+### Per-turn reminder: `remind` (UserPromptSubmit -- opt-in, NEVER a default)
+
+`orient` fires once, at session start; a long session drifts after it (a compaction,
+ten turns of other work -- the F-041 field report). `sdlc_check.py remind` prints ONE
+constant line -- the kb minimum: the triage levels, the topic-index recall trigger, the
+capture moment -- for the client to inject at every prompt. Cost: ~50 tokens per
+prompt, which is exactly why `init` never wires it and never will by default: the
+per-turn cost is the project's choice. The line is constant and zero-read, so nothing
+repo-controlled can ride into the agent's context through it, and the vision's
+no-per-turn-graph-queries non-goal stays honored -- the line re-arms the
+entry-into-topic trigger; it never runs the reading itself.
+
+Claude Code -- in the project's `.claude/settings.json` (or `settings.local.json` when
+the validator path is machine-specific, same rule as the orientation hook above):
+
+```json
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python \"C:\\Users\\<user>\\.claude\\skills\\kb-agentic\\scripts\\sdlc_check.py\" remind"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
 ## 5. Skill eval battery (release gate)
 
 **Skill development only.** `test_*.py` and `evals/` are deliberately absent from the npm `files` allowlist — they never reach an installed consumer, so this section applies to whoever builds the skill, not to a project that uses it. (Consumers get `sdlc_check.py`; §1–§4 are theirs.)

package/skills/kb-agentic-skill/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: kb-agentic
-version: 1.6.0
-description: Knowledge-Base & Document-First protocol with risk-proportional triage, Vision as a guide, Signal Distillation, a complete Standalone mode and optional symbiosis with devPNT. Use for user documentation, knowledge extraction, SOPs, research notes, decision logs and knowledge management.
+version: 1.8.0
+description: Knowledge-Base & Document-First protocol with risk-proportional triage, Vision as a guide, Signal Distillation, a complete Standalone mode and optional symbiosis with devPNT. Use for user documentation, knowledge extraction, SOPs, research notes, decision logs, knowledge management — and for answering project questions from the claim ledger and topic graph.
 author: Antonio Pinto (https://github.com/Antoneeo)
 copyright: (c) 2026 Antonio Pinto
 ---
@@ -15,7 +15,7 @@ This skill guides knowledge management and documentation with a Document-First p
 Support files in the skill directory:
 - `templates.md`: templates for Vision, Knowledge ANALYSIS, Research SPIKE, SOP GUIDE, audit plan, and handoff.
 - `portability.md`: carrying knowledge between projects — what a bundle is, why export is a closure rather than a selection, and the rule that knowledge crosses a project boundary while authority does not (`prov: IMPORTED`). Read before `export`/`import`.
-- `taxonomy.md`: placing a claim in the topic graph — descent over the generated index, the five verdicts (EXISTS / INADEQUATE / MISSING / GENERALIZES / UNPLACED), the sibling rule, guarded re-parenting, canonicalization. Run at L3 before drafting.
+- `taxonomy.md`: placing a claim in the topic graph — descent over the generated index, the five verdicts (EXISTS / INADEQUATE / MISSING / GENERALIZES / UNPLACED), the sibling rule, guarded re-parenting, canonicalization — and the answer-mode descent (`§6`). Run at L3 before drafting.
 - `guides.md`: pipeline for distilling user-provided indications into `ai_docs/reference/GUIDE_[topic].md`.
 - `vision.md`: how to write a Vision a cold reviewer can actually apply — the properties that make a rule hold, the minimum operable sections, and the blind check.
 - `distillation.md`: from a source to claim rows — intake (content-addressed originals, stored canonical extraction, every provenance a real file), the claim table, extraction discipline, signal rules (symbiosis with `distill`).
@@ -23,7 +23,7 @@ Support files in the skill directory:
 - `review.md`: the review discipline — when a review is due, how to request one, how to receive findings, how to review.
 - `dispatch.md`: opt-in subagent execution of an approved plan.
 - `routing.md`: which lens owns this unit of work. Read ONLY when a sibling lens skill is installed alongside this one; a single-lens install never reads it.
-- `scripts/sdlc_check.py` + `scripts/sdlc_core.py`: the mechanical validator for the docs root (`check`, `validate`, `index`, `stale`, `mark`, `gate`, `plan`, `orient`, `migrate`, and the knowledge overlay: `graph`, `corpus`, `claim-id`, `anchor`, `export`, `import`). Two files: the core is the family's shared spine; the entry point IS the knowledge overlay — the claim ledger and topic-graph checks live inside it, so the core alone runs none of them. Copy both, or neither.
+- `scripts/sdlc_check.py` + `scripts/sdlc_core.py`: the mechanical validator for the docs root (`check`, `validate`, `index`, `stale`, `mark`, `gate`, `plan`, `orient`, `migrate`, and the knowledge overlay: `graph`, `corpus`, `claim-id`, `anchor`, `export`, `import`, plus `remind` — the opt-in per-turn one-line reminder, ENFORCEMENT §4). Two files: the core is the family's shared spine; the entry point IS the knowledge overlay — the claim ledger and topic-graph checks live inside it, so the core alone runs none of them. Copy both, or neither.
 - `ENFORCEMENT.md`: optional setup for CI and hooks.
 
 Read these files only when needed. `SKILL.md` is the operating contract; the support files are progressive resources.
@@ -35,7 +35,7 @@ Read these files only when needed. `SKILL.md` is the operating contract; the sup
 - **Signal & Distillation:** eliminate fluff, filler, and speculative statements; keep deterministic facts, constraints, decisions, and clear SOP steps (symbiosis with `distill`).
 - **Lifecycle & Freshness:** mark superseded knowledge (`status: SUPERSEDED` or `DEPRECATED`) so outdated information does not cause hallucination.
 - **Protect the Vision & User Style:** align all knowledge work with user strategic goals, operational preferences, and expected outcomes.
-- **Map-First Navigation:** rely on `ai_docs/README.md`, `INDEX.md`, and `reference/INDEX.md` router for targeted retrieval before creating new documents.
+- **Map-First Navigation:** rely on `ai_docs/README.md`, `INDEX.md`, and `reference/INDEX.md` router for targeted retrieval before creating new documents — and before *answering from model memory* on the project's domain (`## Topic Recall`).
 
 ## Rule Zero: Triage
 
@@ -90,6 +90,7 @@ Triage decides IF documentation is due; this table decides WHICH document each e
 | a KB bundle (`export`) | Knowledge must leave this project. Export is L1 — it writes nothing into the corpus. **Importing one is L3**: a source enters the corpus and nodes are created, and a bundle is external input, so never L1 whatever its size (`portability.md`). | — |
 | `corpus/given/*` + sidecar | A source arrives: it becomes a content-addressed artifact with a sidecar carrying digest/date/`supersedes:`. A text source is copied verbatim. A non-text source yields its stored canonical extraction — copied **beside** the original when that is small enough to keep, or **instead of it** on a large binary corpus, where the original stays where it lives and is recorded as `original_path:`/`original_sha256:` (`distillation.md` §1, which owns this rule). Never edited after ingest — the digest check on whatever `given/` holds is what enforces it. | 4 |
 | `corpus/notes/*` | Something is said (`origin: elicited`), synthesised (`derived_from:`), or ruled (`basis:`). A note with none of the three is refused by the validator. | 4 / 5 |
+| the day's decisions, at a user-signed closing (the Capture Moment sweep) | Verification that the phase-4 notes/claims exist; NEW `corpus/notes/*` + claim rows only for what the sweep surfaces un-captured. The event is the CLOSING, disjoint from the row above (which fires when something is SAID). | 5 / session end |
 | `solutions/PLAN_[topic].md` + its ledger | A source too long for one context is ingested: **one task per reading window** (30 pages by default; the plan states the window used), each ending at a declared `extracted_through:`. That ledger is the register the ingestion resumes from across sessions — ingestion never builds a second one (`distillation.md` §3, `templates.md`). | 4 |
 | `corpus/given/*.meta.md` — `extracted_through:` | Every reading window closes by advancing it (`p=<n>`, `L<n>`, `complete`). Required once any claim cites the artifact: unstated, "I am finished" cannot be falsified, which is how a sampled 200-page manual passes for an ingested one. | 4 |
 | `INDEX.md`, `reference/INDEX.md`, `topics/INDEX.md`, `corpus/INDEX.md` | Regenerated by `sdlc_check.py index` at closure — never by hand; `validate` fails on a hand-edited one. | 5 |
@@ -142,6 +143,106 @@ Guides are consulted, created, and distilled per `guides.md`.
 - **Propose proactively**: when the user hands over indications that will govern future work, propose distilling them into a guide. A proposal, never a silent write, and never from model knowledge — a guide's whole value is that every claim traces to what the user actually provided.
 - Distill from user instructions into `ai_docs/reference/GUIDE_[topic].md`.
 
+## Topic Recall — the answer-side consult
+
+The graph is only a second brain if it is READ when answering, not only written when
+distilling. The descent (`taxonomy.md`) fires here with a new trigger — the answer-side
+twin of the guide consult above.
+
+- **Trigger — unconditional scan on domain assertions.** Whenever the reply would assert
+  facts about the PROJECT'S domain (its topics, decisions, sources, constraints), scan
+  `topics/INDEX.md`. Plausibility of coverage is judged ON the scanned top rows, never
+  before them — "the KB probably doesn't have this" is model memory talking, the exact
+  judgement this reflex removes. Exempt: pure mechanics (running a command, editing per
+  explicit instruction), general knowledge outside the project's domain, L1 gestures.
+- **Once per topic per SESSION.** The dedup key is the matched slug (known ex post); a
+  question plainly within an already-descended branch reuses that consult, and a
+  placement descent already run this session counts. A compaction starts a new session.
+- **The act.** Descend per `taxonomy.md` §6 (same doctrine, answer mode). On claims,
+  answer FROM them citing claim ids; a claim whose `state` is `SUPERSEDED <id>` is never
+  cited without naming its successor.
+- **The declared verdict — only when the recall ran**, never a per-turn ritual. Four
+  legal values:
+  - `kb: <slug> → N claims cited`
+  - `kb: <slug> → node matched, no claims` — surface the node's `gaps:` when it answers
+    the question: "the KB knows it doesn't know" is a first-class answer.
+  - `kb: no coverage` — index read, nothing fits.
+  - `kb: index absent — regenerate (sdlc_check.py index)` — the INDEX is missing, not
+    necessarily the graph (nodes routinely exist while the index lags); regenerate and
+    rescan.
+  Never fake the verdict: an always-"no coverage" verdict certifies a lookup that did
+  not happen. The `router:` and `kb:` verdicts are independent and may co-occur, one
+  line each — a how-to question can match a guide AND carry claims.
+- **Anti-echo — the re-touch rule.** When a DERIVED claim grounds a decision the user is
+  about to take, walk its chain to non-DERIVED ground — a GIVEN artifact, an ELICITED or
+  RULING note — and cite that ground beside the claim id; re-opening only the immediate
+  target may re-read the agent's own synthesis, which is the echo chamber itself. If the
+  ground does not resolve (imported bundle without originals, external `original_path:`,
+  tombstone): say so beside the claim id and treat the claim as **unverified for
+  decision-grounding** — surfaced, never silently cited. Per-provenance stance: GIVEN's
+  source column is already the direct citation; ELICITED/RULING carry the practitioner's
+  own authority; an IMPORTED claim grounding a decision is named as un-re-ratified
+  foreign authority.
+- **The trace persists.** When the decision is recorded (a ruling note, a diary entry),
+  that record cites the claim id AND the re-touched ground — the trace survives in the
+  corpus, not in ephemeral chat.
+- **Under dispatch**, recall is an orchestrator concern: the orchestrator runs the
+  descent itself; a context-free subagent never runs its own. The task schema has no
+  claims field today, so until a dispatch-focused unit adds one, the orchestrator
+  inlines the cited claim rows in the task's free text — an explicit interim.
+
+## The Capture Moment — the day's decisions reach the ledger
+
+Capture today is what makes recall honest tomorrow: a captured elicited or ruled note
+is exactly the non-DERIVED ground the re-touch rule above walks to. The rails all
+exist — this section adds only the MOMENT.
+
+- **When — user-signed closings, once per session.** Phase 5 of a governed unit, or
+  any closing signal from the user in an un-governed session ("chiudiamo", "we're
+  done"); the session-end pass that updates `handoff.md`/`project_notes.md` then runs
+  at that same closing. Never per-turn, never a standing interruption. **Declared
+  residual**: an unsignaled end (the user simply stops writing) captures nothing —
+  the phase-4 duty (a decision stated mid-session owes its note WHEN SAID) is the
+  protection for sessions that never close, and the orient's recency line makes the
+  miss visible next time. That line measures NOTES recency, not full ledger
+  freshness, and trusts frontmatter `date:` over file mtimes — mtimes lie after a
+  clone or worktree.
+- **The sweep question.** At the closing, ONE question, carrying its own search
+  result inline: "today I recorded: [what the sweep found already on the rails] —
+  any other decisions from today to record?". Scoped to TODAY, so it reaches
+  decisions taken outside the session (a meeting, a call) that no transcript search
+  could find — facts only the practitioner owns. This is a **scheduled elicitation**
+  in the same family as the phase-3 round, not a blocking question (nothing stalls;
+  the session is ending), so the blocking form does not attach; the inline result
+  satisfies the search-first duty. "Niente" ends it.
+- **The sweep is idempotent.** It verifies the day's decisions are on the rails; a
+  decision already noted at phase 4 is verified, never re-captured — no second note,
+  no duplicate claim row. The moment closes gaps; the phase-4 row stays the primary
+  channel.
+- **What counts as a decision**: domain choices made or confirmed today — a value, a
+  threshold, a rule, a stated preference, a rejected alternative with its reason.
+  NOT mechanics (commands run, files edited), NOT process state (the handoff's job).
+- **The channeling — existing rails, explicit provenance.**
+  - The user's words → `corpus/notes/*` with `origin: elicited` and a `date:`; a
+    claim row distilled from it carries `prov: ELICITED`, source = that note with a
+    legal `L<a>-<b>` locator.
+  - A synthesis of the day's discussion → a note with `derived_from:` → claim
+    `prov: DERIVED`.
+  - **RULING only when the decision resolves an existing contested set** — then
+    `reconciliation.md` §2 applies in full (mandatory `basis:`, supersession of the
+    whole prior set). A fresh conflict-free decision is captured elicited: a preference
+    is not a fact, and `basis:` is reserved for the fact the corpus lacks.
+  - A fact on an existing topic → claim row, L1 (`id` empty; `claim-id --fill`).
+  - No owning topic → the note is written NOW and the placement is declared as the
+    next kb unit. Capture never smuggles an L3 hierarchy change, and
+    `topics/unplaced.md` is never a decision park — UNPLACED is for topic-less
+    scraps and is invisible to recall.
+- **Reconciliation is wired.** A captured claim meeting an existing claim on the
+  node classifies per `reconciliation.md` — capture can confirm, refine, coexist or
+  CONTEST, never silently overwrite.
+- **Silence stays legal where no one signed off**: no closing signal → no question,
+  no ritual line.
+
 ## Mechanical Enforcement
 - `scripts/sdlc_check.py index`: updates `ai_docs/INDEX.md` and `ai_docs/reference/INDEX.md`.
 - `scripts/sdlc_check.py validate`: validates YAML frontmatter (`status`, `description`).

package/skills/kb-agentic-skill/elicitation.md

@@ -21,8 +21,10 @@ record is reviewable; a guess folded silently into a design is not.
 ## The question discipline
 
 A question to the practitioner spends their attention and stalls the work; the
-round below is the only place the process *plans* that cost. Everywhere, a
-question is legal only when BOTH hold:
+process *plans* that cost in exactly two places — the round below, and the
+Capture Moment sweep at a user-signed closing (`SKILL.md`), a scheduled
+elicitation in the same family that carries its search result inline and stalls
+nothing. Everywhere, a question is legal only when BOTH hold:
 
 1. **Searched first, and the search is named — with its result.** The answer is
    not on record and not derivable from the corpus, the topic graph, `ai_docs/`,

package/skills/kb-agentic-skill/scripts/sdlc_check.py

@@ -1491,6 +1491,133 @@ def kb_cmd_import(args):
     return 0
 
 
+def kb_cmd_orient(argv):
+    """Forward `orient` to the spine untouched, then append the topic router.
+
+    The recall reflex (SKILL.md section "Topic Recall") needs the graph in
+    sight at session start -- by construction, not exhortation (F-039). The
+    spine's orient is never re-implemented here: the raw argv goes through
+    (the --help pattern below), and orient's flags are never mirrored into an
+    overlay argparse -- the drift class the forward-by-default comment warns
+    about. parse_known_args reads ONLY the two root flags the overlay itself
+    needs to locate topics/, and ignores everything else.
+
+    The append fails open: a broken graph read must never break orient itself.
+    """
+    try:
+        rc = sdlc_core.main(argv)
+    except SystemExit as e:
+        rc = e.code if isinstance(e.code, int) else 1
+    # Pre-bind so a throw INSIDE the router print (after root was validly
+    # bound) does not erase it -- the recency block below must survive a
+    # router failure with the bound root intact (closure R2 finding).
+    root = name = None
+    try:
+        probe = argparse.ArgumentParser(add_help=False)
+        probe.add_argument("--root")
+        probe.add_argument("--docs-dir")
+        known, _ = probe.parse_known_args(argv[1:])
+        try:
+            discovered, name = sdlc_core.resolve_docs_dir(known, known.root)
+        except sdlc_core.AmbiguousDocsRoot:
+            # Mirror the spine's degraded orient: fall back to the default
+            # docs dir rather than losing the router on a half-migrated tree.
+            discovered, name = None, sdlc_core.DEFAULT_DOCS_DIR
+        root = (Path(known.root).resolve() if known.root
+                else (discovered or sdlc_core.find_project_root()))
+        topics = root / name / "topics"
+        index = topics / "INDEX.md"
+        if index.is_file():
+            lines = sdlc_core.read_text(index).splitlines()
+            print("\n## Topic router")
+            cap = 30
+            for line in lines[:cap]:
+                print(line)
+            if len(lines) > cap:
+                print("(+%d more lines -- read topics/INDEX.md)" % (len(lines) - cap))
+        elif topics.is_dir():
+            nodes = [p for p in topics.glob("*.md") if p.name != "INDEX.md"]
+            if nodes:
+                print("\n## Topic router")
+                print("index absent (%d node files) -- regenerate: sdlc_check.py index"
+                      % len(nodes))
+        # no topics/ at all: the project has no graph; print nothing.
+    except (Exception, SystemExit):
+        # SystemExit included: the probe parser raises it on a dangling flag
+        # value -- the spine already reported that usage error; the append must
+        # never turn it into an escape. root/name keep whatever binding they
+        # reached: pre-binding throws leave them None (recency skips), a throw
+        # inside the router print leaves them valid (recency still runs).
+        pass
+    try:
+        # Notes recency (F-040) -- its OWN try, genuinely independent of the
+        # router: a router throw must not kill this line. It measures NOTES
+        # recency, not full ledger freshness (an ingest feeding claims from
+        # given/ leaves it unmoved). Date source: frontmatter `date:` first;
+        # per-note mtime as fallback -- mtime LIES after clone/worktree (the
+        # skill's own worktree hygiene makes that routine), which is why the
+        # frontmatter date is primary.
+        if root is None:
+            return rc
+        notes_dir = root / name / "corpus" / "notes"
+        if notes_dir.is_dir():
+            import datetime as _dt
+            newest = None
+            for p in notes_dir.glob("*.md"):
+                stamp = None
+                try:
+                    head = sdlc_core.read_text(p)[:600]
+                    # `date:` counts only INSIDE the frontmatter block: a
+                    # column-0 date: in a note's body must not misdate it.
+                    if head.startswith("---"):
+                        end = head.find("\n---", 3)
+                        if end != -1:
+                            m = re.search(r"^date:\s*(\d{4}-\d{2}-\d{2})",
+                                          head[:end], re.M)
+                            if m:
+                                stamp = _dt.date.fromisoformat(m.group(1))
+                except Exception:
+                    pass
+                if stamp is None:
+                    try:
+                        stamp = _dt.date.fromtimestamp(p.stat().st_mtime)
+                    except Exception:
+                        continue
+                if newest is None or stamp > newest:
+                    newest = stamp
+            if newest is None:
+                print("\nno notes yet (corpus/notes)")
+            else:
+                days = (_dt.date.today() - newest).days
+                print("\nnewest note: %d days old (corpus/notes)" % max(days, 0))
+    except (Exception, SystemExit):
+        # Fail-open: nothing in the recency append may break orient. (The
+        # probe parser lives in the router try above; this guard covers the
+        # date/mtime walk and the print itself.)
+        pass
+    return rc
+
+
+def kb_cmd_remind(_argv):
+    """F-041 item B: the per-turn one-line reminder (UserPromptSubmit, opt-in).
+
+    A CONSTANT, zero-read line -- the kb minimum an agent needs re-armed every
+    prompt: triage, the recall trigger, the capture moment. Constant by
+    contract: nothing repo-controlled may ride a line injected into the agent's
+    context every turn, and zero reads is what keeps the per-turn cost flat.
+    The vision's non-goal bans per-turn GRAPH queries; this line only re-arms
+    the entry-into-topic criterion, it never runs the descent. Never wired by
+    init and never a default: ENFORCEMENT par.4 documents the manual snippet
+    and the ~50 tokens/prompt cost -- the project chooses. Fail-open like every
+    hook surface: argv is ignored whole, the exit code is always 0."""
+    print("kb-agentic: triage before acting -- L1 quick fact, L2 propagation of "
+          "settled knowledge, L3 new knowledge unit, Spike exploration; declare "
+          "the level. Answering about this project's domain? Read topics/INDEX.md "
+          "under the docs root first and cite claim ids, or state no coverage. "
+          "Decisions made today get recorded in the KB at session close.")
+    return 0
+
+
 def kb_cmd_help():
     """The spine's usage, then the overlay's own commands.
 
@@ -1512,6 +1639,8 @@ knowledge overlay (kb-agentic) -- also available:
   anchor <path> <phrase>      resolve a phrase to a verified locator span
   export --out <dir>          bundle a subgraph WITH the bytes its claims cite
   import <dir>                merge a bundle in additively (never overwrites)
+  remind                      one-line per-turn reminder (UserPromptSubmit hook,
+                              opt-in -- ENFORCEMENT par.4; constant, zero-read)
 
   index / validate / check    the spine's behaviour PLUS the claim ledger and
                               the topic graph""")
@@ -1525,6 +1654,14 @@ def main(argv=None):
     # 2026-08-02). Intercepted at argv[0] ONLY.
     if argv and argv[0] in ("-h", "--help"):
         return kb_cmd_help()
+    # `orient` is special-cased BEFORE the overlay argparse, like --help: the
+    # spine runs it on the raw argv, the overlay only appends the topic router.
+    if argv and argv[0] == "orient":
+        return kb_cmd_orient(argv)
+    # `remind` too: it is a hook surface (UserPromptSubmit), so a stray flag
+    # must print the line, not an argparse usage error into someone's prompt.
+    if argv and argv[0] == "remind":
+        return kb_cmd_remind(argv)
     # Forward-by-default: anything not intercepted goes to the spine untouched.
     # Never a hand-copied command tuple - that is how a spine command gets
     # silently dropped (mkt_check.py ships that exact defect with `migrate`).

package/skills/kb-agentic-skill/scripts/sdlc_core.py

@@ -1646,6 +1646,109 @@ def cmd_mark(root, paths):
     return 0
 
 
+# ------------------------------------------------- orientation-hook wiring
+# F-041: read-only mirror of the installer-side detection in lib.js
+# (findOrientHook + orientHookValidator). The JS owns WRITING hooks, with its
+# injection guards; this side only DETECTS, at `check`, so a project whose
+# sessions start unoriented hears about it in-project (ENFORCEMENT par.4: the
+# hook is wired at init only -- pre-F-036 and agent-bootstrapped projects never
+# got it, and a wired-but-dead hook is "the worst of the three states").
+# The file list is a SUPERSET of the JS one: .codex/hooks.json is documented in
+# ENFORCEMENT par.4 but never written by init. Entry-point names are pinned
+# equal on both sides.
+ORIENT_HOOK_ENTRY_POINTS = ("sdlc_check.py", "mkt_check.py")
+ORIENT_HOOK_CONFIG_FILES = (".claude/settings.json",
+                            ".claude/settings.local.json",
+                            ".codex/hooks.json")
+ORIENT_HOOK_CONFIG_CAP = 1024 * 1024  # settings are tiny; cap pathological files
+_ORIENT_HOOK_CMD_RE = re.compile(r" orient(\s|$)")
+_ORIENT_HOOK_TOKEN_RE = re.compile(r'"([^"]*)"|(\S+)')
+
+
+def _orient_hook_commands(root):
+    """Yield the command strings of SessionStart entries invoking an orient
+    entry point, across every known client config under root. Fail-open: an
+    unreadable, oversized, malformed or directory-shaped file contributes
+    nothing. Reads are utf-8-sig -- a BOM'd settings.json (PowerShell/Notepad)
+    must not read as unwired (declared divergence from Node's JSON.parse)."""
+    for rel in ORIENT_HOOK_CONFIG_FILES:
+        p = Path(root) / rel
+        try:
+            if not p.is_file() or p.stat().st_size > ORIENT_HOOK_CONFIG_CAP:
+                continue
+            data = json.loads(p.read_text(encoding="utf-8-sig"))
+        except Exception:
+            continue
+        if not isinstance(data, dict):
+            continue
+        hooks = data.get("hooks")
+        groups = hooks.get("SessionStart") if isinstance(hooks, dict) else None
+        if groups is None:
+            groups = data.get("SessionStart")  # the .codex/hooks.json shape
+        if not isinstance(groups, list):
+            continue
+        for group in groups:
+            if not isinstance(group, dict):
+                continue
+            inner = group.get("hooks")
+            for h in inner if isinstance(inner, list) else [group]:
+                cmd = h.get("command") if isinstance(h, dict) else None
+                if (isinstance(cmd, str)
+                        and any(n in cmd for n in ORIENT_HOOK_ENTRY_POINTS)
+                        and _ORIENT_HOOK_CMD_RE.search(cmd)):
+                    yield cmd
+
+
+def orient_hook_state(root):
+    """'wired' | 'dead' | 'unwired'.
+
+    A matching entry whose tokens name no validator is "cannot tell" and counts
+    as wired (the lib.js contract: never report broken on cannot-tell). 'dead'
+    requires every matching entry to name a validator that does not resolve:
+    the client runs ALL SessionStart hooks, so one live entry beside a dead one
+    still orients the session (any-resolves aggregation). Relative tokens
+    resolve against the project root -- the vendored-validator convention."""
+    matched = False
+    for cmd in _orient_hook_commands(root):
+        matched = True
+        token = None
+        for m in _ORIENT_HOOK_TOKEN_RE.finditer(cmd):
+            tok = m.group(1) if m.group(1) is not None else m.group(2)
+            if any(tok.endswith(n) for n in ORIENT_HOOK_ENTRY_POINTS):
+                token = tok
+                break
+        if token is None:
+            return "wired"
+        tp = Path(token)
+        if not tp.is_absolute():
+            tp = Path(root) / tp
+        if tp.exists():
+            return "wired"
+    return "dead" if matched else "unwired"
+
+
+def print_orient_hook_note(root):
+    """Print the FS-A wiring note (unwired / dead), or nothing when wired.
+
+    Informational only, by contract: never an exit code, never a validate
+    warning (--strict CI must not fail on a hook that legitimately lives in
+    git-ignored settings.local.json). Called by the spine's cmd_check AND by
+    an overlay that replaces check with its own pipeline (the marketing lens
+    does): the note is check-layer behaviour, whoever owns the check."""
+    try:
+        state = orient_hook_state(root)
+        if state == "unwired":
+            print("[note] no session-orientation hook wired (.claude/settings.json, "
+                  ".claude/settings.local.json, .codex/hooks.json): sessions start "
+                  "unoriented -- run the installer's init or wire it per ENFORCEMENT.md par.4")
+        elif state == "dead":
+            print("[note] a session-orientation hook is wired but the validator it names "
+                  "does not resolve: sessions start unoriented -- re-run init or fix the "
+                  "command (ENFORCEMENT.md par.4)")
+    except Exception:
+        pass  # detection must never break check
+
+
 def cmd_check(root, strict=False, hybrid=False):
     print("===== validate =====")
     rc_v = cmd_validate(root, strict=strict, hybrid=hybrid)
@@ -1653,6 +1756,7 @@ def cmd_check(root, strict=False, hybrid=False):
     rc_s = cmd_stale(root, hybrid=hybrid)
     print(f"\ncheck: {'CLEAN' if not (rc_v or rc_s) else 'NOT CLEAN'} "
           f"(validate rc={rc_v}, stale rc={rc_s})")
+    print_orient_hook_note(root)
     return 1 if (rc_v or rc_s) else 0
 
 

package/skills/kb-agentic-skill/taxonomy.md

@@ -78,3 +78,12 @@ unreachable nodes as errors, but the refusal at write time is what prevents them
 A merged or renamed topic keeps its file: `status: SUPERSEDED`, `redirect_to: <slug>`,
 body emptied. Inbound references resolve through it; a claim re-placed from an old
 source lands on the survivor instead of resurrecting the dead slug.
+
+## 6. The same descent, answer mode
+
+The descent above also serves ANSWERING (`SKILL.md` §Topic Recall): when a reply would
+assert facts about the project's domain, descend before answering from model memory.
+Differences only — no placement verdicts, no writes; the descent stops at reading the
+matched node's claims; coverage (found / not found) replaces the five verdicts; UNPLACED
+does not exist when reading. Everything else applies unchanged: descend don't scan,
+follow every parent, synonyms, tombstone redirects resolve to the survivor.