@markjaquith/agency 2.71.9 → 2.71.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.9",
+  "version": "2.71.11",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -70,8 +70,10 @@
     "benchmark:doctor": "bun scripts/benchmark-doctor.ts",
     "benchmark:context": "bun scripts/benchmark-context.ts",
     "benchmark:finish": "bun scripts/benchmark-finish.ts",
+    "benchmark:push": "bun scripts/benchmark-push.ts",
     "benchmark:sync": "bun scripts/benchmark-sync.ts",
     "benchmark:task": "bun scripts/benchmark-task.ts",
+    "benchmark:validate": "bun scripts/benchmark-validate.ts",
     "benchmark:worktree": "bun scripts/benchmark-worktree.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/services/PushService.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { TaskService } from "./TaskService"
 import { PushService } from "./PushService"
+import { parseGitCommits } from "./push-validation"
 import { WorktreeService } from "./WorktreeService"
 
 interface CommandResult {
@@ -39,6 +40,24 @@ const requireCommand = async (args: readonly string[], cwd?: string) => {
 }
 
 describe("PushService", () => {
+	test("parses and validates batched Git commit metadata", () => {
+		const output = [
+			"abc123\0Agency Test\0agency@example.com\0First change\0\x1e",
+			"def456\0Agency Test\0agency@example.com\0Second change\0\x1e",
+		].join("\n")
+		const commits = parseGitCommits(output)
+
+		expect(
+			commits.map(({ commitId, description }) => ({ commitId, description })),
+		).toEqual([
+			{ commitId: "abc123", description: "First change" },
+			{ commitId: "def456", description: "Second change" },
+		])
+		expect(commits.every((commit) => commit.authorEmail.includes("@"))).toBe(
+			true,
+		)
+	})
+
 	const roots: string[] = []
 
 	afterEach(async () => {

package/src/services/PushService.ts

@@ -4,6 +4,7 @@ import { FileSystemService } from "./FileSystemService"
 import { PhaseService } from "./PhaseService"
 import { TaskService } from "./TaskService"
 import { WorkbaseService } from "./WorkbaseService"
+import { parseGitCommits, type PushCommitMetadata } from "./push-validation"
 
 class PushError extends Data.TaggedError("PushError")<{
 	readonly message: string
@@ -15,16 +16,7 @@ interface CommandResult {
 	readonly stderr: string
 }
 
-interface CommitMetadata {
-	readonly commitId: string
-	readonly changeId?: string
-	readonly description: string
-	readonly empty: boolean
-	readonly authorName: string
-	readonly authorEmail: string
-	readonly conflict: boolean
-	readonly parents: readonly string[]
-}
+type CommitMetadata = PushCommitMetadata
 
 interface PushResult {
 	readonly vcs: "git" | "jj"
@@ -105,29 +97,6 @@ const gitAncestor = (
 			}),
 		)
 
-const parseGitCommits = (output: string): readonly CommitMetadata[] =>
-	output
-		.split("\x1e")
-		.map((record) => record.replace(/^\n+|\n+$/g, ""))
-		.filter(Boolean)
-		.map((record) => {
-			const [
-				commitId = "",
-				authorName = "",
-				authorEmail = "",
-				description = "",
-			] = record.split("\0")
-			return {
-				commitId,
-				description,
-				empty: false,
-				authorName,
-				authorEmail,
-				conflict: false,
-				parents: [],
-			}
-		})
-
 const validateGitCommits = (
 	commits: readonly CommitMetadata[],
 	base: string,
@@ -194,11 +163,12 @@ const publishGit = (
 			["fetch", remote, `+refs/heads/*:refs/remotes/${remote}/*`],
 			`Failed to fetch remote '${remote}'`,
 		)
-		const tip = yield* gitRevision(fs, checkout, "HEAD")
-		const baseRevision = yield* gitRevision(
-			fs,
-			checkout,
-			`refs/remotes/${remote}/${base}`,
+		const [tip, baseRevision] = yield* Effect.all(
+			[
+				gitRevision(fs, checkout, "HEAD"),
+				gitRevision(fs, checkout, `refs/remotes/${remote}/${base}`),
+			],
+			{ concurrency: "unbounded" },
 		)
 		if (!tip || !baseRevision) {
 			return yield* new PushError({
@@ -239,12 +209,6 @@ const publishGit = (
 		}
 
 		onProgress?.("publish")
-		yield* git(
-			fs,
-			checkout,
-			["push", remote, `HEAD:refs/heads/${branch}`],
-			`Failed to push declared branch '${branch}'`,
-		)
 		yield* git(
 			fs,
 			checkout,
@@ -259,17 +223,13 @@ const publishGit = (
 			fs,
 			checkout,
 			[
-				"fetch",
+				"push",
+				"-u",
 				remote,
-				`+refs/heads/${branch}:refs/remotes/${remote}/${branch}`,
+				`HEAD:refs/heads/${branch}`,
+				`--force-if-includes`,
 			],
-			`Failed to refresh published branch '${branch}'`,
-		)
-		yield* git(
-			fs,
-			checkout,
-			["branch", "--set-upstream-to", `${remote}/${branch}`, branch],
-			`Failed to establish upstream tracking for branch '${branch}'`,
+			`Failed to push declared branch '${branch}'`,
 		)
 		return { tip }
 	})
@@ -403,10 +363,25 @@ const publishJj = (
 		}
 
 		const baseBookmark = `${base}@${remote}`
-		const baseRevision = yield* optionalJjRevision(
-			fs,
-			checkout,
-			`remote_bookmarks(exact:"${jjExact(base)}", exact:"${jjExact(remote)}")`,
+		const [baseRevision, localBookmark, remoteBookmark] = yield* Effect.all(
+			[
+				optionalJjRevision(
+					fs,
+					checkout,
+					`remote_bookmarks(exact:"${jjExact(base)}", exact:"${jjExact(remote)}")`,
+				),
+				optionalJjRevision(
+					fs,
+					checkout,
+					`bookmarks(exact:"${jjExact(branch)}")`,
+				),
+				optionalJjRevision(
+					fs,
+					checkout,
+					`remote_bookmarks(exact:"${jjExact(branch)}", exact:"${jjExact(remote)}")`,
+				),
+			],
+			{ concurrency: "unbounded" },
 		)
 		if (!baseRevision) {
 			return yield* new PushError({
@@ -432,28 +407,24 @@ const publishJj = (
 			catch: (cause) => cause as PushError,
 		})
 
-		const localBookmark = yield* optionalJjRevision(
-			fs,
-			checkout,
-			`bookmarks(exact:"${jjExact(branch)}")`,
-		)
-		if (
-			localBookmark &&
-			!(yield* jjAncestor(fs, checkout, localBookmark.commitId, tip.commitId))
-		) {
+		const [localBookmarkIsAncestor, remoteBookmarkIsAncestor] =
+			yield* Effect.all(
+				[
+					localBookmark
+						? jjAncestor(fs, checkout, localBookmark.commitId, tip.commitId)
+						: Effect.succeed(true),
+					remoteBookmark
+						? jjAncestor(fs, checkout, remoteBookmark.commitId, tip.commitId)
+						: Effect.succeed(true),
+				],
+				{ concurrency: "unbounded" },
+			)
+		if (!localBookmarkIsAncestor) {
 			return yield* new PushError({
 				message: `Local bookmark '${branch}' is not an ancestor of jj tip ${tip.changeId}; refusing to move it`,
 			})
 		}
-		const remoteBookmark = yield* optionalJjRevision(
-			fs,
-			checkout,
-			`remote_bookmarks(exact:"${jjExact(branch)}", exact:"${jjExact(remote)}")`,
-		)
-		if (
-			remoteBookmark &&
-			!(yield* jjAncestor(fs, checkout, remoteBookmark.commitId, tip.commitId))
-		) {
+		if (!remoteBookmarkIsAncestor) {
 			return yield* new PushError({
 				message: `Remote bookmark '${branch}@${remote}' is not an ancestor of jj tip ${tip.changeId}; refusing a non-fast-forward update`,
 			})

package/src/services/WorkbaseService.test.ts

@@ -3,6 +3,7 @@ import { Effect } from "effect"
 import { mkdir, realpath, rm, symlink } from "node:fs/promises"
 import { dirname, join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
+import { FileSystemService } from "./FileSystemService"
 import { WorkbaseService } from "./WorkbaseService"
 
 const write = async (root: string, path: string, content: string) => {
@@ -104,6 +105,65 @@ pr: null
 		expect(report.issues).toEqual([])
 	})
 
+	test("reads configuration and documents once during validation", async () => {
+		await write(
+			root,
+			"agency.json",
+			JSON.stringify({
+				version: 2,
+				repositories: {
+					agency: { remote: "https://example.com/agency.git" },
+				},
+			}),
+		)
+		await write(
+			root,
+			"tasks/example/TASK.md",
+			`---
+ticketUrl: null
+repo: agency
+branch: task/example
+base: main
+pr: null
+---
+`,
+		)
+
+		const fs = await Effect.runPromise(
+			FileSystemService.pipe(Effect.provide(FileSystemService.Default)),
+		)
+		const reads: string[] = []
+		const exists: string[] = []
+		const trackedFs = {
+			...fs,
+			readFile: (path: string) => {
+				reads.push(path)
+				return fs.readFile(path)
+			},
+			exists: (path: string) => {
+				exists.push(path)
+				return fs.exists(path)
+			},
+		}
+
+		const report = await Effect.runPromise(
+			WorkbaseService.pipe(
+				Effect.flatMap((service) => service.validate(root)),
+				Effect.provide(WorkbaseService.Default),
+				Effect.provideService(FileSystemService, trackedFs),
+			) as Effect.Effect<unknown, unknown, never>,
+		)
+
+		expect(report).toMatchObject({ valid: true, taskCount: 1 })
+		expect(
+			reads.filter((path) => path === join(root, "agency.json")),
+		).toHaveLength(2)
+		expect(
+			reads.filter((path) => path === join(root, "tasks/example/TASK.md")),
+		).toHaveLength(1)
+		expect(exists).not.toContain(join(root, "tasks/example/TASK.md"))
+	})
+
 	test("validates non-PR completion invariants without rejecting legacy done work", async () => {
 		await write(
 			root,

package/src/services/WorkbaseService.ts

@@ -65,6 +65,8 @@ interface DocumentRecord<T> {
 	readonly data: T
 }
 
+const validationConcurrency = 32
+
 interface ValidationDocuments {
 	readonly epics: readonly DocumentRecord<EpicData>[]
 	readonly tasks: readonly DocumentRecord<TaskData>[]
@@ -671,10 +673,23 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 					const service = yield* WorkbaseService
 					const fs = yield* FileSystemService
 					const root = yield* service.discover(startPath)
+					const configPath = join(root, "agency.json")
+					const configInput = JSON.parse(
+						yield* fs.readFile(configPath),
+					) as unknown
+					const configResult = decode(WorkbaseConfig, configInput)
+					if (!configResult.success) {
+						return yield* new WorkbaseConfigError({
+							path: configPath,
+							message: `Invalid workbase configuration in ${configPath}:\n${configResult.error}`,
+						})
+					}
+					const config = configResult.value
 					const issues: ValidationIssue[] = []
 					const epics = new Map<string, DocumentRecord<EpicData>>()
 					const tasks = new Map<string, DocumentRecord<TaskData>>()
 					const phases = new Map<string, DocumentRecord<PhaseData>>()
+					const phaseIdsByTask = new Map<string, Set<string>>()
 
 					const issue = (path: string, message: string) => {
 						issues.push({ path: relative(root, path) || ".", message })
@@ -691,7 +706,13 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 							Effect.catchAll(() => Effect.succeed([])),
 						)
 
-					const aliases = new Set(yield* service.repositoryAliases(root))
+					const aliases = new Set(Object.keys(config.repositories ?? {}))
+					const reposPath = join(root, "repos")
+					if (yield* fs.isDirectory(reposPath)) {
+						for (const entry of yield* fs.readDirectory(reposPath)) {
+							if (!entry.name.startsWith(".agency-")) aliases.add(entry.name)
+						}
+					}
 
 					const readDocument = <S extends Schema.Schema.AnyNoContext>(
 						path: string,
@@ -728,7 +749,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 								return data ? { id, path, data } : null
 							}),
 						),
-						{ concurrency: "unbounded" },
+						{ concurrency: validationConcurrency },
 					)
 					for (const document of epicDocuments) {
 						if (document) epics.set(document.id, document)
@@ -744,6 +765,9 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 								const phaseIds = yield* readDirectories(
 									join(taskPath, "phases"),
 								)
+								if (phaseIds.length > 0) {
+									phaseIdsByTask.set(id, new Set(phaseIds))
+								}
 								const taskPhases = yield* Effect.all(
 									phaseIds.map((phaseId) =>
 										Effect.gen(function* () {
@@ -762,7 +786,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 												: null
 										}),
 									),
-									{ concurrency: "unbounded" },
+									{ concurrency: validationConcurrency },
 								)
 								return {
 									id,
@@ -771,7 +795,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 								}
 							}),
 						),
-						{ concurrency: "unbounded" },
+						{ concurrency: validationConcurrency },
 					)
 					for (const documents of taskDocuments) {
 						if (documents.task) tasks.set(documents.id, documents.task)
@@ -922,10 +946,8 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 							}
 						}
 
-						const phasePrefix = `${task.id}/`
-						const actualPhaseIds = [...phases.keys()]
-							.filter((key) => key.startsWith(phasePrefix))
-							.map((key) => key.slice(phasePrefix.length))
+						const actualPhaseIds =
+							phaseIdsByTask.get(task.id) ?? new Set<string>()
 
 						if ("phases" in task.data) {
 							const declaredIds = new Set(
@@ -952,7 +974,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 							for (const cycle of findDependencyCycles(task.data.phases)) {
 								issue(task.path, `Phase dependency cycle includes '${cycle}'`)
 							}
-						} else if (actualPhaseIds.length > 0) {
+						} else if (actualPhaseIds.size > 0) {
 							issue(
 								task.path,
 								"Single-phase task cannot contain phase directories",

package/src/services/push-validation.ts

@@ -0,0 +1,35 @@
+export interface PushCommitMetadata {
+	readonly commitId: string
+	readonly changeId?: string
+	readonly description: string
+	readonly empty: boolean
+	readonly authorName: string
+	readonly authorEmail: string
+	readonly conflict: boolean
+	readonly parents: readonly string[]
+}
+
+export const parseGitCommits = (
+	output: string,
+): readonly PushCommitMetadata[] =>
+	output
+		.split("\x1e")
+		.map((record) => record.replace(/^\n+|\n+$/g, ""))
+		.filter(Boolean)
+		.map((record) => {
+			const [
+				commitId = "",
+				authorName = "",
+				authorEmail = "",
+				description = "",
+			] = record.split("\0")
+			return {
+				commitId,
+				description,
+				empty: false,
+				authorName,
+				authorEmail,
+				conflict: false,
+				parents: [],
+			}
+		})