@markjaquith/agency 2.71.11 → 2.71.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.11",
+  "version": "2.71.13",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -64,11 +64,14 @@
   "scripts": {
     "postinstall": "bun scripts/install-pi-extension.ts install",
     "preuninstall": "bun scripts/install-pi-extension.ts uninstall",
+    "benchmark:act": "bun scripts/benchmark-act.ts",
     "benchmark:pr": "bun scripts/benchmark-pr.ts",
     "benchmark:status": "bun scripts/benchmark-status.ts",
+    "benchmark:init": "bun scripts/benchmark-init.ts",
     "benchmark:workbase": "bun scripts/benchmark-workbase.ts",
     "benchmark:doctor": "bun scripts/benchmark-doctor.ts",
     "benchmark:context": "bun scripts/benchmark-context.ts",
+    "benchmark:claim": "bun scripts/benchmark-claim.ts",
     "benchmark:finish": "bun scripts/benchmark-finish.ts",
     "benchmark:push": "bun scripts/benchmark-push.ts",
     "benchmark:sync": "bun scripts/benchmark-sync.ts",

package/src/commands/act.ts

@@ -111,31 +111,24 @@ const activeClaim = (node: EntityNode) =>
 
 const executionNode = (
 	node: EntityNode,
-	nodes: readonly GraphNode[],
+	executions: ReadonlyMap<
+		string,
+		Extract<GraphNode, { readonly kind: "execution-unit" }>
+	>,
 ): Extract<GraphNode, { readonly kind: "execution-unit" }> | undefined => {
 	if (node.kind === "epic") return undefined
 	if (node.kind === "task" && "phases" in node.data) return undefined
-	const phaseId =
-		node.kind === "phase"
-			? node.key.slice(node.key.indexOf("/") + 1)
-			: undefined
-	return nodes.find(
-		(
-			candidate,
-		): candidate is Extract<GraphNode, { readonly kind: "execution-unit" }> =>
-			candidate.kind === "execution-unit" &&
-			candidate.data.taskId ===
-				(node.kind === "task" ? node.key : node.key.split("/", 1)[0]) &&
-			(node.kind === "task" ||
-				("phaseId" in candidate.data && candidate.data.phaseId === phaseId)),
-	)
+	return executions.get(node.id)
 }
 
-const canWork = (node: EntityNode, nodes: readonly GraphNode[]) => {
+const canWork = (
+	node: EntityNode,
+	executions: Parameters<typeof executionNode>[1],
+) => {
 	if (node.kind === "epic" || (node.kind === "task" && "phases" in node.data)) {
 		return node.readiness.ready
 	}
-	const execution = executionNode(node, nodes)
+	const execution = executionNode(node, executions)
 	return Boolean(
 		execution &&
 		!activeClaim(node) &&
@@ -147,8 +140,11 @@ const canWork = (node: EntityNode, nodes: readonly GraphNode[]) => {
 	)
 }
 
-const canCreatePr = (node: EntityNode, nodes: readonly GraphNode[]) => {
-	const execution = executionNode(node, nodes)
+const canCreatePr = (
+	node: EntityNode,
+	executions: Parameters<typeof executionNode>[1],
+) => {
+	const execution = executionNode(node, executions)
 	return Boolean(
 		execution &&
 		!execution.readiness.terminal &&
@@ -162,14 +158,14 @@ const canCreatePr = (node: EntityNode, nodes: readonly GraphNode[]) => {
 
 const actionChoices = (
 	node: EntityNode,
-	nodes: readonly GraphNode[],
+	executions: Parameters<typeof executionNode>[1],
 ): readonly Choice<ActAction>[] => {
 	const choices: Choice<ActAction>[] = []
-	const execution = executionNode(node, nodes)
-	if (canWork(node, nodes)) {
+	const execution = executionNode(node, executions)
+	if (canWork(node, executions)) {
 		choices.push({ key: "work", label: "Work on this item", value: "work" })
 	}
-	if (canCreatePr(node, nodes)) {
+	if (canCreatePr(node, executions)) {
 		choices.push({ key: "pr", label: "Create pull request", value: "pr" })
 	}
 	if (execution && isTerminalStatus(node.status) && !activeClaim(node)) {
@@ -243,7 +239,7 @@ const shellCommand = (command: readonly string[]) =>
 
 const targetOutput = (
 	node: EntityNode,
-	nodes: readonly GraphNode[],
+	executions: Parameters<typeof executionNode>[1],
 	options: Pick<ActOptions, "auto" | "draft">,
 ) => ({
 	kind: node.kind,
@@ -252,13 +248,29 @@ const targetOutput = (
 	status: node.status,
 	readiness: node.readiness,
 	revision: node.data.sha256,
-	actions: actionChoices(node, nodes).map((choice) => ({
+	actions: actionChoices(node, executions).map((choice) => ({
 		id: choice.value,
 		label: choice.label,
 		command: actionCommand(node, choice.value, options),
 	})),
 })
 
+const executionNodes = (nodes: readonly GraphNode[]) => {
+	const executions = new Map<
+		string,
+		Extract<GraphNode, { readonly kind: "execution-unit" }>
+	>()
+	for (const node of nodes) {
+		if (node.kind !== "execution-unit") continue
+		const key =
+			"phaseId" in node.data
+				? `phase:${node.data.taskId}/${node.data.phaseId}`
+				: `task:${node.data.taskId}`
+		executions.set(key, node)
+	}
+	return executions
+}
+
 const selectedEntityKey = (options: ActOptions) =>
 	options.epicId
 		? `epic:${options.epicId}`
@@ -321,7 +333,11 @@ export const act = (
 			: false
 		const startPath = isDirectory && directoryPath ? directoryPath : cwd
 		const { root, config } = yield* workbase.loadConfig(startPath)
-		const graph = yield* graphs.get({ cwd: root })
+		const graph = yield* graphs.get({
+			cwd: root,
+			loadedConfig: { root, config },
+		})
+		const executions = executionNodes(graph.nodes)
 		const nodes = graph.nodes.filter(
 			(node): node is EntityNode =>
 				node.kind === "epic" || node.kind === "task" || node.kind === "phase",
@@ -352,7 +368,7 @@ export const act = (
 				JSON.stringify(
 					{
 						targets: matchingNodes.map((node) =>
-							targetOutput(node, graph.nodes, options),
+							targetOutput(node, executions, options),
 						),
 					},
 					null,
@@ -363,7 +379,7 @@ export const act = (
 		}
 
 		const selectableNodes = nodes.filter(
-			(node) => actionChoices(node, graph.nodes).length > 0,
+			(node) => actionChoices(node, executions).length > 0,
 		)
 		if (!requestedKey && selectableNodes.length === 0) {
 			return yield* Effect.fail(
@@ -386,7 +402,7 @@ export const act = (
 				new Error("Selected work item is no longer available"),
 			)
 		}
-		const offeredActions = actionChoices(selected, graph.nodes)
+		const offeredActions = actionChoices(selected, executions)
 		if (offeredActions.length === 0) {
 			return yield* Effect.fail(
 				new Error(
@@ -402,6 +418,7 @@ export const act = (
 		if (action === null) return
 
 		const refreshed = yield* graphs.get({ cwd })
+		const refreshedExecutions = executionNodes(refreshed.nodes)
 		const current = refreshed.nodes.find(
 			(node): node is EntityNode =>
 				(node.kind === "epic" ||
@@ -418,7 +435,7 @@ export const act = (
 		}
 		if (
 			current.data.sha256 !== selected.data.sha256 ||
-			!sameActions(offeredActions, actionChoices(current, refreshed.nodes))
+			!sameActions(offeredActions, actionChoices(current, refreshedExecutions))
 		) {
 			return yield* Effect.fail(
 				new Error("Selected work item changed; run agency act again"),

package/src/services/ClaimService.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, readFile, writeFile } from "node:fs/promises"
 import { join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { ClaimService } from "./ClaimService"
@@ -358,4 +358,59 @@ describe("claim service", () => {
 		)
 		expect(acquired.target).toBe("phase 'multi/implementation'")
 	})
+
+	test("inspects only the requested task on large workbases", async () => {
+		for (let index = 0; index < 100; index += 1) {
+			const taskRoot = join(root, "tasks", `unrelated-${index}`)
+			await mkdir(taskRoot, { recursive: true })
+			await writeFile(join(taskRoot, "TASK.md"), "not valid frontmatter\n")
+		}
+
+		const inspected = await inspect()
+		expect(inspected.target.path).toBe(join(root, "tasks/single/TASK.md"))
+		expect(inspected.data.status).toBe("open")
+	})
+
+	test("inspects only the requested phase", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{ id: "multi", ticketUrl: null, multiPhase: true },
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			PhaseService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							taskId: "multi",
+							id: "requested",
+							repo: "agency",
+							branch: "task/multi",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		const taskPath = join(root, "tasks/multi/TASK.md")
+		await writeFile(
+			taskPath,
+			(await readFile(taskPath, "utf8")).replace("multi", "["),
+		)
+		const unrelatedPhase = join(root, "tasks/multi/phases/unrelated")
+		await mkdir(unrelatedPhase, { recursive: true })
+		await writeFile(join(unrelatedPhase, "PHASE.md"), "not valid frontmatter\n")
+
+		const inspected = await inspect("multi", "requested")
+		expect(inspected.target.path).toBe(
+			join(root, "tasks/multi/phases/requested/PHASE.md"),
+		)
+		expect(inspected.data.status).toBe("open")
+	})
 })

package/src/services/GraphService.test.ts

@@ -6,6 +6,7 @@ import { dirname, join } from "node:path"
 import { AgencyGraph } from "../graph-schema"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { GraphService } from "./GraphService"
+import { VersionControlService } from "./VersionControlService"
 
 const write = async (root: string, path: string, content: string) => {
 	const fullPath = join(root, path)
@@ -204,6 +205,27 @@ describe("GraphService", () => {
 		expect(await getGraph(root)).toEqual(graph)
 	})
 
+	test("does not resolve a VCS backend when git details are not requested", async () => {
+		const root = await createWorkbase()
+		roots.push(root)
+		let calls = 0
+		const graph = await runTestEffect(
+			GraphService.pipe(
+				Effect.flatMap((service) => service.get({ cwd: root })),
+				Effect.provideService(VersionControlService, {
+					_tag: "VersionControlService",
+					forWorkbase: () => {
+						calls += 1
+						throw new Error("unexpected VCS lookup")
+					},
+				}),
+			),
+		)
+
+		expect(graph.nodes.length).toBeGreaterThan(0)
+		expect(calls).toBe(0)
+	})
+
 	test("never reports claimed or terminal execution units as ready", async () => {
 		const root = await createWorkbase()
 		roots.push(root)

package/src/services/GraphService.ts

@@ -30,6 +30,7 @@ import {
 	type EpicFrontmatter as EpicData,
 	type PhaseFrontmatter as PhaseData,
 	type TaskFrontmatter as TaskData,
+	type WorkbaseConfig as WorkbaseConfigData,
 	type WorkStatus,
 } from "../workbase/schemas"
 import { FileSystemService } from "./FileSystemService"
@@ -65,6 +66,10 @@ type ExecutionData =
 
 export interface GraphOptions {
 	readonly cwd?: string
+	readonly loadedConfig?: {
+		readonly root: string
+		readonly config: WorkbaseConfigData
+	}
 	readonly validation?: ValidationReport
 	readonly ready?: boolean
 	readonly blocked?: boolean
@@ -131,14 +136,16 @@ export class GraphService extends Effect.Service<GraphService>()(
 				Effect.gen(function* () {
 					const fs = yield* FileSystemService
 					const workbase = yield* WorkbaseService
-					const { root, config } = yield* workbase.loadConfig(options.cwd)
-					const backend =
-						options.backend ??
-						(yield* VersionControlService.pipe(
-							Effect.flatMap((service) => service.forWorkbase(root)),
-						))
+					const { root, config } =
+						options.loadedConfig ?? (yield* workbase.loadConfig(options.cwd))
 					const includes = [...new Set(options.include ?? [])].sort()
 					const include = new Set(includes)
+					const backend = include.has("git")
+						? (options.backend ??
+							(yield* VersionControlService.pipe(
+								Effect.flatMap((service) => service.forWorkbase(root)),
+							)))
+						: options.backend
 					const epics = new Map<string, Document<EpicData>>()
 					const tasks = new Map<string, Document<TaskData>>()
 					const phases = new Map<string, Document<PhaseData>>()
@@ -681,6 +688,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 
 					const inspectGit = (path: string) =>
 						Effect.gen(function* () {
+							if (!backend) return undefined
 							const inspection = yield* backend.inspectRepository(path)
 							const workspaces = inspection
 								? yield* backend
@@ -718,6 +726,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 								}
 							}
 							if (include.has("git")) {
+								if (!backend) return result
 								const remote = yield* backend.remoteUrl(
 									repositoryPath,
 									"origin",

package/src/services/WorkbaseService.ts

@@ -240,13 +240,18 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 					}
 
 					yield* fs.createDirectory(root)
-					yield* fs.writeJSON(configPath, {
-						version: 2,
-						vcs: preferredVersionControl(),
-					})
-					for (const directory of ["repos", "epics", "tasks"]) {
-						yield* fs.createDirectory(join(root, directory))
-					}
+					yield* Effect.all(
+						[
+							fs.writeJSON(configPath, {
+								version: 2,
+								vcs: preferredVersionControl(),
+							}),
+							...["repos", "epics", "tasks"].map((directory) =>
+								fs.createDirectory(join(root, directory)),
+							),
+						],
+						{ concurrency: "unbounded" },
+					)
 
 					const ignorePath = join(root, ".gitignore")
 					const requiredPatterns = [