@tenkara/afm-linux-arm64 4.0.0-alpha.7 → 4.0.0-alpha.9

package/plugin/claude-code/skills/gotcha/SKILL.md

@@ -9,8 +9,10 @@ description: |
 
 > **Questions in this host.** `afm ask <op>` prompts only in a terminal, and the Bash tool has none: it exits 2. Run `afm ask <op> --json` instead and put each pending question to the operator with `AskUserQuestion`: its `header`, `prompt` and `options` as they come, the recommended option first, `multiSelect` as given. Then record each choice with `afm answer <op> <id> <label>` (one label per selected option). Run `afm ask <op>` again: `all questions answered` means the op may go on.
 
-Atomic skill of `afm`. The canonical procedure is the op `afm path ops/gotcha`. The CLI owns the entry
-gate, the number, the frontmatter the trigger index reads and the index. This skill keeps only the judgment.
+> **Procedure.** Run `afm read ops/gotcha.md` and follow it; read an on-demand section when its condition holds.
+
+The CLI owns the entry gate, the number, the frontmatter the trigger index reads and the index. This skill
+keeps only the judgment.
 
 ## When NOT to activate
 
@@ -34,9 +36,11 @@ signal belongs to `/afm:remediate`.
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES`. Universals §1-8 apply. Two matter most here: #5 (do not
+Most relevant here: #5 (do not
 invent a gotcha without a real case; the 2x entry check is a strong gate) and #6 (autonomy-first: save the
 result and report it).
 
 Passive mode (`/afm:reconcile`) is always on and can propose `/afm:gotcha` when it detects the signal "the
 same runtime surprise blocked work twice." This skill covers only active registration.
+
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/claude-code/skills/init/SKILL.md

@@ -71,14 +71,11 @@ procedure is in `afm path interview/bootstrap` § Alternate branch. `.afm-versio
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES`. For this skill (greenfield), the 8 universals apply (§1-8).
-#9 (retroactive ADR, load-bearing) does NOT apply to init. Bootstrap forbids a retroactive ADR.
+For this skill (greenfield), #9 (retroactive ADR, load-bearing) does NOT apply to init. Bootstrap forbids a retroactive ADR.
 
 ## Continuous doctrine
 
-Passive mode (`/afm:reconcile`) is the responsibility of the `reconcile` skill. It stays always-on in any AFM
+Passive mode (`/afm:reconcile`) stays always-on in any AFM
 project session. This skill covers only the active bootstrap procedure.
 
-## Version
-
-`afm version` prints the version in use. History: `afm path CHANGELOG`.
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/claude-code/skills/plan/SKILL.md

@@ -9,11 +9,11 @@ description: |
 
 > **Questions in this host.** `afm ask <op>` prompts only in a terminal, and the Bash tool has none: it exits 2. Run `afm ask <op> --json` instead and put each pending question to the operator with `AskUserQuestion`: its `header`, `prompt` and `options` as they come, the recommended option first, `multiSelect` as given. Then record each choice with `afm answer <op> <id> <label>` (one label per selected option). Run `afm ask <op>` again: `all questions answered` means the op may go on.
 
-An atomic skill. The procedure lives in the op: read it with `afm path ops/plan.md`, end to end, and follow it literally.
+> **Procedure.** Run `afm read ops/plan.md` and follow it; read an on-demand section when its condition holds.
 
 ## When NOT to activate
 
-There is no `spec.md` yet: run `/afm:specify` first. An end-to-end delivery is `deliver`, which composes this op.
+There is no `spec.md` yet: run `/afm:specify` first. An end-to-end delivery is `/afm:deliver`, which composes this op.
 
 ## Pre-check
 
@@ -25,12 +25,10 @@ Read the stack from `docs/ach.md` and never reopen it. Infer the components, dec
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES.md`. Universals §1-8 apply. In particular #2 (discover-first: scan before you ask), #5 (do not invent contracts or a stack) and #8 (a question carries a recommendation).
+Most relevant here: #2 (discover-first: scan before you ask), #5 (do not invent contracts or a stack) and #8 (a question carries a recommendation).
 
 ## Continuous doctrine
 
-Passive mode is the always-on `reconcile` skill. This skill covers only the planning.
+Passive mode (`/afm:reconcile`) is always on. This skill covers only the planning.
 
