@markjaquith/agency 3.7.0 → 3.9.0

package/src/commands/act.ts

@@ -169,29 +169,18 @@ const entitySummary = (node: ActEntity) => ({
 	readiness: node.readiness,
 	revision: node.data.sha256,
 })
-const actionIcons: Record<string, string> = {
-	reopen: "󰑓",
-	drop: "󰅖",
-	complete: "󰄬",
-	sync: "󰑓",
-	"pr-ready": "󰄬",
-	"pr-close": "",
-}
 const actionChoices = (actions: readonly ActAction[]): Choice<string>[] =>
-	actions.map(({ id, label }) => {
-		const icon =
-			actionIcons[id] ??
-			actionGroups.find((group) =>
-				group.actions.some((action) => action === id),
-			)!.icon
-		const color =
-			id === "drop" || id === "pr-close" ? macchiato.red : macchiato.overlay1
+	actions.map(({ id, label, description, icon, color }) => {
 		return {
 			key: id,
 			value: id,
-			label: `${icon}  ${label}`,
-			plainLabel: label,
-			segments: [{ text: `${icon}  `, color }, { text: label }],
+			label: `${icon}  ${label} — ${description}`,
+			plainLabel: `${label} — ${description}`,
+			segments: [
+				{ text: `${icon}  `, color },
+				{ text: label },
+				{ text: ` — ${description}`, color: macchiato.overlay0 },
+			],
 		}
 	})
 
@@ -568,7 +557,7 @@ const actStep = (
 					graph.nodes
 						.filter((node) => node.kind === "repository")
 						.map((node) => node.key),
-					nodes.filter((node) => node.kind !== "epic").map((node) => node.key),
+					nodes.map((node) => node.key),
 					config.chooserCommand,
 				),
 			)

package/src/commands/archive.ts

@@ -26,11 +26,13 @@ export const archive = (options: ArchiveOptions) =>
 		const [id, phaseId] = options.args
 		let archiveType = options.type
 		let archiveId = id
+		let archiveTaskId: string | undefined
 
-		if (!archiveType && id) {
-			const target = yield* archives.resolvePathTarget(id, cwd)
+		if (!archiveType) {
+			const target = yield* archives.resolvePathTarget(id ?? ".", cwd)
 			archiveType = target.kind
 			archiveId = target.id
+			archiveTaskId = target.taskId
 		}
 
 		if (options.type === "list") {
@@ -106,13 +108,18 @@ export const archive = (options: ArchiveOptions) =>
 				})
 				break
 			case "phase":
-				if (!id || !phaseId)
+				if (!(archiveTaskId && archiveId) && (!id || !phaseId))
 					return yield* Effect.fail(
 						new Error("Usage: agency archive phase <task-id> <phase-id>"),
 					)
-				result = yield* archives.archivePhase(id, phaseId, cwd, {
-					dryRun: options.dryRun,
-				})
+				result = yield* archives.archivePhase(
+					archiveTaskId ?? id!,
+					archiveTaskId ? archiveId! : phaseId!,
+					cwd,
+					{
+						dryRun: options.dryRun,
+					},
+				)
 				break
 			default:
 				return yield* Effect.fail(
@@ -149,14 +156,15 @@ export const archive = (options: ArchiveOptions) =>
 	})
 
 export const help = `
-Usage: agency archive <path|list|show|epic|task|tasks|phase>
+Usage: agency archive [path|list|show|epic|task|tasks|phase]
 
 Browse or archive work items after preflighting worktrees and graph references.
 
-An existing path within an active epic or task infers that work item.
+With no target, the current epic, task, or phase is inferred. An existing path
+within one of those items infers it too.
 
 Commands:
-  <path>                                 Archive the containing epic or task
+  [path]                                 Archive the containing epic, task, or phase
   list [filters]                         List archived work
   show <type> <id>                       Show an archived epic or task
   show phase <task-id> <phase-id>        Show an archived phase

package/src/commands/sync.ts

@@ -129,7 +129,8 @@ repositories, worktrees, branches, references, and pull requests.
 Safe reconciliation transitions are applied by default.
 When a task, phase, or item path is provided, only that target and its
 repositories are queried or reconciled. Task and epic scopes include their
-child execution units.
+child execution units. With no target, the current item is inferred when the
+command runs inside one; the workbase root retains whole-workbase scope.
 
 Options:
   --dry-run                 Report planned safe transitions without changing state

package/src/commands/work.ts

@@ -139,12 +139,8 @@ export const work = (
 		const integrations = yield* IntegrationService
 		const { log, verboseLog } = createLoggers(options)
 		const cwd = options.cwd ?? process.cwd()
-		const directoryPath = options.directory
-			? resolve(cwd, options.directory)
-			: undefined
-		const isDirectory = directoryPath
-			? yield* fs.isDirectory(directoryPath)
-			: false
+		const directoryPath = resolve(cwd, options.directory ?? ".")
+		const isDirectory = yield* fs.isDirectory(directoryPath)
 		const startPath = isDirectory && directoryPath ? directoryPath : cwd
 		const inputAllowed = options.inputAllowed ?? true
 		const root = yield* resolveWorkbase(startPath, pickBase, inputAllowed)
@@ -660,16 +656,17 @@ export const help = `
 Usage: agency work [<directory-or-task-id> | --epic <epic-id>] [--agent <name>] [--auto]
        agency work prepare [target] [--evidence <json-or-path>] [--force] [--dry-run] [--json]
 
