@markjaquith/agency 2.17.0 → 2.19.0

package/src/cli.test.ts

@@ -217,6 +217,15 @@ describe("CLI", () => {
 		await expect(access(root)).rejects.toThrow()
 	})
 
+	test("resolves relative init paths from explicit cwd", async () => {
+		const parent = await createTempDir()
+		tempDirs.push(parent)
+		const result = parseJson(
+			await runCli(["init", "child", "--cwd", parent, "--json"], projectRoot),
+		)
+		expect(result.root).toBe(join(parent, "child"))
+	})
+
 	test("refuses guided input without a TTY or with --no-input", async () => {
 		for (const args of [
 			["task", "new"],
@@ -349,12 +358,93 @@ describe("CLI", () => {
 		).toEqual({
 			root,
 		})
-		expect(
-			parseJson(await runCli(["workbase", "add", root, "--json"], parent, env)),
-		).toEqual({ path: await realpath(root) })
+		const registration = parseJson(
+			await runCli(
+				[
+					"workbase",
+					"add",
+					"workbase",
+					"--cwd",
+					parent,
+					"--name",
+					"primary",
+					"--json",
+				],
+				projectRoot,
+				env,
+			),
+		)
+		expect(registration).toMatchObject({
+			name: "primary",
+			path: await realpath(root),
+		})
 		expect(
 			parseJson(await runCli(["workbase", "list", "--json"], parent, env)),
-		).toEqual([await realpath(root)])
+		).toEqual({ workbases: [registration] })
+
+		await mkdir(join(root, "repos", "agency"), { recursive: true })
+		parseJson(
+			await runCli(
+				[
+					"task",
+					"create",
+					"explicit",
+					"--repo",
+					"agency",
+					"--workbase",
+					"primary",
+					"--no-input",
+					"--json",
+				],
+				parent,
+				env,
+			),
+		)
+		const shown = parseJson(
+			await runCli(
+				[
+					"task",
+					"show",
+					"--task",
+					"explicit",
+					"--workbase",
+					registration.id,
+					"--no-input",
+					"--json",
+				],
+				parent,
+				env,
+			),
+		)
+		expect(shown.id).toBe("explicit")
+		const inferred = parseJson(
+			await runCli(
+				["context", "--cwd", join(root, "tasks", "explicit"), "--json"],
+				projectRoot,
+				env,
+			),
+		)
+		expect(inferred.target).toMatchObject({
+			kind: "task",
+			taskId: "explicit",
+		})
+
+		parseJson(
+			await runCli(["workbase", "default", "primary", "--json"], parent, env),
+		)
+		expect(
+			parseJson(await runCli(["task", "list", "--json"], parent, env)),
+		).toHaveLength(1)
+		const explicitOutside = await runCli(
+			["task", "list", "--cwd", parent, "--json"],
+			projectRoot,
+			env,
+		)
+		expect(explicitOutside.exitCode).toBe(1)
+		expect(explicitOutside.stderr).toBe("")
+		expect(JSON.parse(explicitOutside.stdout).error.message).toContain(
+			"No Agency workbase found from",
+		)
 	})
 
 	test("exports equivalent JSON and JSONL graph contracts", async () => {
@@ -684,10 +774,20 @@ status: open
 			await runCli(["phase", "list", "ship", "--json"], root),
 		)
 		expect(phaseList.map((phase: { id: string }) => phase.id)).toEqual([
-			"implement",
 			"prepare",
+			"implement",
 			"release",
 		])
+		const phaseTable = await runCli(
+			["phase", "list", "ship", "--repository", "agency", "--no-pr"],
+			root,
+		)
+		expect(phaseTable.stdout).toMatch(
+			/PHASE\s+PARENT\s+STATUS\s+READINESS\s+REPOSITORIES\s+BRANCH/,
+		)
+		expect(phaseTable.stdout.indexOf("prepare")).toBeLessThan(
+			phaseTable.stdout.indexOf("implement"),
+		)
 
 		const phaseShow = parseJson(
 			await runCli(["phase", "show", "ship", "release", "--json"], root),

package/src/commands/context.ts

@@ -26,4 +26,7 @@ defaults to the current directory and may be an entity path or task ID.
 Options:
   --json              Output a versioned machine result
   --compact           Omit prose bodies and low-level Git details
+  --epic <id>         Select an epic
+  --task <id>         Select a task
+  --phase <id>        Select a phase together with --task
 `

package/src/commands/epic.test.ts

@@ -100,4 +100,26 @@ describe("epic command", () => {
 			},
 		})
 	})
+
+	test("renders a readable operational table", async () => {
+		await runTestEffect(
+			epic({
+				subcommand: "create",
+				args: ["example"],
+				ticketUrl: "https://example.com/epic",
+				repos: ["agency:main"],
+				cwd: root,
+				silent: true,
+			}),
+		)
+
+		const logs = await captureLogs(() =>
+			runTestEffect(epic({ subcommand: "list", args: [], cwd: root })),
+		)
+		expect(logs[0]).toContain(
+			"EPIC     STATUS  READINESS  REPOSITORIES  PR  WORKTREE",
+		)
+		expect(logs[0]).toContain("example  open    waiting    agency")
+		expect(logs[0]).not.toMatch(/[\u{e000}-\u{f8ff}]/u)
+	})
 })

package/src/commands/epic.ts

@@ -2,6 +2,8 @@ import { Effect } from "effect"
 import type { BaseCommandOptions } from "../utils/command"
 import { EpicService } from "../services/EpicService"
 import { createLoggers } from "../utils/effect"
+import { formatTable } from "../utils/table"
+import { getWorkViews } from "../work-view"
 import { parseRepositoryReferences } from "../workbase/repository-reference"
 
 interface EpicOptions extends BaseCommandOptions {
@@ -11,6 +13,11 @@ interface EpicOptions extends BaseCommandOptions {
 	readonly description?: string
 	readonly repos?: readonly string[]
 	readonly json?: boolean
+	readonly statuses?: readonly string[]
+	readonly repositories?: readonly string[]
+	readonly ready?: boolean
+	readonly blocked?: boolean
+	readonly pr?: boolean
 }
 
 export const epic = (options: EpicOptions) =>
@@ -47,16 +54,40 @@ export const epic = (options: EpicOptions) =>
 
 			case "list": {
 				const records = yield* epics.list(cwd)
+				const { epicRows } = yield* getWorkViews({
+					cwd,
+					statuses: options.statuses,
+					repositories: options.repositories,
+					ready: options.ready,
+					blocked: options.blocked,
+					pr: options.pr,
+				})
+				const ordered = epicRows.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(
+							["EPIC", "STATUS", "READINESS", "REPOSITORIES", "PR", "WORKTREE"],
+							epicRows.map((row) => [
+								row.id,
+								row.status,
+								row.readiness,
+								row.repositories,
+								row.pr,
+								row.worktree,
+							]),
+						),
+					)
 				}
 				return
 			}
@@ -98,4 +129,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 epics
+  --blocked             Include only blocked epics
+  --pr / --no-pr        Filter by recorded PR presence
 `

package/src/commands/init.ts

@@ -1,4 +1,5 @@
 import { Effect } from "effect"
+import { resolve } from "node:path"
 import type { BaseCommandOptions } from "../utils/command"
 import { WorkbaseService } from "../services/WorkbaseService"
 import { createLoggers } from "../utils/effect"
@@ -11,8 +12,9 @@ export const init = (options: InitOptions = {}) =>
 	Effect.gen(function* () {
 		const workbase = yield* WorkbaseService
 		const { log } = createLoggers(options)
+		const cwd = options.cwd ?? process.cwd()
 		const root = yield* workbase.initialize(
-			options.path ?? options.cwd ?? process.cwd(),
+			options.path ? resolve(cwd, options.path) : cwd,
 		)
 		log(
 			options.json

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/validate.test.ts

@@ -80,6 +80,7 @@ pr: null
 					: Effect.succeed(path)
 			},
 			listRegistered: () => Effect.succeed(["/first", "/selected"]),
+			getDefault: () => Effect.succeed(undefined),
 			validate: (path: string) =>
 				Effect.succeed({
 					root: path,
@@ -116,6 +117,7 @@ pr: null
 					message: "No Agency workbase found from /outside",
 				}),
 			listRegistered: () => Effect.succeed(["/selected"]),
+			getDefault: () => Effect.succeed(undefined),
 		}
 		const fs = {
 			runCommand: () => Effect.fail(new Error("unexpected fzf probe")),

package/src/commands/work.test.ts

@@ -98,6 +98,7 @@ const createHarness = (options: HarnessOptions = {}) => {
 					})
 				: Effect.succeed("/workbase"),
 		listRegistered: () => Effect.succeed(options.registeredWorkbases ?? []),
+		getDefault: () => Effect.succeed(undefined),
 		loadConfig: () =>
 			Effect.succeed({
 				root: "/workbase",

package/src/commands/work.ts

@@ -297,9 +297,13 @@ export const workPrepare = (options: WorkOptions = {}) =>
 		const isDirectory = yield* fs.isDirectory(targetPath)
 		const root = yield* workbase.discover(isDirectory ? targetPath : cwd)
 
-		let taskId: string | undefined
-		let phaseId: string | undefined
-		if (options.directory && !isDirectory) {
+		let taskId = options.taskId
+		let phaseId = options.phaseId
+		if (taskId) {
+			const task = yield* tasks.show(taskId, root)
+			taskId = task.id
+			if (phaseId) phaseId = (yield* phases.show(task.id, phaseId, root)).id
+		} else if (options.directory && !isDirectory) {
 			const task = yield* tasks.show(options.directory, root)
 			taskId = task.id
 		} else {
@@ -353,12 +357,16 @@ launching an agent or changing lifecycle status. --dry-run reports planned Git
 changes without fetching, creating branches, or creating worktrees.
 
 Options:
-  --epic <id>         Work on an epic
+  --epic <id>          Work on an epic
+  --task <id>          Work on a task
+  --phase <id>         Work on a phase selected with --task
+  --workbase <target>  Select a workbase by ID, name, or path
+  --cwd <path>         Resolve context from a specific directory
   --opencode           Require OpenCode
   --claude             Require Claude Code
   --force              Override readiness and terminal-state guards
-  --no-input          Never open an interactive selector
+  --no-input           Never open an interactive selector
 
-Without interactive input, provide a directory, task ID, or --epic and run the
-command from a workbase. Workbase and target selection otherwise fail.
+Without interactive input, provide an explicit workbase or cwd and an entity
+selector. Workbase and target selection otherwise fail.
 `