@markjaquith/agency 2.71.18 → 2.71.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.18",
+  "version": "2.71.20",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -70,6 +70,7 @@
     "benchmark:status": "bun scripts/benchmark-status.ts",
     "benchmark:next": "bun scripts/benchmark-next.ts",
     "benchmark:init": "bun scripts/benchmark-init.ts",
+    "benchmark:integration": "bun scripts/benchmark-integration.ts",
     "benchmark:workbase": "bun scripts/benchmark-workbase.ts",
     "benchmark:doctor": "bun scripts/benchmark-doctor.ts",
     "benchmark:context": "bun scripts/benchmark-context.ts",
@@ -77,6 +78,7 @@
     "benchmark:finish": "bun scripts/benchmark-finish.ts",
     "benchmark:epic": "bun scripts/benchmark-epic.ts",
     "benchmark:phase": "bun scripts/benchmark-phase.ts",
+    "benchmark:graph": "bun scripts/benchmark-graph.ts",
     "benchmark:push": "bun scripts/benchmark-push.ts",
     "benchmark:archive": "bun scripts/benchmark-archive.ts",
     "benchmark:sync": "bun scripts/benchmark-sync.ts",

package/src/commands/init.ts

@@ -18,7 +18,7 @@ export const init = (options: InitOptions = {}) =>
 		const root = yield* workbase.initialize(
 			options.path ? resolve(cwd, options.path) : cwd,
 		)
-		yield* integrations.sync(root)
+		yield* integrations.syncRoot(root)
 		log(
 			options.json
 				? JSON.stringify({ root }, null, 2)

package/src/commands/work.test.ts

@@ -258,6 +258,18 @@ const createHarness = (options: HarnessOptions = {}) => {
 				],
 			})
 		},
+		syncRoot: () => {
+			integrationSyncs += 1
+			return Effect.succeed({
+				root: "/workbase",
+				files: [
+					{
+						name: "opencode",
+						state: "managed",
+					},
+				],
+			})
+		},
 	}
 	const fs = {
 		isDirectory: (path: string) =>

package/src/commands/work.ts

@@ -130,7 +130,7 @@ export const work = (
 		const inputAllowed = options.inputAllowed ?? true
 		const root = yield* resolveWorkbase(startPath, pickBase, inputAllowed)
 		if (!root) return
-		yield* integrations.sync(root)
+		yield* integrations.syncRoot(root)
 		const { config } = yield* workbase.loadConfig(root)
 		const globalConfig = yield* workbase.loadGlobalConfig()
 

package/src/services/FileSystemService.ts

@@ -91,6 +91,38 @@ export class FileSystemService extends Effect.Service<FileSystemService>()(
 					catch: () => new FileNotFoundError({ path }),
 				}),
 
+			inspectFile: (path: string) =>
+				Effect.tryPromise({
+					try: async () => {
+						try {
+							const stats = await lstat(path)
+							if (stats.isSymbolicLink()) {
+								return { kind: "symlink" as const }
+							}
+							if (!stats.isFile()) return { kind: "other" as const }
+							return {
+								kind: "file" as const,
+								content: await Bun.file(path).text(),
+							}
+						} catch (error) {
+							if (
+								typeof error === "object" &&
+								error !== null &&
+								"code" in error &&
+								error.code === "ENOENT"
+							) {
+								return { kind: "missing" as const }
+							}
+							throw error
+						}
+					},
+					catch: (error) =>
+						new FileSystemError({
+							message: `Failed to inspect file: ${path}`,
+							cause: error,
+						}),
+				}),
+
 			writeFile: (path: string, content: string) =>
 				Effect.tryPromise({
 					try: () => Bun.write(path, content),

package/src/services/GraphService.test.ts

@@ -6,7 +6,10 @@ 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"
+import {
+	VersionControlService,
+	type VersionControlBackend,
+} from "./VersionControlService"
 
 const write = async (root: string, path: string, content: string) => {
 	const fullPath = join(root, path)
@@ -364,6 +367,15 @@ status: open
 
 		const detailed = await getGraph(root, {
 			include: ["bodies", "workspace", "git", "pr"],
+			backend: {
+				kind: "git",
+				inspectRepository: () => Effect.succeed(null),
+				listWorkspaces: () => Effect.succeed([]),
+				resolveRevision: () => Effect.succeed(null),
+				workspaceHead: () => Effect.succeed(null),
+				workspaceDirty: () => Effect.succeed(null),
+				remoteUrl: () => Effect.succeed(null),
+			} as unknown as VersionControlBackend,
 		})
 		expect(detailed.includes).toEqual(["bodies", "git", "pr", "workspace"])
 		expect(detailed.workbase.root).toBe(root)
@@ -386,4 +398,51 @@ status: open
 		expect(execution?.pr).toEqual({ url: null, state: "none" })
 		expect(Schema.decodeUnknownSync(AgencyGraph)(detailed)).toEqual(detailed)
 	})
+
+	test("reuses repository metadata and revision lookups for git details", async () => {
+		const root = await createWorkbase()
+		roots.push(root)
+		const calls = {
+			listWorkspaces: 0,
+			remoteUrl: 0,
+			resolveRevision: new Map<string, number>(),
+		}
+		const backend = {
+			kind: "git",
+			inspectRepository: () => Effect.succeed(null),
+			listWorkspaces: () =>
+				Effect.sync(() => {
+					calls.listWorkspaces += 1
+					return []
+				}),
+			remoteUrl: () =>
+				Effect.sync(() => {
+					calls.remoteUrl += 1
+					return null
+				}),
+			resolveRevision: (_path: string, revision: string) =>
+				Effect.sync(() => {
+					calls.resolveRevision.set(
+						revision,
+						(calls.resolveRevision.get(revision) ?? 0) + 1,
+					)
+					return revision
+				}),
+			workspaceHead: () => Effect.succeed(null),
+			workspaceDirty: () => Effect.succeed(null),
+		} as unknown as VersionControlBackend
+
+		await getGraph(root, { include: ["git"], backend })
+
+		expect(calls.listWorkspaces).toBe(0)
+		expect(calls.remoteUrl).toBe(1)
+		expect(calls.resolveRevision).toEqual(
+			new Map([
+				["feat/prepare", 1],
+				["feat/implement", 1],
+				["feat/verify", 1],
+				["main", 1],
+			]),
+		)
+	})
 })

