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

package/bin/afm

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/bin/afm
 size: 83871736 bytes
-sha256: 381b8325ab8908b866a4b165f018661ad726b3478427fb04d57029f074255a05
+sha256: 59bf1e0b083418a2b27f2105c93a4f6f6f3e6c66f2522b62fe1326fdeb6d7806

package/content/CHANGELOG.md

@@ -9,6 +9,16 @@ Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Versioning [Se
 
 ## [Unreleased]
 
+## [4.0.0-alpha.11] - 2026-10-23
+
+### Added
+
+- **`ops/obligations.md`, `skills/obligations.md` and `questions/obligations.questions.yaml`.** The AI step of the obligations root: read a contract, map every operator obligation into a typed entry (`hard` only with a built-in check), loop `afm obligations lint` to clean, and install the hooks only on an explicit answer.
+
+### Consumer migration
+
+- **record-pristine-alpha11.** A docs file already equal to what afm init writes today is recorded in the manifest as AFM's own. (ops: custom)
+
 ## [4.0.0-alpha.10] - 2026-10-21
 
 ### Changed

package/content/ops/obligations.md

@@ -0,0 +1,145 @@
+---
+type: op
+description: Maps a contract into an obligations root in a parent folder, so git enforces the mechanical obligations on every repository below it.
+load: warm
+writes: [".afm-obligations/*"]
+composes: []
+---
+# Sub-flow: map a contract into an obligations root (`obligations`)
+
+> **Form** — effect: `<root>/.afm-obligations/`, and on `install-now` one `includeIf` entry in the global git config (written by `afm obligations install`) · trigger: `afm obligations`, a contract to map · precondition: none (it runs in a parent folder, not in a project) · **degree of freedom: medium**
+
+Triggers: `afm obligations`, or natural language: "map this contract", "turn my contract into rules",
+"what does this contract make me do", "set up the obligations for this client folder".
+
+## What an obligations root is
+
+A parent folder that holds the repositories of one client gets a hidden `.afm-obligations/` folder:
+
+| File | What it holds |
+| --- | --- |
+| `root.toml` | the contract (path, version, dates), who receives notices, the deploy refs, the AI allowlist |
+| `obligations/<id>.md` | one obligation: YAML frontmatter, then the operator's notes |
+| `approvals.jsonl` | the written approvals the operator received, appended with `afm approval add` |
+| `hooks/`, `gitconfig` | written by `afm obligations install` |
+
+The root lives outside every project repository and nothing is written inside a project. The operator
+may make `.afm-obligations/` its own repository; the checks treat it as a records repository, never as
+a project. `afm obligations install` adds one `includeIf "gitdir:<root>/"` entry to the global git
+config, so every repository below the root runs the checks at pre-commit and pre-push, then its own
+hooks. No AI and no harness take part in the enforcement.
+
+**This op is the only AI step.** The CLI never reads a contract. The op reads it and writes data, and
+the CLI validates and enforces that data.
+
+**Questions.** Its two questions (`existing-root`, `install`) are the ones `afm ask obligations`
+prints, but this op runs outside an AFM project, where that command exits 1. Put them to the operator
+in plain words or through the host's question facility, with the same options. Never assume an answer: `install` edits the
+operator's global git config.
+
+## Procedure
+
+1. **Locate the folder and the contract.** The folder is the parent of the client's repositories (the
+   current directory unless the operator names one). The contract is a file the operator points to (PDF
+   or text). If a playbook or summary of the contract exists, read it too, but the contract is the
+   source: cite clauses from the contract, not from the summary.
+2. **Scaffold.** Run `afm obligations init` in the folder. If a root already exists, ask `existing-root`.
+3. **Fill `root.toml`.** Replace every `[TBD]`; `afm obligations lint` warns while one is left. The full
+   shape:
+
+   ```toml
+   name = "acme"                         # the client
+   notice_to = "legal@acme.example"      # who receives notices under the contract
+   deploy_refs = ["refs/heads/main", "refs/heads/master", "refs/heads/production", "refs/tags/v*"]
+   ai_allowlist = []                     # providers the DELIVERED CODE may call (see the AI row below)
+
+   [contract]
+   file = "~/contracts/acme-2026.pdf"       # where the contract already lives; never copy it here
+   version = "signed 2026-10-23"
+   effective = "2026-10-15"              # the contract's dates, not today's
+   expires = "2027-10-15"
+
+   [projects.mobile-app]                 # optional: a project whose deploy refs differ
+   deploy_refs = ["refs/tags/release-*"]
+   ```
+
+   A deploy ref is a full ref; `*` is the only wildcard. `contract.file` points to the contract where it
+   already lives: never copy the contract, an e-mail or client data into the root, which the operator may
+   version and push.
+4. **Extract every obligation of the operator.** Read the whole contract, clause by clause, schedules
+   and annexes included. Keep only what the operator (the contractor) must do, must not do, must ask
+   before doing, must deliver by a date, or must notify. Leave out what binds only the client.
+5. **Map each one** to one file `obligations/<id>.md`, the id in the file name. The frontmatter is YAML
+   between two `---` lines; quote every string value, because clause references and remedies hold `:`.
+
+   ```markdown
+   ---
+   id: "OBL-DEPLOY-01"
+   source: "Section II; Schedule A, B.2"
+   kind: "approval-required"
+   enforcement: "hard"
+   check: "deploy-approval"
+   scope: "deploy"
+   remedy: "Ask legal@acme.example for written approval before any deploy or public build; record it with afm approval add --scope deploy."
+   evidence: "an approval id in approvals.jsonl"
+   ---
+
+   Deploys and public builds need prior written approval. Discord does not count.
+   ```
+
+   - `id`: `OBL-<AREA>-<NN>`, upper case.
+   - `source`: the clause or schedule reference, exact.
+   - `kind`: `prohibition`, `approval-required`, `deadline`, `recurring` or `notice`.
+   - `enforcement` and `check`, by this table, and never stronger than the check can prove:
+
+     | The obligation… | `enforcement` | `check` |
+     | --- | --- | --- |
+     | forbids a deploy, a public build or a publication without written approval | `hard` | `deploy-approval`, with `kind: approval-required` and `scope: deploy` |
+     | forbids credentials or secrets in the work | `hard` | `secrets` |
+     | forbids personal data hardcoded in the work | `hard` | `personal-data` |
+     | limits which AI providers the delivered code may call | `hard`, or `soft` when the product is expected to use one | `ai-allowlist` |
+     | limits which AI tools or models may touch client data (assistants, chat tools, training) | `manual` | none, `kind: approval-required`, `scope: tool` or `model` |
+     | needs approval for anything else that fits a scope below | `manual` | none, with `scope` |
+     | needs approval for something no scope fits (budget, material decisions, pre-existing material) | `manual` | none, `kind: prohibition`, the condition in the notes |
+     | sets a date or a period (report, invoice, incident notice, data return, post-term restriction) | `reminder` | none |
+     | anything no built-in check can see (devices, accounts, conduct, tax) | `manual` | none |
+
+   - What the checks prove, so the map never claims more: `secrets` blocks known token formats and
+     plaintext key/value secrets on added lines. `personal-data` blocks Brazilian CPF and CNPJ with valid
+     check digits and card numbers that pass Luhn; e-mail addresses and phone numbers only warn. It sees
+     only the code, never tools. `ai-allowlist` blocks SDK imports, manifest entries, API hosts and key
+     prefixes of providers outside `ai_allowlist`; it says nothing about which assistant the operator
+     uses. An approved assistant (for example a coding agent) is a `manual` `scope: tool` entry, and it
+     does NOT put its provider in `ai_allowlist`.
+   - `scope` (for `approval-required`): `deploy` (deploys, public builds, publications: a public build is
+     recorded as `deploy`, because only `deploy` unblocks a push), `build`, `tool`, `vendor`, `library`,
+     `third-party`, `subcontractor`, `model`, `public-statement`.
+   - `remedy`: what to do, to whom, in how much time, in one or two sentences. It is printed on every
+     blocked commit or push, so it carries no confidential text.
+   - `evidence`: what proves compliance (an approval id, a sent report, a certificate).
+   - The body: the operator's notes. Paraphrase. Never paste confidential text of the contract beyond
+     what the operator needs to act.
+6. **Validate.** Run `afm obligations lint` and fix every finding. Loop until it exits 0 and prints no
+   `[TBD]` warning. A `hard` or `soft` entry without a `check` is refused: mark it `manual` or `reminder`.
+   Never invent a check.
+7. **Show the map.** Print one table: id, source, kind, enforcement, check. Count the entries per
+   enforcement level. Then ask `install`.
+8. **Install** only on `install-now`: run `afm obligations install` and report what it wrote and which
+   repositories set their own `core.hooksPath` (those are not covered until the operator removes it).
+
+## What it must never do
+
+- Never give legal advice or interpret a clause beyond what the operator must do. Say once that the
+  map reflects the operator's reading and should be reviewed with a lawyer.
+- Never mark an obligation `hard` without a `check`, or invent a check outside the closed set.
+- Never copy the contract, e-mail content, client data or confidential text into the root. Only paths,
+  references and metadata.
+- Never write inside a project repository.
+- Never record an approval for the operator. Approvals come from the operator with `afm approval add`,
+  each with an e-mail Message-ID or link.
+
+## Invariant principles
+
+The single canonical source is `afm path PRINCIPLES`. Universals §1-8 apply. #2 (discover-first: the
+contract answers what it can, ask only the irreducible) and #5 (never invent: an obligation without a
+clause is not an obligation).

