@tenkara/afm-linux-arm64 0.0.0-stage → 4.0.0-alpha.11

package/content/skills/diagnose.md

@@ -0,0 +1,42 @@
+---
+name: diagnose
+description: |
+  Scans the health of the local docs on 7 axes. The axes are dead reference, stale marker, instance-to-plugin drift, broken ADR chain, dead rule trigger, inflation or orphan, and cross-doc contradiction. It reads only `<consumer>/docs/` and returns evidence as `command + file:line`. It proposes no edit.
+  Activates: `afm diagnose`, "diagnose the methodology", "what is broken in the docs?", "run the AFM health check".
+---
+
+
+# AFM — Diagnose (mechanical weakness-mining, read-only)
+
+> **Carve-out (does not overlap existing ops):** `afm analyze` audits **one feature**. `diagnose` audits the **whole instance** of `/docs/`. `afm reflect` uses **behavioral** evidence, where the agent stumbled. `diagnose` is **static**, based on filesystem and git. `afm evolve` is the **orchestrator**. It combines `diagnose` (mechanical evidence) with `afm reflect` (behavioral evidence) into one proposal and one gate. `diagnose` is **read-only**. It never proposes an edit or opens a gate.
+
+## When NOT to activate
+
+This section disambiguates for a skill that already activated. It does not define activation, so it stays in the body, not in the resident listing.
+
+Validation of ONE feature is `afm analyze`. Behavioral friction, where a doc misguided the agent at apply time, is `afm reflect`. Proposing or applying a fix is `afm evolve` (the full cycle, which includes diagnose).
+
+## 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.
+
+## Procedure
+
+The procedure has two phases. **Phase 0 — Scan** is gap-driven. Run `afm doctor --json`: it checks A1-A6, staleness and dead gotchas mechanically, and every finding carries a command plus `file:line`. You add A7 yourself. All 7 axes are checked, every time.
+
+Axis A7, cross-doc contradiction, uses a paired read. That read applies an anti-false-positive layer test. An axis that cannot be covered becomes "not-covered: <reason>".
+
+**Phase 1 — Diagnosis** has the ANALYZER role. **It must not propose an edit.** The signature is φ = `(symptom, causal-status-of-behavior, mechanism)`.
+
+Phase 1 requires rival mechanisms, for example "agent non-compliant" versus "target legitimately removed". It applies an addressability filter and a self-sufficient severity matrix.
+
+**Output** is an evidence bundle ordered by severity. Run à la carte, the skill prints the report to chat. It does not write to disk. It opens no gate. Under `afm evolve`, it feeds the proposal instead.
+
+This scan has no cooldown. It is read-only and cheap. The cycle's cooldown belongs to the orchestrator.
+
+## Invariant principles
+
+Most relevant here: #2 (discover-first — diagnose with evidence before any proposal). Also #3 (mechanize-or-demote — the checks must pass the test they audit). Also #5 (no finding without evidence external to the text).
+
+**No new principle here.** `diagnose` is a composed materialization. The doctrine lives in the op file.

package/content/skills/evolve.md

@@ -0,0 +1,43 @@
+---
+name: evolve
+description: |
+  Runs the full self-evolution cycle over `<consumer>/docs/`. It combines diagnose and reflect, adds generalize, restructure, update and remediate on demand, and delivers one package through one gate (`afm ask evolve`). It conducts the mechanisms and never touches the plugin.
+  Activates: `afm evolve`, "audit the methodology", "the docs are a mess", "the rules no longer trigger", "clean up the docs", "reorganize the docs".
+---
+
+
+# AFM — Evolve (orchestrator for the self-evolution cycle)
+
+This is an orchestrator skill of AFM. The canonical procedure is the op file that `afm path ops/evolve.md` prints.
+
+> **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
+
+This section helps someone who already activated the skill decide if it fits. It is not an activation trigger, so it stays in the body, not in the resident listing.
+
+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`. 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`.
+
+## 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. **Does `afm evolve gate-check` allow a cycle?** Pass `--symptom "<what the user said>"` when there is one. Exit 0 runs; exit 1 is the cooldown refusing (no new signal inside the window), so say so and stop; 3 and 4 mean not a project or undecided.
+
+## Procedure
+
+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.
+
+## Most relevant principles
+
+#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
+
+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

