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

package/plugin/opencode/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/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));
-		},
-	};
-};