@markjaquith/agency 2.4.0 → 2.5.0

package/src/services/TaskService.ts

@@ -9,6 +9,7 @@ import {
 	TaskFrontmatter,
 	type RepositoryReference,
 	type TaskFrontmatter as TaskData,
+	WorkStatus,
 } from "../workbase/schemas"
 import {
 	formatMarkdownDocument,
@@ -28,7 +29,7 @@ interface TaskRecord {
 
 export interface CreateTaskInput {
 	readonly id: string
-	readonly ticketUrl: string
+	readonly ticketUrl: string | null
 	readonly description?: string
 	readonly epic?: string
 	readonly multiPhase?: boolean
@@ -57,6 +58,13 @@ const decodeId = (id: string) => {
 		: Effect.succeed(result.right)
 }
 
+const decodeStatus = (status: string) => {
+	const result = Schema.decodeUnknownEither(WorkStatus)(status)
+	return Either.isLeft(result)
+		? Effect.fail(new TaskError({ message: `Invalid work status '${status}'` }))
+		: Effect.succeed(result.right)
+}
+
 export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 	sync: () => ({
 		create: (input: CreateTaskInput, startPath: string = process.cwd()) =>
@@ -188,5 +196,27 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 				}
 				return record
 			}),
+
+		setStatus: (
+			id: string,
+			status: string,
+			startPath: string = process.cwd(),
+		) =>
+			Effect.gen(function* () {
+				const fs = yield* FileSystemService
+				const service = yield* TaskService
+				const validStatus = yield* decodeStatus(status)
+				const record = yield* service.show(id, startPath)
+				if ("phases" in record.data) {
+					return yield* new TaskError({
+						message: `Task '${id}' has multiple phases; set status on a phase instead`,
+					})
+				}
+				const parsed = yield* parseFrontmatter(record.content, record.path)
+				const data = { ...record.data, status: validStatus }
+				const content = formatMarkdownDocument(data, parsed.body)
+				yield* fs.writeFile(record.path, content)
+				return { ...record, content, data } satisfies TaskRecord
+			}),
 	}),
 }) {}

package/src/services/WorkbaseService.test.ts

