@markjaquith/agency 3.9.6 → 3.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "3.9.6",
+  "version": "3.10.1",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",

package/src/commands/act-actions.ts

@@ -17,6 +17,7 @@ import { status } from "./status"
 import { pr, prCreate } from "./pr"
 import { validate } from "./validate"
 import { work as startWork, type StartWork } from "./work"
+import { worktree } from "./worktree"
 import { macchiato } from "../utils/theme"
 
 export type ActEntity = Extract<
@@ -37,6 +38,7 @@ type NativeOperation =
 	| ReturnType<typeof validate>
 	| ReturnType<typeof prCreate>
 	| ReturnType<typeof archive>
+	| ReturnType<typeof worktree>
 	| ReturnType<StartWork>
 type Operation = Effect.Effect<
 	unknown,
@@ -72,6 +74,12 @@ export interface ActAction extends Details {
 	readonly prepare: (prompts: ActionPrompts) => Effect.Effect<Plan, Error>
 }
 
+export interface ActCheckoutState {
+	readonly paths: readonly string[]
+	readonly conflicts: readonly string[]
+	readonly dirty: boolean
+}
+
 const actionPresentation: Record<
 	string,
 	{
@@ -205,6 +213,12 @@ const actionPresentation: Record<
 		icon: "",
 		color: macchiato.green,
 	},