package/src/services/GraphService.ts

@@ -674,6 +674,40 @@ export class GraphService extends Effect.Service<GraphService>()(
 					}
 					const dependents = (id: string) =>
 						[...(reverseDependencies.get(id) ?? [])].sort()
+					const repositoryWorkspaces = new Map<
+						string,
+						ReturnType<VersionControlBackend["listWorkspaces"]>
+					>()
+					const listWorkspaces = (path: string) => {
+						if (!backend) return Effect.succeed([])
+						const cached = repositoryWorkspaces.get(path)
+						if (cached) return cached
+						const workspaces = backend
+							.listWorkspaces(path)
+							.pipe(Effect.catchAll(() => Effect.succeed([])))
+						repositoryWorkspaces.set(path, workspaces)
+						return workspaces
+					}
+					const repositoryRemotes = new Map<string, string | null>()
+					const remoteUrl = (path: string, remote: string) =>
+						Effect.gen(function* () {
+							if (!backend) return null
+							const key = `${path}\u0000${remote}`
+							if (repositoryRemotes.has(key)) return repositoryRemotes.get(key)!
+							const url = yield* backend.remoteUrl(path, remote)
+							repositoryRemotes.set(key, url)
+							return url
+						})
+					const resolvedRevisions = new Map<string, string | null>()
+					const resolveRevision = (path: string, revision: string) =>
+						Effect.gen(function* () {
+							if (!backend) return null
+							const key = `${path}\u0000${revision}`
+							if (resolvedRevisions.has(key)) return resolvedRevisions.get(key)!
+							const resolved = yield* backend.resolveRevision(path, revision)
+							resolvedRevisions.set(key, resolved)
+							return resolved
+						})
 
 					const documentDetails = <T extends Record<string, unknown>>(
 						document: Document<T>,
@@ -697,11 +731,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 						Effect.gen(function* () {
 							if (!backend) return undefined
 							const inspection = yield* backend.inspectRepository(path)
-							const workspaces = inspection
-								? yield* backend
-										.listWorkspaces(path)
-										.pipe(Effect.catchAll(() => Effect.succeed([])))
-								: []
+							const workspaces = inspection ? yield* listWorkspaces(path) : []
 							const primary = workspaces.find(
 								(workspace) => workspace.path === path,
 							)
@@ -734,15 +764,12 @@ export class GraphService extends Effect.Service<GraphService>()(
 							}
 							if (include.has("git")) {
 								if (!backend) return result
-								const remote = yield* backend.remoteUrl(
-									repositoryPath,
-									"origin",
-								)
+								const remote = yield* remoteUrl(repositoryPath, "origin")
 								const canonicalCheckoutPath = materialized
 									? yield* fs.realPath(checkoutPath)
 									: checkoutPath
 								const actualBranch = materialized
-									? yield* backend.listWorkspaces(repositoryPath).pipe(
+									? yield* listWorkspaces(repositoryPath).pipe(
 											Effect.map(
 												(workspaces) =>
 													workspaces
@@ -783,11 +810,11 @@ export class GraphService extends Effect.Service<GraphService>()(
 										: {
 												branch: data.branch,
 												base: data.base,
-												branchCommit: yield* backend.resolveRevision(
+												branchCommit: yield* resolveRevision(
 													repositoryPath,
 													data.branch,
 												),
-												baseCommit: yield* backend.resolveRevision(
+												baseCommit: yield* resolveRevision(
 													repositoryPath,
 													data.base,
 												),

package/src/services/IntegrationService.test.ts

@@ -17,6 +17,7 @@ import {
 	managedWorkbaseOpencodeTuiPlugin,
 } from "../workbase/opencode-tui-plugin-file"
 import { IntegrationService } from "./IntegrationService"
+import { FileSystemService } from "./FileSystemService"
 
 const write = async (root: string, path: string, content: string) => {
 	const fullPath = join(root, path)
@@ -90,6 +91,54 @@ describe("IntegrationService", () => {
 		])
 	})
 
+	test("inspects each integration path once per status call", async () => {
+		const service = await Effect.runPromise(
+			Effect.provide(FileSystemService, FileSystemService.Default),
+		)
+		const inspected = new Map<string, number>()
+		const instrumented = {
+			...service,
+			inspectFile: (path: string) => {
+				inspected.set(path, (inspected.get(path) ?? 0) + 1)
+				return service.inspectFile(path)
+			},
+		}
+
+		await runTestEffect(
+			IntegrationService.pipe(
+				Effect.flatMap((integration) => integration.statusRoot(root)),
+				Effect.provideService(FileSystemService, instrumented),
+			),
+		)
+
+		expect(inspected.size).toBe(8)
+		expect([...inspected.values()]).toEqual(Array(8).fill(1))
+	})
+
+	test("inspects integration and legacy paths once per synchronized call", async () => {
+		const service = await Effect.runPromise(
+			Effect.provide(FileSystemService, FileSystemService.Default),
+		)
+		const inspected = new Map<string, number>()
+		const instrumented = {
+			...service,
+			inspectFile: (path: string) => {
+				inspected.set(path, (inspected.get(path) ?? 0) + 1)
+				return service.inspectFile(path)
+			},
+		}
+
+		await runTestEffect(
+			IntegrationService.pipe(
+				Effect.flatMap((integration) => integration.syncRoot(root)),
+				Effect.provideService(FileSystemService, instrumented),
+			),
+		)
+
+		expect(inspected.size).toBe(11)
+		expect([...inspected.values()]).toEqual(Array(11).fill(1))
+	})
+
 	test("reports customized and checksum-safe drifted files", async () => {
 		await write(root, ".agency/AGENTS.md", "# Custom instructions\n")
 		await write(

package/src/services/IntegrationService.ts

@@ -202,35 +202,54 @@ const inspect = (root: string) =>
 			"agency-repository-skills.ts",
 		)
 		const tuiPluginPath = join(opencodeDirectory, "tui", "agency-debug.ts")
+		const [
+			agents,
+			opencode,
+			opencodeJson,
+			plugin,
+			legacyPlugin,
+			tui,
+			tuiJson,
+			tuiPlugin,
+		] = yield* Effect.all(
+			[
+				fs.inspectFile(agentsPath),
+				fs.inspectFile(opencodePath),
+				fs.inspectFile(opencodeJsonPath),
+				fs.inspectFile(pluginPath),
+				fs.inspectFile(legacyPluginPath),
+				fs.inspectFile(tuiPath),
+				fs.inspectFile(tuiJsonPath),
+				fs.inspectFile(tuiPluginPath),
+			] as const,
+			{ concurrency: 8 },
+		)
 		const files: IntegrationFileStatus[] = []
 
 		files.push(
-			(yield* fs.readSymlinkTarget(agentsPath)) !== null
+			agents.kind === "symlink"
 				? fileStatus("agents", agentsPath, "customized")
-				: (yield* fs.exists(agentsPath))
+				: agents.kind === "file"
 					? classify(
 							"agents",
 							agentsPath,
-							yield* fs.readFile(agentsPath),
+							agents.content,
 							managedWorkbaseAgents,
 							canUpdateManagedWorkbaseAgents,
 						)
 					: fileStatus("agents", agentsPath, "missing"),
 		)
 
-		if ((yield* fs.readSymlinkTarget(opencodePath)) !== null) {
+		if (opencode.kind === "symlink") {
 			files.push(fileStatus("opencode", opencodePath, "customized"))
-		} else if (
-			(yield* fs.readSymlinkTarget(opencodeJsonPath)) !== null ||
-			(yield* fs.exists(opencodeJsonPath))
-		) {
+		} else if (opencodeJson.kind !== "missing") {
 			files.push(fileStatus("opencode", opencodeJsonPath, "customized"))
-		} else if (yield* fs.exists(opencodePath)) {
+		} else if (opencode.kind === "file") {
 			files.push(
 				classify(
 					"opencode",
 					opencodePath,
-					yield* fs.readFile(opencodePath),
+					opencode.content,
 					managedWorkbaseOpencode,
 					canUpdateManagedWorkbaseOpencode,
 				),
@@ -239,26 +258,21 @@ const inspect = (root: string) =>
 			files.push(fileStatus("opencode", opencodePath, "missing"))
 		}
 
-		if ((yield* fs.readSymlinkTarget(pluginPath)) !== null) {
+		if (plugin.kind === "symlink") {
 			files.push(fileStatus("opencode-plugin", pluginPath, "customized"))
-		} else if (yield* fs.exists(pluginPath)) {
+		} else if (plugin.kind === "file") {
 			files.push(
 				classify(
 					"opencode-plugin",
 					pluginPath,
-					yield* fs.readFile(pluginPath),
+					plugin.content,
 					managedWorkbaseOpencodePlugin,
 					canUpdateManagedWorkbaseOpencodePlugin,
 				),
 			)
-		} else if (
-			(yield* fs.readSymlinkTarget(legacyPluginPath)) !== null ||
-			(yield* fs.exists(legacyPluginPath))
-		) {
+		} else if (legacyPlugin.kind !== "missing") {
 			const legacyContent =
-				(yield* fs.readSymlinkTarget(legacyPluginPath)) === null
-					? yield* fs.readFile(legacyPluginPath)
-					: null
+				legacyPlugin.kind === "file" ? legacyPlugin.content : null
 			files.push(
 				legacyContent !== null &&
 					canUpdateManagedWorkbaseOpencodePlugin(legacyContent)
@@ -269,19 +283,16 @@ const inspect = (root: string) =>
 			files.push(fileStatus("opencode-plugin", pluginPath, "missing"))
 		}
 
-		if ((yield* fs.readSymlinkTarget(tuiPath)) !== null) {
+		if (tui.kind === "symlink") {
 			files.push(fileStatus("opencode-tui", tuiPath, "customized"))
-		} else if (
-			(yield* fs.readSymlinkTarget(tuiJsonPath)) !== null ||
-			(yield* fs.exists(tuiJsonPath))
-		) {
+		} else if (tuiJson.kind !== "missing") {
 			files.push(fileStatus("opencode-tui", tuiJsonPath, "customized"))
-		} else if (yield* fs.exists(tuiPath)) {
+		} else if (tui.kind === "file") {
 			files.push(
 				classify(
 					"opencode-tui",
 					tuiPath,
-					yield* fs.readFile(tuiPath),
+					tui.content,
 					managedWorkbaseOpencodeTui,
 					canUpdateManagedWorkbaseOpencodeTui,
 				),
@@ -290,14 +301,14 @@ const inspect = (root: string) =>
 			files.push(fileStatus("opencode-tui", tuiPath, "missing"))
 		}
 
-		if ((yield* fs.readSymlinkTarget(tuiPluginPath)) !== null) {
+		if (tuiPlugin.kind === "symlink") {
 			files.push(fileStatus("opencode-tui-plugin", tuiPluginPath, "customized"))
-		} else if (yield* fs.exists(tuiPluginPath)) {
+		} else if (tuiPlugin.kind === "file") {
 			files.push(
 				classify(
 					"opencode-tui-plugin",
 					tuiPluginPath,
-					yield* fs.readFile(tuiPluginPath),
+					tuiPlugin.content,
 					managedWorkbaseOpencodeTuiPlugin,
 					canUpdateManagedWorkbaseOpencodeTuiPlugin,
 				),
@@ -306,32 +317,25 @@ const inspect = (root: string) =>
 			files.push(fileStatus("opencode-tui-plugin", tuiPluginPath, "missing"))
 		}
 
-		return files
+		return { files, legacyPlugin }
 	})
 
 const canRemoveLegacyAgents = (root: string) =>
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
 		const path = join(root, "AGENTS.md")
-		if (
-			(yield* fs.readSymlinkTarget(path)) !== null ||
-			!(yield* fs.exists(path))
-		)
-			return false
-		return canUpdateManagedWorkbaseAgents(yield* fs.readFile(path))
+		const file = yield* fs.inspectFile(path)
+		return file.kind === "file" && canUpdateManagedWorkbaseAgents(file.content)
 	})
 
 const canRemoveLegacyOpencodeCommand = (root: string) =>
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
 		const path = join(root, ".opencode", "command", "agency.md")
-		if (
-			(yield* fs.readSymlinkTarget(path)) !== null ||
-			!(yield* fs.exists(path))
-		)
-			return false
+		const file = yield* fs.inspectFile(path)
+		if (file.kind !== "file") return false
 
-		const content = yield* fs.readFile(path)
+		const content = file.content
 		const header = /^---\r?\n# agency-managed: sha256=([a-f0-9]{64})\r?\n/
 		const match = content.match(header)
 		if (!match?.[1]) return false
@@ -340,23 +344,6 @@ const canRemoveLegacyOpencodeCommand = (root: string) =>
 		return createHash("sha256").update(canonical).digest("hex") === match[1]
 	})
 
-const canRemoveLegacyOpencodePlugin = (root: string) =>
-	Effect.gen(function* () {
-		const fs = yield* FileSystemService
-		const path = join(
-			root,
-			".opencode",
-			"plugin",
-			"agency-repository-skills.ts",
-		)
-		if (
-			(yield* fs.readSymlinkTarget(path)) !== null ||
-			!(yield* fs.exists(path))
-		)
-			return false
-		return canUpdateManagedWorkbaseOpencodePlugin(yield* fs.readFile(path))
-	})
-
 export class IntegrationService extends Effect.Service<IntegrationService>()(
 	"IntegrationService",
 	{
@@ -365,34 +352,59 @@ export class IntegrationService extends Effect.Service<IntegrationService>()(
 				Effect.gen(function* () {
 					const workbase = yield* WorkbaseService
 					const root = yield* workbase.discover(startPath)
-					return { root, files: yield* inspect(root) }
+					return { root, files: (yield* inspect(root)).files }
 				}),
 
+			statusRoot: (root: string) =>
+				inspect(root).pipe(Effect.map(({ files }) => ({ root, files }))),
+
 			sync: (startPath: string = process.cwd()) =>
 				Effect.gen(function* () {
-					const fs = yield* FileSystemService
 					const workbase = yield* WorkbaseService
 					const root = yield* workbase.discover(startPath)
-					const statuses = yield* inspect(root)
-					const removeLegacyAgents =
-						statuses.some(
-							(status) =>
-								status.name === "opencode" && status.state !== "customized",
-						) && (yield* canRemoveLegacyAgents(root))
-					const removeLegacyOpencodeCommand =
-						yield* canRemoveLegacyOpencodeCommand(root)
-					const removeLegacyOpencodePlugin =
-						yield* canRemoveLegacyOpencodePlugin(root)
+					const service = yield* IntegrationService
+					return yield* service.syncRoot(root)
+				}),
+
+			syncRoot: (root: string) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const { files: statuses, legacyPlugin } = yield* inspect(root)
 					const legacyPiExtension = join(
 						root,
 						".pi",
 						"extensions",
 						"agency-workbase.ts",
 					)
-					const removeLegacyPiExtension =
-						(yield* fs.readSymlinkTarget(legacyPiExtension)) === null &&
-						(yield* fs.exists(legacyPiExtension)) &&
-						canRemoveLegacyPiExtension(yield* fs.readFile(legacyPiExtension))
+					const canRemoveAgents = statuses.some(
+						(status) =>
+							status.name === "opencode" && status.state !== "customized",
+					)
+					const [
+						removeLegacyAgents,
+						removeLegacyOpencodeCommand,
+						removeLegacyPiExtension,
+					] = yield* Effect.all(
+						[
+							canRemoveAgents
+								? canRemoveLegacyAgents(root)
+								: Effect.succeed(false),
+							canRemoveLegacyOpencodeCommand(root),
+							fs
+								.inspectFile(legacyPiExtension)
+								.pipe(
+									Effect.map(
+										(file) =>
+											file.kind === "file" &&
+											canRemoveLegacyPiExtension(file.content),
+									),
+								),
+						] as const,
+						{ concurrency: 3 },
+					)
+					const removeLegacyOpencodePlugin =
+						legacyPlugin.kind === "file" &&
+						canUpdateManagedWorkbaseOpencodePlugin(legacyPlugin.content)
 					const files: IntegrationSyncFile[] = []
 
 					for (const status of statuses) {