@markjaquith/agency 3.2.0 → 3.2.2

package/README.md

@@ -1107,13 +1107,21 @@ without creating a pull request. It requires a valid, registered writable
 checkout in `working` state, fetches the configured delivery remote, verifies
 that the declared base is in the publication history, validates every outgoing
 commit's description, author, and conflict state, and refuses non-fast-forward
-updates.
+updates. Local commit validation runs before network access when cached remote
+state is available, and the network fetch is limited to the declared base and
+delivery branch.
 
 YAML `branch` must exactly match the checked-out local branch, the worktree must
 be clean, and `HEAD` is pushed with upstream tracking. Missing commit descriptions
 or authors stop publication with exact commits and remediation commands. Push
 reports deterministic fetch, inspection, validation, and publication progress on
-stderr, including while `--json` reserves stdout for one machine result.
+stderr, including while `--json` reserves stdout for one machine result. Git
+authentication is non-interactive. Fetch defaults to a 30-second deadline and
+one retry for transient failures; push defaults to a 120-second deadline. Set
+`AGENCY_PUSH_FETCH_TIMEOUT_MS` or `AGENCY_PUSH_TIMEOUT_MS` to positive millisecond
+values to override them. After a failed or timed-out push, Agency compares the
+exact remote delivery ref with the expected tip before reporting success, a safe
+retryable failure, or an unknown publication outcome.
 
 Task-aware `agency pr create <task-id> [phase-id]` uses Agency's delivery flow,
 including readiness checks and durable PR recording. It accepts draft, title,

package/cli-main.ts

@@ -828,6 +828,42 @@ let usageFlagNames = rawArguments
 	.filter((argument) => argument.startsWith("--"))
 	.map((argument) => argument.slice(2).split("=", 1)[0]!)
 
+const pushUsageDetails = (error?: unknown) => {
+	if (usageCommandPath !== "push") return {}
+	const seen = new Set<object>()
+	const visit = (
+		value: unknown,
+	): { stage?: string; category?: string } | null => {
+		if (typeof value !== "object" || value === null || seen.has(value))
+			return null
+		seen.add(value)
+		if (
+			"stage" in value &&
+			typeof value.stage === "string" &&
+			"category" in value &&
+			typeof value.category === "string"
+		) {
+			return { stage: value.stage, category: value.category }
+		}
+		for (const nestedValue of [
+			...Object.values(value),
+			...Object.getOwnPropertySymbols(value).map(
+				(symbol) => (value as Record<symbol, unknown>)[symbol],
+			),
+		]) {
+			const nested = visit(nestedValue)
+			if (nested) return nested
+		}
+		return null
+	}
+	const details = error ? visit(error) : null
+	return {
+		vcs: "git" as const,
+		terminalStage: details?.stage ?? (error ? "unknown" : "publish"),
+		category: details?.category ?? (error ? "unknown" : "success"),
+	}
+}
+
 try {
 	const {
 		commandName,
@@ -921,6 +957,7 @@ try {
 			durationMs: performance.now() - invocationStartedAt,
 			outcome: exitStatus === 0 ? "success" : "failure",
 			exitStatus,
+			...pushUsageDetails(),
 		},
 		VERSION,
 	)
@@ -932,6 +969,7 @@ try {
 			durationMs: performance.now() - invocationStartedAt,
 			outcome: "failure",
 			exitStatus: 1,
+			...pushUsageDetails(error),
 		},
 		VERSION,
 	)

package/package.json

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

package/src/commands/context.test.ts

