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

package/content/skills/evolve.md

@@ -10,9 +10,7 @@ description: |
 
 This is an orchestrator skill of AFM. The canonical procedure is the op file that `afm path ops/evolve.md` prints.
 
-> **Conductor, not executor** (same pattern as `deliver`). `evolve` owns 3 things that no mechanism owns alone: (1) the evidence-collection driver for the whole instance (combines `diagnose` + `reflect`), (2) the split into buckets plus the single gate, (3) the apply driver, post-conditions, and the log/lineage record. It reads and follows everything else from the mechanisms, through a suppression contract.
->
-> **Carve-outs (it does not override existing ops):** `diagnose`/`reflect`/`generalize`/`restructure` are the **mechanisms** (each runs à la carte). `analyze` audits **one feature** (read-only). `reconcile` proposes **one single edit** at the end of a turn. `promote` **records** a finding meant for the plugin (it does not edit the plugin). `evolve` is the **cycle** that chains the mechanisms with one gate and one log — the level no other op covers.
+> **Carve-outs (it does not override existing ops):** `afm diagnose`, `afm reflect`, `afm generalize` and `afm restructure` are the **mechanisms** (each runs à la carte). `afm analyze` audits **one feature** (read-only). Passive mode (`afm reconcile`) proposes **one single edit** at the end of a turn. `afm promote` **records** a finding meant for the plugin (it does not edit the plugin). `evolve` is the **cycle** that chains the mechanisms with one gate and one log — the level no other op covers.
 
 ## When NOT to activate
 
@@ -20,7 +18,7 @@ This section helps someone who already activated the skill decide if it fits. It
 
 Use a single mechanism instead when the need is narrow. A report is `afm diagnose`. Refining a doc that misled you is `afm reflect`. Merging gotchas is `afm generalize`.
 
-A structure or staleness check is `afm restructure`. A version bump is `afm update`. `reconcile` proposes a one-off additive signal (new gotcha, rule, or ADR) directly.
+A structure or staleness check is `afm restructure`. A version bump is `afm update`. Passive mode (`afm reconcile`) proposes a one-off additive signal (new gotcha, rule, or ADR) directly.
 
 A feature-level check is `afm analyze` or `afm deliver`. Recording a finding for the plugin is `afm promote`.
 
@@ -32,36 +30,14 @@ A feature-level check is `afm analyze` or `afm deliver`. Recording a finding for
 
 ## Procedure
 
-Read the op (`afm path ops/evolve.md`) end to end and follow it exactly. The op has 5 phases.
-
-**Phase 1 — Evidence collection.** Combine two sources through the suppression contract. `diagnose` is the mechanical scan of the 7 axes (`afm doctor --json` plus the A7 reading), read-only. `reflect` is behavioral evidence of docs that misled the agent. Run `generalize`/`restructure` on demand, when their own trigger signal fires. An empty diagnosis counts as a valid result.
-
-**Phase 2 — Proposal.** This phase plays the IMPROVER role. Apply the op's **shared proposal discipline**: retrieval before create, then a dry run before the gate. Split the proposals into 3 buckets.
-
-A non-restorable change always goes through the gate. It never invents its own target. Decide here whether to downgrade, archive, or merge an artifact. Cap bucket (b) at 8 items per cycle (`afm evolve gate-check --critical <n> --high <n> --medium <n> --low <n>` computes what to ask and what to stage). Recurring failures come from `afm failures promotable`.
-
-**Phase 3 — Single gate.** Ask item by item with `afm ask evolve --scope <item-slug>`, at most 4 questions per call. This gate is never skippable — there is no "go" shortcut.
-
-**Phase 4 — Apply and post-conditions.** Re-run `afm doctor --json`, `afm index --check` and `afm detect --for <file>` over the touched docs, and confirm the content root is clean (`git status`, or a timestamp check with no git).
-
-**Phase 5 — Log.** Record the cycle in `docs/evolution/NNN-<date>.md`. Suggest `promote` when a finding generalizes beyond this instance.
+Read the op (`afm path ops/evolve.md`) end to end and follow it exactly. The op has 5 phases: evidence collection (diagnose plus reflect), proposal in 3 buckets, a single gate (`afm ask evolve`), apply with post-conditions, and the log in `docs/evolution/`.
 
 Consult the rubric `rubrics/when-to-evolve-methodology.md` (`afm path rubrics/when-to-evolve-methodology.md`) to decide between a full cycle, a single mechanism, or a one-off fix.
 