@@ -5,6 +5,7 @@ import { mkdir } from "node:fs/promises"
 import { dirname, join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { managedWorkbaseAgents } from "../workbase/agents-file"
+import { managedWorkbaseOpencode } from "../workbase/opencode-file"
 import { WorkbaseService } from "./WorkbaseService"
 
 const write = async (root: string, path: string, content: string) => {
@@ -18,6 +19,11 @@ const managedAgents = (body: string) => {
 	return `<!-- agency-managed: sha256=${checksum} -->\n\n${body}`
 }
 
+const managedOpencode = (body: string) => {
+	const checksum = createHash("sha256").update(body).digest("hex")
+	return `// agency-managed: sha256=${checksum}\n\n${body}`
+}
+
 describe("WorkbaseService", () => {
 	let root: string
 
@@ -45,6 +51,66 @@ describe("WorkbaseService", () => {
 		expect(await Bun.file(join(root, "AGENTS.md")).text()).toBe(
 			managedWorkbaseAgents,
 		)
+		expect(await Bun.file(join(root, ".opencode/opencode.jsonc")).text()).toBe(
+			managedWorkbaseOpencode,
+		)
+	})
+
+	test("preserves an unmanaged workbase OpenCode config", async () => {
+		await write(root, "agency.json", '{"version":2}\n')
+		await write(root, ".opencode/opencode.jsonc", '{"model":"test/model"}\n')
+
+		await runTestEffect(
+			WorkbaseService.pipe(Effect.flatMap((service) => service.discover(root))),
+		)
+
+		expect(await Bun.file(join(root, ".opencode/opencode.jsonc")).text()).toBe(
+			'{"model":"test/model"}\n',
+		)
+	})
+
+	test("does not override an existing JSON OpenCode config", async () => {
+		await write(root, "agency.json", '{"version":2}\n')
+		await write(root, ".opencode/opencode.json", '{"model":"test/model"}\n')
+
+		await runTestEffect(
+			WorkbaseService.pipe(Effect.flatMap((service) => service.discover(root))),
+		)
+
+		expect(
+			await Bun.file(join(root, ".opencode/opencode.jsonc")).exists(),
+		).toBe(false)
+	})
+
+	test("updates an unmodified managed workbase OpenCode config", async () => {
+		await write(root, "agency.json", '{"version":2}\n')
+		await write(
+			root,
+			".opencode/opencode.jsonc",
+			managedOpencode('{"references":{}}\n'),
+		)
+
+		await runTestEffect(
+			WorkbaseService.pipe(Effect.flatMap((service) => service.discover(root))),
+		)
+
+		expect(await Bun.file(join(root, ".opencode/opencode.jsonc")).text()).toBe(
+			managedWorkbaseOpencode,
+		)
+	})
+
+	test("preserves a modified managed workbase OpenCode config", async () => {
+		await write(root, "agency.json", '{"version":2}\n')
+		const content = `${managedOpencode('{"references":{}}\n')}\n// User edit\n`
+		await write(root, ".opencode/opencode.jsonc", content)
+
+		await runTestEffect(
+			WorkbaseService.pipe(Effect.flatMap((service) => service.discover(root))),
+		)
+
+		expect(await Bun.file(join(root, ".opencode/opencode.jsonc")).text()).toBe(
+			content,
+		)
 	})
 
 	test("preserves an unmanaged workbase AGENTS.md", async () => {

package/src/services/WorkbaseService.ts

@@ -19,6 +19,10 @@ import {
 	canUpdateManagedWorkbaseAgents,
 	managedWorkbaseAgents,
 } from "../workbase/agents-file"
+import {
+	canUpdateManagedWorkbaseOpencode,
+	managedWorkbaseOpencode,
+} from "../workbase/opencode-file"
 
 class WorkbaseNotFoundError extends Data.TaggedError("WorkbaseNotFoundError")<{
 	readonly message: string
@@ -86,6 +90,32 @@ const ensureWorkbaseAgents = (root: string) =>
 		}
 	})
 
+const ensureWorkbaseOpencode = (root: string) =>
+	Effect.gen(function* () {
+		const fs = yield* FileSystemService
+		const directory = join(root, ".opencode")
+		const path = join(directory, "opencode.jsonc")
+		if (!(yield* fs.exists(path))) {
+			if (yield* fs.exists(join(directory, "opencode.json"))) return
+			yield* fs.createDirectory(directory)
+			yield* fs.writeFile(path, managedWorkbaseOpencode)
+			return
+		}
+
+		const content = yield* fs.readFile(path)
+		if (
+			content !== managedWorkbaseOpencode &&
+			canUpdateManagedWorkbaseOpencode(content)
+		) {
+			yield* fs.writeFile(path, managedWorkbaseOpencode)
+		}
+	})
+
+const ensureWorkbaseAgentFiles = (root: string) =>
+	Effect.all([ensureWorkbaseAgents(root), ensureWorkbaseOpencode(root)], {
+		concurrency: "unbounded",
+	})
+
 const findCycles = (nodes: readonly Dependency[]): readonly string[] => {
 	const dependencies = new Map(
 		nodes.map((node) => [node.id, [...(node.dependsOn ?? [])]]),
@@ -164,7 +194,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 							`${existing}${prefix}${missing.join("\n")}\n`,
 						)
 					}
-					yield* ensureWorkbaseAgents(root)
+					yield* ensureWorkbaseAgentFiles(root)
 
 					return root
 				}),
@@ -221,7 +251,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 										})
 									}
 								}
-								yield* ensureWorkbaseAgents(current)
+								yield* ensureWorkbaseAgentFiles(current)
 								return current
 							}
 						}

package/src/services/WorktreeService.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { mkdir } from "node:fs/promises"
+import { mkdir, rm } from "node:fs/promises"
 import { join } from "node:path"
 import {
 	captureLogs,
@@ -600,6 +600,155 @@ pr: null
 		).rejects.toThrow("is attached to branch 'main'")
 	})
 
