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

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

@@ -9,11 +9,11 @@ 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/specify.md`, end to end, and follow it literally.
+> **Procedure.** Run `afm read ops/specify.md` and follow it; read an on-demand section when its condition holds.
 
 ## When NOT to activate
 
-A trivial change (no feature folder needed) goes straight to the `afm.md § 2` loop. A full end-to-end delivery is `deliver`, which composes this op.
+A trivial change (no feature folder needed) goes straight to the `afm.md § 2` loop. A full end-to-end delivery is `afm-deliver`, which composes this op.
 
 ## Pre-check
 
@@ -25,12 +25,10 @@ The number comes from `afm next-id feature`, never by hand. What is left to you
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES.md`. Universals §1-8 apply. In particular #2 (discover-first: compute the heuristic and the US from the scan), #5 (never invent a success criterion) and #6 (autonomy-first).
+Most relevant here: #2 (discover-first: compute the heuristic and the US from the scan), #5 (never invent a success criterion) and #6 (autonomy-first).
 
 ## Continuous doctrine
 
-Passive mode is the always-on `reconcile` skill. This skill covers only the opening of the feature.
+Passive mode (`afm-reconcile`) is always on. This skill covers only the opening of the feature.
 
-## 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-tasks/SKILL.md

@@ -1,34 +1,28 @@
 ---
 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".
 ---
 
 # AFM — Tasks
 
-An atomic skill. The procedure lives in the op: read it with `afm path ops/tasks.md`, end to end, and follow it literally.
+> **Procedure.** Run `afm read ops/tasks.md` and follow it; read an on-demand section when its condition holds.
 
 ## When NOT to activate
 
-There is no `plan.md` yet: run `afm-plan` first. An end-to-end delivery is `deliver`, which composes this op.
+There is no `plan.md` yet: run `afm-plan` first. An end-to-end delivery is `afm-deliver`, which composes this op.
 
 ## Pre-check
 
 Run `afm preflight` (exit 3: stop and suggest `afm-init` or `afm-refactor`). Run `afm feature status <NNN> --json`: a non-empty `blockers` is an open `[NEEDS CLARIFICATION:]` in the plan. That is a hard refusal with no override, not a question.
 
-## Procedure
+## Principles
 
-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.
-
-## 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).
+Most relevant here: #5 (every task traces to a US or RF) and rule 1 (TDD: no green task without the red task it closes).
 
 ## Continuous doctrine
 
-Passive mode is the always-on `reconcile` skill. This skill covers only the task list.
-
-## Version
+Passive mode (`afm-reconcile`) is always on. This skill covers only the task list.
 
-`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-update/SKILL.md

@@ -9,8 +9,9 @@ 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.
 
-This is the sync skill of `afm`. The canonical procedure is the op `afm path ops/update`. The CLI runs the
-codemod registry, proves each op and moves the pin. This skill keeps the judgment.
+> **Procedure.** Run `afm read ops/update.md` and follow it; read an on-demand section when its condition holds.
+
+The CLI runs the codemod registry, proves each op and moves the pin. This skill keeps the judgment.
 
 > **Carve-out (does not overlap existing ops):** `afm-init` and `afm-refactor` **create** the instance
 > (bootstrap). `update` brings an **existing** instance forward, the path that `afm-refactor` refuses.
@@ -44,15 +45,20 @@ the run. A pin **ahead** of the binary is an anomaly: report it, never roll it b
 4. **Language migration** (when the instance is not English): read `prd.md` § 11.1 FIRST and derive the
    excluded scope from it, and only then read a file. `[TBD]` there stops the step and asks
    `afm ask update-strings`. It never picks a language. The artifacts question is
-   `afm ask update-artifacts`.
+   `afm ask update-artifacts`. On migrate, run the rewrite as one orchestrated batch through
+   parallel subagents through the `task` tool, with a light model per agent (the smallest model of the configured provider) for the rewrite and the loss
+   check. Escalate only a flagged file to a capable model. The session model keeps the excluded scope and
+   the final gate.
 5. Post-conditions: `afm index --check` returns 0 and the plugin boundary stays clean. Report in chat what
    migrated and what stayed pending. Under `afm-evolve`, feed it to `docs/evolution/`.
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES`. Universals §1-8 apply. Follow #2 (discover-first): the proof of
+Most relevant here: #2 (discover-first): the proof of
 need is the grep that shows what is missing. Follow #4/#5: materialize only what the plugin already provides
 ready-made, and never invent missing product content. Follow #6 (autonomy-first with a gate). Bright line
 #7 applies: only **read** the plugin, and write only to the instance.
 
 **No new principle here.** `update` is composed materialization. The doctrine lives in the op file.
+
+**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-verify/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.
 
-Atomic skill of `afm`. The canonical procedure is the op `afm path ops/verify`.
+> **Procedure.** Run `afm read ops/verify.md` and follow it; read an on-demand section when its condition holds.
 
 ## When not to activate
 
@@ -30,4 +30,6 @@ agent actor. Report the tier that resulted and what it means.
 
 ## Invariant principles
 