-## Invariant principles
+## Most relevant principles
 
-The single canonical source is `PRINCIPLES.md` (`afm path PRINCIPLES.md`). Universals §1-8 apply. #2 (discover-first) applies: diagnose with evidence before you propose. #3 (mechanize-or-downgrade) applies too: evolve's own signals must pass the same test evolve applies to others.
-
-#8 (earned questions, recommendation-first) also applies to this skill.
-
-#6 (autonomy-first with self-check) follows the pattern *produce → self-check → report*. The gate is the load-bearing residue. Bright lines for #7 plugin, deletion, and push still apply.
-
-**No new principle here** — evolve is a composed materialization. The doctrine lives in the op and the rubric.
+#2 (discover-first): diagnose with evidence before you propose. #3 (mechanize-or-downgrade): evolve's own signals must pass the same test evolve applies to others. #6 (autonomy-first with self-check): the gate is the load-bearing residue, and the bright lines for #7 plugin, deletion, and push still apply. #8 (earned questions, recommendation-first).
 
 ## Continuous doctrine
 
-The `reconcile` skill owns passive mode, and it is always on. Reconcile may **suggest** `afm evolve` when it detects a Class B signal. That signal is a lived contradiction between docs, or perceived inflation at apply time. Only the user can invoke the full cycle.
-
-## Version
-
-Content version: `afm version` prints it.
+Passive mode (`afm reconcile`) is always on. It may **suggest** `afm evolve` when it detects a Class B signal. That signal is a lived contradiction between docs, or perceived inflation at apply time. Only the user can invoke the full cycle.

package/content/skills/export-template.md

@@ -7,8 +7,7 @@ description: |
 
 # AFM — Export-template
 
-Atomic skill of `afm`. The canonical procedure is the op `afm path ops/export-template`. The CLI owns the plan,
-the diff and the marker. This skill keeps the judgment.
+The CLI owns the plan, the diff and the marker. This skill keeps the judgment.
 
 ## When NOT to activate
 