+	test("removes worktrees without deleting branches", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "removable",
+							ticketUrl: "https://example.com/task",
+							repo: "agency",
+							repos: [{ repo: "effect", ref: "main" }],
+							branch: "task/removable",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("removable", undefined, root),
+				),
+			),
+		)
+
+		const removed = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.remove("removable", undefined, root),
+				),
+			),
+		)
+
+		expect(removed.sort()).toEqual(
+			[
+				join(workspace.codePath, "agency"),
+				join(workspace.codePath, "effect"),
+			].sort(),
+		)
+		expect(await Bun.file(workspace.codePath).exists()).toBe(false)
+		const branch = Bun.spawnSync([
+			"git",
+			"-C",
+			join(root, "repos/agency"),
+			"show-ref",
+			"--verify",
+			"refs/heads/task/removable",
+		])
+		expect(branch.exitCode).toBe(0)
+	})
+
+	test("refuses to remove a worktree with uncommitted changes", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "dirty",
+							ticketUrl: "https://example.com/task",
+							repo: "agency",
+							branch: "task/dirty",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("dirty", undefined, root),
+				),
+			),
+		)
+		await Bun.write(
+			join(workspace.writablePath, "uncommitted.txt"),
+			"keep me\n",
+		)
+
+		await expect(
+			runTestEffect(
+				WorktreeService.pipe(
+					Effect.flatMap((service) => service.remove("dirty", undefined, root)),
+				),
+			),
+		).rejects.toThrow("Failed to remove worktree for 'agency'")
+		expect(
+			await Bun.file(join(workspace.writablePath, "uncommitted.txt")).text(),
+		).toBe("keep me\n")
+	})
+
+	test("handles a missing checkout without deleting its branch", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "stale",
+							ticketUrl: "https://example.com/task",
+							repo: "agency",
+							branch: "task/stale",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("stale", undefined, root),
+				),
+			),
+		)
+		await rm(workspace.codePath, { recursive: true })
+
+		const removed = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) => service.remove("stale", undefined, root)),
+			),
+		)
+
+		expect(removed).toEqual([])
+		const worktrees = Bun.spawnSync([
+			"git",
+			"-C",
+			join(root, "repos/agency"),
+			"worktree",
+			"list",
+			"--porcelain",
+		])
+		expect(new TextDecoder().decode(worktrees.stdout)).not.toContain(
+			workspace.writablePath,
+		)
+		expect(
+			Bun.spawnSync([
+				"git",
+				"-C",
+				join(root, "repos/agency"),
+				"show-ref",
+				"--verify",
+				"refs/heads/task/stale",
+			]).exitCode,
+		).toBe(0)
+	})
+
 	test("supports Worktrunk as the configured command", async () => {
 		if (Bun.spawnSync(["which", "wt"], { stdout: "ignore" }).exitCode !== 0) {
 			return

package/src/services/WorktreeService.ts

@@ -1,5 +1,5 @@
 import { Data, Effect } from "effect"
-import { dirname, join, resolve } from "node:path"
+import { basename, dirname, join, resolve } from "node:path"
 import { FileSystemService } from "./FileSystemService"
 import { WorkbaseService } from "./WorkbaseService"
 import { TaskService } from "./TaskService"
@@ -372,6 +372,128 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 						repos: execution.repos ?? [],
 					} satisfies ExecutionWorkspace
 				}),