-Single canonical source: `afm path PRINCIPLES`. Universals §1-8 apply. #5 is load-bearing here.
+Most relevant here: #5 is load-bearing.
+
+**Principles and version.** `afm path PRINCIPLES.md` (universals §1-8 apply). `afm version` prints the version; history: `afm path CHANGELOG.md`.

package/plugin/opencode/afm.js

@@ -1,196 +0,0 @@
-// AFM for opencode: 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 output or the system prompt. 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", "multiedit", "bash", "skill"]);
-
-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;
-	}
-}
-
-/** Puts the notice on the operator's screen as a toast. The host may lack the API, and a notice is never worth a failure. */
-async function showNotice(client, message) {
-	try {
-		await client?.tui?.showToast?.({
-			body: { title: "AFM", message, variant: "warning", duration: 20000 },
-		});
-	} catch {
-		// nowhere to show it: the next session start tries again
-	}
-}
-
-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),
-	);
-};
-
-/**
- * What the host says of a session: whether it is a sub-agent's (it has a parent) and the agent its
- * last user message names (a sub-agent session starts with the task prompt addressed to it). The
- * lookups are bounded and their 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 sessionOf(client, sessionID, cache) {
-	if (typeof sessionID !== "string") return { child: false };
-	const known = cache.get(sessionID);
-	if (known) return known;
-	const [info, messages] = await Promise.all([
-		bounded(
-			Promise.resolve(client?.session?.get?.({ path: { id: sessionID } })),
-		),
-		bounded(
-			Promise.resolve(client?.session?.messages?.({ path: { id: sessionID } })),
-		),
-	]);
-	const users = (messages?.data ?? []).filter(
-		(message) => message?.info?.role === "user",
-	);
-	const agent = users.at(-1)?.info?.agent;
-	const session = {
-		child: typeof info?.data?.parentID === "string",
-		...(typeof agent === "string" ? { agent } : {}),
-	};
-	if (info?.data) cache.set(sessionID, session);
-	return session;
-}
-
-export const AfmHooks = async ({ directory, client }) => {
-	const sessions = new Map();
-	const starts = new Map();
-	const pending = new Map();
-	const base = (sessionID, session) => ({
-		harness: MARKER,
-		session_id: sessionID,
-		cwd: directory,
-		...(session?.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) => {
-		if (typeof sessionID !== "string") return Promise.resolve(null);
-		if (!starts.has(sessionID))
-			starts.set(
-				sessionID,
-				(async () => {
-					const session = await sessionOf(client, sessionID, sessions);
-					if (!session.child) {
-						const out = await afmHook("SessionStart", {
-							...base(sessionID, session),
-							source: "startup",
-						});
-						const notice = noticeOf(out);
-						if (notice) await showNotice(client, notice);
-						return decisionOf(out).additionalContext;
-					}
-					if (!session.agent) return undefined;
-					return decisionOf(
-						await afmHook("SubagentStart", {
-							...base(sessionID, session),
-							agent_type: session.agent,
-						}),
-					).additionalContext;
-				})(),
-			);
-		return starts.get(sessionID);
-	};
-	return {
-		"experimental.chat.system.transform": async (input, output) => {
-			const text = await startOf(input.sessionID);
-			if (text) output.system.push(text);
-		},
-		"tool.execute.before": async (input, output) => {
-			if (!FORWARDED.has(input.tool)) return;
-			const session = await sessionOf(client, input.sessionID, sessions);
-			const decision = decisionOf(
-				await afmHook("PreToolUse", {
-					...base(input.sessionID, session),
-					tool_name: input.tool,
-					tool_input: output.args ?? {},
-				}),
-			);
-			if (decision.permissionDecision === "deny")
-				throw new Error(decision.permissionDecisionReason);
-			// A PreToolUse cannot speak to the agent before the tool runs: its context joins the output.
-			if (decision.additionalContext && input.callID)
-				pending.set(input.callID, decision.additionalContext);
-		},
-		"tool.execute.after": async (input, output) => {
-			if (!FORWARDED.has(input.tool)) return;
-			const session = await sessionOf(client, input.sessionID, sessions);
-			const exit = output.metadata?.exit;
-			const failed =
-				input.tool === "bash" && typeof exit === "number" && exit !== 0;
-			const decision = decisionOf(
-				await afmHook(failed ? "PostToolUseFailure" : "PostToolUse", {
-					...base(input.sessionID, session),
-					tool_name: input.tool,
-					tool_input: input.args ?? {},
-					...(failed ? { exit, error: output.output ?? "" } : {}),
-				}),
-			);
-			const context = [pending.get(input.callID), decision.additionalContext]
-				.filter(Boolean)
-				.join("\n\n");
-			pending.delete(input.callID);
-			if (context) output.output = `${output.output ?? ""}\n\n${context}`;
-		},
-		// opencode cannot hold a session open, so a Stop only records the handoff.
-		event: async ({ event }) => {
-			if (event?.type !== "session.idle") return;
-			const sessionID = event.properties?.sessionID;
-			const session = await sessionOf(client, sessionID, sessions);
-			if (!session.child) await afmHook("Stop", base(sessionID, session));
-		},
-	};
-};