@antoneeo/agentic-sdlc-skill 1.30.0 → 1.32.0

package/CHANGELOG.md

@@ -2,6 +2,65 @@
 
 Tutte le modifiche significative a questa skill saranno documentate in questo file.
 
+## [1.32.0] - 2026-09-06
+
+### Added
+- **F-046: the protocol reaches every turn (`remind`, UserPromptSubmit, wired by
+  default).** `orient` fires once at session start and decays; a session that
+  never loads the skill never had the protocol at all. Measured 2026-09-06: a
+  release ran against a `GUIDE_release.md` the session never consulted, because
+  `SKILL.md` -- where the duty is written -- had not been read. `remind` prints
+  ONE constant line at every prompt, and its first duty is that one: decide
+  whether the skill governs the work in front of you and, if it does, LOAD it
+  once. The carrier is kb's F-041 item B, LIFTED into the shared spine rather
+  than duplicated, so all three lenses share one machine; each lens declares its
+  own line in `set_profile(remind_line=...)`. Installing the package wires it
+  machine-wide on Claude Code alongside the orientation hook, never instead of
+  it; removing the hook entry is a standing opt-out. Per-turn cost disclosed and
+  accepted by the owner (`vision/rulings.md` r19, the "no ceremony ratchet"
+  Non-Goal's second door), and bounded to stay flat by a contract the new shared
+  `scripts/test_remind.py` guards: constant text, zero reads, one line under 500
+  characters, argv ignored whole, always exit 0.
+
+### Changed
+- **`guides.md` said something false about code guides.** It claimed `stale`
+  works unchanged for `source_kind: code` because "the code-excerpt snapshot
+  drifts when the code changes". A snapshot is a frozen copy and never drifts:
+  freshness is NOT mechanized there, and the duty is the author's twice -- when
+  you MODIFY code a comprehension guide describes, and when you merely READ one
+  before trusting it. Measured 2026-09-06: the guided module had gained 388
+  lines and lost 71 across four commits with `stale` silent.
+
+- **The guide question moves to the analysis phase (SKILL.md).** Two lines in the
+  ANALYSIS -- does a CURRENT guide cover what I am about to touch, and did
+  understanding this force a model of a high-complexity component none covers.
+  The Phase-5 Comprehension checkpoint stays the backstop for a signal that only
+  became visible later; it is no longer the moment of first asking.
+
+## [1.31.0] - 2026-09-05
+
+### Changed
+- **Execute-Before-Specify now covers text-about-text (SKILL.md, Phase 3).** A
+  deliverable that is itself text -- doctrine, a schema, a prompt, a reviewer
+  definition -- is probed the same way as code: replay it against the recorded
+  case that motivated it (the incident artifact, the tool-usage transcript, the
+  review that missed the defect), red under the old text, green under the new.
+  "No probe is possible" is shown, never declared. The exemption an earlier
+  proposal would have granted was rejected on evidence: the unit cited as
+  unprobeable text was a code unit that modified six production modules and
+  shipped four assertion harnesses, while doctrine and prompt changes have been
+  measured here by replay (three headless probes of a prompt change; an ad-hoc
+  checklist that caught in one round what ten rounds missed). Paid for per this
+  skill's own `vision.md` cumulative-ratchet rule: 67 words of illustration and
+  rationale deleted from the same paragraph, net -2 words.
+- **Form budget belongs to the first draft (shared spine `review.md`,
+  byte-identical x3).** The lean operative form is the FIRST draft's form, not
+  the round-3 rescue: the review request states the artifact's line count
+  against a budget the author fixed before drafting, and an artifact over budget
+  is the reviewer's first finding, before content. The ~1,250 -> ~500 line
+  measurement already in the file is its anchor. Spine delta is synced in the
+  repo; kb and mkt ship it at their next release.
+
 ## [1.30.0] - 2026-09-01
 
 ### Added

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-sdlc-skill",
-  "version": "1.30.0",
+  "version": "1.32.0",
   "description": "Documentation-First SDLC protocol with triage, Vision governance and optional devPNT integration.",
   "author": "Antonio Pinto (https://github.com/Antoneeo)"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antoneeo/agentic-sdlc-skill",
-  "version": "1.30.0",
+  "version": "1.32.0",
   "description": "Documentation-First SDLC protocol for Claude Code, Gemini CLI, Google Antigravity and Codex with risk triage, Vision governance, installed support files and optional devPNT integration.",
   "keywords": [
     "claude-code",

package/scripts/lib.js

@@ -639,6 +639,73 @@ function removeGlobalOrientHooks(removedRoots) {
   return removedFrom;
 }
 
+// --- Per-turn reminder hook (F-046) ----------------------------------------
+// `orient` fires once and decays; a session that never loads the skill never
+// had the protocol at all. This hook re-arms one constant line every prompt.
+// It is wired ALONGSIDE the orient hook and never instead of it, and it is its
+// own function because `wireOrientHook` returns early when the session hook is
+// already there -- which is the state of every existing installation.
+// Owner-accepted per-turn cost: `ai_docs/vision/rulings.md` r19.
+
+const REMIND_HOOK_TIMEOUT = 5;
+
+function remindHookCommand(python, validator) {
+  return python + ' "' + validator + '" remind';
+}
+
+function findRemindHook(settings) {
+  const groups = settings && settings.hooks && settings.hooks.UserPromptSubmit;
+  if (!Array.isArray(groups)) return null;
+  for (const group of groups) {
+    if (!group || typeof group !== 'object') continue;
+    const inner = Array.isArray(group.hooks) ? group.hooks : [group];
+    for (const h of inner) {
+      const cmd = h && typeof h.command === 'string' ? h.command : '';
+      if (ORIENT_ENTRY_POINTS.some((n) => cmd.includes(n)) && / remind(\s|$)/.test(cmd)) {
+        return cmd;
+      }
+    }
+  }
+  return null;
+}
+
+// Writes the hook into `target` (an already-chosen settings file) unless it is
+// there or the user opted out. Returns a code, never throws: an installer must
+// not die on someone's settings file.
+function wireRemindHookInto(target, python, validator) {
+  if (!python) return { code: 'no-python' };
+  if (!validator || ORIENT_UNSAFE_IN_PATH.test(validator)) return { code: 'unsafe-path', validator };
+  const state = orientSettingsState(target);
+  if (!state.ok) return { code: 'malformed', target, why: state.why };
+  if (orientMarkerHas(target)) return { code: 'opted-out', target };
+  const settings = state.settings;
+  const existing = findRemindHook(settings);
+  if (existing) return { code: 'already', target, command: existing };
+  const command = remindHookCommand(python, validator);
+  if (!settings.hooks) settings.hooks = {};
+  if (!Array.isArray(settings.hooks.UserPromptSubmit)) settings.hooks.UserPromptSubmit = [];
+  settings.hooks.UserPromptSubmit.push({
+    hooks: [{ type: 'command', command, timeout: REMIND_HOOK_TIMEOUT }],
+  });
+  try {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, JSON.stringify(settings, null, 2) + String.fromCharCode(10), 'utf8');
+  } catch (e) {
+    return { code: 'write-failed', target, command, error: e.message };
+  }
+  return { code: 'wired', target, command };
+}
+
+
+// The machine-global twin of wireGlobalOrientHook, same target and validator.
+function wireGlobalRemindHook(options) {
+  const client = options.client;
+  const validator = path.join(skillTarget(client), 'scripts', ORIENT_ENTRY_POINT);
+  if (!fs.existsSync(validator)) return { code: 'no-validator', validator };
+  return wireRemindHookInto(path.join(client.home, 'settings.json'), options.python, validator);
+}
+
+
 module.exports = {
   PACKAGE_ROOT,
   SKILL_SOURCE,
@@ -649,6 +716,10 @@ module.exports = {
   clientDetected,
   skillTarget,
   wireOrientHook,
+  wireRemindHookInto,
+  wireGlobalRemindHook,
+  remindHookCommand,
+  findRemindHook,
   wireGlobalOrientHook,
   removeGlobalOrientHooks,
   detectPython,

package/scripts/postinstall.js

@@ -3,7 +3,7 @@
 const fs = require('fs');
 const {
   SKILL_SOURCE, CLIENTS, clientDetected, skillTarget, copyRecursive,
-  wireGlobalOrientHook, detectPython,
+  wireGlobalOrientHook, wireGlobalRemindHook, detectPython,
 } = require('./lib');
 
 function installSkill(client) {
@@ -39,6 +39,18 @@ for (const client of CLIENTS) {
     // marker remembers. A convenience must never fail an npm install: wrapped.
     if (client.key === 'claude' && installed) {
       try {
+        // F-046: the per-turn reminder, wired alongside and never instead of
+        // the session hook. `orient` decays; this one re-arms one constant line
+        // every prompt, and its first duty is the one that was missing -- decide
+        // whether the skill governs the work and, if so, load it once, because
+        // an unread protocol cannot be applied. Owner-accepted per-turn cost:
+        // ai_docs/vision/rulings.md r19.
+        const rr = wireGlobalRemindHook({ client, python: detectPython() });
+        if (rr.code === 'wired') {
+          console.log('🔗 Per-turn protocol reminder wired for every project on this machine');
+          console.log(`   (${rr.target}). One constant line per prompt; remove that hook`);
+          console.log('   entry to opt out — it will not be re-added.');
+        }
         const r = wireGlobalOrientHook({ client, python: detectPython() });
         if (r.code === 'wired') {
           console.log('🔗 Session orientation wired for every project on this machine');

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

@@ -157,6 +157,46 @@ 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 the validator into the repo, the hook references that copy — keep both files current when you update the skill.
 
+### Per-turn reminder: `remind` (UserPromptSubmit -- wired by default)
+
+`orient` fires once, at session start; a long session drifts after it, and a session
+that never loads the skill never had the protocol at all. Measured (F-046, 2026-09-06):
+a release ran against a `GUIDE_release.md` the session never consulted, because
+`SKILL.md` -- where the duty is written -- had not been read. `sdlc_check.py remind` prints
+ONE constant line at every prompt, and its first duty is that one: decide whether the
+skill governs the work in front of you and, if it does, load it once.
+
+Cost: 478 characters, ~80 tokens per prompt, paid on every turn including
+trivial ones. That is admissible only because the owner accepted it explicitly
+(`ai_docs/vision/rulings.md` r19, the "no ceremony ratchet" Non-Goal's second door) --
+and the acceptance was for a FLAT cost. Hence the contract, guarded by
+`scripts/test_remind.py`: the line is **constant and reads nothing** (so nothing repo-
+or session-controlled rides into the agent's context through it, and the cost cannot
+grow with the session), it is **one line under 500 characters**, and it **can never
+break a prompt** (argv ignored whole, always exit 0). A trivial turn pays a yes/no
+judgement, never a load.
+
+Installing the package wires it machine-wide on Claude Code, alongside the orientation
+hook and never instead of it; **removing that hook entry is a standing opt-out.** To
+wire it by hand:
+
+```json
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python \"C:\Users\<user>\.claude\skills\agentic-sdlc\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` + `sdlc_core.py`; §1–§4 are theirs.)

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

@@ -1,6 +1,6 @@
 ---
 name: agentic-sdlc
-version: 1.30.0
+version: 1.32.0
 description: Documentation-First SDLC protocol with risk-proportional triage, Vision as a guide, a complete Standalone mode and optional symbiosis with devPNT. Use for features, significant bugs, refactors, audits and documented maintenance.
 author: Antonio Pinto (https://github.com/Antoneeo)
 copyright: (c) 2026 Antonio Pinto
@@ -238,9 +238,11 @@ For any L3, run the spec elicitation round in `elicitation.md` BEFORE drafting t
 
 **Architect before you list files.** Once the spec is known and BEFORE drafting the Impact, run the architect pass in `architect.md`: state what the feature requires the system to be able to DO (capabilities — verbs over domain nouns, no files), rule each one against the platform — **EXISTS** (name the component and where it lives) / **INADEQUATE** (name the gap) / **MISSING** (say what you searched) — and design what is missing as a component with **its own contract, in its own vocabulary**, of which this feature is one consumer. The output goes where that mode keeps designs — Standalone: the ANALYSIS `## Capability Ledger`; Hybrid: the `E-ISP`, above its Impacted Components map (`architect.md`; never a second copy in `ai_docs/`) — and it feeds the Impact. Note the coverage asymmetry: the validator backstop reads Standalone ANALYSIS files only, so in Hybrid the sole check that the pass ran is `review.md`'s ledger clause — which is why that clause fires on a MISSING ledger and not only on the rows of one that is present. Why it is its own step: a feature is not a unit of construction, and an agent that skips it builds the missing capability inside the feature's code path, where no component owns it and the next feature rebuilds it differently. The pass is a question, not a form — when every capability plainly exists, one line answers it.
 
+**Would a guide be worth writing here?** Ask it while you analyze — this is when you are paying to build the model, and the answer decides whether the next session inherits it or re-derives it. Two questions, one line each in the ANALYSIS: does a CURRENT guide already cover what I am about to touch, and did understanding this force a model of a high-complexity component that none covers (then writing it is a duty, `guides.md` §1)?
+
 **Blast-radius enumeration is an authoring duty, not a review finding.** Before writing the Impact (the list of what changes), for every symbol whose signature you change, thread a new field through, or that has more than one caller: mechanically enumerate EVERY consumer with the best symbol-graph tool your toolchain offers — an LSP/IDE call hierarchy or a find-usages / call-graph capability — with `grep` only as a last-resort fallback, and list the full set in the Impact. Anchor to symbol identity, not line numbers (they rot). This is deterministic and cheap: doing it up-front collapses the review into one pass, instead of the reviewer returning "you missed a consumer" one round at a time. Leaving completeness to the closure review is the myopia failure this whole workflow exists to prevent.
 
-**Execute-Before-Specify — behavioural claims about existing code are probed, not read.** Every claim in an L3 design artifact of the form "the code today does X" — what a loader leaves behind on failure, which exception escapes a `try`, what a store publishes when its file is corrupt — MUST derive from an executed probe (a small script or assertion harness run against the real system in its real states) before the prose is written, never from reading the source alone. Reading is structurally insufficient for behaviour: an author who only reads cannot see that a called function does not exist, or that the exception they reasoned about is caught two frames down. The duty is proportional: it covers the claims the design RESTS on — where a wrong answer changes the design — never every mention of existing code; structural facts (a file exists, a symbol's signature, who calls it) belong to the blast-radius enumeration above, not to a probe. And a probe must be able to FAIL: show it red first — negate the condition or the state it asserts — then green against the real system (the RED gesture of `tdd.md`, applied to the experiment); a probe you cannot make fail establishes nothing, and a vacuous assertion is a read claim wearing a probe's clothes. Keep the probes as an assertion harness that ships WITH the artifact, in the repo (e.g. `ai_docs/solutions/harness_[feature]/` — a scratchpad dies with the session): the reviewer re-runs assertions instead of re-deriving claims, and every later revision re-verifies them for free. Field measurement (2026-08): eight consecutive design-review FAILs, every finding the class "the design describes intent, not behaviour", converged to a PASS in one round once each behavioural claim was executed first — probed claims held in every subsequent round; read claims failed in every one.
+**Execute-Before-Specify — behavioural claims about existing code are probed, not read.** Every claim in an L3 design artifact of the form "the code today does X" MUST derive from an executed probe (a small script or assertion harness run against the real system in its real states) before the prose is written, never from reading the source alone. The duty is proportional: it covers the claims the design RESTS on — where a wrong answer changes the design — never every mention of existing code; structural facts (a file exists, a symbol's signature, who calls it) belong to the blast-radius enumeration above, not to a probe. A deliverable that is itself text — doctrine, a schema, a prompt, a reviewer definition — is probed the same way: replay it against the recorded case that motivated it (the incident artifact, the tool-usage transcript, the review that missed the defect), red under the old text, green under the new. "No probe is possible" is shown, never declared. And a probe must be able to FAIL: show it red first — negate the condition or the state it asserts — then green against the real system (the RED gesture of `tdd.md`, applied to the experiment); a probe you cannot make fail establishes nothing. Keep the probes as an assertion harness that ships WITH the artifact, in the repo (e.g. `ai_docs/solutions/harness_[feature]/` — a scratchpad dies with the session): the reviewer re-runs assertions instead of re-deriving claims, and every later revision re-verifies them for free. Field measurement (2026-08): eight consecutive design-review FAILs, every finding the class "the design describes intent, not behaviour", converged to a PASS in one round once each behavioural claim was executed first — probed claims held in every subsequent round; read claims failed in every one.
 
 Standalone L3:
 - Before creating a new `ANALYSIS_[feature].md`, search `ai_docs/solutions/` with glob/grep for an existing analysis on the same topic: if there is one, update it instead of duplicating it.
@@ -264,7 +266,7 @@ Hybrid L3:
 - Isolate the work: run an L3 change on its own branch. In Hybrid, prefer a git worktree from the start — a running devPNT server locks `.devpnt/*.db` and blocks in-place branch switches/merges in the primary worktree.
 - Modify surgically, consistently with the plan.
 - Implementation work follows the TDD discipline in `tdd.md` (RED/GREEN/REFACTOR — the L2/L3 default; record the reason when it does not apply).
-- Before implementing (L2/L3; L1 exempt), **consult the guide router** for a guide covering the task — operative, or a comprehension map of the component you are about to touch — and read it first (the consult trigger, `guides.md` §0, summarized under `## Operative Guides`). A targeted description match, not a blanket read. Its result is the router verdict already declared with the triage level (Rule Zero); re-run the lookup here only if the work has moved to a topic the first lookup did not cover, and say so if the verdict changes.
+- Before implementing (L2/L3; L1 exempt), **consult the guide router** — the verdict already declared with the triage level (`## Operative Guides`). Re-run the lookup here only if the work has moved to a topic the first one did not cover, and say so if the verdict changes.
 - If the environment does not allow automated tests, declare the alternative verification and the reason.
 - For bugs (L2/L3), follow the systematic debugging method in `debugging.md`.
 - Circuit breaker: after 3 consecutive runs without progress on the tests, stop, switch to the systematic method in `debugging.md`, and ask for instructions if still stuck. `debugging.md` also covers **chronic fragility** — a component that breaks repeatedly across sessions is a comprehension + complexity signal (write the `source_kind: code` guide AND escalate a refactor), not a fourth patch.
@@ -278,7 +280,7 @@ Hybrid L3:
 - For the review itself follow `review.md` (requesting and receiving findings) — the single definition, intended for reuse by the Hybrid review gates (devPNT-side wiring out of this unit's scope).
 - Verify alignment with the local Vision or the devPNT M-VISION.
 - If the work was governed by user-provided indications and is reusable, **PROPOSE distilling a guide** (proactive trigger, `guides.md` §1) — a proposal for the user, never a silent write, never from model knowledge.
-- **Comprehension checkpoint**: ask explicitly — *did this session force me to build a model of a high-complexity component that no CURRENT guide covers?* If yes, WRITE the `source_kind: code` guide now (a duty, not a proposal — `guides.md` §1) and say so in the closure. The knowledge you paid to build is at its most complete right here; one closure later it is gone, and the next session re-derives it or breaks the component from partial understanding.
+- **Comprehension checkpoint** — the backstop for the Phase-3 question, when the signal only became visible while implementing: did this session force a model of a high-complexity component no CURRENT guide covers? If yes, WRITE the `source_kind: code` guide now (a duty, not a proposal) and say so in the closure. One closure later that model is gone.
 - Update only the documents actually impacted.
 - **Update the workstream registry (`audit/handoff.md`)** — mandatory at every L3 closure: DELETE the closed workstream's `audit/HANDOFF_[feature].md` (history lives in git and in the Diary) and re-run `sdlc_check.py index`. Deleting the file *is* removing the row, and no other workstream's file is touched — that is the parallel-safety the registry exists for. Never edit the generated file: `validate` errors when it disagrees with its sources. The session-end rule and the L2 case: Write Triggers.
 - **Aligned indexes (Poka-Yoke)**: if you created, moved or removed canonical documents (`vision/`, `reference/`, `architecture/`, `functional/`, `strategic/`):

package/skills/agentic-sdlc-skill/guides.md

@@ -60,6 +60,10 @@ already cover how to do this well?*
   match was not targeted (T7). Two guides are legitimate only when they cover
   distinct concerns — typically an operative guide plus the comprehension map of
   the component being touched; three is a smell, not a thorough lookup.
+- **Check a `code` guide against the code before you trust it.** No check can do
+  this for you (§6): the reader is the only one who sees that the map and the
+  component have parted. A divergence you observe is yours to close in the same
+  unit of work.
 - **Under subagent dispatch** the consult happens at plan-authoring time (the
   orchestrator populates each task's `guides` field); a context-free subagent
   reads the pointers it was handed and does not run its own router lookup. See
@@ -271,17 +275,17 @@ state it explicitly when handing off a newly created guide.
 
 ## 6. Maintenance
 
-- **Source changed**: create a new snapshot (new hash), regenerate the guide
-  from it (new `source_hash`), and if the guide is replacing a prior guide
-  rather than updating in place, mark the old one `status: SUPERSEDED`.
-- **`stale` flags hash drift**: `sdlc_check.py stale` (also under `--hybrid`)
-  compares each guide's recorded `source_hash` against the live snapshot file
-  and reports `[stale]` when they diverge — that is the signal to regenerate,
-  not a manual freshness check.
-- **`source_kind: code` freshness**: `stale` works unchanged (the code-excerpt
-  snapshot drifts when the code changes → regenerate). ADDITIONALLY, when you modify
-  the code a comprehension guide describes, refresh that guide in the SAME closure
-  (docs travel with the code) — do not wait for `stale` to catch it. A stale
-  comprehension guide is a confident-wrong map, worse than none.
+- **Source changed**: new snapshot, regenerate the guide from it (new
+  `source_hash`); a guide REPLACING another is `status: SUPERSEDED` on the old
+  one. `sdlc_check.py stale` (also under `--hybrid`) reports `[stale]` when a
+  guide's recorded hash and its snapshot file diverge — the signal to regenerate.
+- **`source_kind: code` freshness is NOT mechanized.** `stale` compares the guide
+  to its snapshot, and a code snapshot is a frozen copy — so a map whose component
+  was rewritten reports FRESH forever (measured 2026-09-06: +388/-71 lines in the
+  guided module, `stale` silent). The duty is therefore the author's, twice: when
+  you MODIFY code a comprehension guide describes, refresh the guide in the same
+  closure (docs travel with the code); when you merely READ one, check it against
+  the code before trusting it. Too large to absorb → mark it `SUPERSEDED` rather
+  than leave a confident-wrong map badged CURRENT, which is worse than none.
 - **Agent-global KB guides** use the same pipeline and validator via
   `--root ~/.agentic-sdlc`; freshness via the same `stale` engine.

package/skills/agentic-sdlc-skill/review.md

@@ -98,10 +98,12 @@ unfalsifiable, the same defect as an unnamed EXISTS or a faked router verdict.
 own findings and can make the cap unreachable honestly. (1) *Patch-on-patch*:
 each round's fixes are grafted onto the previous text until stale counts,
 duplicated sections and internal contradictions are findings the revisions
-themselves created. When a round's findings are of that artifact-consistency
-class — and at the latest before a round-3 attempt — rewrite the artifact lean
-and operative against the checklist instead of patching again; a from-scratch
-rewrite is cheaper than a burned round. (2) *Revision narrative in the
+themselves created. The lean operative form is the FIRST draft's form, not the
+round-3 rescue: the review request states the artifact's line count against a
+budget the author fixed before drafting (default: the measured figure below), and
+an artifact over budget is the reviewer's first finding, before content. When a
+round's findings are of that artifact-consistency class, rewrite lean instead of
+patching again. (2) *Revision narrative in the
 artifact*: the artifact under review carries its own review archaeology
 ("v1.2 fixed…", "as the round-2 review noted…"). An artifact states what IS,
 once; how it got there lives in the REVIEW_LOG row's notes, never in the

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

@@ -60,6 +60,15 @@ sdlc_core.set_profile(
         "subagent_dispatch", "legacy_narrative_handoff", "question_discipline",
     ),
     design_gate_between=("### 3. Request Analysis", "### 4. Development and Testing"),
+    remind_line=(
+        "first decide if this skill governs the work; if yes, LOAD it once -- an "
+        "unread protocol cannot be applied. Declare the level (L1/L2/L3/Spike) "
+        "and the guide-router verdict before acting; an imperative is a request "
+        "to triage. Name the mechanism before fixing the first defect you can "
+        "measure -- symptom patches recur and stack. Replay governing text -- "
+        "doctrine, a prompt, a schema -- against the case that motivated it: red "
+        "under the old text, green under the new."
+    ),
 )
 
 

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

@@ -268,16 +268,18 @@ _PROFILE = {
     "support_files": (),
     "capabilities": frozenset(),
     "design_gate_between": (),
+    "remind_line": "",
 }
 
 
 def set_profile(skill_name, support_files=(), capabilities=(), unit_noun="feature",
-                design_gate_between=()):
+                design_gate_between=(), remind_line=""):
     _PROFILE.update(skill_name=skill_name,
                     unit_noun=unit_noun,
                     support_files=tuple(support_files),
                     capabilities=frozenset(capabilities),
-                    design_gate_between=tuple(design_gate_between))
+                    design_gate_between=tuple(design_gate_between),
+                    remind_line=remind_line)
 
 
 def profile():
@@ -1796,6 +1798,43 @@ def cmd_check(root, strict=False, hybrid=False):
 
 # --------------------------------------------------------------------- gate
 
+# --- UserPromptSubmit reminder hook (F-046) --------------------------------
+# `orient` fires once per session and decays; a session that never invokes the
+# skill never had the protocol at all. Measured 2026-09-06: a release ran in
+# this repo against a `GUIDE_release.md` the session never consulted, because
+# SKILL.md -- where the duty is written -- had not been read.
+#
+# The carrier is kb's (F-041 item B), lifted here so all three lenses share one
+# machine instead of two that do the same thing. Its contract is kept: the line
+# is CONSTANT and reads NOTHING -- nothing repo- or session-controlled may ride
+# text injected every turn, and zero reads is what keeps the per-turn cost flat.
+# What changed is the payload's first duty and the wiring. First duty: decide
+# whether the skill governs this work and, if it does, read it once -- an
+# unread protocol cannot be applied, which is the failure above. Wiring: a
+# default instead of opt-in, on the owner's explicit acceptance of the per-turn
+# cost (`vision/rulings.md` r19; the "no ceremony ratchet" Non-Goal admits a
+# never-zero cost by that acceptance, and a trivial turn pays a yes/no
+# judgement, never a load).
+
+REMIND_FALLBACK = (
+    "decide whether the {skill} skill governs this work; if it does, load it "
+    "once before acting -- an unread protocol cannot be applied."
+)
+
+
+def cmd_remind(args):
+    """UserPromptSubmit hook: print the lens's constant per-turn line. Always 0.
+
+    argv is ignored whole and nothing is read: a hook surface must not fail, and
+    a flag typo must not cost a turn's context."""
+    try:
+        prof = profile()
+        line = prof.get("remind_line") or REMIND_FALLBACK.format(skill=prof["skill_name"])
+        print(f"{prof['skill_name']}: {line}")
+    except Exception:
+        pass
+    return 0
+
 def cmd_gate(args):
     file_path = args.file or ""
     if args.hook:
@@ -2229,6 +2268,12 @@ def cmd_migrate(root, args):
 # --------------------------------------------------------------------- main
 
 def main(argv=None):
+    # `remind` is intercepted BEFORE argparse (kb's F-041 rule, kept): it is a
+    # hook surface fired on every prompt, so a stray flag must cost a usage
+    # message and a non-zero exit on a turn, not the turn itself.
+    if (argv if argv is not None else sys.argv[1:])[:1] == ["remind"]:
+        return cmd_remind(None)
+
     common = argparse.ArgumentParser(add_help=False)
     common.add_argument("--root", help="project root (default: walk up until a docs root is found)")
     common.add_argument("--docs-dir", dest="docs_dir",
@@ -2273,6 +2318,10 @@ def main(argv=None):
     sub.add_parser("orient", parents=[common, hybrid_opt],
                    help="SessionStart hook: emit docs-root orientation to stdout (fail-open, zero-execution)")
 
+    sub.add_parser("remind", parents=[common],
+                   help="UserPromptSubmit hook: print the constant per-turn line "
+                        "(fail-open, zero-read, zero-execution)")
+
     pp = sub.add_parser("plan", parents=[common],
                         help="Subagent Execution: validate/brief a PLAN_[feature].md (zero-execution)")
     pp_sub = pp.add_subparsers(dest="plan_cmd", required=True)
@@ -2296,7 +2345,7 @@ def main(argv=None):
             # nothing is being guessed. Refusing here would make the guard block the
             # one command that ends the ambiguity.
             discovered, name = None, args.from_dir
-        elif args.cmd == "orient":
+        elif args.cmd in ("orient", "remind"):
             # The SessionStart hook is fail-open by contract: it must never block a
             # session, not even on a half-migrated tree. It orients on the default
             # and says so rather than exiting non-zero.
@@ -2311,6 +2360,8 @@ def main(argv=None):
         return cmd_gate(args)
     if args.cmd == "orient":
         return cmd_orient(args)
+    if args.cmd == "remind":
+        return cmd_remind(args)
 
     root = Path(args.root).resolve() if args.root else (discovered or find_project_root())
     if args.cmd == "check":