+
+			remove: (
+				taskId: string,
+				phaseId?: string,
+				startPath: string = process.cwd(),
+			) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const workbase = yield* WorkbaseService
+					const tasks = yield* TaskService
+					const phases = yield* PhaseService
+					const root = yield* workbase.discover(startPath)
+					const task = yield* tasks.show(taskId, root)
+
+					let execution: {
+						repo: string
+						repos?: readonly RepositoryReference[]
+					}
+					let codePath: string
+					if ("phases" in task.data) {
+						if (!phaseId) {
+							return yield* new WorktreeError({
+								message: `Task '${taskId}' has multiple phases; phase ID is required`,
+							})
+						}
+						const phase = yield* phases.show(taskId, phaseId, root)
+						execution = phase.data
+						codePath = join(dirname(phase.path), "code")
+					} else {
+						if (phaseId) {
+							return yield* new WorktreeError({
+								message: `Task '${taskId}' is single-phase and does not accept a phase ID`,
+							})
+						}
+						execution = task.data
+						codePath = join(dirname(task.path), "code")
+					}
+
+					const codeDirectoryExists = yield* fs.isDirectory(codePath)
+					const removed: string[] = []
+					for (const alias of [
+						execution.repo,
+						...(execution.repos ?? []).map((reference) => reference.repo),
+					]) {
+						const repositoryPath = join(root, "repos", alias)
+						const checkoutPath = join(codePath, alias)
+						const listed = yield* fs.runCommand(
+							[
+								"git",
+								"-C",
+								repositoryPath,
+								"worktree",
+								"list",
+								"--porcelain",
+								"-z",
+							],
+							{ captureOutput: true },
+						)
+						if (listed.exitCode !== 0) {
+							return yield* new WorktreeError({
+								message: `Failed to inspect worktrees for '${alias}': ${listed.stderr}`,
+							})
+						}
+
+						const checkoutExists = yield* fs.isDirectory(checkoutPath)
+						const canonicalCheckoutPath = checkoutExists
+							? yield* fs.realPath(checkoutPath)
+							: join(
+									yield* fs.realPath(dirname(codePath)),
+									basename(codePath),
+									alias,
+								)
+						let registeredPath: string | undefined
+						for (const worktree of parseWorktreeList(listed.stdout)) {
+							const worktreePath = (yield* fs.exists(worktree.path))
+								? yield* fs.realPath(worktree.path)
+								: resolve(worktree.path)
+							if (worktreePath === canonicalCheckoutPath) {
+								registeredPath = worktreePath
+								break
+							}
+						}
+						if (!registeredPath) {
+							if (checkoutExists) {
+								return yield* new WorktreeError({
+									message: `Existing checkout ${checkoutPath} is not registered as a Git worktree`,
+								})
+							}
+							continue
+						}
+
+						const result = yield* fs.runCommand(
+							[
+								"git",
+								"-C",
+								repositoryPath,
+								"worktree",
+								"remove",
+								...(!checkoutExists ? ["--force"] : []),
+								checkoutExists ? checkoutPath : registeredPath,
+							],
+							{ captureOutput: true },
+						)
+						if (result.exitCode !== 0) {
+							return yield* new WorktreeError({
+								message: `Failed to remove worktree for '${alias}': ${result.stderr}`,
+							})
+						}
+						if (checkoutExists) removed.push(checkoutPath)
+					}
+
+					if (codeDirectoryExists && (yield* fs.isDirectory(codePath))) {
+						const remaining = yield* fs.readDirectory(codePath)
+						if (remaining.length > 0) {
+							return yield* new WorktreeError({
+								message: `Cannot remove ${codePath}; it contains unmanaged entries: ${remaining.map((entry) => entry.name).join(", ")}`,
+							})
+						}
+						yield* fs.deleteDirectory(codePath)
+					}
+					return removed
+				}),
 		}),
 	},
 ) {}

package/src/test-utils.ts

@@ -11,6 +11,7 @@ import { TaskService } from "./services/TaskService"
 import { PhaseService } from "./services/PhaseService"
 import { WorktreeService } from "./services/WorktreeService"
 import { PullRequestService } from "./services/PullRequestService"
+import { ArchiveService } from "./services/ArchiveService"
 
 export const createTempDir = () => mkdtemp(join(tmpdir(), "agency-test-"))
 