-## Version
-
-`afm version`. History: `afm path CHANGELOG.md`.
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/claude-code/skills/policy/SKILL.md

@@ -7,7 +7,7 @@ description: |
 
 # AFM — Policy (report the organisation layer)
 
-Atomic skill of `afm`. The canonical procedure is the op `afm path ops/policy`.
+> **Procedure.** Run `afm read ops/policy.md` and follow it; read an on-demand section when its condition holds.
 
 ## When not to activate
 
@@ -26,6 +26,4 @@ Run `afm policy report` and read it by family. Say plainly that a policy bundle
 nothing, and name what the reader may not edit here and who owns it. Never report a policy rule as
 enforced.
 
-## Invariant principles
-
-Single canonical source: `afm path PRINCIPLES`. Universals §1-8 apply.
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/claude-code/skills/promote/SKILL.md

@@ -7,7 +7,7 @@ description: |
 
 # AFM — Promote
 
-Atomic skill of `afm`. The canonical procedure is the op `afm path ops/promote`.
+> **Procedure.** Run `afm read ops/promote.md` and follow it; read an on-demand section when its condition holds.
 
 ## When NOT to activate
 
@@ -31,7 +31,7 @@ bring the plugin INTO the instance (the opposite direction).
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES`. Universals §1-8 apply. That includes #5: never record a
+Most relevant here: #5: never record a
 project-specific learning, and never one without a real case; the list grows on demand.
 
 It also includes #6/#7: the plugin boundary is **absolute**. This op records a finding and never applies a
@@ -39,3 +39,5 @@ change.
 
 Passive mode (`/afm:reconcile`) is always on and can propose `/afm:promote` when it detects a signal that a
 learning generalizes to any project.
+
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/claude-code/skills/protocol/SKILL.md

@@ -7,8 +7,9 @@ description: |
 
 # AFM — Protocol (declared autonomy posture)
 
-Skill of `afm`. The canonical procedure is the op `afm path ops/protocol`. Field and preset definitions are
-in `afm path core/protocol`.
+> **Procedure.** Run `afm read ops/protocol.md` and follow it; read an on-demand section when its condition holds.
+
+Field and preset definitions are in `afm path core/protocol`.
 
 > **A protocol is data, not a new execution path.** It parametrizes operations that already exist. A project
 > with no `protocol:` declared uses the defaults, which reproduce pre-v4 behavior.
@@ -35,8 +36,10 @@ Outside the three presets, the file must already exist: never invent one.
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES`. See especially #4 and #5.
+Most relevant here: #4 and #5.
 
 #4: `[TBD]` beats invention. An instance with no declared posture does not receive an assumed one.
 
 #5: Do not invent a preset without a real case.
+
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/claude-code/skills/reconcile/SKILL.md

@@ -6,6 +6,8 @@ description: |
 
 # AFM — Reconcile (passive mode, always-on)
 
+> **Procedure.** Run `afm read ops/reconcile.md` and follow it; read an on-demand section when its condition holds.
+
 The always-on skill. It loads the continuous doctrine and the passive-mode procedure, and it is the only skill that activates by default in any AFM project session. Every other skill needs explicit invocation or specific natural language.
 
 ## When NOT to activate
