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

package/plugin/opencode/afm/index.js

@@ -0,0 +1,245 @@
+// AFM for opencode 2, server side: forwards what the hooks decide on to `afm hook <Event>` with the
+// native tool name, the harness marker and the session, and carries the answer back: a deny throws,
+// injected context rides in the tool's result or the system prompt, and a notice for the operator
+// goes to the terminal client (tui.js) as the `notice` event of the afm RPC. A hook that cannot
+// answer never blocks the tool. All decisions live in the afm CLI; this file only translates
+// opencode's plugin API.
+import { spawn } from "node:child_process";
+
+const MARKER = "opencode";
+const TIMEOUT_MS = 20000;
+const LOOKUP_TIMEOUT_MS = 2000;
+// The tools whose calls AFM decides on or records; every other call is not worth a process.
+const FORWARDED = new Set(["write", "edit", "shell", "skill"]);
+// The events that end a turn: opencode cannot hold a session open, so each one only records the handoff.
+const ENDED = new Set([
+	"session.execution.succeeded",
+	"session.execution.failed",
+	"session.execution.interrupted",
+]);
+
+function afmHook(event, payload) {
+	return new Promise((resolve) => {
+		let out = "";
+		const child = spawn("afm", ["hook", event], {
+			stdio: ["pipe", "pipe", "ignore"],
+		});
+		const timer = setTimeout(() => {
+			child.kill();
+			resolve("");
+		}, TIMEOUT_MS);
+		child.stdout.on("data", (chunk) => {
+			out += chunk;
+		});
+		child.on("error", () => {
+			clearTimeout(timer);
+			resolve("");
+		});
+		child.on("close", () => {
+			clearTimeout(timer);
+			resolve(out);
+		});
+		child.stdin.on("error", () => {});
+		child.stdin.end(JSON.stringify(payload));
+	});
+}
+
+/** The `hookSpecificOutput` of an `afm hook` answer; empty when there is none or it is not JSON. */
+function decisionOf(out) {
+	try {
+		return JSON.parse(out).hookSpecificOutput ?? {};
+	} catch {
+		return {};
+	}
+}
+
+/** The `systemMessage` of an `afm hook` answer: what the operator must read, not the model; undefined when there is none. */
+function noticeOf(out) {
+	try {
+		const notice = JSON.parse(out).systemMessage;
+		return typeof notice === "string" && notice !== "" ? notice : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** The afm RPC: one event, the notice the terminal client shows as a toast. Plain JSON Schema, no Effect. */
+const RPC = {
+	id: "afm",
+	methods: {},
+	events: {
+		notice: {
+			schema: {
+				type: "object",
+				properties: { message: { type: "string" } },
+				required: ["message"],
+			},
+		},
+	},
+};
+
+const bounded = (promise) => {
+	let timer;
+	const limit = new Promise((resolve) => {
+		timer = setTimeout(resolve, LOOKUP_TIMEOUT_MS, undefined);
+	});
+	return Promise.race([promise.catch(() => undefined), limit]).finally(() =>
+		clearTimeout(timer),
+	);
+};
+
+/** A tool result's content as a list of parts: the host may hand a plain string. */
+const partsOf = (content) =>
+	typeof content === "string"
+		? [{ type: "text", text: content }]
+		: Array.isArray(content)
+			? content
+			: [];
+
+/** The text the model reads in a tool result. */
+const textOf = (result) =>
+	partsOf(result?.content)
+		.filter((part) => part?.type === "text")
+		.map((part) => part.text)
+		.join("\n");
+
+/**
+ * Whether a session is a sub-agent's (it has a parent). The lookup is bounded and its failure is not an
+ * error: the call is then treated as the main thread's. Only an answered lookup is remembered, so a failed
+ * one is tried again.
+ */
+async function isChild(session, sessionID, cache) {
+	if (typeof sessionID !== "string") return false;
+	if (cache.has(sessionID)) return cache.get(sessionID);
+	const info = await bounded(
+		Promise.resolve().then(() => session?.get?.({ sessionID })),
+	);
+	if (info === undefined || info === null) return false;
+	const child = typeof info.parentID === "string";
+	cache.set(sessionID, child);
+	return child;
+}
+
+export default {
+	id: "afm",
+	async setup(ctx) {
+		const directory = ctx.location?.directory;
+		// A host whose RPC is missing or refuses the definition still runs the hooks: only the toast is lost.
+		const rpc = await Promise.resolve()
+			.then(() => ctx.rpc?.register?.(RPC, {}))
+			.catch(() => undefined);
+		const notify = async (message) => {
+			try {
+				await rpc?.events?.emit?.("notice", { message });
+			} catch {
+				// nowhere to show it: the next session start tries again
+			}
+		};
+		const children = new Map();
+		const starts = new Map();
+		const pending = new Map();
+		const childOf = (sessionID) => isChild(ctx.session, sessionID, children);
+		const base = (sessionID, child) => ({
+			harness: MARKER,
+			session_id: sessionID,
+			cwd: directory,
+			...(child ? { agent_id: sessionID } : {}),
+		});
+		// The digest a session starts with: the main thread's, or the sub-agent's rules. Asked once.
+		const startOf = (sessionID, agent) => {
+			if (typeof sessionID !== "string") return Promise.resolve(undefined);
+			if (!starts.has(sessionID))
+				starts.set(
+					sessionID,
+					(async () => {
+						const child = await childOf(sessionID);
+						if (!child) {
+							const out = await afmHook("SessionStart", {
+								...base(sessionID, false),
+								source: "startup",
+							});
+							const notice = noticeOf(out);
+							if (notice) await notify(notice);
+							return decisionOf(out).additionalContext;
+						}
+						if (typeof agent !== "string") return undefined;
+						return decisionOf(
+							await afmHook("SubagentStart", {
+								...base(sessionID, true),
+								agent_type: agent,
+							}),
+						).additionalContext;
+					})(),
+				);
+			return starts.get(sessionID);
+		};
+
+		// Runs before every model request: the system prompt is rebuilt each time, so the digest is added each time.
+		await ctx.session.hook("context", async (event) => {
+			const text = await startOf(event.sessionID, event.agent);
+			if (text) event.system.push({ type: "text", text });
+		});
+		await ctx.tool.hook("execute.before", async (event) => {
+			if (!FORWARDED.has(event.tool)) return;
+			const child = await childOf(event.sessionID);
+			const decision = decisionOf(
+				await afmHook("PreToolUse", {
+					...base(event.sessionID, child),
+					tool_name: event.tool,
+					tool_input: event.input ?? {},
+				}),
+			);
+			if (decision.permissionDecision === "deny")
+				throw new Error(decision.permissionDecisionReason);
+			// A PreToolUse cannot speak to the agent before the tool runs: its context joins the result.
+			if (decision.additionalContext && event.id)
+				pending.set(event.id, decision.additionalContext);
+		});
+		await ctx.tool.hook("execute.after", async (event) => {
+			if (!FORWARDED.has(event.tool)) return;
+			const child = await childOf(event.sessionID);
+			const exit =
+				event.status === "completed" ? event.result?.metadata?.exit : undefined;
+			const failed =
+				event.tool === "shell" && typeof exit === "number" && exit !== 0;
+			const decision = decisionOf(
+				await afmHook(failed ? "PostToolUseFailure" : "PostToolUse", {
+					...base(event.sessionID, child),
+					tool_name: event.tool,
+					tool_input: event.input ?? {},
+					...(failed ? { exit, error: textOf(event.result) } : {}),
+				}),
+			);
+			const context = [pending.get(event.id), decision.additionalContext]
+				.filter(Boolean)
+				.join("\n\n");
+			pending.delete(event.id);
+			if (context && event.status === "completed")
+				event.result = {
+					...event.result,
+					content: [
+						...partsOf(event.result?.content),
+						{ type: "text", text: context },
+					],
+				};
+		});
+
+		const controller = new AbortController();
+		(async () => {
+			for await (const event of ctx.event.subscribe({
+				signal: controller.signal,
+			})) {
+				if (!ENDED.has(event?.type)) continue;
+				const sessionID = event.data?.sessionID;
+				if (!(await childOf(sessionID)))
+					await afmHook("Stop", base(sessionID, false));
+			}
+		})().catch(() => {
+			// the stream ends with the plugin: nothing is left to record
+		});
+		return () => {
+			controller.abort();
+			return rpc?.dispose?.();
+		};
+	},
+};

package/plugin/opencode/afm/tui.js

@@ -0,0 +1,21 @@
+// AFM for opencode 2, terminal-client side: shows the notice the server side (index.js) emits on the
+// afm RPC as a toast. opencode loads this file in the terminal client only; a server plugin has no screen.
+
+/** How long a notice stays: long enough to read a sentence about a failed update. */
+const DURATION_MS = 20000;
+
+export default {
+	id: "afm",
+	setup(ctx) {
+		return ctx.data.on("rpc.afm.notice", (event) => {
+			const message = event?.data?.message;
+			if (typeof message !== "string" || message === "") return;
+			ctx.ui.toast.show({
+				title: "AFM",
+				message,
+				variant: "warning",
+				duration: DURATION_MS,
+			});
+		});
+	},
+};

package/plugin/opencode/agents/afm-executor.md

@@ -1,20 +1,28 @@
 ---
 description: Writer of one bounded change. Makes the edit its brief names, test first, inside the files the brief grants, and reports what changed; dispatched with a brief.
 mode: subagent
-permission:
-  "*": deny
-  read: allow
-  edit: allow
-  glob: allow
-  grep: allow
-  list: allow
-  webfetch: deny
-  websearch: deny
-  external_directory: deny
-  task: deny
-  bash:
-    "*": allow
-  "afm_*": allow
+permissions:
+  - action: "*"
+    resource: "*"
+    effect: deny
+  - action: "read"
+    resource: "*"
+    effect: allow
+  - action: "glob"
+    resource: "*"
+    effect: allow
+  - action: "grep"
+    resource: "*"
+    effect: allow
+  - action: "edit"
+    resource: "*"
+    effect: allow
+  - action: "shell"
+    resource: "*"
+    effect: allow
+  - action: "afm_*"
+    resource: "*"
+    effect: allow
 ---
 You are an executor. The message that dispatched you is your brief: follow it.
 

package/plugin/opencode/agents/afm-explorer.md

@@ -2,34 +2,79 @@
 description: Read-only investigator. Answers one question from the code, the docs or the web, cites what it read, and changes nothing; dispatched with a brief.
 mode: subagent
 steps: 60
-permission:
-  "*": deny
-  read: allow
-  edit: deny
-  glob: allow
-  grep: allow
-  list: allow
-  webfetch: allow
-  websearch: allow
-  external_directory: deny
-  task: deny
-  bash:
-    "*": deny
-  "afm_approve": allow
-  "afm_config": allow
-  "afm_detect": allow
-  "afm_doctor": allow
-  "afm_failures_promotable": allow
-  "afm_feature_lint": allow
-  "afm_feature_status": allow
-  "afm_gate": allow
-  "afm_index": allow
-  "afm_lang": allow
-  "afm_next_id": allow
-  "afm_path": allow
-  "afm_policy": allow
-  "afm_preflight": allow
-  "afm_version": allow
+permissions:
+  - action: "*"
+    resource: "*"
+    effect: deny
+  - action: "read"
+    resource: "*"
+    effect: allow
+  - action: "glob"
+    resource: "*"
+    effect: allow
+  - action: "grep"
+    resource: "*"
+    effect: allow
+  - action: "webfetch"
+    resource: "*"
+    effect: allow
+  - action: "websearch"
+    resource: "*"
+    effect: allow
+  - action: "afm_approve"
+    resource: "*"
+    effect: allow
+  - action: "afm_config"
+    resource: "*"
+    effect: allow
+  - action: "afm_detect"
+    resource: "*"
+    effect: allow
+  - action: "afm_doctor"
+    resource: "*"
+    effect: allow
+  - action: "afm_failures_promotable"
+    resource: "*"
+    effect: allow
+  - action: "afm_feature_lint"
+    resource: "*"
+    effect: allow
+  - action: "afm_feature_status"
+    resource: "*"
+    effect: allow
+  - action: "afm_gate"
+    resource: "*"
+    effect: allow
+  - action: "afm_index"
+    resource: "*"
+    effect: allow
+  - action: "afm_lang"
+    resource: "*"
+    effect: allow
+  - action: "afm_next_id"
+    resource: "*"
+    effect: allow
+  - action: "afm_path"
+    resource: "*"
+    effect: allow
+  - action: "afm_policy"
+    resource: "*"
+    effect: allow
+  - action: "afm_preflight"
+    resource: "*"
+    effect: allow
+  - action: "afm_read"
+    resource: "*"
+    effect: allow
+  - action: "afm_sessions"
+    resource: "*"
+    effect: allow
+  - action: "afm_sessions_signals"
+    resource: "*"
+    effect: allow
+  - action: "afm_version"
+    resource: "*"
+    effect: allow
 ---
 You are an explorer. The message that dispatched you is your brief: follow it.
 

package/plugin/opencode/agents/afm-reviewer.md

@@ -1,34 +1,79 @@
 ---
 description: Blind auditor. Checks one piece of work it did not write against its sources and rules, and returns a verdict with evidence; dispatched with a brief.
 mode: subagent
-permission:
-  "*": deny
-  read: allow
-  edit: deny
-  glob: allow
-  grep: allow
-  list: allow
-  webfetch: allow
-  websearch: allow
-  external_directory: deny
-  task: deny
-  bash:
-    "*": deny
-  "afm_approve": allow
-  "afm_config": allow
-  "afm_detect": allow
-  "afm_doctor": allow
-  "afm_failures_promotable": allow
-  "afm_feature_lint": allow
-  "afm_feature_status": allow
-  "afm_gate": allow
-  "afm_index": allow
-  "afm_lang": allow
-  "afm_next_id": allow
-  "afm_path": allow
-  "afm_policy": allow
-  "afm_preflight": allow
-  "afm_version": allow
+permissions:
+  - action: "*"
+    resource: "*"
+    effect: deny
+  - action: "read"
+    resource: "*"
+    effect: allow
+  - action: "glob"
+    resource: "*"
+    effect: allow
+  - action: "grep"
+    resource: "*"
+    effect: allow
+  - action: "webfetch"
+    resource: "*"
+    effect: allow
+  - action: "websearch"
+    resource: "*"
+    effect: allow
+  - action: "afm_approve"
+    resource: "*"
+    effect: allow
+  - action: "afm_config"
+    resource: "*"
+    effect: allow
+  - action: "afm_detect"
+    resource: "*"
+    effect: allow
+  - action: "afm_doctor"
+    resource: "*"
+    effect: allow
+  - action: "afm_failures_promotable"
+    resource: "*"
+    effect: allow
+  - action: "afm_feature_lint"
+    resource: "*"
+    effect: allow
+  - action: "afm_feature_status"
+    resource: "*"
+    effect: allow
+  - action: "afm_gate"
+    resource: "*"
+    effect: allow
+  - action: "afm_index"
+    resource: "*"
+    effect: allow
+  - action: "afm_lang"
+    resource: "*"
+    effect: allow
+  - action: "afm_next_id"
+    resource: "*"
+    effect: allow
+  - action: "afm_path"
+    resource: "*"
+    effect: allow
+  - action: "afm_policy"
+    resource: "*"
+    effect: allow
+  - action: "afm_preflight"
+    resource: "*"
+    effect: allow
+  - action: "afm_read"
+    resource: "*"
+    effect: allow
+  - action: "afm_sessions"
+    resource: "*"
+    effect: allow
+  - action: "afm_sessions_signals"
+    resource: "*"
+    effect: allow
+  - action: "afm_version"
+    resource: "*"
+    effect: allow
 ---
 You are a reviewer. The message that dispatched you is your brief: follow it.
 

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

@@ -9,8 +9,10 @@ description: |
 
 > **Questions in this host.** `afm ask <op>` prompts only in a terminal, and your shell tool has none: it exits 2. Run `afm ask <op> --json` instead and put each pending question to the operator with the host's question tool when it has one, and otherwise in chat as a numbered list: the `prompt`, then the `options` with their descriptions, the recommended one first and marked. Wait for the answer. Then record each choice with `afm answer <op> <id> <label>` (one label per selected option). Run `afm ask <op>` again: `all questions answered` means the op may go on.
 
-Atomic skill of `afm`. The canonical procedure is the op `afm path ops/adr`. The CLI owns the number, the
-template, the frontmatter, the supersede link and the index. This skill keeps only the judgment.
+> **Procedure.** Run `afm read ops/adr.md` and follow it; read an on-demand section when its condition holds.
+
+The CLI owns the number, the template, the frontmatter, the supersede link and the index. This skill keeps
+only the judgment.
 
 ## When NOT to activate
 
@@ -37,8 +39,10 @@ project (signal: `afm.md` § 3.1 forward-only exists). A greenfield project forb
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES`. Universals §1-8 apply. Additional #9 (a retroactive ADR is
+Additional #9 (a retroactive ADR is
 load-bearing-only) applies ONLY in a refactored project.
 
 Passive mode (`afm-reconcile`) is always on and can propose `afm-adr` when it detects a "novel structural
 decision" signal. This skill covers only the active creation.
+
+**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-analyze/SKILL.md

@@ -9,7 +9,7 @@ description: |
 
 > **Questions in this host.** `afm ask <op>` prompts only in a terminal, and your shell tool has none: it exits 2. Run `afm ask <op> --json` instead and put each pending question to the operator with the host's question tool when it has one, and otherwise in chat as a numbered list: the `prompt`, then the `options` with their descriptions, the recommended one first and marked. Wait for the answer. Then record each choice with `afm answer <op> <id> <label>` (one label per selected option). Run `afm ask <op>` again: `all questions answered` means the op may go on.
 
-An atomic skill. The procedure lives in the op: read it with `afm path ops/analyze.md`, end to end, and follow it exactly.
+> **Procedure.** Run `afm read ops/analyze.md` and follow it; read an on-demand section when its condition holds.
 
 ## When NOT to activate
 
@@ -21,16 +21,14 @@ Run `afm preflight` (exit 3: no `docs/.afm-version`, stop and suggest `afm-init`
 
 ## Procedure
 
-Start from the mechanical findings: `afm feature lint <NNN> --json` covers the passes A, C, D, E and the structure of `tasks.md`. Add the judgment on top (constitution violations, duplication, the semantic side of inconsistency and ambiguity), build the coverage table, assign severities by the matrix, and report in chat with metrics. Close with the `remediation` question (`afm ask analyze`). Gating mode sorts findings into buckets instead of reporting.
+Start from the mechanical findings: `afm feature lint <NNN> --json` covers the passes A, C, D, E and the structure of `tasks.md`. Add the judgment on top (constitution violations, duplication, the semantic side of inconsistency and ambiguity), build the coverage table, assign severities by the matrix, and report in chat with metrics. Close with the `remediation` question (`afm ask analyze`); a remediation that adds a task runs `afm task add`, never a hand edit of the `tasks:` list, and a task is closed only with `afm task done`. Gating mode sorts findings into buckets instead of reporting.
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES.md`. Universals §1-8 apply, especially #2 (detection is an autonomous scan, not a question), #5 (no finding without evidence) and #6 (analyze is read-only: it reports in chat, writes no file, and remediates only on request).
+Most relevant here: #2 (detection is an autonomous scan, not a question), #5 (no finding without evidence) and #6 (analyze is read-only: it reports in chat, writes no file, and remediates only on request).
 
 ## Continuous doctrine
 
-Passive mode is the always-on `reconcile` skill. This skill covers only active auditing.
+Passive mode (`afm-reconcile`) is always on. This skill covers only active auditing.
 
-## Version
-
-`afm version`. History: `afm path CHANGELOG.md`.
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

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

@@ -9,7 +9,7 @@ description: |
 
 > **Questions in this host.** `afm ask <op>` prompts only in a terminal, and your shell tool has none: it exits 2. Run `afm ask <op> --json` instead and put each pending question to the operator with the host's question tool when it has one, and otherwise in chat as a numbered list: the `prompt`, then the `options` with their descriptions, the recommended one first and marked. Wait for the answer. Then record each choice with `afm answer <op> <id> <label>` (one label per selected option). Run `afm ask <op>` again: `all questions answered` means the op may go on.
 
-An atomic skill. The procedure lives in the op: read it with `afm path ops/clarify.md`, end to end, and follow it literally.
+> **Procedure.** Run `afm read ops/clarify.md` and follow it; read an on-demand section when its condition holds.
 
 ## When NOT to activate
 
@@ -25,12 +25,10 @@ Judgment only: a 9-category scan of the spec, a prioritized queue (at most 5 que
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES.md`. Universals §1-8 apply. #2 is discover-first: resolve each question yourself through the scan or the docs, then ask. #4 says `[TBD]` beats invention, and a recommendation is a rejectable hypothesis, not a guess. #6 is autonomy-first: write the integration into spec § 7 and report. #8 is recommendation-first questions.
+Most relevant here: #2 is discover-first: resolve each question yourself through the scan or the docs, then ask. #4 says `[TBD]` beats invention, and a recommendation is a rejectable hypothesis, not a guess. #6 is autonomy-first: write the integration into spec § 7 and report. #8 is recommendation-first questions.
 
 ## Continuous doctrine
 
-Passive mode is the always-on `reconcile` skill. This skill covers only the active resolution of ambiguity.
+Passive mode (`afm-reconcile`) is always on. This skill covers only the active resolution of ambiguity.
 
-## Version
-
-`afm version`. History: `afm path CHANGELOG.md`.
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

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

@@ -7,9 +7,9 @@ description: |
 
 # AFM — Deliver (orchestrated autonomous delivery)
 
-> **Questions in this host.** `afm ask <op>` prompts only in a terminal, and your shell tool has none: it exits 2. Run `afm ask <op> --json` instead and put each pending question to the operator with the host's question tool when it has one, and otherwise in chat as a numbered list: the `prompt`, then the `options` with their descriptions, the recommended one first and marked. Wait for the answer. Then record each choice with `afm answer <op> <id> <label>` (one label per selected option). Run `afm ask <op>` again: `all questions answered` means the op may go on.
+> **Procedure.** Run `afm read ops/deliver.md` and follow it; read an on-demand section when its condition holds.
 
-The **orchestrator** of the delivery loop. One request takes "build feature X" from discovery to a delivered feature. The procedure lives in the op: read it with `afm path ops/deliver.md`, end to end, and follow it literally. It does not duplicate the sub-steps: it reads and follows `specify`, `plan`, `tasks`, `clarify`, `analyze` and `reconcile` through a suppression contract.
+The **orchestrator** of the delivery loop. One request takes "build feature X" from discovery to a delivered feature. It does not duplicate the sub-steps: it reads and follows `afm-specify`, `afm-plan`, `afm-tasks`, `afm-clarify`, `afm-analyze` and `afm-reconcile` through a suppression contract. External unknowns go through `nasca-research`, or `nasca-campaign` for a deep study; ask the operator if nasca is missing.
 
 ## When NOT to activate
 
@@ -19,26 +19,12 @@ An isolated step ("just open the spec", "just generate the tasks") is the matchi
 
 Run `afm preflight`. Exit 0 continues. Exit 3 means no `docs/.afm-version`: stop and suggest `afm-init` (greenfield) or `afm-refactor` (brownfield). Exit 4 or 5: report the line it printed. Do not fall back silently.
 
-## Procedure
+## Most relevant here
 
-The CLI holds the state; the skill keeps only the judgment. Drive the loop with `afm feature status <NNN> --json`, which returns the phase to resume at, the next task and the blockers.
-
-- **Discovery:** scan scoped to the feature, external unknowns through the nasca research flow (`nasca-research`, or `nasca-campaign` for a deep study; ask the operator if nasca is missing), unknowns sorted into resolved-by-scan, researchable and irreducible. One batched, recommendation-first round, capped by the protocol (`afm-protocol`).
-- **Draft:** spec, plan and tasks, verified with `afm feature lint <NNN>` plus the judgment passes of `analyze`.
-- **Gate:** the earned questions plus the `outcome` question (`afm ask deliver`), then `afm approve <NNN>`. An explicit "go" skips the questions, never the record.
-- **Execute:** each task is one `core/afm.md` § 2 cycle, checked with `afm gate --staged`, then `afm task done <NNN> <Txxx>`. Halt on a non-`[P]` failure after the capped retry.
-- **Reconcile:** § 8.5 plus a passive sweep.
-
-If artifacts already exist, resume from the correct phase, including "tasks already exist, run from the first `[ ]`".
-
-## Invariant principles
-
-Single canonical source: `afm path PRINCIPLES.md`. Universals §1-8 apply. The backbone is **#2** (discover-first: resolve unknowns by scan and research, ask only the irreducible part, never guess product or criteria) and **#6** (autonomy-first: approval at checkpoint granularity, the consolidated plan IS the proposal).
+**#2** (discover-first: resolve unknowns by scan and research, ask only the irreducible part, never guess product or criteria) and **#6** (autonomy-first: approval at checkpoint granularity, the consolidated plan IS the proposal).
 
 ## Continuous doctrine
 
-Passive mode is the always-on `reconcile` skill. It runs in parallel with `deliver` and takes the closing turn of Phase 4.
-
-## Version
+Passive mode (`afm-reconcile`) is always on. It runs in parallel with `afm-deliver` and takes the closing turn of Phase 4 (`core/afm.md` § 8.5 plus a passive sweep).
 
-`afm version`. History: `afm path CHANGELOG.md`.
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.