@vimhead.dev/norn-cli 0.1.0-tip.35614826665.1 → 0.1.0-tip.35724621678.1

package/assets/examples/shared-state/shared-state.ts

@@ -5,20 +5,34 @@ import { DatabaseSync } from "node:sqlite";
 import type { Static, TSchema } from "typebox";
 import { Value } from "typebox/value";
 
-export type SharedStateField<Schema extends TSchema = TSchema> = { readonly id: string; readonly schema: Schema };
-export type SharedStateAccess = Pick<SharedState, "get" | "getOptional" | "set">;
+export type SharedStateField<Schema extends TSchema = TSchema> = {
+	readonly id: string;
+	readonly schema: Schema;
+};
+export type SharedStateAccess = Pick<
+	SharedState,
+	"get" | "getOptional" | "set"
+>;
 
 export class SharedState {
 	private isClosed = false;
 	private constructor(private readonly database: DatabaseSync) {}
 
-	static async open(input: { readonly path: string; readonly create: boolean }): Promise<SharedState> {
+	static async open(input: {
+		readonly path: string;
+		readonly create: boolean;
+	}): Promise<SharedState> {
 		if (input.create) await mkdir(dirname(input.path), { recursive: true });
 		else await access(input.path);
 		const database = new DatabaseSync(input.path);
 		try {
-			database.exec("PRAGMA busy_timeout = 30000; PRAGMA journal_mode = DELETE;");
-			if (input.create) database.exec("CREATE TABLE IF NOT EXISTS state (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
+			database.exec(
+				"PRAGMA busy_timeout = 30000; PRAGMA journal_mode = DELETE;",
+			);
+			if (input.create)
+				database.exec(
+					"CREATE TABLE IF NOT EXISTS state (key TEXT PRIMARY KEY, value TEXT NOT NULL)",
+				);
 			database.prepare("SELECT key, value FROM state LIMIT 0").all();
 			return new SharedState(database);
 		} catch (error) {
@@ -27,20 +41,36 @@ export class SharedState {
 		}
 	}
 
-	async get<Schema extends TSchema>(field: SharedStateField<Schema>): Promise<Static<Schema>> {
+	async get<Schema extends TSchema>(
+		field: SharedStateField<Schema>,
+	): Promise<Static<Schema>> {
 		const value = await this.getOptional(field);
-		if (value === undefined) throw new Error(`Missing shared state: ${field.id}`);
+		if (value === undefined)
+			throw new Error(`Missing shared state: ${field.id}`);
 		return value;
 	}
 
-	async getOptional<Schema extends TSchema>(field: SharedStateField<Schema>): Promise<Static<Schema> | undefined> {
-		const row = this.database.prepare("SELECT value FROM state WHERE key = ?").get(field.id);
-		return row === undefined ? undefined : copyValue(field.schema, JSON.parse(String(row.value)));
+	async getOptional<Schema extends TSchema>(
+		field: SharedStateField<Schema>,
+	): Promise<Static<Schema> | undefined> {
+		const row = this.database
+			.prepare("SELECT value FROM state WHERE key = ?")
+			.get(field.id);
+		return row === undefined
+			? undefined
+			: copyValue(field.schema, JSON.parse(String(row.value)));
 	}
 
-	async set<Schema extends TSchema>(field: SharedStateField<Schema>, value: NoInfer<Static<Schema>>): Promise<void> {
+	async set<Schema extends TSchema>(
+		field: SharedStateField<Schema>,
+		value: NoInfer<Static<Schema>>,
+	): Promise<void> {
 		const checked = copyValue(field.schema, value);
-		this.database.prepare("INSERT INTO state (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(field.id, JSON.stringify(checked));
+		this.database
+			.prepare(
+				"INSERT INTO state (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
+			)
+			.run(field.id, JSON.stringify(checked));
 	}
 
 	close(): void {
@@ -50,7 +80,10 @@ export class SharedState {
 	}
 }
 
-function copyValue<Schema extends TSchema>(schema: Schema, value: unknown): Static<Schema> {
+function copyValue<Schema extends TSchema>(
+	schema: Schema,
+	value: unknown,
+): Static<Schema> {
 	Value.Assert(jsonValueSchema, value);
 	return structuredClone(Value.Parse(schema, value));
 }

package/assets/examples/shared-state/state-tools.ts

@@ -4,7 +4,11 @@ import type { ToolDefinition } from "@vimhead.dev/norn";
 import type { SharedStateAccess, SharedStateField } from "./shared-state.ts";
 import { inspectSchema } from "@vimhead.dev/norn/schema";
 
-function defineTool<Schema extends TSchema>(tool: ToolDefinition<Schema>): ToolDefinition<Schema> { return tool; }
+function defineTool<Schema extends TSchema>(
+	tool: ToolDefinition<Schema>,
+): ToolDefinition<Schema> {
+	return tool;
+}
 
 export type StateFieldAccess = {
 	readonly field: SharedStateField;
@@ -12,57 +16,105 @@ export type StateFieldAccess = {
 };
 
 const pageParameters = {
-	offset: Type.Integer({ minimum: 0, description: "Zero-based UTF-16 offset into the serialized JSON. Start at 0." }),
+	offset: Type.Integer({
+		minimum: 0,
+		description:
+			"Zero-based UTF-16 offset into the serialized JSON. Start at 0.",
+	}),
 	limit: Type.Integer({ minimum: 1, maximum: 10000 }),
 };
 
-export function createStateTools(input: { readonly state: SharedStateAccess; readonly fields: readonly StateFieldAccess[] }): ToolDefinition[] {
+export function createStateTools(input: {
+	readonly state: SharedStateAccess;
+	readonly fields: readonly StateFieldAccess[];
+}): ToolDefinition[] {
 	const fields = new Map(input.fields.map((grant) => [grant.field.id, grant]));
-	if (fields.size !== input.fields.length || fields.size === 0) throw new Error("State tools require unique, explicitly selected fields");
+	if (fields.size !== input.fields.length || fields.size === 0)
+		throw new Error("State tools require unique, explicitly selected fields");
 	const selectField = (key: string, access: "read" | "write") => {
 		const grant = fields.get(key);
-		if (!grant || (grant.access !== access && grant.access !== "read-write")) throw new Error(`State ${access} is not attached: ${key}`);
+		if (!grant || (grant.access !== access && grant.access !== "read-write"))
+			throw new Error(`State ${access} is not attached: ${key}`);
 		return grant.field;
 	};
 	return [
 		defineTool({
 			name: "norn_state_list",
 			label: "Attached workflow state",
-			description: "List only attached workflow-state field IDs, permissions and value schemas. JSON is paginated; use nextOffset until null.",
+			description: `List only attached workflow-state field IDs, permissions and
+value schemas. JSON is paginated; use nextOffset until null.`,
 			parameters: Type.Object(pageParameters),
 			async execute(_id, args) {
-				return serializePage({ value: [...fields.values()].map(({ field, access }) => ({ id: field.id, access, schema: inspectSchema(field.schema) })), ...args });
+				return serializePage({
+					value: [...fields.values()].map(({ field, access }) => ({
+						id: field.id,
+						access,
+						schema: inspectSchema(field.schema),
+					})),
+					...args,
+				});
 			},
 		}),
 		defineTool({
 			name: "norn_state_get",
 			label: "Read workflow state",
-			description: "Read a selected workflow-state field. Unset fields return isSet:false. JSON is paginated; concurrent writes can change later pages, so compare revision before combining pages.",
+			description: `Read a selected workflow-state field.
+Unset fields return isSet:false. JSON is paginated; concurrent writes can
+change later pages, so compare revision before combining pages.`,
 			parameters: Type.Object({ key: Type.String(), ...pageParameters }),
 			async execute(_id, args) {
-				const value = await input.state.getOptional(selectField(args.key, "read"));
-				return serializePage({ value: value === undefined ? { isSet: false } : { isSet: true, value }, ...args });
+				const value = await input.state.getOptional(
+					selectField(args.key, "read"),
+				);
+				return serializePage({
+					value:
+						value === undefined ? { isSet: false } : { isSet: true, value },
+					...args,
+				});
 			},
 		}),
 		defineTool({
 			name: "norn_state_set",
 			label: "Write workflow state",
-			description: "Set an explicitly writable workflow-state field. Validate the value against its schema from norn_state_list. A get followed by set is not a transaction.",
+			description: `Set an explicitly writable workflow-state field.
+Validate the value against its schema from norn_state_list.
+A get followed by set is not a transaction.`,
 			parameters: Type.Object({ key: Type.String(), value: Type.Unknown() }),
 			async execute(_id, args, signal) {
 				signal?.throwIfAborted();
 				const field = selectField(args.key, "write");
 				await input.state.set(field, args.value);
-				return { content: [{ type: "text", text: "Workflow state saved." }], details: {} };
+				return {
+					content: [{ type: "text", text: "Workflow state saved." }],
+					details: {},
+				};
 			},
 		}),
 	];
 }
 
-function serializePage(input: { readonly value: unknown; readonly offset: number; readonly limit: number }) {
+function serializePage(input: {
+	readonly value: unknown;
+	readonly offset: number;
+	readonly limit: number;
+}) {
 	const serialized = JSON.stringify(input.value);
-	if (!Number.isInteger(input.offset) || input.offset < 0 || !Number.isInteger(input.limit) || input.limit < 1 || input.limit > 10000) throw new Error("Invalid state output page");
+	if (
+		!Number.isInteger(input.offset) ||
+		input.offset < 0 ||
+		!Number.isInteger(input.limit) ||
+		input.limit < 1 ||
+		input.limit > 10000
+	)
+		throw new Error("Invalid state output page");
 	const end = Math.min(serialized.length, input.offset + input.limit);
-	const details = { text: serialized.slice(input.offset, end), nextOffset: end < serialized.length ? end : null, revision: createHash("sha256").update(serialized).digest("hex") };
-	return { content: [{ type: "text" as const, text: JSON.stringify(details) }], details };
+	const details = {
+		text: serialized.slice(input.offset, end),
+		nextOffset: end < serialized.length ? end : null,
+		revision: createHash("sha256").update(serialized).digest("hex"),
+	};
+	return {
+		content: [{ type: "text" as const, text: JSON.stringify(details) }],
+		details,
+	};
 }

package/assets/examples/worktree-development-loop/README.md

@@ -19,13 +19,13 @@ workflow:
 
 ## Source layout
 
-| File or directory | Role in this example |
-|---|---|
-| [scope.ts](scope.ts) | Declares the shared namespace and repository configuration. |
-| [plugin.ts](plugin.ts) | Exports the workflows for registration. |
-| [workflows/development-loop/](workflows/development-loop/) | Defines entrypoint inputs and repository setup. |
-| [workflows/planning/](workflows/planning/), [workflows/implementation/](workflows/implementation/), [workflows/review/](workflows/review/) | Define each agent step's inputs and execution. |
-| [workflows/review-router/](workflows/review-router/) | Defines editable gate fields and routes the chosen decision. |
+| File or directory                                                                                                                          | Role in this example                                         |
+| ------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------ |
+| [scope.ts](scope.ts)                                                                                                                       | Declares the shared namespace and repository configuration.  |
+| [plugin.ts](plugin.ts)                                                                                                                     | Exports the workflows for registration.                      |
+| [workflows/development-loop/](workflows/development-loop/)                                                                                 | Defines entrypoint inputs and repository setup.              |
+| [workflows/planning/](workflows/planning/), [workflows/implementation/](workflows/implementation/), [workflows/review/](workflows/review/) | Define each agent step's inputs and execution.               |
+| [workflows/review-router/](workflows/review-router/)                                                                                       | Defines editable gate fields and routes the chosen decision. |
 
 ## Setup
 
@@ -90,11 +90,11 @@ proof that the task succeeded.
 
 Only `decision` and `summary` are gate-editable fields:
 
-| Decision | Result after resume |
-|---|---|
-| `accept` | Complete with outcome data `status: done`, including at the iteration limit. |
-| `revise` | Run the next implementation/review iteration, then interrupt again. At `maxIterations`, fail with outcome data `status: needs-attention`. |
-| `blocked` | Fail with outcome data `status: blocked` and the supplied summary. |
+| Decision  | Result after resume                                                                                                                       |
+| --------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
+| `accept`  | Complete with outcome data `status: done`, including at the iteration limit.                                                              |
+| `revise`  | Run the next implementation/review iteration, then interrupt again. At `maxIterations`, fail with outcome data `status: needs-attention`. |
+| `blocked` | Fail with outcome data `status: blocked` and the supplied summary.                                                                        |
 
 For an authorized acceptance decision after checking the work:
 

package/assets/examples/worktree-development-loop/norn.project.json

@@ -1,9 +1,9 @@
 {
-  "version": 1,
-  "workflows": ["./plugin.ts"],
-  "config": {
-    "worktreeDevelopmentLoop": {
-      "repositoryRoot": "/absolute/path/to/source-repository"
-    }
-  }
+	"version": 1,
+	"workflows": ["./plugin.ts"],
+	"config": {
+		"worktreeDevelopmentLoop": {
+			"repositoryRoot": "/absolute/path/to/source-repository"
+		}
+	}
 }

package/assets/examples/worktree-development-loop/plugin.ts

@@ -4,4 +4,10 @@ import { implementationWorkflow } from "./workflows/implementation/execute.ts";
 import { reviewWorkflow } from "./workflows/review/execute.ts";
 import { reviewRouterWorkflow } from "./workflows/review-router/execute.ts";
 
-export default [developmentLoopWorkflow, planningWorkflow, implementationWorkflow, reviewWorkflow, reviewRouterWorkflow];
+export default [
+	developmentLoopWorkflow,
+	planningWorkflow,
+	implementationWorkflow,
+	reviewWorkflow,
+	reviewRouterWorkflow,
+];

package/assets/examples/worktree-development-loop/scope.ts

@@ -1,4 +1,7 @@
 import { workflowScope } from "@vimhead.dev/norn";
 import { developmentLoopConfigSchema } from "./workflows/development-loop/schema.ts";
 
-export const developmentLoopScope = workflowScope({ name: "worktreeDevelopmentLoop", config: developmentLoopConfigSchema });
+export const developmentLoopScope = workflowScope({
+	name: "worktreeDevelopmentLoop",
+	config: developmentLoopConfigSchema,
+});

package/assets/examples/worktree-development-loop/shared/commands.ts

@@ -1,6 +1,10 @@
 import type { NornCommandRunResult } from "@vimhead.dev/norn";
 
-export async function ensureCommandSucceeded(result: NornCommandRunResult): Promise<void> {
+export async function ensureCommandSucceeded(
+	result: NornCommandRunResult,
+): Promise<void> {
 	if (result.exitCode === 0) return;
-	throw new Error(`${result.label} failed with exit code ${result.exitCode ?? "unknown"}: ${result.stderrTail || result.stdoutTail}`);
+	throw new Error(
+		`${result.label} failed with exit code ${result.exitCode ?? "unknown"}: ${result.stderrTail || result.stdoutTail}`,
+	);
 }

package/assets/examples/worktree-development-loop/workflows/development-loop/execute.ts

@@ -6,11 +6,25 @@ import { materializeWorkspaceRepository } from "./repository.ts";
 
 export const developmentLoopWorkflow = developmentLoopScope.workflow({
 	name: "developmentLoop",
-	entrypoint: { instructions: "Use when you want a repository task planned, implemented, and reviewed in a separate clone with a caller approval gate. Starts from committed content and retains changes for inspection without automatically merging or pushing results back. Requires Git, Bash, and model access." },
+	entrypoint: {
+		instructions: `Use when you want a repository task planned, implemented,
+and reviewed in a separate clone with a caller approval gate. Starts from
+committed content and retains changes for inspection without automatically
+merging or pushing results back. Requires Git, Bash, and model access.`,
+	},
 	args: developmentLoopArgsSchema,
 	async execute({ args, scope, paths, commands }): Promise<WorkflowResult> {
-		const repositoryPath = await materializeWorkspaceRepository({ commands, paths, repositoryRoot: scope.config.repositoryRoot, baseRef: args.baseRef });
+		const repositoryPath = await materializeWorkspaceRepository({
+			commands,
+			paths,
+			repositoryRoot: scope.config.repositoryRoot,
+			baseRef: args.baseRef,
+		});
 
-		return planningWorkflow({ task: args.task, repositoryPath, maxIterations: args.maxIterations });
-	}
+		return planningWorkflow({
+			task: args.task,
+			repositoryPath,
+			maxIterations: args.maxIterations,
+		});
+	},
 });

package/assets/examples/worktree-development-loop/workflows/development-loop/index.ts

@@ -1,3 +1,6 @@
 export { developmentLoopWorkflow } from "./execute.ts";
-export { developmentLoopConfigSchema, developmentLoopArgsSchema } from "./schema.ts";
+export {
+	developmentLoopConfigSchema,
+	developmentLoopArgsSchema,
+} from "./schema.ts";
 export type { DevelopmentLoopConfig, DevelopmentLoopArgs } from "./schema.ts";

package/assets/examples/worktree-development-loop/workflows/development-loop/repository.ts

@@ -4,7 +4,17 @@ import { ensureCommandSucceeded } from "../../shared/commands.ts";
 
 const WORKSPACE_REPOSITORY_PATH = "repo";
 
-export async function materializeWorkspaceRepository({ commands, paths, repositoryRoot, baseRef }: { commands: NornCommands; paths: NornWorkflowPaths; repositoryRoot: string; baseRef: string }): Promise<string> {
+export async function materializeWorkspaceRepository({
+	commands,
+	paths,
+	repositoryRoot,
+	baseRef,
+}: {
+	commands: NornCommands;
+	paths: NornWorkflowPaths;
+	repositoryRoot: string;
+	baseRef: string;
+}): Promise<string> {
 	const repositoryPath = join(paths.workspace, WORKSPACE_REPOSITORY_PATH);
 	const result = await commands.run({
 		label: "materialize-workspace-repository",

package/assets/examples/worktree-development-loop/workflows/development-loop/schema.ts

@@ -10,5 +10,9 @@ export const developmentLoopArgsSchema = Type.Object({
 	maxIterations: Type.Integer({ minimum: 1, maximum: 10, default: 3 }),
 });
 
-export type DevelopmentLoopConfig = StaticDecode<typeof developmentLoopConfigSchema>;
-export type DevelopmentLoopArgs = StaticDecode<typeof developmentLoopArgsSchema>;
+export type DevelopmentLoopConfig = StaticDecode<
+	typeof developmentLoopConfigSchema
+>;
+export type DevelopmentLoopArgs = StaticDecode<
+	typeof developmentLoopArgsSchema
+>;

package/assets/examples/worktree-development-loop/workflows/implementation/execute.ts

@@ -11,15 +11,28 @@ export const implementationWorkflow = developmentLoopScope.workflow({
 	name: "implementation",
 	entrypoint: false,
 	args: implementationArgsSchema,
-	async execute({ args, paths, agents, commands, logs }): Promise<WorkflowResult> {
+	async execute({
+		args,
+		paths,
+		agents,
+		commands,
+		logs,
+	}): Promise<WorkflowResult> {
 		const repositoryPath = resolve(paths.workspace, args.repositoryPath);
 		const plan = await readFile(join(paths.workspace, args.planPath), "utf8");
-		const previousReview = args.previousReviewPath ? await readFile(join(paths.workspace, args.previousReviewPath), "utf8") : undefined;
+		const previousReview = args.previousReviewPath
+			? await readFile(join(paths.workspace, args.previousReviewPath), "utf8")
+			: undefined;
 		const implementation = await agents.prompt({
 			label: `implementation-${args.iteration}`,
 			cwd: repositoryPath,
 			tools: ["read", "grep", "find", "ls", "edit", "write", "bash"],
-			prompt: buildImplementationPrompt(args.task, plan, args.iteration, previousReview),
+			prompt: buildImplementationPrompt(
+				args.task,
+				plan,
+				args.iteration,
+				previousReview,
+			),
 			response: implementationAgentResponseSchema,
 		});
 		const status = await commands.run({
@@ -30,17 +43,33 @@ export const implementationWorkflow = developmentLoopScope.workflow({
 		await ensureCommandSucceeded(status);
 		const statusOutput = await logs.read(status.stdoutLog);
 		await mkdir(join(paths.workspace, "implementation"), { recursive: true });
-		await writeFile(join(paths.workspace, `implementation/iteration-${args.iteration}-status.txt`), statusOutput);
-		return reviewWorkflow({ ...args, implementationSummary: implementation.summary });
-	}
+		await writeFile(
+			join(
+				paths.workspace,
+				`implementation/iteration-${args.iteration}-status.txt`,
+			),
+			statusOutput,
+		);
+		return reviewWorkflow({
+			...args,
+			implementationSummary: implementation.summary,
+		});
+	},
 });
 
-function buildImplementationPrompt(task: string, plan: string, iteration: number, previousReview: string | undefined): string {
+function buildImplementationPrompt(
+	task: string,
+	plan: string,
+	iteration: number,
+	previousReview: string | undefined,
+): string {
 	return [
 		`Implement iteration ${iteration} for this repository task.`,
 		"Modify files as needed in the current repository.",
 		"Keep changes focused and run a cheap relevant check when possible.",
-		previousReview ? "Address the previous review before making new changes." : undefined,
+		previousReview
+			? "Address the previous review before making new changes."
+			: undefined,
 		"",
 		"Task:",
 		task,
@@ -50,6 +79,7 @@ function buildImplementationPrompt(task: string, plan: string, iteration: number
 		previousReview ? "" : undefined,
 		previousReview ? "Previous review:" : undefined,
 		previousReview,
-	].filter((line): line is string => line !== undefined).join("\n");
+	]
+		.filter((line): line is string => line !== undefined)
+		.join("\n");
 }
-

package/assets/examples/worktree-development-loop/workflows/implementation/index.ts

@@ -1,2 +1,6 @@
 export { implementationWorkflow } from "./execute.ts";
-export { implementationAgentResponseSchema, implementationArgsSchema, type ImplementationArgs } from "./schema.ts";
+export {
+	implementationAgentResponseSchema,
+	implementationArgsSchema,
+	type ImplementationArgs,
+} from "./schema.ts";

package/assets/examples/worktree-development-loop/workflows/planning/execute.ts

@@ -23,7 +23,7 @@ export const planningWorkflow = developmentLoopScope.workflow({
 		await mkdir(join(paths.workspace, "planning"), { recursive: true });
 		await writeFile(join(paths.workspace, planPath), planning.plan);
 		return implementationWorkflow({ ...args, planPath, iteration: 1 });
-	}
+	},
 });
 
 function buildPlanningPrompt(task: string): string {

package/assets/examples/worktree-development-loop/workflows/planning/index.ts

@@ -1,2 +1,6 @@
 export { planningWorkflow } from "./execute.ts";
-export { planningAgentResponseSchema, planningArgsSchema, type PlanningArgs } from "./schema.ts";
+export {
+	planningAgentResponseSchema,
+	planningArgsSchema,
+	type PlanningArgs,
+} from "./schema.ts";

package/assets/examples/worktree-development-loop/workflows/review/execute.ts

@@ -11,28 +11,46 @@ export const reviewWorkflow = developmentLoopScope.workflow({
 	name: "review",
 	entrypoint: false,
 	args: reviewArgsSchema,
-	async execute({ args, paths, agents, commands, logs }): Promise<WorkflowResult> {
+	async execute({
+		args,
+		paths,
+		agents,
+		commands,
+		logs,
+	}): Promise<WorkflowResult> {
 		const repositoryPath = resolve(paths.workspace, args.repositoryPath);
 		const implementationSummary = args.implementationSummary;
 		const plan = await readFile(join(paths.workspace, args.planPath), "utf8");
 		const diff = await commands.run({
 			label: `review-${args.iteration}-diff`,
 			cwd: repositoryPath,
-			command: "git status --short && git diff --stat HEAD -- . && git diff HEAD -- .",
+			command:
+				"git status --short && git diff --stat HEAD -- . && git diff HEAD -- .",
 		});
 		await ensureCommandSucceeded(diff);
 		const diffOutput = await logs.read(diff.stdoutLog);
 		await mkdir(join(paths.workspace, "review"), { recursive: true });
-		await writeFile(join(paths.workspace, `review/iteration-${args.iteration}-diff.txt`), diffOutput);
+		await writeFile(
+			join(paths.workspace, `review/iteration-${args.iteration}-diff.txt`),
+			diffOutput,
+		);
 		const review = await agents.prompt({
 			label: `review-${args.iteration}`,
 			cwd: repositoryPath,
 			tools: ["read", "grep", "find", "ls", "bash"],
-			prompt: buildReviewPrompt(args.task, plan, implementationSummary, diffOutput),
+			prompt: buildReviewPrompt(
+				args.task,
+				plan,
+				implementationSummary,
+				diffOutput,
+			),
 			response: reviewAgentResponseSchema,
 		});
 		const automatedReviewPath = `review/iteration-${args.iteration}-automated.json`;
-		await writeFile(join(paths.workspace, automatedReviewPath), JSON.stringify(review, null, 2));
+		await writeFile(
+			join(paths.workspace, automatedReviewPath),
+			JSON.stringify(review, null, 2),
+		);
 		return reviewRouterWorkflow({
 			...args,
 			iteration: args.iteration,
@@ -40,13 +58,20 @@ export const reviewWorkflow = developmentLoopScope.workflow({
 			summary: review.summary,
 			automatedReviewPath,
 		});
-	}
+	},
 });
 
-function buildReviewPrompt(task: string, plan: string, implementationSummary: string, diff: string): string {
+function buildReviewPrompt(
+	task: string,
+	plan: string,
+	implementationSummary: string,
+	diff: string,
+): string {
 	return [
 		"Review the current repository changes against the task and plan.",
-		"Use accept only when the work is ready. Use revise for fixable issues. Use blocked when manual input is needed. Include review details in the summary.",
+		`Use accept only when the work is ready. Use revise for fixable issues.
+Use blocked when manual input is needed. Include review details in the
+summary.`,
 		"",
 		"Task:",
 		task,
@@ -61,4 +86,3 @@ function buildReviewPrompt(task: string, plan: string, implementationSummary: st
 		diff.slice(0, 40_000),
 	].join("\n");
 }
-