@@ -24,7 +26,7 @@ One criterion decides where something belongs (universal principle #1, source in
 
 `docs/` holds rules, decisions, gotchas, architecture, persona, flows and cross-module contracts. The agent's memory holds only the user's style and durable preferences ("small PRs, not big bundles") and personal context (role, years of experience, current focus).
 
-`docs/` is a living source, **not a frozen bootstrap artifact**: it evolves through the whole session by passive reconcile. The signal table is `afm path interview/triggers.md`. The procedure is the op: read it with `afm path ops/reconcile.md`.
+`docs/` is a living source, **not a frozen bootstrap artifact**: it evolves through the whole session by passive reconcile. The signal table is `afm path interview/triggers.md`.
 
 ## Procedure (always-on)
 
@@ -42,8 +44,6 @@ Never apply an edit without proposing it first, never save a project rule in mem
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES.md`. Universals §1-8 apply, in particular #1 (the one criterion for memory against doc), #5 (no gotcha or rule without a case) and #6 (reconcile PROPOSES at the end of the turn).
-
-## Version
+Most relevant here: #1 (the one criterion for memory against doc), #5 (no gotcha or rule without a case) and #6 (reconcile PROPOSES at the end of the turn).
 
-`afm version`. History: `afm path CHANGELOG.md`.
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/claude-code/skills/refactor/SKILL.md

@@ -72,15 +72,12 @@ For brownfield projects without `docs/.afm-version`:
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES`. For this skill (brownfield), **all** apply: the 8 universals
+For this skill (brownfield), **all** principles apply: the 8 universals
 §1-8 plus the addition §9 (a retroactive ADR is load-bearing-only). #9 separates refactor from init. Init
 forbids retroactive ADRs.
 
 ## Continuous doctrine
 
-Passive mode (`/afm:reconcile`) is the responsibility of the `reconcile` skill. It is always-on in any AFM
-project session. This skill covers only the active refactor procedure.
+Passive mode (`/afm:reconcile`) is always-on in any AFM project session. This skill covers only the active refactor procedure.
 
-## Version
-
-`afm version` prints the version in use. History: `afm path CHANGELOG`.
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/claude-code/skills/reflect/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: reflect
 description: |
-  Finds where the local docs failed AS A HARNESS in this session. Examples are an ambiguous rule applied wrong, a doc that misled, and a user correction against the doc. The evidence is the session trajectory, never a static scan. It proposes edits that make the docs more assertive.
+  Finds where the local docs failed AS A HARNESS in the live session and the project's sessions since the last cycle. Examples are an ambiguous rule applied wrong, a doc that misled, and a user correction against the doc. The evidence is the session trajectory, never a static scan. It proposes edits that make the docs more assertive.
   Activates: `/afm:reflect`, "this rule is ambiguous", "the doc sent me the wrong way", "why do I keep getting this wrong when the doc covers it?".
 ---
 
@@ -10,46 +10,40 @@ description: |
 
 > **Questions in this host.** `afm ask <op>` prompts only in a terminal, and the Bash tool has none: it exits 2. Run `afm ask <op> --json` instead and put each pending question to the operator with `AskUserQuestion`: its `header`, `prompt` and `options` as they come, the recommended option first, `multiSelect` as given. Then record each choice with `afm answer <op> <id> <label>` (one label per selected option). Run `afm ask <op>` again: `all questions answered` means the op may go on.
 
-Mechanism skill of AFM. The canonical procedure is the op file that `afm path ops/reflect.md` prints.
+> **Procedure.** Run `afm read ops/reflect.md` and follow it; read an on-demand section when its condition holds.
 
-> **Carve-out (does not overlap existing ops):** `reconcile` works **code to docs, and is additive**. It learns a new fact and proposes adding it. `reflect` works **docs to docs, and refines**. An existing doc guided the agent wrong, so `reflect` proposes a clearer version. `diagnose` runs a **static** scan. `reflect` uses **behavioral** evidence from the session trajectory. Only the agent sees its own stumble. `evolve` is the **orchestrator**. It composes `reflect` and `diagnose` into one cycle with a single gate.
+> **Carve-out (does not overlap existing ops):** `/afm:reconcile` works **code to docs, and is additive**. It learns a new fact and proposes adding it. `reflect` works **docs to docs, and refines**. An existing doc guided the agent wrong, so `reflect` proposes a clearer version. `/afm:diagnose` runs a **static** scan. `reflect` uses **behavioral** evidence from the session trajectory. Only the agent sees its own stumble. `/afm:evolve` is the **orchestrator**. It composes `reflect` and `/afm:diagnose` into one cycle with a single gate.
 
 ## When not to activate
 
 This is a disambiguation criterion for a skill already active, not an activation criterion. That is why it lives in the body, not in the resident listing.
 
-Learning a new fact, gotcha, or decision belongs to `reconcile`. Route it to `/afm:gotcha`, `/afm:rule`, or `/afm:adr`. A static mechanical scan belongs to `/afm:diagnose`. Merging N gotchas belongs to `/afm:generalize`. A failure with an external signal belongs to `/afm:remediate`. The full cycle belongs to `/afm:evolve`.
+Learning a new fact, gotcha, or decision belongs to passive mode (`/afm:reconcile`). Route it to `/afm:gotcha`, `/afm:rule`, or `/afm:adr`. A static mechanical scan belongs to `/afm:diagnose`. Merging N gotchas belongs to `/afm:generalize`. A failure with an external signal belongs to `/afm:remediate`. The full cycle belongs to `/afm:evolve`.
 
 ## Pre-check
 
 1. **Does `<consumer>/docs/.afm-version` exist?** If not, stop. Suggest `/afm:init` (greenfield) or `/afm:refactor` (brownfield) first.
 2. **Does `afm preflight` exit 0?** A non-zero exit says why (docs not bootstrapped, content unresolved, pin mismatch). Report it to the user. Do not fall back silently.
-3. **Did the session hit a doc-friction event** (or an articulated symptom)? If not, report "no doc friction observed" and stop. Reflection without behavioral evidence is forbidden (#5).
+3. **Did the live session or the project's sessions since the last cycle hit a doc-friction event** (or an articulated symptom)? Read the window with `afm sessions --since reflect --json` and `afm sessions signals --since reflect --json`. If the whole window has no signal, report "no doc friction observed" and stop. Reflection without behavioral evidence is forbidden (#5).
 
 ## Procedure
 
-Read the op (`afm path ops/reflect.md`) end to end. Follow it literally.
-
 The steps are:
 
-**1. Collection.** Build the behavioral signature φ_b = `(symptom-lived, doc-causal-status, mechanism)`. Cite both the doc passage **and** the session event.
+**1. Collection.** Build the behavioral signature φ_b = `(symptom-lived, doc-causal-status, mechanism)`. Cite both the doc passage **and** the session event (`session:<id>@<ts>`). Weight: one signal in the live session suffices; a past-session signal needs 2 or more sessions, an explicit correction, or `regressed`, and `regressed` comes first. A repeated prompt is a finding: propose the artifact that stops the retyping.
 
 **2. Self-critique.** Consider a rival hypothesis: it was me, not the doc. Apply the guardrail: a violated rule is not a wrong rule. Apply an addressability filter.
 
 **3. Proposal.** Refine instructiveness: rewrite the ambiguous part, add an executable trigger, and remove ambiguity. Add suggestions for the human. This step follows the **shared proposal discipline** in `evolve.md` (`afm path ops/evolve.md`) and does not duplicate it.
 
-**4. Own gate.** Ask item by item, earned, with `afm ask reflect --scope <item-slug>`. `evolve` suppresses this gate.
+**4. Own gate.** Ask item by item, earned, with `afm ask reflect --scope <item-slug>`. `/afm:evolve` suppresses this gate.
 
-**5. Record.** Write to `docs/evolution/NNN-<date>.md`. Add a `promote` suggestion when the finding generalizes. Hand off to `reconcile`.
+**5. Record.** Write to `docs/evolution/NNN-<date>.md`. Add an `/afm:promote` suggestion when the finding generalizes. Hand off to passive mode (`/afm:reconcile`).
 
 ## Invariant principles
 
-The single canonical source is `PRINCIPLES.md` (`afm path PRINCIPLES.md`). Universals §1-8 apply.
-
 Rule #1 applies: refine the doc's instructiveness, not the agent's memory. Rule #5 applies: no lived event, no finding. Rule #6 applies: self-verify, then report. The gate is a load-bearing residue. Bright lines #7 for plugin, deletion, and push apply.
 
 Rule #8 applies: a suggestion or question must be earned, recommendation-first. **No new principle here.** `reflect` is a composed materialization. The doctrine lives in the op file.
 
-## Version
-
-Content version: `afm version` prints it.
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/claude-code/skills/remediate/SKILL.md

@@ -10,7 +10,7 @@ description: |
 
 > **Questions in this host.** `afm ask <op>` prompts only in a terminal, and the Bash tool has none: it exits 2. Run `afm ask <op> --json` instead and put each pending question to the operator with `AskUserQuestion`: its `header`, `prompt` and `options` as they come, the recommended option first, `multiSelect` as given. Then record each choice with `afm answer <op> <id> <label>` (one label per selected option). Run `afm ask <op>` again: `all questions answered` means the op may go on.
 
-Atomic skill of AFM. The canonical procedure is the op file that `afm path ops/remediate.md` prints.
+> **Procedure.** Run `afm read ops/remediate.md` and follow it; read an on-demand section when its condition holds.
 
 ## When NOT to activate
 
@@ -26,16 +26,14 @@ Use `afm.md § 5.1` for an in-task retry at the moment of the error. Use `/afm:g
 
 ## Procedure
 
-Read the op (`afm path ops/remediate.md`) end to end and follow it literally. It includes the promotion gate (#5): 1 user correction OR at least 2 mechanical occurrences promote a failure. A transient failure does not promote. It also includes classification through the rubric `rubrics/failure-classification.md` (`afm path rubrics/failure-classification.md`). For each delta, propose the artifact (procedure or learning) and cite the source `sig=` (hard rule 19). Ask the artifact question with `afm ask remediate --scope <sig>`, materialize the result, close the signature with `afm failures close --sig <sig> --as remediated`, and report it (#6).
+The op includes the promotion gate (#5): 1 user correction OR at least 2 mechanical occurrences promote a failure. A transient failure does not promote. It also includes classification through the rubric `rubrics/failure-classification.md` (`afm path rubrics/failure-classification.md`). For each delta, propose the artifact (procedure or learning) and cite the source `sig=` (hard rule 19). Ask the artifact question with `afm ask remediate --scope <sig>`, materialize the result, close the signature with `afm failures close --sig <sig> --as remediated`, and report it (#6).
 
 ## Invariant principles
 
-The single canonical source is `PRINCIPLES.md` (`afm path PRINCIPLES.md`). See in particular #3 (CRITIC corollary — recognition by tool, not self-judgment). See also #5 (do not promote a failure without recurrence or an oracle) and #6 (propose only, the human approves).
+Most relevant here: #3 (CRITIC corollary — recognition by tool, not self-judgment). See also #5 (do not promote a failure without recurrence or an oracle) and #6 (propose only, the human approves).
 
 ## Continuous doctrine
 
-The `reconcile` skill owns passive mode, and it is always on. It reads `afm failures promotable` at the end of the turn and can propose remediation with no explicit command. The `evolve` cycle uses the failure events as evidence for `reflect`, toward a final remediation. This skill is the active record of the loop.
+Passive mode (`/afm:reconcile`) is always on. It reads `afm failures promotable` at the end of the turn and can propose remediation with no explicit command. The `/afm:evolve` cycle uses the failure events as evidence for `/afm:reflect`, toward a final remediation. This skill is the active record of the loop.
 
-## Version
-
-Content version: `afm version` prints it.
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/claude-code/skills/restructure/SKILL.md

@@ -10,9 +10,9 @@ description: |
 
 > **Questions in this host.** `afm ask <op>` prompts only in a terminal, and the Bash tool has none: it exits 2. Run `afm ask <op> --json` instead and put each pending question to the operator with `AskUserQuestion`: its `header`, `prompt` and `options` as they come, the recommended option first, `multiSelect` as given. Then record each choice with `afm answer <op> <id> <label>` (one label per selected option). Run `afm ask <op>` again: `all questions answered` means the op may go on.
 
-This is a mechanism skill of AFM. The canonical procedure is the op file that `afm path ops/restructure.md` prints.
+> **Procedure.** Run `afm read ops/restructure.md` and follow it; read an on-demand section when its condition holds.
 
-> **Carve-out (does not overlap existing ops):** `diagnose` A1 finds a **dead reference** (the path does not exist). `restructure` staleness finds a path that **exists but changed** while the doc did not. `reconcile` adds **missing** information. `restructure` relocates information that **exists but sits in the wrong place**. `reflect` targets **clarity**. `restructure` targets **location and freshness**. `evolve` is the **orchestrator** that composes this skill when `diagnose` flags staleness or bloat.
+> **Carve-out (does not overlap existing ops):** `/afm:diagnose` A1 finds a **dead reference** (the path does not exist). `restructure` staleness finds a path that **exists but changed** while the doc did not. `/afm:reconcile` adds **missing** information. `restructure` relocates information that **exists but sits in the wrong place**. `/afm:reflect` targets **clarity**. `restructure` targets **location and freshness**. `/afm:evolve` is the **orchestrator** that composes this skill when `/afm:diagnose` flags staleness or bloat.
 >
 > **Maturity (honest YAGNI):** the actionable core today is **staleness** (from git) plus **findability**. **Temperature tiering** (always-hot vs on-demand) is an **opt-in** ADR proposal, only for a doc that has actually outgrown its size. Small docs do not need it.
 
@@ -20,7 +20,7 @@ This is a mechanism skill of AFM. The canonical procedure is the op file that `a
 
 This is a disambiguation guide for a skill that has already activated. It does not gate activation, so it stays in the body, not in the resident listing.
 
-A path that does not exist belongs to `/afm:diagnose` (A1). Staleness means the path exists but changed. Information never documented belongs to `reconcile` → `/afm:gotcha` or `/afm:rule`. An ambiguous doc belongs to `/afm:reflect`. Merging gotchas belongs to `/afm:generalize`. The full cycle belongs to `/afm:evolve`.
+A path that does not exist belongs to `/afm:diagnose` (A1). Staleness means the path exists but changed. Information never documented belongs to passive mode (`/afm:reconcile`) → `/afm:gotcha` or `/afm:rule`. An ambiguous doc belongs to `/afm:reflect`. Merging gotchas belongs to `/afm:generalize`. The full cycle belongs to `/afm:evolve`.
 
 ## Pre-check
 
@@ -30,25 +30,23 @@ A path that does not exist belongs to `/afm:diagnose` (A1). Staleness means the
 
 ## Procedure
 
-Read the op (`afm path ops/restructure.md`) end to end. Follow it literally. Use these five steps.
+Use these five steps.
 
 1. **Staleness scan.** `afm doctor --json` runs it (findings with axis `staleness` and `dead-gotcha`); read them. The git trigger fires in two cases. First case: a path cited in the doc has a later last commit than the doc. Second case: the doc has been stale for more than N commits. A hit is a candidate, not a verdict. The scan never rewrites the doc on its own.
-2. **Findability.** Relocate or cross-reference information that exists but sits buried or in the wrong doc. Cite both locations. Route information that is genuinely missing to `reconcile`.
+2. **Findability.** Relocate or cross-reference information that exists but sits buried or in the wrong doc. Cite both locations. Route information that is genuinely missing to passive mode (`/afm:reconcile`).
 3. **Temperature partition.** Propose a hot/on-demand loading strategy as an opt-in ADR. Do this only when a doc has outgrown its size. Preserve 100% of the content.
-4. **Its own gate.** This gate is load-bearing and earned, one `afm ask restructure --scope <item-slug>` per finding. It follows the **shared-proposal discipline** in `evolve.md` (`afm path ops/evolve.md`), instead of a duplicate copy of that discipline. `evolve` suppresses this gate when it runs.
-5. **Record.** Write the result to `docs/evolution/NNN-<date>.md`. Suggest `promote` if the finding generalizes.
+4. **Its own gate.** This gate is load-bearing and earned, one `afm ask restructure --scope <item-slug>` per finding. It follows the **shared-proposal discipline** in `evolve.md` (`afm path ops/evolve.md`), instead of a duplicate copy of that discipline. `/afm:evolve` suppresses this gate when it runs.
+5. **Record.** Write the result to `docs/evolution/NNN-<date>.md`. Suggest `/afm:promote` if the finding generalizes.
 
 ## Invariant principles
 
-The single canonical source is `PRINCIPLES.md` (`afm path PRINCIPLES.md`). Universal principles §1-8 apply here. Four principles matter most for this skill.
+Most relevant here:
 
 - #2: get git evidence before you propose a change.
 - #3: staleness needs an executable git trigger.
-- #4/#5: missing product content becomes `[TBD]` or goes to `reconcile`. Never invent it.
+- #4/#5: missing product content becomes `[TBD]` or goes to passive mode (`/afm:reconcile`). Never invent it.
 - #6/#8: self-check the work, then pass an earned gate.
 
 **No new principle here.** `restructure` is a composed materialization. The doctrine lives in the op file.
 
-## Version
-
-Content version: `afm version` prints it.
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/claude-code/skills/rule/SKILL.md

@@ -9,9 +9,10 @@ description: |
 
 > **Questions in this host.** `afm ask <op>` prompts only in a terminal, and the Bash tool has none: it exits 2. Run `afm ask <op> --json` instead and put each pending question to the operator with `AskUserQuestion`: its `header`, `prompt` and `options` as they come, the recommended option first, `multiSelect` as given. Then record each choice with `afm answer <op> <id> <label>` (one label per selected option). Run `afm ask <op>` again: `all questions answered` means the op may go on.
 
-Atomic skill of `afm`. The canonical procedure is the op `afm path ops/rule`. The CLI owns the number, the
-rule file, the index line and the runner skeleton, and refuses a rule with no honest trigger form. This
-skill keeps only the judgment.
+> **Procedure.** Run `afm read ops/rule.md` and follow it; read an on-demand section when its condition holds.
+
+The CLI owns the number, the rule file, the index line and the runner skeleton, and refuses a rule with no
+honest trigger form. This skill keeps only the judgment.
 
 ## When NOT to activate
 
@@ -38,9 +39,11 @@ that already exist.
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES`. Universals §1-8 apply. Note especially #3 (a hard rule needs
+Most relevant here: #3 (a hard rule needs
 a mechanical trigger, or it is a principle instead) and #6 (autonomy-first: materialize the change and
 report it).
 
 Passive mode (`/afm:reconcile`) is always on and can propose `/afm:rule` when it detects the signal "the user
 corrected an approach with a reusable rule".
+
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/claude-code/skills/specify/SKILL.md

@@ -9,11 +9,11 @@ description: |
 
 > **Questions in this host.** `afm ask <op>` prompts only in a terminal, and the Bash tool has none: it exits 2. Run `afm ask <op> --json` instead and put each pending question to the operator with `AskUserQuestion`: its `header`, `prompt` and `options` as they come, the recommended option first, `multiSelect` as given. Then record each choice with `afm answer <op> <id> <label>` (one label per selected option). Run `afm ask <op>` again: `all questions answered` means the op may go on.
 
-An atomic skill. The procedure lives in the op: read it with `afm path ops/specify.md`, end to end, and follow it literally.
+> **Procedure.** Run `afm read ops/specify.md` and follow it; read an on-demand section when its condition holds.
 
 ## When NOT to activate
 
-A trivial change (no feature folder needed) goes straight to the `afm.md § 2` loop. A full end-to-end delivery is `deliver`, which composes this op.
+A trivial change (no feature folder needed) goes straight to the `afm.md § 2` loop. A full end-to-end delivery is `/afm:deliver`, which composes this op.
 
 ## Pre-check
 
@@ -25,12 +25,10 @@ The number comes from `afm next-id feature`, never by hand. What is left to you
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES.md`. Universals §1-8 apply. In particular #2 (discover-first: compute the heuristic and the US from the scan), #5 (never invent a success criterion) and #6 (autonomy-first).
+Most relevant here: #2 (discover-first: compute the heuristic and the US from the scan), #5 (never invent a success criterion) and #6 (autonomy-first).
 
 ## Continuous doctrine
 
-Passive mode is the always-on `reconcile` skill. This skill covers only the opening of the feature.
+Passive mode (`/afm:reconcile`) is always on. This skill covers only the opening of the feature.
 
-## Version
-
-`afm version`. History: `afm path CHANGELOG.md`.
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/claude-code/skills/tasks/SKILL.md

@@ -1,34 +1,28 @@
 ---
 name: tasks
 description: |
-  Generates `tasks.md` in TDD order, and marks the parallel tasks with `[P]`. Every task references a user story or a requirement. It hard-blocks on an open `[NEEDS CLARIFICATION:]` in the plan.
+  Generates the `tasks:` list of `tasks.md` in TDD order with `afm task add`. Every task references a user story or a requirement. It hard-blocks on an open `[NEEDS CLARIFICATION:]` in the plan.
   Activates: `/afm:tasks [<feature>]`, "generate the tasks", "break the feature into tasks".
 ---
 
 # AFM — Tasks
 
-An atomic skill. The procedure lives in the op: read it with `afm path ops/tasks.md`, end to end, and follow it literally.
+> **Procedure.** Run `afm read ops/tasks.md` and follow it; read an on-demand section when its condition holds.
 
 ## When NOT to activate
 
-There is no `plan.md` yet: run `/afm:plan` first. An end-to-end delivery is `deliver`, which composes this op.
+There is no `plan.md` yet: run `/afm:plan` first. An end-to-end delivery is `/afm:deliver`, which composes this op.
 
 ## Pre-check
 
 Run `afm preflight` (exit 3: stop and suggest `/afm:init` or `/afm:refactor`). Run `afm feature status <NNN> --json`: a non-empty `blockers` is an open `[NEEDS CLARIFICATION:]` in the plan. That is a hard refusal with no override, not a question.
 
-## Procedure
+## Principles
 
-Break the plan into four phases (Setup, Foundation RED/GREEN, Boundary, Reconciliation) from the generator (`afm new feature-tasks --feature NNN-slug`). Mark `[P]` only where a task does not depend on the one before it; a GREEN never is. Give every task a `US-NNN` or `RF-NN`. Then run `afm feature lint <NNN>` and fix what it reports until it exits 0. The last task closes the `status:` keys. Autonomy-first: write and report.
-
-## Invariant principles
-
-Single canonical source: `afm path PRINCIPLES.md`. Universals §1-8 apply. In particular #5 (every task traces to a US or RF) and rule 1 (TDD: no GREEN without the RED before it).
+Most relevant here: #5 (every task traces to a US or RF) and rule 1 (TDD: no green task without the red task it closes).
 
 ## Continuous doctrine
 
-Passive mode is the always-on `reconcile` skill. This skill covers only the task list.
-
-## Version
+Passive mode (`/afm:reconcile`) is always on. This skill covers only the task list.
 
-`afm version`. History: `afm path CHANGELOG.md`.
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/claude-code/skills/update/SKILL.md

@@ -9,8 +9,9 @@ description: |
 
 > **Questions in this host.** `afm ask <op>` prompts only in a terminal, and the Bash tool has none: it exits 2. Run `afm ask <op> --json` instead and put each pending question to the operator with `AskUserQuestion`: its `header`, `prompt` and `options` as they come, the recommended option first, `multiSelect` as given. Then record each choice with `afm answer <op> <id> <label>` (one label per selected option). Run `afm ask <op>` again: `all questions answered` means the op may go on.
 
-This is the sync skill of `afm`. The canonical procedure is the op `afm path ops/update`. The CLI runs the
-codemod registry, proves each op and moves the pin. This skill keeps the judgment.
+> **Procedure.** Run `afm read ops/update.md` and follow it; read an on-demand section when its condition holds.
+
+The CLI runs the codemod registry, proves each op and moves the pin. This skill keeps the judgment.
 
 > **Carve-out (does not overlap existing ops):** `/afm:init` and `/afm:refactor` **create** the instance
 > (bootstrap). `update` brings an **existing** instance forward, the path that `/afm:refactor` refuses.
@@ -44,15 +45,20 @@ the run. A pin **ahead** of the binary is an anomaly: report it, never roll it b
 4. **Language migration** (when the instance is not English): read `prd.md` § 11.1 FIRST and derive the
    excluded scope from it, and only then read a file. `[TBD]` there stops the step and asks
    `afm ask update-strings`. It never picks a language. The artifacts question is
-   `afm ask update-artifacts`.
+   `afm ask update-artifacts`. On migrate, run the rewrite as one orchestrated batch through
+   the `Workflow` tool (an ultracode run), with a light model per agent (`haiku` as the `model` of each agent call) for the rewrite and the loss
+   check. Escalate only a flagged file to a capable model. The session model keeps the excluded scope and
+   the final gate.
 5. Post-conditions: `afm index --check` returns 0 and the plugin boundary stays clean. Report in chat what
    migrated and what stayed pending. Under `/afm:evolve`, feed it to `docs/evolution/`.
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES`. Universals §1-8 apply. Follow #2 (discover-first): the proof of
+Most relevant here: #2 (discover-first): the proof of
 need is the grep that shows what is missing. Follow #4/#5: materialize only what the plugin already provides
 ready-made, and never invent missing product content. Follow #6 (autonomy-first with a gate). Bright line
 #7 applies: only **read** the plugin, and write only to the instance.
 
 **No new principle here.** `update` is composed materialization. The doctrine lives in the op file.
+
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/claude-code/skills/verify/SKILL.md

@@ -9,7 +9,7 @@ description: |
 
 > **Questions in this host.** `afm ask <op>` prompts only in a terminal, and the Bash tool has none: it exits 2. Run `afm ask <op> --json` instead and put each pending question to the operator with `AskUserQuestion`: its `header`, `prompt` and `options` as they come, the recommended option first, `multiSelect` as given. Then record each choice with `afm answer <op> <id> <label>` (one label per selected option). Run `afm ask <op>` again: `all questions answered` means the op may go on.
 
-Atomic skill of `afm`. The canonical procedure is the op `afm path ops/verify`.
+> **Procedure.** Run `afm read ops/verify.md` and follow it; read an on-demand section when its condition holds.
 
 ## When not to activate
 
@@ -30,4 +30,6 @@ agent actor. Report the tier that resulted and what it means.
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES`. Universals §1-8 apply. #5 is load-bearing here.
+Most relevant here: #5 is load-bearing.
+
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.