@@ -26,6 +27,7 @@ const TestLayer = Layer.mergeAll(
 	PhaseService.Default,
 	WorktreeService.Default,
 	PullRequestService.Default,
+	ArchiveService.Default,
 )
 
 export async function runTestEffect<A, E>(

package/src/utils/progress.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test"
+import { createProgress } from "./progress"
+
+describe("progress", () => {
+	test("replaces an active TTY line with its completed state", () => {
+		const output: string[] = []
+		const progress = createProgress(
+			{},
+			{ isTTY: true, write: (text) => output.push(text) },
+		)
+
+		progress.start("Preparing workspace...")
+		progress.succeed("Workspace ready")
+
+		expect(output).toEqual([
+			"\r\x1b[2K\x1b[2m○\x1b[0m Preparing workspace...",
+			"\r\x1b[2K\x1b[32m✓\x1b[0m Workspace ready\n",
+		])
+	})
+
+	test("stays quiet for silent or non-TTY output", () => {
+		const output: string[] = []
+		for (const [silent, isTTY] of [
+			[true, true],
+			[false, false],
+		] as const) {
+			const progress = createProgress(
+				{ silent },
+				{ isTTY, write: (text) => output.push(text) },
+			)
+			progress.start("Preparing workspace...")
+			progress.fail("Workspace preparation failed")
+		}
+
+		expect(output).toEqual([])
+	})
+})

package/src/utils/progress.ts

@@ -0,0 +1,36 @@
+interface ProgressOptions {
+	readonly silent?: boolean
+}
+
+interface ProgressOutput {
+	readonly isTTY: boolean
+	readonly write: (text: string) => void
+}
+
+export interface Progress {
+	readonly start: (message: string) => void
+	readonly succeed: (message: string) => void
+	readonly fail: (message: string) => void
+}
+
+const terminalOutput: ProgressOutput = {
+	isTTY: Boolean(process.stderr.isTTY),
+	write: (text) => process.stderr.write(text),
+}
+
+export const createProgress = (
+	options: ProgressOptions,
+	output: ProgressOutput = terminalOutput,
+): Progress => {
+	const enabled = !options.silent && output.isTTY
+	const write = (symbol: string, message: string, complete: boolean) => {
+		if (!enabled) return
+		output.write(`\r\x1b[2K${symbol} ${message}${complete ? "\n" : ""}`)
+	}
+
+	return {
+		start: (message) => write("\x1b[2m○\x1b[0m", message, false),
+		succeed: (message) => write("\x1b[32m✓\x1b[0m", message, true),
+		fail: (message) => write("\x1b[31m✗\x1b[0m", message, true),
+	}
+}

package/src/workbase/AGENTS.md

@@ -24,7 +24,10 @@ field. Repositories listed in plural `repos` are read-only references.
 
 - Keep task-level decisions in `TASK.md` and phase-specific delivery context in
   `PHASE.md`.
+- Keep execution-unit `status` current with `agency task status` or
+  `agency phase status`; `agency work` marks launched work as `working`.
 - Do not manually create, move, or remove worktrees under `code/`.
+- Use `agency archive`, rather than moving work item folders manually.
 - Do not edit bare repositories or repository symlinks under `repos/`.
 - Do not run `agency work` from an active agent session unless the user
   explicitly asks to launch another agent.

package/src/workbase/opencode-file.ts

@@ -0,0 +1,37 @@
+import { createHash } from "node:crypto"
+
+const managedHeaderPattern =
+	/^\/\/ agency-managed: sha256=([a-f0-9]{64})\r?\n\r?\n/
+
+const checksum = (content: string) =>
+	createHash("sha256").update(content).digest("hex")
+
+const body = `${JSON.stringify(
+	{
+		$schema: "https://opencode.ai/config.json",
+		references: {
+			tasks: {
+				path: "../tasks",
+				description: "Agency task definitions and execution context",
+			},
+			epics: {
+				path: "../epics",
+				description: "Agency epic definitions and orchestration context",
+			},
+		},
+	},
+	null,
+	2,
+)}\n`
+
+const renderManagedWorkbaseOpencode = (content: string = body) =>
+	`// agency-managed: sha256=${checksum(content)}\n\n${content}`
+
+export const managedWorkbaseOpencode = renderManagedWorkbaseOpencode()
+
+export const canUpdateManagedWorkbaseOpencode = (content: string) => {
+	const match = content.match(managedHeaderPattern)
+	if (!match?.[1]) return false
+
+	return checksum(content.slice(match[0].length)) === match[1]
+}