@markjaquith/agency 2.71.1 → 2.71.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.1",
+  "version": "2.71.3",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -66,6 +66,7 @@
     "postinstall": "bun scripts/install-pi-extension.ts install",
     "preuninstall": "bun scripts/install-pi-extension.ts uninstall",
     "benchmark:workbase": "bun scripts/benchmark-workbase.ts",
+    "benchmark:context": "bun scripts/benchmark-context.ts",
     "benchmark:sync": "bun scripts/benchmark-sync.ts",
     "test": "find src \\( -name '*.test.ts' -o -name '*.test.tsx' \\) -print0 | xargs -0 -n 1 -P 4 bun test",
     "test:opencode": "AGENCY_TEST_OPENCODE=1 bun test src/cli.test.ts --test-name-pattern 'provides effective whole-workbase OpenCode access'",

package/src/commands/context.test.ts

@@ -1,5 +1,5 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { mkdir, rename, rm } from "node:fs/promises"
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test"
+import { mkdir, readFile as nodeReadFile, rename, rm } from "node:fs/promises"
 import { dirname, join } from "node:path"
 import {
 	captureLogs,
@@ -343,6 +343,31 @@ status: dropped
 		})
 	})
 
+	test("reads each workbase document at most once per invocation", async () => {
+		const reads = new Map<string, number>()
+		const originalFile = Bun.file
+		Bun.file = mock((path: string) => {
+			const file = originalFile(path)
+			return Object.assign(file, {
+				text: async () => {
+					reads.set(path, (reads.get(path) ?? 0) + 1)
+					return nodeReadFile(path, "utf8")
+				},
+			})
+		}) as unknown as typeof Bun.file
+		try {
+			await readContext(root, "tasks/agent-contract/phases/context-command")
+		} finally {
+			Bun.file = originalFile
+		}
+
+		const documents = [...reads].filter(([path]) =>
+			/(?:EPIC|TASK|PHASE)\.md$/.test(path),
+		)
+		expect(documents.length).toBeGreaterThan(0)
+		expect(documents.every(([, count]) => count === 1)).toBe(true)
+	})
+
 	test("resolves a bare task ID and returns root discovery context", async () => {
 		const task = await readContext(root, "agent-contract")
 		expect(task.target).toMatchObject({

package/src/commands/work.test.ts

@@ -394,6 +394,15 @@ describe("work command", () => {
 			target: "execution-unit:task/example",
 			override: true,
 		})
+		expect(forced.materializeOptions[0]?.validationAlreadyPerformed).toBe(false)
+	})
+
+	test("reuses successful readiness validation during materialization", async () => {
+		const harness = createHarness()
+
+		await harness.run({ taskId: "example", opencode: true })
+
+		expect(harness.materializeOptions[0]?.validationAlreadyPerformed).toBe(true)
 	})
 
 	test("reopens forced terminal tasks through open before launching as working", async () => {

package/src/commands/work.ts

@@ -237,6 +237,7 @@ export const work = (
 			if (!target) return
 		}
 		yield* readiness.guardWorkTarget(targetNodeId(target), root, options.force)
+		const validationAlreadyPerformed = !options.force
 
 		const continuing =
 			target.kind !== "epic" &&
@@ -257,7 +258,10 @@ export const work = (
 			const phaseId = target.kind === "phase" ? target.phaseId : undefined
 			progress.start("Preparing workspace...")
 			const workspace = yield* worktrees
-				.materialize(taskId, phaseId, root, options)
+				.materialize(taskId, phaseId, root, {
+					...options,
+					validationAlreadyPerformed,
+				})
 				.pipe(
 					Effect.tap(() =>
 						Effect.sync(() => progress.succeed("Workspace ready")),

package/src/services/ContextService.ts

@@ -1,5 +1,5 @@
 import { Schema, TreeFormatter } from "@effect/schema"
-import { Data, Effect, Either } from "effect"
+import { Data, Deferred, Effect, Either, Exit } from "effect"
 import { join, relative, resolve, sep } from "node:path"
 import { FileSystemService } from "./FileSystemService"
 import { WorkbaseService } from "./WorkbaseService"
@@ -131,10 +131,76 @@ export class ContextService extends Effect.Service<ContextService>()(
 				readonly full?: boolean
 			}) =>
 				Effect.gen(function* () {
-					const fs = yield* FileSystemService
+					const sourceFs = yield* FileSystemService
 					const workbase = yield* WorkbaseService
 					const repositoryService = yield* RepositoryService
 					const versionControl = yield* VersionControlService
+					const memoize = <A, E, R>(
+						cache: Map<string, Deferred.Deferred<A, E>>,
+						key: string,
+						effect: Effect.Effect<A, E, R>,
+					) => {
+						const cached = cache.get(key)
+						if (cached) return Deferred.await(cached)
+						return Effect.gen(function* () {
+							const deferred = yield* Deferred.make<A, E>()
+							cache.set(key, deferred)
+							const exit = yield* Effect.exit(effect)
+							yield* Deferred.done(deferred, exit)
+							return yield* Exit.match(exit, {
+								onFailure: Effect.failCause,
+								onSuccess: Effect.succeed,
+							})
+						})
+					}
+					const existsCache = new Map<
+						string,
+						Deferred.Deferred<
+							Effect.Effect.Success<ReturnType<typeof sourceFs.exists>>,
+							Effect.Effect.Error<ReturnType<typeof sourceFs.exists>>
+						>
+					>()
+					const directoryCache = new Map<
+						string,
+						Deferred.Deferred<
+							Effect.Effect.Success<ReturnType<typeof sourceFs.isDirectory>>,
+							Effect.Effect.Error<ReturnType<typeof sourceFs.isDirectory>>
+						>
+					>()
+					const readCache = new Map<
+						string,
+						Deferred.Deferred<
+							Effect.Effect.Success<ReturnType<typeof sourceFs.readFile>>,
+							Effect.Effect.Error<ReturnType<typeof sourceFs.readFile>>
+						>
+					>()
+					const listingCache = new Map<
+						string,
+						Deferred.Deferred<
+							Effect.Effect.Success<ReturnType<typeof sourceFs.readDirectory>>,
+							Effect.Effect.Error<ReturnType<typeof sourceFs.readDirectory>>
+						>
+					>()
+					const realPathCache = new Map<
+						string,
+						Deferred.Deferred<
+							Effect.Effect.Success<ReturnType<typeof sourceFs.realPath>>,
+							Effect.Effect.Error<ReturnType<typeof sourceFs.realPath>>
+						>
+					>()
+					const fs = {
+						...sourceFs,
+						exists: (path: string) =>
+							memoize(existsCache, path, sourceFs.exists(path)),
+						isDirectory: (path: string) =>
+							memoize(directoryCache, path, sourceFs.isDirectory(path)),
+						readFile: (path: string) =>
+							memoize(readCache, path, sourceFs.readFile(path)),
+						readDirectory: (path: string) =>
+							memoize(listingCache, path, sourceFs.readDirectory(path)),
+						realPath: (path: string) =>
+							memoize(realPathCache, path, sourceFs.realPath(path)),
+					} satisfies FileSystemService
 					const cwd = resolve(options.cwd ?? process.cwd())
 					const suppliedTarget = options.target ?? "."
 					const candidate = resolve(cwd, suppliedTarget)
@@ -142,7 +208,66 @@ export class ContextService extends Effect.Service<ContextService>()(
 					const { root, config } = yield* workbase.loadConfig(
 						candidateExists ? candidate : cwd,
 					)
-					const backend = yield* versionControl.forWorkbase(root)
+					const sourceBackend = yield* versionControl.forWorkbase(root)
+					const revisionCache = new Map<
+						string,
+						Deferred.Deferred<
+							Effect.Effect.Success<
+								ReturnType<typeof sourceBackend.resolveRevision>
+							>,
+							Effect.Effect.Error<
+								ReturnType<typeof sourceBackend.resolveRevision>
+							>
+						>
+					>()
+					const workspaceCache = new Map<
+						string,
+						Deferred.Deferred<
+							Effect.Effect.Success<
+								ReturnType<typeof sourceBackend.listWorkspaces>
+							>,
+							Effect.Effect.Error<
+								ReturnType<typeof sourceBackend.listWorkspaces>
+							>
+						>
+					>()
+					const backend = {
+						...sourceBackend,
+						resolveRevision: (repositoryPath: string, revision: string) =>
+							memoize(
+								revisionCache,
+								`${repositoryPath}\0${revision}`,
+								sourceBackend.resolveRevision(repositoryPath, revision),
+							),
+						listWorkspaces: (repositoryPath: string) =>
+							memoize(
+								workspaceCache,
+								repositoryPath,
+								sourceBackend.listWorkspaces(repositoryPath),
+							),
+					}
+					const contextWorkbase = {
+						...workbase,
+						discover: (startPath?: string) =>
+							workbase
+								.discover(startPath)
+								.pipe(Effect.provideService(FileSystemService, fs)),
+						loadConfig: (startPath?: string) =>
+							workbase
+								.loadConfig(startPath)
+								.pipe(Effect.provideService(FileSystemService, fs)),
+						repositoryAliases: (startPath?: string) =>
+							workbase
+								.repositoryAliases(startPath)
+								.pipe(Effect.provideService(FileSystemService, fs)),
+					}
+					const provideContextServices = <A, E, R>(
+						effect: Effect.Effect<A, E, R>,
+					) =>
+						effect.pipe(
+							Effect.provideService(FileSystemService, fs),
+							Effect.provideService(WorkbaseService, contextWorkbase),
+						)
 
 					if (relative(root, candidate) === "") {
 						const compact = !options.full
@@ -216,7 +341,9 @@ export class ContextService extends Effect.Service<ContextService>()(
 							}
 						}
 
-						const validation = yield* workbase.validate(root)
+						const validation = yield* provideContextServices(
+							workbase.validate(root),
+						)
 						return {
 							projection: compact ? "compact" : "complete",
 							workbase: {
@@ -593,7 +720,9 @@ export class ContextService extends Effect.Service<ContextService>()(
 						})
 					}
 
-					const validation = yield* workbase.validate(root)
+					const validation = yield* provideContextServices(
+						workbase.validate(root),
+					)
 					const relevantPaths = new Set<string>(
 						[epic?.path, task?.path, phase?.path]
 							.filter((path): path is string => Boolean(path))
@@ -888,10 +1017,9 @@ export class ContextService extends Effect.Service<ContextService>()(
 					const codePath = join(entityDirectory, "code")
 					const inspectionWarnings: string[] = []
 					const repositories = new Map(
-						(yield* repositoryService.list(root)).map((repository) => [
-							repository.alias,
-							repository,
-						]),
+						(yield* provideContextServices(repositoryService.list(root))).map(
+							(repository) => [repository.alias, repository],
+						),
 					)
 
 					const inspectCheckout = (