@@ -0,0 +1,37 @@
+---
+name: export-template
+description: |
+  Converts a bootstrapped project into an architectural template. It deletes the product files, keeps ach, afm, gotchas and adr, and writes the `docs/.template` marker. It touches `docs/` only.
+  Activates: `afm export-template`, "export as template", "turn this project into a starter".
+---
+
+# AFM — Export-template
+
+The CLI owns the plan, the diff and the marker. This skill keeps the judgment.
+
+## When NOT to activate
+
+This is a criterion for a skill already active, not an activation trigger. If the project is already a
+template (`docs/.template` exists), the op is idempotent but asks first.
+
+## Pre-check
+
+`afm template export --dry-run` does it: a project with no `docs/.afm-version` is not bootstrapped yet, so
+stop and suggest `afm init` (greenfield) or `afm refactor` (brownfield) first.
+
+## Procedure (judgment only)
+
+1. Collect the template name and version as free text. A blank answer stays `[TBD]`; never derive the name
+   from the folder.
+2. Ask what to keep: `afm ask export-template`. Put every coherence warning of the dry run to the operator.
+3. Induce the reusable task template from the latest all-green feature BEFORE `docs/features/` goes.
+4. Show the full diff with `afm template export --dry-run ...`, then ask `afm ask export-template-apply`.
+   Deleting files is a bright line: it is never applied without that confirmation.
+5. Apply with the same flags and `--yes`, and suggest the commit message the command prints.
+
+## Invariant principles
+
+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

@@ -0,0 +1,31 @@
+---
+name: generalize
+description: |
+  Merges two or more similar gotchas into one abstract rule, from episodic to semantic. Merged entries become tombstones and nothing is deleted.
+  Activates: `afm generalize`, "these gotchas are all the same thing", "merge these rules", "I have 3 gotchas that say the same thing".
+---
+
+
+# AFM — Generalize (semantic consolidation of 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 `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
+
+1. **Does `<consumer>/docs/.afm-version` exist?** If not, stop and 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. **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).
+
+## Gate
+
+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.
+
+## Most relevant here
+
+#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