@@ -282,6 +282,20 @@ status: dropped
 	})
 
 	test("reads each workbase document at most once per invocation", async () => {
+		const unrelatedArchive = join(root, "archive/tasks/unrelated/TASK.md")
+		await write(
+			root,
+			"archive/tasks/unrelated/TASK.md",
+			`---
+ticketUrl: null
+repo: agency
+branch: unrelated
+base: main
+pr: null
+status: done
+---
+`,
+		)
 		const reads = new Map<string, number>()
 		const originalFile = Bun.file
 		Bun.file = mock((path: string) => {
@@ -304,6 +318,48 @@ status: dropped
 		)
 		expect(documents.length).toBeGreaterThan(0)
 		expect(documents.every(([, count]) => count === 1)).toBe(true)
+		expect(reads.has(unrelatedArchive)).toBe(false)
+	})
+
+	test("limits repository inspection and overlaps independent Git observations", async () => {
+		const commands: string[][] = []
+		let activeGitCommands = 0
+		let maxActiveGitCommands = 0
+		const originalSpawn = Bun.spawn
+		;(Bun as { spawn: unknown }).spawn = mock(((
+			args: string[],
+			options: Parameters<typeof Bun.spawn>[1],
+		) => {
+			const command = [...args]
+			const child = originalSpawn(command, options)
+			if (command[0] !== "git") return child
+			commands.push(command)
+			activeGitCommands += 1
+			maxActiveGitCommands = Math.max(maxActiveGitCommands, activeGitCommands)
+			const exited = child.exited.finally(() => {
+				activeGitCommands -= 1
+			})
+			return new Proxy(child, {
+				get(target, property) {
+					return property === "exited"
+						? exited
+						: Reflect.get(target, property, target)
+				},
+			})
+		}) as unknown as typeof Bun.spawn)
+		try {
+			await readContext(root, "tasks/agent-contract/phases/context-command")
+		} finally {
+			;(Bun as { spawn: unknown }).spawn = originalSpawn
+		}
+
+		expect(
+			commands.some(
+				(command) =>
+					command.includes("config") && command.includes("--show-origin"),
+			),
+		).toBe(false)
+		expect(maxActiveGitCommands).toBeGreaterThanOrEqual(3)
 	})
 
 	test("resolves a bare task ID and returns root discovery context", async () => {

package/src/commands/push.test.ts

@@ -28,9 +28,10 @@ describe("push command", () => {
 						publish: (_cwd: string, options: any) => {
 							for (const stage of [
 								"context",
-								"fetch",
 								"inspect",
 								"validate",
+								"fetch",
+								"validate",
 								"publish",
 							] as const)
 								options.onProgress(stage)
@@ -44,9 +45,10 @@ describe("push command", () => {
 		expect(logs).toEqual([JSON.stringify(result, null, 2)])
 		expect(updates).toEqual([
 			"start:Inspecting Agency execution context",
-			"start:Fetching remote state",
 			"start:Selecting the publication tip",
 			"start:Validating outgoing changes",
+			"start:Fetching remote state",
+			"start:Validating outgoing changes",
 			"start:Publishing the declared branch",
 			"succeed:Published task/example to origin",
 		])

package/src/commands/push.ts

@@ -10,6 +10,7 @@ const stageMessage = {
 	inspect: "Selecting the publication tip",
 	validate: "Validating outgoing changes",
 	publish: "Publishing the declared branch",
+	reconcile: "Confirming the remote publication outcome",
 } as const
 
 export const push = (
@@ -22,6 +23,7 @@ export const push = (
 		const showProgress = !options.silent
 		const result = yield* publications
 			.publish(options.cwd ?? process.cwd(), {
+				forwardOutput: options.verbose,
 				onProgress: showProgress
 					? (stage) => progress.start(stageMessage[stage])
 					: undefined,

package/src/protocol.test.ts

@@ -161,4 +161,28 @@ describe("machine protocol", () => {
 			},
 		})
 	})
+
+	test("uses dynamic protocol metadata without duplicating it in fields", () => {
+		expect(
+			errorEnvelope({
+				_tag: "PushError",
+				message: "remote timed out",
+				protocolCode: "PUSH_TIMEOUT",
+				retryable: true,
+				remediation: "Retry after checking connectivity.",
+				category: "timeout",
+				stage: "fetch",
+			}),
+		).toEqual({
+			version: 1,
+			ok: false,
+			error: {
+				code: "PUSH_TIMEOUT",
+				message: "remote timed out",
+				fields: { category: "timeout", stage: "fetch" },
+				retryable: true,
+				remediation: "Retry after checking connectivity.",
+			},
+		})
+	})
 })

package/src/protocol.ts

@@ -198,6 +198,36 @@ const errorTag = (error: unknown): string | undefined => {
 	return undefined
 }
 
+const unwrapEffectError = (error: unknown): unknown => {
+	const seen = new Set<object>()
+	const visit = (value: unknown): unknown => {
+		if (typeof value !== "object" || value === null || seen.has(value))
+			return null
+		seen.add(value)
+		if ("protocolCode" in value && typeof value.protocolCode === "string") {
+			return value
+		}
+		for (const nested of [
+			...Object.values(value),
+			...Object.getOwnPropertySymbols(value).map(
+				(symbol) => (value as Record<symbol, unknown>)[symbol],
+			),
+		]) {
+			const found = visit(nested)
+			if (found) return found
+		}
+		if (
+			"_tag" in value &&
+			typeof value._tag === "string" &&
+			value._tag.endsWith("Error")
+		) {
+			return value
+		}
+		return null
+	}
+	return visit(error) ?? error
+}
+
 const errorMessage = (error: unknown): string => {
 	if (
 		typeof error === "object" &&
@@ -219,6 +249,9 @@ const errorFields = (error: unknown): Record<string, unknown> => {
 				key !== "name" &&
 				key !== "message" &&
 				key !== "cause" &&
+				key !== "protocolCode" &&
+				key !== "retryable" &&
+				key !== "remediation" &&
 				value !== undefined,
 		),
 	)
@@ -231,17 +264,36 @@ export const successEnvelope = (result: unknown): SuccessEnvelope => ({
 })
 
 export const errorEnvelope = (error: unknown): ErrorEnvelope => {
-	const metadata = errorMetadata[errorTag(error) ?? ""] ?? {
+	const normalized = unwrapEffectError(error)
+	const defaults = errorMetadata[errorTag(normalized) ?? ""] ?? {
 		code: "COMMAND_FAILED",
 		retryable: false,
 	}
+	const dynamic =
+		typeof normalized === "object" && normalized !== null
+			? {
+					...("protocolCode" in normalized &&
+					typeof normalized.protocolCode === "string"
+						? { code: normalized.protocolCode }
+						: {}),
+					...("retryable" in normalized &&
+					typeof normalized.retryable === "boolean"
+						? { retryable: normalized.retryable }
+						: {}),
+					...("remediation" in normalized &&
+					typeof normalized.remediation === "string"
+						? { remediation: normalized.remediation }
+						: {}),
+				}
+			: {}
 	return {
 		version: PROTOCOL_VERSION,
 		ok: false,
 		error: {
-			...metadata,
-			message: errorMessage(error),
-			fields: errorFields(error),
+			...defaults,
+			...dynamic,
+			message: errorMessage(normalized),
+			fields: errorFields(normalized),
 		},
 	}
 }