@@ -32,9 +31,7 @@ stop and suggest `afm init` (greenfield) or `afm refactor` (brownfield) first.
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES`. Universals §1-8 apply.
-
-Especially #5 (do not invent metadata when the operator leaves it blank: use `[TBD]` in the JSON). Also #6
+Most relevant here: #5 (do not invent metadata when the operator leaves it blank: use `[TBD]` in the JSON). Also #6
 (autonomy-first, but deleting files is a bright line): confirm the diff before you delete.
 
 Passive mode (`afm reconcile`) is always on. This skill focuses only on the active conversion to a template.

package/content/skills/generalize.md

@@ -8,15 +8,13 @@ description: |
 
 # AFM — Generalize (semantic consolidation of gotchas)
 
-Mechanism skill of AFM. The canonical procedure is the op file that `afm path ops/generalize.md` prints.
-
-> **Carve-out (does not overlap existing ops):** `promote` **registers** a finding meant for the plugin. It does not write to the plugin. `generalize` merges **inside the instance** (N gotchas become 1 rule in the same `/docs/`). `reconcile` **adds** a new gotcha. `generalize` **merges** gotchas that already exist. `reflect` refines **one** doc. `generalize` consolidates **many**. `evolve` is the **orchestrator** and it composes this skill when `diagnose` flags inflation from redundant gotchas.
+> **Carve-out (does not overlap existing ops):** `afm promote` **registers** a finding meant for the plugin. It does not write to the plugin. `afm generalize` merges **inside the instance** (N gotchas become 1 rule in the same `/docs/`). `afm reconcile` **adds** a new gotcha. `afm generalize` **merges** gotchas that already exist. `afm reflect` refines **one** doc. `afm generalize` consolidates **many**. `afm evolve` is the **orchestrator** and it composes this skill when `afm diagnose` flags inflation from redundant gotchas.
 
 ## When NOT to activate
 
 This is a disambiguation criterion for someone who already activated the skill, not an activation trigger. That is why it lives in the body, not in the resident listing.
 
-Sending ONE learning to the plugin is `afm promote`. ADDING a new gotcha or rule is `reconcile` -> `afm gotcha`/`afm rule` (`generalize` only merges what already exists). Refining the clarity of ONE doc is `afm reflect`. With fewer than 2 similar candidates, there is no generalization to do.
+Sending ONE learning to the plugin is `afm promote`. ADDING a new gotcha or rule is `afm reconcile` -> `afm gotcha`/`afm rule` (`afm generalize` only merges what already exists). Refining the clarity of ONE doc is `afm reflect`. With fewer than 2 similar candidates, there is no generalization to do.
 
 ## Pre-check
 
@@ -24,24 +22,10 @@ Sending ONE learning to the plugin is `afm promote`. ADDING a new gotcha or rule
 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. **Is there a batch of >=2** similar gotchas/reflections? If not, report "nothing to generalize (no batch)" and stop. Generalizing from 1 case is forbidden (#5).
 
-## Procedure
-
-Read the op (`afm path ops/generalize.md`) end to end. Follow it literally.
-
-**1. Identify the batch:** cluster by shared abstract cause, >=2 cases. Ask "would one more general instruction have prevented all N?" A larger batch yields a more abstract rule.
-
-**2. MetaReflect:** draft the generalized, non-case-specific rule. The original cases become examples. Follow the **shared proposal discipline** from `evolve.md` (`afm path ops/evolve.md`) instead of duplicating it. Reduce, do not create a parallel path.
-
-**3. ShowsImprovement + backtracking:** check if the rule covers all N cases. A hard rule needs an executable 0/1 trigger. Otherwise it becomes a § 1.3 principle. If it cannot cover all cases without turning vague, back out and keep the cases separate.
-
--> **4. Own gate** (item (b), unavoidable and earned, through `afm ask generalize`; suppressed under `evolve`. On approval: write the rule via `rule.md` (`afm rule new <slug>`) and **archive the merged entries as tombstones**. Never delete) -> **5. Record** the result in `docs/evolution/NNN-<date>.md`. Suggest `promote` if the finding matters beyond this instance.
-
-## Invariant principles
-
-Single canonical source: `PRINCIPLES.md` (`afm path PRINCIPLES.md`). Universals §1-8 apply here, especially #1 (episodic `gotchas.md` -> semantic `afm.md`). Also #3: a merged rule becomes hard only with an executable 0/1 trigger, the ShowsImprovement step of MetaReflection. Also #5: do not invent an abstraction without a real batch.
+## Gate
 
-Also #6/#8: self-verify before an earned gate. Deletion is a bright line. Use tombstones instead. **No new principle here** — `generalize` is a composed materialization. The doctrine lives in the op file.
+The merge is load-bearing and goes through its own earned gate, `afm ask generalize` (suppressed under `afm evolve`). Merged entries become tombstones; never delete.
 
-## Version
+## Most relevant here
 
-Content version: `afm version` prints it.
+#1 (episodic `gotchas.md` -> semantic `afm.md`), #3 (a merged rule becomes hard only with an executable 0/1 trigger), #5 (no abstraction without a real batch), #6/#8 (self-verify before an earned gate; deletion is a bright line, so archive as tombstones). No new principle here: the doctrine lives in the op.

package/content/skills/gotcha.md

@@ -7,8 +7,8 @@ description: |
 
 # AFM — Gotcha
 
-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.
+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
 
@@ -32,7 +32,7 @@ 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).
 

package/content/skills/init.md

@@ -69,14 +69,9 @@ 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`.