@@ -0,0 +1,40 @@
+---
+name: gotcha
+description: |
+  Writes a counterintuitive surprise to `<consumer>/docs/gotchas/`. The entry gate is mandatory: the issue must have bitten twice, or it must be documented behavior of an external SDK or runtime.
+  Activates: `afm gotcha`, "register a gotcha", "this has confused me before", "note this surprise for the next person".
+---
+
+# AFM — Gotcha
+
+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
+
+This is a disambiguation for a skill that already activated. An architectural decision belongs to
+`afm adr`. A rule with an executable trigger belongs to `afm rule`. A recurring failure with an external
+signal belongs to `afm remediate`.
+
+## Pre-check
+
+`afm preflight`. Exit 3 means there is no instance: stop and suggest `afm init` or `afm refactor` first.
+
+## Procedure (judgment only)
+
+1. Validate the entry rule BEFORE you collect content: `afm ask gotcha`. `neither` stops: reject a gotcha
+   without a 2x incidence or an external doc.
+2. Collect the area, trigger, behavior, solution and references as free text. Decide how it fires: an
+   `event` when no file shape can fire it, a `file-shape` only with a narrow glob. A guessed trigger is worse
+   than one that never fires.
+3. Run `afm gotcha new <slug> --basis <bitten-twice|documented-sdk> ...` and report the path (#6). A later
+   re-bite is `afm gotcha bite <id>`.
+
+## Invariant principles
+
+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.

package/content/skills/init.md

@@ -0,0 +1,77 @@
+---
+name: init
+description: |
+  Bootstraps AFM in a greenfield project. The CLI materializes `<consumer>/docs/` mechanically; the skill runs the interview for what only the operator knows, asking closed questions through `afm ask`. It detects the `docs/.template` marker and branches to the from-template path. It activates ONLY on explicit invocation and never from project state.
+  Activates: `afm init`, "build the AFM doc", "bootstrap AFM".
+---
+
+# AFM — Init (greenfield bootstrap)
+
+This skill of `afm` handles **greenfield bootstrap** and the from-template branch. It has a single
+responsibility. It does not route ops (each op is its own skill).
+
+The interview script is `afm path interview/bootstrap`. This skill is a router. It **never invents a
+procedure. It always reads the source first.** The layout of the shipped content is `afm path README`.
+
+---
+
+## When NOT to activate
+
+This is a disambiguation criterion for a skill that already activated. It is not an activation trigger.
+
+If the project already has `docs/.afm-version`, use the atomic skills instead. To move to a new version, use
+`afm update`. A brownfield codebase with no docs needs `afm refactor` instead.
+
+## Pre-check (before any action)
+
+1. **`afm preflight`.** Exit 3 means there is no `docs/.afm-version`: continue. Any other exit means the
+   project is already bootstrapped. **Do not run bootstrap again.** The atomic skills stay available
+   (`afm gotcha`, `afm adr`, `afm rule`, `afm promote`, `afm specify`, `afm plan`, `afm tasks`, `afm clarify`,
+   `afm analyze`, `afm export-template`), and passive mode (`afm reconcile`) stays always-on.
+2. **Does `docs/.template` exist?** Yes means the project comes from a template: ask `afm ask init-template`
+   whether to run the from-template branch, a subset focused on the product (default `Product only`). `Full
+   interview` goes to pre-check 3.
+3. **Does the project have significant pre-existing code?** A populated source root and a manifest with real
+   dependencies, or a git log with more than 20 commits. If so this is NOT the right path: stop and suggest
+   `afm refactor`: *"This project already has code. Greenfield bootstrap would make you pretend it is new.
+   `afm refactor` infers the docs from the existing code. Want to run it?"* `afm refactor --mechanical
+   --dry-run` states the verdict with its reasons.
+4. **Is the shipped content resolved?** `afm preflight` exit 4 means it is not. Tell the operator. Do not
+   guess the content and do not fail silently.
+
+---
+
+## Procedure (greenfield bootstrap)
+
+For projects without `docs/.afm-version`:
+
+1. Read `afm path interview/bootstrap` end to end.
+2. Ask the closed decisions the mechanical pass needs: `afm ask init`. Then run `afm init --mechanical`
+   (preview with `--dry-run`, or `--answers <file>` for a headless run). It creates `docs/` and `docs/adr/`,
+   fills the skeletons with the measured rule constants and `[TBD]` where the code answers nothing, copies
+   every rubric and pattern, writes `AGENTS.md` plus the harness stubs, and writes `docs/.afm-version` last.
+3. **Run the 7-step interview literally.** One question per turn. Free text only for open descriptions. For
+   everything with closed options, ask through `afm ask <op>` with the recommendation first (invariant
+   principle #8). Validate each answer with `afm ask confirm`. Fill each step into the matching
+   `docs/<file>.md`, replacing `{{placeholders}}` with the operator's answers and leaving unknown answers as
+   `[TBD]` (invariant principle #4).
+4. Apply opt-in modules. For each stack the operator confirms, read `afm path modules/<stack>/ach.patch` and
+   `afm path modules/<stack>/rules.patch` and merge them into `docs/ach.md` and `docs/afm.md`. A
+   `gotchas.seed` is a **commented reference** only: the project's `docs/gotchas/` starts empty.
+5. Generate the indexes (`afm index --materialize`) and print a summary: list every `[TBD]` and ask which ones
+   to fill in now.
+
+**Branch from-template** (if pre-check 2 found `docs/.template`): run a subset of the steps. The subset is
+0 + 3 + 6 short + 7 adapted. Skip steps 1, 2, 4 and 5, because the template already has them. The full
+procedure is in `afm path interview/bootstrap` § Alternate branch. `.afm-version` gets an inheritance line.
+
+---
+
+## Invariant principles
+
+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`) stays always-on in any AFM
+project session. This skill covers only the active bootstrap procedure.

package/content/skills/obligations.md

@@ -0,0 +1,27 @@
+---
+name: obligations
+description: |
+  Maps a contract into an obligations root in a parent folder that holds a client's repositories. Each obligation of the operator becomes a typed entry, and git enforces the mechanical ones on every repository below the folder, with no AI and no harness. It never gives legal advice.
+  Activates: `afm obligations`, "map this contract", "turn my contract into rules", "what does this contract make me do", "set up the obligations for this client folder".
+---
+
+# AFM — Obligations (map a contract into an obligations root)
+
+The CLI owns the scaffold, the schema, the lint, the approvals log and the hooks. This skill keeps the
+judgment: reading the contract and mapping each obligation honestly.
+
+## When NOT to activate
+
+To record an approval the operator received, run `afm approval add`. To check a project's code against
+the AFM rules, run `afm gate`. A project's own rules belong to `afm rule`.
+
+## Pre-check
+
+None: the op runs in a parent folder, which is not an AFM project. The operator must point to the
+contract file. Without one, ask for it in plain words and stop.
+
+## Procedure (judgment only)
+
+Map honestly: an obligation is `hard` only when a built-in check can prove it, and every entry cites
+its clause. Outside an AFM project `afm ask` exits 1: put the op's two questions to the operator in plain
+words, and never install without an explicit `install-now`.

