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

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

@@ -21,7 +21,7 @@ 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
 

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

@@ -26,10 +26,10 @@ The CLI holds the state; the skill keeps only the judgment. Drive the loop with
 - **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.
+- **Execute:** the tasks of the `tasks:` list run in order (`core/afm.md` § 2: a red task, the green task that closes it, an optional refactor), each checked with `afm gate --staged`, then closed with `afm task done <NNN> <Txxx>`. Tasks are added with `afm task add`, never by hand. Halt on the failure of a task that is not `parallel` 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 `[ ]`".
+If artifacts already exist, resume from the correct phase, including "tasks already exist, run from the first task that is not done".
 
 ## Invariant principles
 

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

@@ -1,7 +1,7 @@
 ---
 name: afm-tasks
 description: |
-  Generates `tasks.md` in TDD order, and marks the parallel tasks with `[P]`. Every task references a user story or a requirement. It hard-blocks on an open `[NEEDS CLARIFICATION:]` in the plan.
+  Generates the `tasks:` list of `tasks.md` in TDD order with `afm task add`. Every task references a user story or a requirement. It hard-blocks on an open `[NEEDS CLARIFICATION:]` in the plan.
   Activates: `afm-tasks [<feature>]`, "generate the tasks", "break the feature into tasks".
 ---
 
@@ -19,11 +19,11 @@ Run `afm preflight` (exit 3: stop and suggest `afm-init` or `afm-refactor`). Run
 
 ## Procedure
 
-Break the plan into four phases (Setup, Foundation RED/GREEN, Boundary, Reconciliation) from the generator (`afm new feature-tasks --feature NNN-slug`). Mark `[P]` only where a task does not depend on the one before it; a GREEN never is. Give every task a `US-NNN` or `RF-NN`. Then run `afm feature lint <NNN>` and fix what it reports until it exits 0. The last task closes the `status:` keys. Autonomy-first: write and report.
+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
 
-Single canonical source: `afm path PRINCIPLES.md`. Universals §1-8 apply. In particular #5 (every task traces to a US or RF) and rule 1 (TDD: no GREEN without the RED before it).
+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).
 
 ## Continuous doctrine
 

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.7",
+	"version": "4.0.0-alpha.8",
 	"author": {
 		"name": "Mapree"
 	},

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

@@ -21,7 +21,7 @@ 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
 

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

@@ -26,10 +26,10 @@ The CLI holds the state; the skill keeps only the judgment. Drive the loop with
 - **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.
+- **Execute:** the tasks of the `tasks:` list run in order (`core/afm.md` § 2: a red task, the green task that closes it, an optional refactor), each checked with `afm gate --staged`, then closed with `afm task done <NNN> <Txxx>`. Tasks are added with `afm task add`, never by hand. Halt on the failure of a task that is not `parallel` 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 `[ ]`".
+If artifacts already exist, resume from the correct phase, including "tasks already exist, run from the first task that is not done".
 
 ## Invariant principles
 

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

@@ -1,7 +1,7 @@
 ---
 name: tasks
 description: |
-  Generates `tasks.md` in TDD order, and marks the parallel tasks with `[P]`. Every task references a user story or a requirement. It hard-blocks on an open `[NEEDS CLARIFICATION:]` in the plan.
+  Generates the `tasks:` list of `tasks.md` in TDD order with `afm task add`. Every task references a user story or a requirement. It hard-blocks on an open `[NEEDS CLARIFICATION:]` in the plan.
   Activates: `/afm:tasks [<feature>]`, "generate the tasks", "break the feature into tasks".
 ---
 
@@ -19,11 +19,11 @@ Run `afm preflight` (exit 3: stop and suggest `/afm:init` or `/afm:refactor`). R
 
 ## Procedure
 
-Break the plan into four phases (Setup, Foundation RED/GREEN, Boundary, Reconciliation) from the generator (`afm new feature-tasks --feature NNN-slug`). Mark `[P]` only where a task does not depend on the one before it; a GREEN never is. Give every task a `US-NNN` or `RF-NN`. Then run `afm feature lint <NNN>` and fix what it reports until it exits 0. The last task closes the `status:` keys. Autonomy-first: write and report.
+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
 
-Single canonical source: `afm path PRINCIPLES.md`. Universals §1-8 apply. In particular #5 (every task traces to a US or RF) and rule 1 (TDD: no GREEN without the RED before it).
+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).
 
 ## Continuous doctrine
 

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,70 @@
 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_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,70 @@
 ---
 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_version"
+    resource: "*"
+    effect: allow
 ---
 You are a reviewer. The message that dispatched you is your brief: follow it.
 

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

@@ -21,7 +21,7 @@ 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
 

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

@@ -26,10 +26,10 @@ The CLI holds the state; the skill keeps only the judgment. Drive the loop with
 - **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.
+- **Execute:** the tasks of the `tasks:` list run in order (`core/afm.md` § 2: a red task, the green task that closes it, an optional refactor), each checked with `afm gate --staged`, then closed with `afm task done <NNN> <Txxx>`. Tasks are added with `afm task add`, never by hand. Halt on the failure of a task that is not `parallel` 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 `[ ]`".
+If artifacts already exist, resume from the correct phase, including "tasks already exist, run from the first task that is not done".
 
 ## Invariant principles