package/content/questions/obligations.questions.yaml

@@ -0,0 +1,17 @@
+questions:
+  - id: existing-root
+    prompt: This folder already has an obligations root. What should the mapping do?
+    header: Root
+    options:
+      - label: extend
+        description: Keep the existing entries and add or update only what the contract changes.
+      - label: stop
+        description: Change nothing; the existing root stays as it is.
+  - id: install
+    prompt: The map passes the lint. Install the git hooks for every repository below this folder now?
+    header: Install
+    options:
+      - label: install-now
+        description: Adds one includeIf entry to the global git config; every repository below the folder runs the checks, then its own hooks.
+      - label: later
+        description: Nothing is enforced until the operator runs afm obligations install.

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/package.json

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

package/plugin/agy/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "afm",
-  "version": "4.0.0-alpha.10",
+  "version": "4.0.0-alpha.11",
   "description": "AFM (Agent Flow Methodology): hooks and an MCP server that keep a project's docs and its code in step.",
   "license": "UNLICENSED"
 }

package/plugin/agy/skills/afm-obligations/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: afm-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)
+
+> **Procedure.** Run `afm read ops/obligations.md` and follow it; read an on-demand section when its condition holds.
+
+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`.
+
+**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/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
 	"name": "afm",
 	"description": "Agent Flow Methodology: autonomous discovery, a strict TDD delivery loop, and documentation that evolves from measured evidence. The CLI owns state, ids, gates and lint; the skills carry the judgment.",
-	"version": "4.0.0-alpha.10",
+	"version": "4.0.0-alpha.11",
 	"author": {
 		"name": "Mapree"
 	},

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

@@ -0,0 +1,31 @@
+---
+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)
+
+> **Procedure.** Run `afm read ops/obligations.md` and follow it; read an on-demand section when its condition holds.
+
+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`.
+
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/opencode/skills/afm-obligations/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: afm-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)
+
+> **Procedure.** Run `afm read ops/obligations.md` and follow it; read an on-demand section when its condition holds.
+
+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`.
+
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.