package/content/skills/plan.md

@@ -0,0 +1,28 @@
+---
+name: plan
+description: |
+  Fills `plan.md` for the active feature. It reads the stack from `ach.md` and infers the affected components from the code. It records each decision with its rejected alternatives. It soft-blocks on an open `[NEEDS CLARIFICATION:]` in the spec.
+  Activates: `afm plan [<feature>]`, "plan feature", "draft plan for feature X".
+---
+
+# AFM — Plan
+
+## When NOT to activate
+
+There is no `spec.md` yet: run `afm specify` 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` means open `[NEEDS CLARIFICATION:]` markers in the spec, and the op asks the `open-markers` question (`afm ask plan`) before it goes on.
+
+## Procedure
+
+Read the stack from `docs/ach.md` and never reopen it. Infer the components, decisions, contracts and complexity from the code scan, and ask only for what the scan cannot resolve. Create the plan with `afm new feature-plan --feature NNN-slug` and fill it, including the first real `for_paths`. List the hard rules of `docs/afm.md` § 3 that apply, each binary. Suggest an ADR (`afm adr new <slug>`) for a load-bearing decision. Autonomy-first: write and report.
+
+## Invariant principles
+
+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 (`afm reconcile`) is always on. This skill covers only the planning.

package/content/skills/policy.md

@@ -0,0 +1,25 @@
+---
+name: policy
+description: |
+  Reports what the organisation policy bundle imposes in this project. It answers which rules apply, which gotchas apply, whether the bundle can block, and what the reader may not edit here. It reads only and writes to neither bundle.
+  Activates: `afm policy`, "what does the organisation impose here", "which rules come from outside this repository", "why can I not edit this rule".
+---
+
+# AFM — Policy (report the organisation layer)
+
+## When not to activate
+
+Never to CHANGE the policy. This skill reads. The organisation bundle belongs to whoever owns it, and no
+operation in this plugin writes to it.
+
+## Pre-check
+
+`afm preflight`. Exit 3 means there is no instance: stop. No organisation policy configured is a valid state
+that `afm policy report` says plainly, and a bundle with no `policy.md` is not a policy bundle: report it
+and stop.
+
+## Procedure (judgment only)
+
+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.

package/content/skills/promote.md

@@ -0,0 +1,39 @@
+---
+name: promote
+description: |
+  Records an instance learning that applies to every AFM project. It stores the finding in the project's machine state, classifies the target, and formats it as an issue body. It needs reproducible mechanical evidence. It never edits the plugin.
+  Activates: `afm promote`, "this applies to any project", "this rule should be in the template", "this gotcha should be in the template".
+---
+
+# AFM — Promote
+
+## When NOT to activate
+
+This disambiguation applies once this skill has already activated. Project-specific learning stays in
+`<consumer>/docs/`. Use `afm generalize` to consolidate gotchas INSIDE the instance. Use `afm update` to
+bring the plugin INTO the instance (the opposite direction).
+
+## Pre-check
+
+`afm preflight`. Exit 3 means there is no instance: stop and suggest `afm init` or `afm refactor` first.
+
+## Procedure (judgment only)
+
+1. Read `afm path interview/promotion` and apply the gate for reproducible mechanical evidence: the command
+   that proves the defect or the learning, with its output before and expected after. No command means an
+   observation in the report, not a finding.
+2. Walk the classification (project entity, one stack, a convention, a pattern, or universal) to set the
+   `target`. A learning that names a project entity stays in `docs/`.
+3. Record it: `afm findings record --target <target> --title "<title>" --evidence "<command> → <output>"
+   --note "<why it applies to any instance>"`. Report and stop.
+
+## Invariant principles
+
+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
+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.

package/content/skills/protocol.md

@@ -0,0 +1,41 @@
+---
+name: protocol
+description: |
+  Declares or reports the autonomy protocol of the project. The protocol parametrizes the PLAN threshold, the retry cap and the learning cadence. Three presets exist: p1 autonomous, p2 assisted, p3 planned-autonomous. It writes `protocol:` to `docs/_focus.md`, and with no argument it only reports.
+  Activates: `afm protocol [<name>]`, "what protocol am I using", "switch to assisted", "decide on your own for this delivery", "stop asking me so much".
+---
+
+# AFM — Protocol (declared autonomy posture)
+
+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.
+
+## When NOT to activate
+
+This is a disambiguation for a skill that already activated. Running a delivery is `afm deliver` (it
+**reads** the current protocol, it does not set it). Changing a hard rule is `afm rule`. Adjusting the work
+focus without touching posture is a direct edit to `docs/_focus.md`. A mid-delivery "go ahead" is an
+**ephemeral gate override**, not a protocol change, and it does not activate this skill.
+
+## Pre-check
+
+1. `afm preflight`. Exit 3 means there is no instance: stop and suggest `afm init` or `afm refactor`.
+2. **`p1` becomes current only through explicit invocation in this session.** Never infer it from natural
+   language and never inherit it from `git pull`. Granting the loosest posture is a human act, not a
+   repository act: a person runs `afm protocol p1 --i-mean-it`.
+
+## Procedure (judgment only)
+
+Run `afm protocol` to report, or `afm protocol <p1|p2|p3>` to switch. Then explain the **behavior delta** the
+command printed, because switching protocols without knowing what changes means switching contracts blind.
+Outside the three presets, the file must already exist: never invent one.
+
+## Invariant principles
+
+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.

package/content/skills/reconcile.md

@@ -0,0 +1,45 @@
+---
+name: reconcile
+description: |
+  Always-on passive mode. It watches the signals in `interview/triggers.md` and proposes one edit to `docs/` at the end of the turn. It never applies the edit on its own and needs no command. It stays active in any project with `docs/.afm-version`, next to any other skill and to normal code work.
+---
+
+# AFM — Reconcile (passive mode, always-on)
+
+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
+
+A project without `docs/.afm-version`: stay silent until bootstrap. Do not interfere with a bootstrap session (`afm init`) or a refactor session (`afm refactor`); they create `.afm-version`, and reconcile starts after that.
+
+## Pre-check
+
+`afm preflight` exits 0 when the project is bootstrapped: reconcile is active, so load the signal table and the procedure and watch the whole session. Exit 3 means it is not: stay silent and propose nothing.
+
+## Doctrine
+
+One criterion decides where something belongs (universal principle #1, source in `afm path PRINCIPLES.md`):
+
+> *"If another developer, or another agent without my memory, needs to know this to avoid breaking something, it is a doc, not memory."*
+
+`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`.
+
+## Procedure (always-on)
+
+In any session of a project with `docs/.afm-version`:
+
+1. Load `afm path interview/triggers.md`: the signals, the affected docs and the ready-made phrasing.
+2. Load the op `afm path ops/reconcile.md`: the literal passive-mode procedure.
+3. Monitor the work in progress (code, debugging, refactor, feature, doc edit). When a signal fires (a new structural decision, a runtime surprise twice, a correction with a reusable rule, a new component), **propose an edit** to the right `docs/` file at the end of the turn.
+4. **Never auto-apply** (principle #6: autonomy-first applies inside an invoked op or an approved feature; a passive signal is not approved scope).
+5. When a proposal becomes a concrete action, suggest the matching op: `afm adr`, `afm gotcha`, `afm rule`, `afm promote`, `afm specify`, and more.
+
+## Critical anti-patterns
+
+Never apply an edit without proposing it first, never save a project rule in memory, never invent a gotcha without a 2x trigger, never promote to the template before the operator confirms, and never interrupt code work with a long proposal: use one short line at the end of the turn. The full list is in the op.
+
+## Invariant principles
+
+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

@@ -0,0 +1,79 @@
+---
+name: refactor
+description: |
+  Adopts AFM retroactively in a brownfield codebase. The CLI reads the code, the git log and the existing rules and materializes `<consumer>/docs/` with `[TBD]` in the gaps; the skill then asks the gap questions through `afm ask`. New rules are forward-only in `afm.md § 3.1`. It activates ONLY on explicit invocation and never from project state.
+  Activates: `afm refactor`, "adopt AFM here", "build the doc retroactively", "infer docs from the code".
+---
+
+# AFM — Refactor (brownfield retroactive)
+
+This skill of `afm` handles **retroactive AFM adoption in a brownfield codebase**. Single responsibility. It
+does not route ops (each op is its own skill).
+
+The roadmap is `afm path interview/refactor`. This skill is a router. It **never invents procedure and always
+reads the source first**. The layout of the shipped content is `afm path README`.
+
+---
+
+## When NOT to activate
+
+This is a disambiguation check for a skill already active. It is not an activation trigger.
+
+The project already has `docs/.afm-version`: use `afm update` to raise the version, refactor refuses. A
+project with `docs/.template` needs `afm init` (from-template branch).
+
+## Pre-check (before any action)
+
+1. **`afm preflight`.** Exit 3 means there is no `docs/.afm-version`: continue. Any other exit means the
+   project is already bootstrapped: **refactor does not run.** The atomic skills stay available (`afm gotcha`,
+   `afm adr`, `afm rule`, `afm promote`, `afm specify`, `afm plan`, `afm tasks`, `afm clarify`, `afm analyze`,
+   `afm export-template`), and passive mode (`afm reconcile`) is already always-on. **If the
+   goal was to raise the instance to a newer version** (`.afm-version` drift), use `afm update`: refactor
+   creates an instance, update updates an existing one.
+2. **Does `docs/.template` exist?** Yes means the project comes from a template, and refactor is not the right
+   path. Suggest `afm init` (it detects the marker and branches to the from-template flow).
+3. **Is this real brownfield?** `afm refactor --mechanical --dry-run` checks it and states the reasons: a
+   manifest with real dependencies, a populated source root, a git history of more than 20 commits. Any
+   false means this is not brownfield: suggest `afm init` (*"This project does not yet seem to have a relevant
+   codebase. `afm init` does the greenfield bootstrap. Want to run that?"*).
+4. **Is the shipped content resolved?** `afm preflight` exit 4 means it is not. Report it. Do not guess the
+   content and do not fall back silently.
+
+---
+
+## Procedure (brownfield refactor)
+
+For brownfield projects without `docs/.afm-version`:
+
+1. Read `afm path interview/refactor` end to end.
+2. Ask the closed decisions the mechanical pass needs (`afm ask init`), announce the plan in one line and
+   proceed directly: **no gate** (invoking `afm refactor` already approves this, per invariant principle #6).
+3. **Run the 4 parts literally:**
+   - **Part A**: `afm refactor --mechanical` runs the autonomous code archaeology (stack scan, folder tree,
+     entity scan, CI and hooks scan, hard-rule audit, retroactive ADR candidates) and prints the report. No
+     turns with the operator. Read the README and the history yourself for the prose-only facts.
+   - **Part B**: the same command materialized the skeleton of `docs/{prd,ach,afm,ust,gotchas}`; fill the
+     drafts from the report with `[TBD]` in the gaps and report a summary plus paths. Review happens through
+     `git diff`. No review gate applies.
+   - **Part C**: run a short interview, one question per turn, closed ones through `afm ask <op>`
+     recommendation-first (invariant principle #8). Cover the pain point, the persona and the README summary
+     validation, retroactive ADRs (with a load-bearing guardrail, invariant principle #9), confirmed gotchas,
+     DoD + pre-push and code-style seeds.
+   - **Part D**: write `afm.md § 3.1` with forward-only rules based on the audit. Check `docs/.afm-version` and
+     `AGENTS.md`.
+4. Apply the opt-in modules detected in A.1. For each stack, merge `afm path modules/<stack>/ach.patch` and
+   `afm path modules/<stack>/rules.patch` into the draft. A `gotchas.seed` becomes a commented block in the
+   gotchas doc. Only the entries the operator confirms in C.9.5 become active.
+5. Print a closing summary plus a suggested commit (see the roadmap § Closing).
+
+---
+
+## Invariant principles
+
+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 always-on in any AFM project session. This skill covers only the active refactor procedure.

package/content/skills/reflect.md

@@ -0,0 +1,43 @@
+---
+name: reflect
+description: |
+  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)
+
+> **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 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 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
+
+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 (`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>`. `afm evolve` suppresses this gate.
+
+**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
+
+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.