package/content/skills/plan.md

@@ -7,11 +7,9 @@ description: |
 
 # AFM — Plan
 
-An atomic skill. The procedure lives in the op: read it with `afm path ops/plan.md`, end to end, and follow it literally.
-
 ## 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
 
@@ -23,12 +21,8 @@ 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.
-
-## Version
-
-`afm version`. History: `afm path CHANGELOG.md`.
+Passive mode (`afm reconcile`) is always on. This skill covers only the planning.

package/content/skills/policy.md

@@ -7,8 +7,6 @@ description: |
 
 # AFM — Policy (report the organisation layer)
 
-Atomic skill of `afm`. The canonical procedure is the op `afm path ops/policy`.
-
 ## When not to activate
 
 Never to CHANGE the policy. This skill reads. The organisation bundle belongs to whoever owns it, and no
@@ -25,7 +23,3 @@ and stop.
 Run `afm policy report` and read it by family. Say plainly that a policy bundle injects context and blocks
 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.

package/content/skills/promote.md

@@ -7,8 +7,6 @@ description: |
 
 # AFM — Promote
 
-Atomic skill of `afm`. The canonical procedure is the op `afm path ops/promote`.
-
 ## When NOT to activate
 
 This disambiguation applies once this skill has already activated. Project-specific learning stays in
@@ -31,7 +29,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

package/content/skills/protocol.md

@@ -7,8 +7,7 @@ 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`.
+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,7 +34,7 @@ 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.
 

package/content/skills/reconcile.md

@@ -24,7 +24,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 +42,4 @@ 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
-
-`afm version`. History: `afm path CHANGELOG.md`.
+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).

package/content/skills/refactor.md

@@ -70,15 +70,10 @@ 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.
-
-## Version
-
-`afm version` prints the version in use. History: `afm path CHANGELOG`.
+Passive mode (`afm reconcile`) is always-on in any AFM project session. This skill covers only the active refactor procedure.

package/content/skills/reflect.md

@@ -1,53 +1,43 @@
 ---
 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?".
 ---
 
 
 # AFM — Reflect (behavioral self-reflection on the docs)
 
-Mechanism skill of AFM. The canonical procedure is the op file that `afm path ops/reflect.md` prints.
-
-> **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.

package/content/skills/remediate.md

@@ -8,8 +8,6 @@ description: |
 
 # AFM — Remediate (CRITIC loop)
 
-Atomic skill of AFM. The canonical procedure is the op file that `afm path ops/remediate.md` prints.
-
 ## When NOT to activate
 
 This is a disambiguation for a skill that already activated. It is not an activation trigger. That is why it lives in the body and not in the resident listing.
@@ -24,16 +22,12 @@ Use `afm.md § 5.1` for an in-task retry at the moment of the error. Use `afm go
 
 ## 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.
-
-## Version
-
-Content version: `afm version` prints it.
+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.

package/content/skills/restructure.md

@@ -8,9 +8,7 @@ description: |
 
 # AFM — Restructure (context architecture health)
 
-This is a mechanism skill of AFM. The canonical procedure is the op file that `afm path ops/restructure.md` prints.
-
-> **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.
 
@@ -18,7 +16,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
 
@@ -28,25 +26,21 @@ A path that does not exist belongs to `afm diagnose` (A1). Staleness means the p
 
 ## 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.

package/content/skills/rule.md

@@ -7,9 +7,8 @@ description: |
 
 # AFM — Rule
 
-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.
+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
 
@@ -36,7 +35,7 @@ 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).
 

package/content/skills/specify.md

@@ -7,11 +7,9 @@ description: |
 
 # AFM — Specify
 