+	"worktree-remove": {
+		description:
+			"Remove clean local worktrees while preserving the item, commits, and branches. Agency recreates the checkout when you work on this item again.",
+		icon: "󰆴",
+		color: macchiato.red,
+	},
 	push: {
 		description: "Validate and publish this execution branch without a PR.",
 		icon: "󰜷",
@@ -440,7 +454,11 @@ export const actionGroups = [
 
 export const actActions = (
 	nodes: readonly GraphNode[],
-	options: BaseCommandOptions & { auto?: boolean; draft?: boolean },
+	options: BaseCommandOptions & {
+		auto?: boolean
+		draft?: boolean
+		checkoutStates?: ReadonlyMap<string, ActCheckoutState>
+	},
 	work: StartWork = startWork,
 	node?: ActEntity,
 ): readonly ActAction[] => {
@@ -878,6 +896,26 @@ export const actActions = (
 		blockedReason: validation ?? reason,
 	})
 	const noExecution = execution ? null : "Select an execution unit"
+	const checkoutState = options.checkoutStates?.get(node.id)
+	const activeClaim =
+		"claim" in node.data &&
+		typeof node.data.claim === "object" &&
+		node.data.claim !== null &&
+		"state" in node.data.claim &&
+		node.data.claim.state === "active"
+	const checkoutBlockedReason = noExecution
+		? noExecution
+		: !checkoutState
+			? "Local checkout is not materialized"
+			: activeClaim
+				? "Item has an active claim; release or finish it before clearing its checkout"
+				: node.status === "working" || node.status === "delegated"
+					? `Item has active '${node.status}' ownership; reopen it before clearing its checkout`
+					: checkoutState.conflicts.length
+						? checkoutState.conflicts.join("; ")
+						: checkoutState.dirty
+							? "Local checkout has uncommitted changes"
+							: null
 	const statusCommand = (status: string) => [
 		"agency",
 		target.phaseId ? "phase" : "task",
@@ -937,6 +975,29 @@ export const actActions = (
 				run: Effect.suspend(() => work({ ...options, ...workTarget })),
 			},
 		),
+		action(
+			{
+				id: "worktree-remove",
+				label: "Clear local checkout",
+				blockedReason: checkoutBlockedReason,
+			},
+			undefined,
+			(p) =>
+				options.dryRun
+					? Effect.void
+					: p.confirm(
+							`Clear these local worktrees?\n${checkoutState?.paths.map((path) => `  ${path}`).join("\n") ?? ""}\n\nThe item, commits, and branches will be preserved.`,
+							"Clear local checkout",
+						),
+			() => ({
+				command: ["agency", "worktree", "remove", ...args],
+				run: worktree({
+					...options,
+					subcommand: "remove",
+					args,
+				}),
+			}),
+		),
 		immediate(
 			details(
 				"push",

package/src/commands/act-prompts.ts

@@ -248,6 +248,18 @@ export const actionPrompts = (
 		})
 	return {
 		text,
+		confirm: (prompt: string, label = "Confirm") =>
+			Effect.gen(function* () {
+				const confirmed = yield* interaction.select(
+					prompt,
+					[
+						{ key: "confirm", label, value: true },
+						{ key: "cancel", label: "Cancel", value: false },
+					],
+					chooser,
+				)
+				if (!confirmed) return yield* Effect.fail(new ActCancelled())
+			}),
 		id: (label: string, suggestion: string, prefix = "") => {
 			const base = slug(suggestion)
 			let candidate = base

package/src/commands/act.ts

@@ -5,6 +5,7 @@ import { ActDiscovery } from "../act-schema"
 import { FileSystemService } from "../services/FileSystemService"
 import { GraphService } from "../services/GraphService"
 import { WorkbaseService } from "../services/WorkbaseService"
+import { WorktreeService } from "../services/WorktreeService"
 import type { BaseCommandOptions } from "../utils/command"
 import type { Choice } from "../utils/chooser"
 import { createLoggers } from "../utils/effect"
@@ -17,6 +18,7 @@ import {
 	isActActionId,
 	type ActAction,
 	type ActEntity,
+	type ActCheckoutState,
 } from "./act-actions"
 import {
 	ActCancelled,
@@ -159,6 +161,32 @@ const shellCommand = (argv: readonly string[]) =>
 		)
 		.join(" ")
 const available = (action: ActAction) => !action.blockedReason
+const checkoutState = (inspection: {
+	readonly checkouts: readonly {
+		readonly exists: boolean
+		readonly path: string
+		readonly registeredPath: string | null
+		readonly dirty: boolean | null
+	}[]
+	readonly conflicts: readonly {
+		readonly kind: string
+		readonly message: string
+	}[]
+}): ActCheckoutState => ({
+	paths: inspection.checkouts.flatMap((checkout) =>
+		checkout.exists
+			? [checkout.path]
+			: checkout.registeredPath
+				? [checkout.registeredPath]
+				: [],
+	),
+	conflicts: inspection.conflicts
+		.filter((conflict) => conflict.kind !== "stale-registration")
+		.map((conflict) => conflict.message),
+	dirty: inspection.checkouts.some(
+		(checkout) => checkout.exists && checkout.dirty !== false,
+	),
+})
 const entitySummary = (node: ActEntity) => ({
 	kind: node.kind,
 	id: node.id,
@@ -170,17 +198,27 @@ const entitySummary = (node: ActEntity) => ({
 	readiness: node.readiness,
 	revision: node.data.sha256,
 })
+
 const actionChoices = (actions: readonly ActAction[]): Choice<string>[] =>
-	actions.map(({ id, label, description, icon, color }) => {
+	actions.map(({ id, label, description, icon, color, blockedReason }) => {
+		const availability = blockedReason ? ` — unavailable: ${blockedReason}` : ""
 		return {
 			key: id,
 			value: id,
-			label: `${icon}  ${label} — ${description}`,
-			plainLabel: `${label} — ${description}`,
+			label: `${icon}  ${label} — ${description}${availability}`,
+			plainLabel: `${label} — ${description}${availability}`,
 			segments: [
 				{ text: `${icon}  `, color },
 				{ text: label },
 				{ text: ` — ${description}`, color: macchiato.overlay0 },
+				...(blockedReason
+					? [
+							{
+								text: availability,
+								color: macchiato.yellow,
+							},
+						]
+					: []),
 			],
 		}
 	})
@@ -300,6 +338,7 @@ const actStep = (
 		const fs = yield* FileSystemService
 		const workbase = yield* WorkbaseService
 		const graphs = yield* GraphService
+		const worktrees = yield* WorktreeService
 		const { log } = createLoggers(options)
 		const cwd = options.cwd ?? process.cwd()
 		const path = resolve(cwd, options.directory ?? ".")
@@ -313,7 +352,34 @@ const actStep = (
 		const graph = yield* graphs.get({
 			cwd: root,
 			loadedConfig: { root, config },
+			include: ["workspace"],
 		})
+		const checkoutStates = new Map<string, ActCheckoutState>()
+		for (const node of graph.nodes) {
+			if (node.kind !== "execution-unit" || !node.workspace?.materialized)
+				continue
+			const id =
+				"phaseId" in node.data
+					? `phase:${node.data.taskId}/${node.data.phaseId}`
+					: `task:${node.data.taskId}`
+			checkoutStates.set(id, {
+				paths: [node.workspace.checkoutPath],
+				conflicts: [],
+				dirty: false,
+			})
+		}
+		if (options.json && checkoutStates.size > 0) {
+			checkoutStates.clear()
+			for (const inspection of yield* worktrees.list(root, {
+				materializedOnly: true,
+			})) {
+				const id =
+					inspection.owner.kind === "phase"
+						? `phase:${inspection.owner.taskId}/${inspection.owner.phaseId}`
+						: `task:${inspection.owner.taskId}`
+				checkoutStates.set(id, checkoutState(inspection))
+			}
+		}
 		const nodes = graph.nodes.filter(
 			(node): node is ActEntity =>
 				node.kind === "epic" || node.kind === "task" || node.kind === "phase",
@@ -341,6 +407,7 @@ const actStep = (
 			inputAllowed: options.inputAllowed,
 			silent: session ? true : options.silent,
 			verbose: options.verbose,
+			checkoutStates,
 		}
 		const runWork: StartWork = session
 			? (args) => work({ ...args, silent: options.silent })
@@ -538,15 +605,39 @@ const actStep = (
 			state.item = selected.id
 			session.activateTab("workstream")
 		}
-		const actions = selected ? catalog.get(selected.id)! : globals
+		let actions = selected ? catalog.get(selected.id)! : globals
 		if (!actionId) {
 			state.view = "item-menu"
+			const menuActions = actions.filter(
+				(action) =>
+					available(action) ||
+					(action.id === "worktree-remove" &&
+						action.blockedReason !== "Local checkout is not materialized"),
+			)
 			actionId = yield* select(
 				`Act on ${selected!.kind} ${selected!.key}`,
-				actionChoices(actions.filter(available)),
+				actionChoices(menuActions),
 			)
 			state.view = "flow"
 		}
+		if (
+			selected &&
+			selected.kind !== "epic" &&
+			actionId === "worktree-remove" &&
+			!options.json
+		) {
+			const inspection = yield* worktrees.inspect(
+				selected.kind === "phase"
+					? selected.key.slice(0, selected.key.lastIndexOf("/"))
+					: selected.key,
+				selected.kind === "phase"
+					? selected.key.slice(selected.key.lastIndexOf("/") + 1)
+					: undefined,
+				root,
+			)
+			checkoutStates.set(selected.id, checkoutState(inspection))
+			actions = actActions(graph.nodes, nativeOptions, runWork, selected)
+		}
 		const action = actions.find((action) => action.id === actionId)
 		if (!action || action.blockedReason)
 			return yield* Effect.fail(