-Launch an agent for an epic, task, or phase. With no directory, select one
-interactively. A positional argument resolves as a directory first, then as a task
-ID. Use '.' for the current directory. Outside a workbase, select a registered
-workbase first. Managed OpenCode launches receive whole-workbase access through
-Agency's project plugin; Agency context remains authoritative for writes. Automatic
-agent discovery checks opencode2, opencode, pi, then claude.
+Launch an agent for an epic, task, or phase. With no directory, infer the current
+item or select one interactively at the workbase root. A positional argument
+resolves as a directory first, then as a task ID. Outside a workbase, select a
+registered workbase first. Managed OpenCode launches receive whole-workbase access
+through Agency's project plugin; Agency context remains authoritative for writes.
+Automatic agent discovery checks opencode2, opencode, pi, then claude.
 
 The prepare subcommand resolves and materializes an execution workspace without
-launching an agent or changing lifecycle status. --dry-run reports planned Git
-changes without fetching, creating branches, or creating worktrees.
+launching an agent or changing lifecycle status. Its omitted target defaults to
+the current execution unit. --dry-run reports planned Git changes without
+fetching, creating branches, or creating worktrees.
 It emits revision-bound validation evidence and an idempotent external-orchestrator
 contract. Evidence is reused only while the target, workbase, configuration, and
 repository mapping remain unchanged. Dynamic readiness and workspace safety checks

package/src/services/ArchiveService.ts

@@ -54,8 +54,9 @@ class ArchiveError extends Data.TaggedError("ArchiveError")<{
 export type ArchiveKind = "epic" | "task" | "phase"
 
 interface ArchivePathTarget {
-	readonly kind: "epic" | "task"
+	readonly kind: ArchiveKind
 	readonly id: string
+	readonly taskId?: string
 }
 
 const LifecycleEventSchema = Schema.Struct({
@@ -489,14 +490,11 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 								: undefined
 					if (!kind || !id) {
 						return yield* new ArchiveError({
-							message: `Archive path must be within an active epic or task: ${canonicalPath}`,
-						})
-					}
-					if (kind === "task" && parts[2] === "phases") {
-						return yield* new ArchiveError({
-							message: `Archive path identifies a phase; use 'agency archive phase <task-id> <phase-id>': ${canonicalPath}`,
+							message: `Archive path must be within an active epic, task, or phase: ${canonicalPath}`,
 						})
 					}
+					const phaseId =
+						kind === "task" && parts[2] === "phases" ? parts[3] : undefined
 
 					const document = join(
 						root,
@@ -509,6 +507,26 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 							message: `Archive path does not identify an active ${kind}: ${canonicalPath}`,
 						})
 					}
+					if (phaseId) {
+						const phaseDocument = join(
+							root,
+							"tasks",
+							id,
+							"phases",
+							phaseId,
+							"PHASE.md",
+						)
+						if (!(yield* fs.exists(phaseDocument))) {
+							return yield* new ArchiveError({
+								message: `Archive path does not identify an active phase: ${canonicalPath}`,
+							})
+						}
+						return {
+							kind: "phase",
+							id: phaseId,
+							taskId: id,
+						} satisfies ArchivePathTarget
+					}
 					return { kind, id } satisfies ArchivePathTarget
 				}),
 

package/src/services/SyncService.ts

@@ -229,13 +229,10 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 				const repositories = yield* RepositoryService
 				const versionControl = yield* VersionControlService
 				const cwd = resolve(options.cwd ?? process.cwd())
-				const candidate = options.taskId
-					? resolve(cwd, options.taskId)
-					: undefined
-				const candidateExists =
-					candidate !== undefined && !options.phaseId
-						? yield* fs.exists(candidate)
-						: false
+				const candidate = resolve(cwd, options.taskId ?? ".")
+				const candidateExists = !options.phaseId
+					? yield* fs.exists(candidate)
+					: false
 				const { root, config } = yield* workbase.loadConfig(
 					candidateExists ? candidate : cwd,
 				)
@@ -262,7 +259,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 				const existingTaskSelector =
 					options.taskId !== undefined &&
 					documents.tasks.some((task) => task.id === options.taskId)
-				if (candidateExists && candidate && !existingTaskSelector) {
+				if (candidateExists && !existingTaskSelector) {
 					const canonicalPath = yield* fs.realPath(candidate)
 					const canonicalRoot = yield* fs.realPath(root)
 					const parts = relative(canonicalRoot, canonicalPath).split(sep)
@@ -272,7 +269,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 					} else if (parts[0] === "tasks" && parts[1]) {
 						taskId = parts[1]
 						phaseId = parts[2] === "phases" && parts[3] ? parts[3] : undefined
-					} else {
+					} else if (options.taskId !== undefined) {
 						return yield* new SyncError({
 							message: `Sync path does not identify an active task, phase, or epic: ${canonicalPath}`,
 						})