-An atomic skill. The procedure lives in the op: read it with `afm path ops/specify.md`, end to end, and follow it literally.
-
 ## 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
 
@@ -23,12 +21,8 @@ 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.
-
-## Version
-
-`afm version`. History: `afm path CHANGELOG.md`.
+Passive mode (`afm reconcile`) is always on. This skill covers only the opening of the feature.

package/content/skills/tasks.md

@@ -7,28 +7,18 @@ description: |
 
 # 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.
-
 ## 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
-
-Create the file with the generator (`afm new feature-tasks --feature NNN-slug`), then add every task with `afm task add <NNN> --kind <k> --text <t>`: setup tasks, then for each spec scenario a red task (`--scenario N`) and the green task that closes it (`--closes Txxx`), an optional refactor, the validation task of each plan boundary (`--validates <boundary name>`), and one reconcile task, last. Never write a task by hand: the tasks live in the frontmatter `tasks:` list, and the CLI assigns the id and validates the item. Mark `--parallel` 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` (`--refs`). The CLI refuses an item that breaks a lint rule. Then run `afm feature lint <NNN>` and fix what it reports until it exits 0: a missing task with `afm task add`, a wrong field or kind with `afm task set <NNN> <Txxx> --<field> <value>` (`--clear <field>` clears one), a task that should not exist with `afm task remove <NNN> <Txxx>`. Never edit the YAML by hand. The reconcile task closes the `status:` keys; close each task with `afm task done`. Autonomy-first: write and report.
-
-## Invariant principles
+## 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 task without the red task it closes).
+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
-
-`afm version`. History: `afm path CHANGELOG.md`.
+Passive mode (`afm reconcile`) is always on. This skill covers only the task list.

package/content/skills/update.md

@@ -7,8 +7,7 @@ description: |
 
 # AFM — Update (sync instance-plugin)
 
-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.
+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.
@@ -42,13 +41,16 @@ 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
+   {{host:workflow}}, with a light model per agent ({{host:light-model}}) 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.

package/content/skills/verify.md

@@ -7,8 +7,6 @@ description: |
 
 # AFM — Verify (stamp a human review)
 
-Atomic skill of `afm`. The canonical procedure is the op `afm path ops/verify`.
-
 ## When not to activate
 
 Never on ordinary work, and never on your own output. This skill records that a PERSON read a document. An
@@ -28,4 +26,4 @@ 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.

package/content/templates/evolution-report.template.md

@@ -11,6 +11,7 @@ frontmatter_for_output: |
   date: 'YYYY-MM-DD'
   cycle_trigger: '<explicit invocation or the symptom stated by the user: cite it>'
   new_signal: '<which Class A delta or symptom released the cooldown>'
+  resolves: []   # optional: fingerprints (from `afm sessions signals`) of the friction this cycle fixed
 ---
 
 # Evolution cycle {{NNN}} — {{date YYYY-MM-DD}}
@@ -20,6 +21,10 @@ frontmatter_for_output: |
 > sorting these names, and an ordinal-first name sorts by ordinal before date — a low ordinal on
 > a recent date rewinds the window in silence. `NNN` is now only a same-day tiebreak.
 >
+> **`resolves:` (frontmatter, optional)** lists the signal fingerprints this cycle fixed. `afm sessions signals`
+> marks a signal with one of them `resolved` when it happened before this report's date, and `regressed` when
+> it happens again after it (the fix did not hold).
+>
 > **`mechanism:` (frontmatter) is mandatory and it is not decoration.** `reflect`, `evolve` and `restructure`
 > all write into this one directory, and each one's cadence window is "since MY last report".
 > Without the field the windows collapse into one, and the cheap mechanism starves the expensive

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tenkara/afm-linux-arm64",
-	"version": "4.0.0-alpha.8",
+	"version": "4.0.0-alpha.9",
 	"description": "The afm binary (CLI and MCP server) for linux-arm64.",
 	"license": "UNLICENSED",
 	"publishConfig": {