@markjaquith/agency 2.18.0 → 2.20.0

package/src/commands/phase.ts

@@ -2,6 +2,8 @@ import { Effect } from "effect"
 import type { BaseCommandOptions } from "../utils/command"
 import { PhaseService } from "../services/PhaseService"
 import { createLoggers } from "../utils/effect"
+import { formatTable } from "../utils/table"
+import { getWorkViews } from "../work-view"
 import { parseRepositoryReferences } from "../workbase/repository-reference"
 
 interface PhaseOptions extends BaseCommandOptions {
@@ -15,6 +17,11 @@ interface PhaseOptions extends BaseCommandOptions {
 	readonly dependsOn?: readonly string[]
 	readonly firstPhase?: string
 	readonly json?: boolean
+	readonly statuses?: readonly string[]
+	readonly repositories?: readonly string[]
+	readonly ready?: boolean
+	readonly blocked?: boolean
+	readonly pr?: boolean
 }
 
 export const phase = (options: PhaseOptions) =>
@@ -64,15 +71,53 @@ export const phase = (options: PhaseOptions) =>
 			case "list": {
 				if (!taskId) return yield* Effect.fail(new Error("Task ID is required"))
 				const records = yield* phases.list(taskId, cwd)
+				const { phaseRows } = yield* getWorkViews({
+					cwd,
+					statuses: options.statuses,
+					repositories: options.repositories,
+					ready: options.ready,
+					blocked: options.blocked,
+					pr: options.pr,
+				})
+				const rows = phaseRows.filter((row) => row.parent === taskId)
+				const ordered = rows.flatMap((row) => {
+					const record = records.find((item) => item.id === row.id)
+					return record ? [record] : []
+				})
 				if (options.json) {
 					log(
 						JSON.stringify(
-							records.map(({ content: _, ...record }) => record),
+							ordered.map(({ content: _, ...record }) => record),
 							null,
 							2,
 						),
 					)
-				} else for (const record of records) log(record.id)
+				} else {
+					log(
+						formatTable(
+							[
+								"PHASE",
+								"PARENT",
+								"STATUS",
+								"READINESS",
+								"REPOSITORIES",
+								"BRANCH",
+								"PR",
+								"WORKTREE",
+							],
+							rows.map((row) => [
+								row.id,
+								row.parent,
+								row.status,
+								row.readiness,
+								row.repositories,
+								row.branch,
+								row.pr,
+								row.worktree,
+							]),
+						),
+					)
+				}
 				return
 			}
 			case "show": {
@@ -139,4 +184,9 @@ Create options:
 
 Options:
   --json                Output results as JSON
+  --status <status>     Filter list by status; repeatable
+  --repository <alias>  Filter list by repository; repeatable
+  --ready               Include only ready phases
+  --blocked             Include only blocked phases
+  --pr / --no-pr        Filter by recorded PR presence
 `

package/src/commands/status.test.ts

@@ -8,6 +8,7 @@ import {
 	runTestEffect,
 } from "../test-utils"
 import { status } from "./status"
+import { task } from "./task"
 
 describe("status command", () => {
 	let root: string
@@ -44,4 +45,47 @@ describe("status command", () => {
 			},
 		])
 	})
+
+	test("renders and filters the execution dashboard", async () => {
+		await runTestEffect(
+			task({
+				subcommand: "create",
+				args: ["example"],
+				repo: "agency",
+				branch: "feat/example",
+				base: "main",
+				cwd: root,
+				silent: true,
+			}),
+		)
+
+		const logs = await captureLogs(() =>
+			runTestEffect(
+				status({ cwd: root, repositories: ["agency"], ready: true, pr: false }),
+			),
+		)
+		expect(logs).toContain("Repositories: 1")
+		expect(logs.at(-1)).toContain(
+			"KIND  WORK     PARENT  STATUS  READINESS  REPOSITORIES  BRANCH",
+		)
+		expect(logs.at(-1)).toContain(
+			"task  example  -       open    ready      agency        feat/example  absent  absent",
+		)
+	})
+
+	test("reports validation issues without requiring a decodable graph", async () => {
+		await mkdir(join(root, "tasks/broken"), { recursive: true })
+		await Bun.write(
+			join(root, "tasks/broken/TASK.md"),
+			"---\nrepo: agency\nstatus: invalid\n---\n",
+		)
+
+		const logs = await captureLogs(() =>
+			runTestEffect(status({ cwd: root, json: true })),
+		)
+		const output = JSON.parse(logs[0]!)
+		expect(output.valid).toBe(false)
+		expect(output.issues.length).toBeGreaterThan(0)
+		expect(output.work).toEqual([])
+	})
 })

package/src/commands/status.ts

@@ -3,9 +3,16 @@ import type { BaseCommandOptions } from "../utils/command"
 import { WorkbaseService } from "../services/WorkbaseService"
 import { RepositoryService } from "../services/RepositoryService"
 import { createLoggers } from "../utils/effect"
+import { formatTable } from "../utils/table"
+import { getWorkViews } from "../work-view"
 
 interface StatusOptions extends BaseCommandOptions {
 	readonly json?: boolean
+	readonly statuses?: readonly string[]
+	readonly repositories?: readonly string[]
+	readonly ready?: boolean
+	readonly blocked?: boolean
+	readonly pr?: boolean
 }
 
 export const status = (options: StatusOptions = {}) =>
@@ -16,7 +23,17 @@ export const status = (options: StatusOptions = {}) =>
 		const cwd = options.cwd ?? process.cwd()
 		const report = yield* workbase.validate(cwd)
 		const repos = yield* repositories.list(report.root)
-		const data = { ...report, repositories: repos }
+		const executionRows = report.valid
+			? (yield* getWorkViews({
+					cwd,
+					statuses: options.statuses,
+					repositories: options.repositories,
+					ready: options.ready,
+					blocked: options.blocked,
+					pr: options.pr,
+				})).executionRows
+			: []
+		const data = { ...report, repositories: repos, work: executionRows }
 
 		if (options.json) {
 			log(JSON.stringify(data, null, 2))
@@ -31,6 +48,33 @@ export const status = (options: StatusOptions = {}) =>
 		log(
 			`Validation: ${report.valid ? "valid" : `${report.issues.length} issues`}`,
 		)
+		log("")
+		log(
+			formatTable(
+				[
+					"KIND",
+					"WORK",
+					"PARENT",
+					"STATUS",
+					"READINESS",
+					"REPOSITORIES",
+					"BRANCH",
+					"PR",
+					"WORKTREE",
+				],
+				executionRows.map((row) => [
+					row.kind,
+					row.kind === "phase" ? row.key : row.id,
+					row.parent,
+					row.status,
+					row.readiness,
+					row.repositories,
+					row.branch,
+					row.pr,
+					row.worktree,
+				]),
+			),
+		)
 	})
 
 export const help = `
@@ -39,5 +83,10 @@ Usage: agency status [options]
 Show workbase repository, entity, and validation status.
 
 Options:
-  --json              Output status as JSON
+  --json                Output status as JSON
+  --status <status>     Filter by status; repeatable
+  --repository <alias>  Filter by repository; repeatable
+  --ready               Include only ready work
+  --blocked             Include only blocked work
+  --pr / --no-pr        Filter by recorded PR presence
 `

package/src/commands/task-phase.test.ts

@@ -124,6 +124,26 @@ describe("task and phase command JSON output", () => {
 		})
 	})
 
+	test("renders task and phase operational tables", async () => {
+		const taskLogs = await captureLogs(() =>
+			runTestEffect(task({ subcommand: "list", args: [], cwd: root })),
+		)
+		expect(taskLogs[0]).toContain(
+			"TASK   PARENT  STATUS  READINESS  REPOSITORIES  BRANCH",
+		)
+		expect(taskLogs[0]).toContain("multi  -       open    ready")
+
+		const phaseLogs = await captureLogs(() =>
+			runTestEffect(phase({ subcommand: "list", args: ["multi"], cwd: root })),
+		)
+		expect(phaseLogs[0]).toContain(
+			"PHASE  PARENT  STATUS  READINESS  REPOSITORIES  BRANCH",
+		)
+		expect(phaseLogs[0]).toContain(
+			"first  multi   open    ready      agency        task/first  absent  absent",
+		)
+	})
+
 	test("outputs created task and phase records as JSON", async () => {
 		const taskLogs = await captureLogs(() =>
 			runTestEffect(

package/src/commands/task.ts

@@ -8,6 +8,8 @@ import { createLoggers } from "../utils/effect"
 import { parseRepositoryReferences } from "../workbase/repository-reference"
 import { WorkbaseService } from "../services/WorkbaseService"
 import { choose } from "../utils/chooser"
+import { formatTable } from "../utils/table"
+import { getWorkViews } from "../work-view"
 
 interface TaskOptions extends BaseCommandOptions {
 	readonly subcommand?: string
@@ -21,6 +23,11 @@ interface TaskOptions extends BaseCommandOptions {
 	readonly base?: string
 	readonly multiPhase?: boolean
 	readonly json?: boolean
+	readonly statuses?: readonly string[]
+	readonly repositories?: readonly string[]
+	readonly ready?: boolean
+	readonly blocked?: boolean
+	readonly pr?: boolean
 }
 
 export interface TaskInteraction {
@@ -208,16 +215,51 @@ export const task = (options: TaskOptions, interaction?: TaskInteraction) =>
 			}
 			case "list": {
 				const records = yield* tasks.list(cwd)
+				const { taskRows } = yield* getWorkViews({
+					cwd,
+					statuses: options.statuses,
+					repositories: options.repositories,
+					ready: options.ready,
+					blocked: options.blocked,
+					pr: options.pr,
+				})
+				const ordered = taskRows.flatMap((row) => {
+					const record = records.find((item) => item.id === row.key)
+					return record ? [record] : []
+				})
 				if (options.json) {
 					log(
 						JSON.stringify(
-							records.map(({ content: _, ...record }) => record),
+							ordered.map(({ content: _, ...record }) => record),
 							null,
 							2,
 						),
 					)
 				} else {
-					for (const record of records) log(record.id)
+					log(
+						formatTable(
+							[
+								"TASK",
+								"PARENT",
+								"STATUS",
+								"READINESS",
+								"REPOSITORIES",
+								"BRANCH",
+								"PR",
+								"WORKTREE",
+							],
+							taskRows.map((row) => [
+								row.id,
+								row.parent,
+								row.status,
+								row.readiness,
+								row.repositories,
+								row.branch,
+								row.pr,
+								row.worktree,
+							]),
+						),
+					)
 				}
 				return
 			}
@@ -286,4 +328,9 @@ through task new, which fails when --no-input is set or no TTY is available.
 Options:
   --json                Output results as JSON
   --no-input            Never open interactive task creation
+  --status <status>     Filter list by status; repeatable
+  --repository <alias>  Filter list by repository; repeatable
+  --ready               Include only ready tasks
+  --blocked             Include only blocked tasks
+  --pr / --no-pr        Filter by recorded PR presence
 `

package/src/commands/work.test.ts

@@ -47,8 +47,16 @@ const multiPhaseWorkspace: ExecutionWorkspace = {
 interface HarnessOptions {
 	readonly workspace?: ExecutionWorkspace
 	readonly materializeError?: Error
-	readonly available?: Partial<Record<"opencode" | "claude", boolean>>
+	readonly available?: Readonly<Record<string, boolean>>
 	readonly chooserCommand?: readonly string[]
+	readonly runners?: Record<
+		string,
+		{
+			command: readonly [string, ...string[]]
+			resumeCommand?: readonly [string, ...string[]]
+			environment?: Record<string, string>
+		}
+	>
 	readonly multiPhaseTasks?: readonly string[]
 	readonly epicRecords?: readonly any[]
 	readonly taskRecords?: readonly any[]
@@ -72,6 +80,7 @@ const createHarness = (options: HarnessOptions = {}) => {
 		args: readonly string[]
 		cwd: string
 	}> = []
+	const launchEnvironments: Array<Readonly<Record<string, string>>> = []
 	const materializeOptions: Array<
 		Parameters<WorktreeService["materialize"]>[3]
 	> = []
@@ -105,6 +114,7 @@ const createHarness = (options: HarnessOptions = {}) => {
 				config: {
 					version: 2 as const,
 					chooserCommand: options.chooserCommand,
+					runners: options.runners,
 				},
 			}),
 	}
@@ -204,7 +214,7 @@ const createHarness = (options: HarnessOptions = {}) => {
 		isDirectory: (path: string) =>
 			Effect.succeed(options.existingDirectories?.includes(path) ?? true),
 		runCommand: (args: readonly string[]) => {
-			const cli = args[1] as "opencode" | "claude"
+			const cli = args[1]!
 			events.push(`probe:${cli}`)
 			probes.push(cli)
 			return Effect.succeed({
@@ -214,9 +224,15 @@ const createHarness = (options: HarnessOptions = {}) => {
 			})
 		},
 	}
-	const launch = (cli: string, args: readonly string[], cwd: string) => {
+	const launch = (
+		cli: string,
+		args: readonly string[],
+		cwd: string,
+		environment: Readonly<Record<string, string>>,
+	) => {
 		events.push(`launch:${cli}`)
 		launches.push({ cli, args, cwd })
+		launchEnvironments.push(environment)
 	}
 	const defaultPick: PickWorkTarget = () => Effect.succeed(null)
 	const defaultPickWorkbase: PickWorkbase = () => Effect.succeed(null)
@@ -257,6 +273,7 @@ const createHarness = (options: HarnessOptions = {}) => {
 		events,
 		probes,
 		launches,
+		launchEnvironments,
 		materializeOptions,
 		statusUpdates,
 		shownTasks,
@@ -353,7 +370,6 @@ describe("work command", () => {
 			cli: "opencode",
 			args: [
 				"opencode",
-				"--continue",
 				"--prompt",
 				"Work on the epic. Read /workbase/epics/delivery/EPIC.md.",
 			],
@@ -403,7 +419,6 @@ describe("work command", () => {
 			cli: "opencode",
 			args: [
 				"opencode",
-				"--continue",
 				"--prompt",
 				"Work on the task. Read /workbase/tasks/delivery/TASK.md.",
 			],
@@ -429,7 +444,6 @@ describe("work command", () => {
 			cli: "opencode",
 			args: [
 				"opencode",
-				"--continue",
 				"--prompt",
 				"Start the task. Read /workbase/tasks/example/TASK.md and /workbase/tasks/example/phases/implementation/PHASE.md.",
 			],
@@ -596,7 +610,7 @@ describe("work command", () => {
 
 		await expect(
 			harness.run({ taskId: "example", opencode: true, claude: true }),
-		).rejects.toThrow("Cannot use both --opencode and --claude")
+		).rejects.toThrow("Cannot combine --runner, --opencode, and --claude")
 		expect(harness.events).toEqual([])
 	})
 
@@ -624,7 +638,6 @@ describe("work command", () => {
 				cli: "opencode",
 				args: [
 					"opencode",
-					"--continue",
 					"--prompt",
 					"Start the task. Read /workbase/tasks/example/TASK.md.",
 				],
@@ -638,14 +651,18 @@ describe("work command", () => {
 		])
 	})
 
-	test("continues OpenCode with explicit task and phase context", async () => {
+	test("resumes OpenCode deterministically when a session identity exists", async () => {
 		const harness = createHarness({ workspace: multiPhaseWorkspace })
-
-		await harness.run({
-			taskId: "example",
-			phaseId: "implementation",
-			opencode: true,
-		})
+		process.env.AGENCY_SESSION_ID = "existing-session"
+		try {
+			await harness.run({
+				taskId: "example",
+				phaseId: "implementation",
+				opencode: true,
+			})
+		} finally {
+			delete process.env.AGENCY_SESSION_ID
+		}
 
 		expect(harness.launches[0]).toEqual({
 			cli: "opencode",
@@ -659,6 +676,78 @@ describe("work command", () => {
 		})
 	})
 
+	test("expands a named runner with shared context and claim identity", async () => {
+		const harness = createHarness({
+			available: { codex: true },
+			runners: {
+				custom: {
+					command: ["codex", "--task", "{task}", "{prompt}"],
+					environment: {
+						CUSTOM_TARGET: "{target}",
+						AGENCY_TARGET: "cannot-override",
+					},
+				},
+			},
+		})
+
+		await harness.run({ taskId: "example", runner: "custom" })
+
+		expect(harness.probes).toEqual(["codex"])
+		expect(harness.launches[0]).toEqual({
+			cli: "codex",
+			args: [
+				"codex",
+				"--task",
+				"example",
+				"Start the task. Read /workbase/tasks/example/TASK.md.",
+			],
+			cwd: singlePhaseWorkspace.writablePath,
+		})
+		expect(harness.launchEnvironments[0]).toMatchObject({
+			AGENCY_RUNNER: "custom",
+			AGENCY_CLAIMANT: process.env.USER ?? "agency",
+			AGENCY_WORKBASE: "/workbase",
+			AGENCY_TARGET: "execution-unit:task/example",
+			AGENCY_TASK_ID: "example",
+			AGENCY_PHASE_ID: "",
+			AGENCY_CLAIM_REVISION: "1".repeat(64),
+			CUSTOM_TARGET: "execution-unit:task/example",
+		})
+	})
+
+	test("prints the exact command contract without launching and omits secrets", async () => {
+		const harness = createHarness({
+			available: { agent: true },
+			runners: {
+				custom: {
+					command: ["agent", "{prompt}"],
+					environment: {
+						VISIBLE: "{task}",
+						API_TOKEN: "do-not-print",
+					},
+				},
+			},
+		})
+
+		const output = await captureLogs(() =>
+			harness.run({
+				taskId: "example",
+				runner: "custom",
+				printCommand: true,
+			}),
+		)
+		const printed = JSON.parse(output.join("\n"))
+
+		expect(harness.launches).toEqual([])
+		expect(printed.cwd).toBe(singlePhaseWorkspace.writablePath)
+		expect(printed.argv).toEqual([
+			"agent",
+			"Start the task. Read /workbase/tasks/example/TASK.md.",
+		])
+		expect(printed.environment.VISIBLE).toBe("example")
+		expect(printed.environment.API_TOKEN).toBeUndefined()
+	})
+
 	test("automatically falls back to Claude", async () => {
 		const harness = createHarness({ available: { opencode: false } })
 
@@ -729,7 +818,7 @@ describe("work command", () => {
 			verboseHarness.run({ taskId: "example", verbose: true }),
 		)
 		expect(verboseLogs).toEqual([
-			"Launching command: opencode --continue --prompt 'Start the task. Read /workbase/tasks/example/TASK.md.' (cwd: /workbase/tasks/example/code/agency)",
+			"Launching command: opencode --prompt 'Start the task. Read /workbase/tasks/example/TASK.md.' (cwd: /workbase/tasks/example/code/agency)",
 		])
 		expect(verboseHarness.materializeOptions[0]?.verbose).toBe(true)