@markjaquith/agency 3.2.2 → 3.2.4

package/src/services/WorktreeService.ts

@@ -182,6 +182,14 @@ const formatCommand = (args: readonly string[]) =>
 		)
 		.join(" ")
 
+const describeError = (error: unknown) =>
+	typeof error === "object" &&
+	error !== null &&
+	"message" in error &&
+	typeof error.message === "string"
+		? error.message
+		: String(error)
+
 const runPostCheckoutHook = (options: {
 	readonly command: readonly string[] | undefined
 	readonly variables: CheckoutCommandVariables
@@ -1871,6 +1879,10 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 							  }
 							| { review: { repo: string; commit: string } }
 						let codePath: string
+						let executionState: {
+							readonly status: string
+							readonly claim?: { readonly state: string }
+						}
 						if ("phases" in task.data) {
 							if (!phaseId) {
 								return yield* new WorktreeError({
@@ -1880,6 +1892,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 							const phase =
 								options.phase ?? (yield* phases.show(taskId, phaseId, root))
 							execution = phase.data
+							executionState = phase.data
 							codePath = join(dirname(phase.path), "code")
 						} else {
 							if (phaseId) {
@@ -1888,8 +1901,25 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 								})
 							}
 							execution = task.data
+							executionState = task.data
 							codePath = join(dirname(task.path), "code")
 						}
+						const ownerLabel = phaseId
+							? `Phase '${taskId}/${phaseId}'`
+							: `Task '${taskId}'`
+						if (executionState.claim?.state === "active") {
+							return yield* new WorktreeError({
+								message: `${ownerLabel} has an active claim; release or finish it before removing its worktrees`,
+							})
+						}
+						if (
+							executionState.status === "working" ||
+							executionState.status === "delegated"
+						) {
+							return yield* new WorktreeError({
+								message: `${ownerLabel} has active '${executionState.status}' ownership; reopen it before removing its worktrees`,
+							})
+						}
 
 						const codeDirectoryExists = yield* fs.isDirectory(codePath)
 						const removalPlans: {
@@ -1931,6 +1961,11 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 							const alias = checkout.repo
 							const repositoryPath = join(root, "repos", alias)
 							const checkoutPath = join(codePath, alias)
+							if ((yield* fs.readSymlinkTarget(checkoutPath)) !== null) {
+								return yield* new WorktreeError({
+									message: `Cannot remove ${codePath}; expected checkout ${checkoutPath} is a symbolic link`,
+								})
+							}
 							if (
 								(yield* fs.exists(checkoutPath)) &&
 								!(yield* fs.isDirectory(checkoutPath))
@@ -2024,7 +2059,12 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 									["git", "-C", checkoutPath, "status", "--porcelain"],
 									{ captureOutput: true },
 								)
-								if (status.exitCode !== 0 || status.stdout.trim()) {
+								if (status.exitCode !== 0) {
+									return yield* new WorktreeError({
+										message: `Failed to remove worktree for '${alias}': checkout cleanliness could not be verified: ${status.stderr.trim() || `git status exited with code ${status.exitCode}`}`,
+									})
+								}
+								if (status.stdout.trim()) {
 									return yield* new WorktreeError({
 										message: `Failed to remove worktree for '${alias}': checkout has uncommitted changes`,
 									})
@@ -2039,6 +2079,25 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 								head: registered.head,
 								branch: registered.branch?.replace(/^refs\/heads\//, ""),
 							})
+							if (!checkoutExists) {
+								const unrelatedStale: string[] = []
+								for (const worktree of parseWorktreeList(listed.stdout)) {
+									const worktreePath = (yield* fs.exists(worktree.path))
+										? yield* fs.realPath(worktree.path)
+										: resolve(worktree.path)
+									if (
+										worktreePath !== registered.path &&
+										!(yield* fs.exists(worktree.path))
+									) {
+										unrelatedStale.push(worktree.path)
+									}
+								}
+								if (unrelatedStale.length > 0) {
+									return yield* new WorktreeError({
+										message: `Cannot remove stale registration ${registered.path} because pruning would also remove unrelated stale registrations: ${unrelatedStale.join(", ")}`,
+									})
+								}
+							}
 						}
 						for (const plan of removalPlans) {
 							if (!plan.checkoutExists || !plan.head) continue
@@ -2056,6 +2115,38 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 						}
 
 						const completed: typeof removalPlans = []
+						const planState = (plan: (typeof removalPlans)[number]) =>
+							Effect.gen(function* () {
+								const checkoutExists = yield* fs.isDirectory(plan.checkoutPath)
+								const listed = yield* fs.runCommand(
+									[
+										"git",
+										"-C",
+										plan.repositoryPath,
+										"worktree",
+										"list",
+										"--porcelain",
+										"-z",
+									],
+									{ captureOutput: true },
+								)
+								if (listed.exitCode !== 0) {
+									return yield* new WorktreeError({
+										message: `Failed to inspect worktrees for '${plan.alias}' during recovery: ${listed.stderr.trim() || `git worktree list exited with code ${listed.exitCode}`}`,
+									})
+								}
+								let registered = false
+								for (const worktree of parseWorktreeList(listed.stdout)) {
+									const worktreePath = (yield* fs.exists(worktree.path))
+										? yield* fs.realPath(worktree.path)
+										: resolve(worktree.path)
+									if (worktreePath === plan.registeredPath) {
+										registered = true
+										break
+									}
+								}
+								return { checkoutExists, registered }
+							})
 						const removed = yield* Effect.gen(function* () {
 							for (const plan of removalPlans) {
 								const command = plan.checkoutExists
@@ -2080,8 +2171,18 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 									captureOutput: true,
 								})
 								if (result.exitCode !== 0) {
+									const state = yield* planState(plan).pipe(
+										Effect.catchAll(() => Effect.succeed(undefined)),
+									)
+									if (
+										!state ||
+										state.checkoutExists !== plan.checkoutExists ||
+										!state.registered
+									) {
+										completed.push(plan)
+									}
 									return yield* new WorktreeError({
-										message: `Failed to remove worktree for '${plan.alias}': ${result.stderr}`,
+										message: `Failed to remove worktree for '${plan.alias}': ${result.stderr.trim() || `git exited with code ${result.exitCode}`}`,
 									})
 								}
 								completed.push(plan)
@@ -2099,43 +2200,77 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 									for (const plan of [...completed].reverse()) {
 										if (!plan.checkoutExists) {
 											manualRecovery.push(
-												`Re-run worktree repair for stale registration ${plan.registeredPath}`,
+												`Restore stale registration ${plan.registeredPath} if it is still needed`,
 											)
 											continue
 										}
-										yield* fs.createDirectory(dirname(plan.checkoutPath))
-										const command = plan.branch
-											? [
-													"git",
-													"-C",
-													plan.repositoryPath,
-													"worktree",
-													"add",
-													plan.checkoutPath,
-													plan.branch,
-												]
-											: [
-													"git",
-													"-C",
-													plan.repositoryPath,
-													"worktree",
-													"add",
-													"--detach",
-													plan.checkoutPath,
-													plan.head!,
-												]
-										const restored = yield* fs.runCommand(command, {
-											captureOutput: true,
-										})
-										if (restored.exitCode === 0)
-											rolledBack.push(plan.checkoutPath)
-										else manualRecovery.push(`Restore ${plan.checkoutPath}`)
+										const recovery = Effect.gen(function* () {
+											const state = yield* planState(plan)
+											if (state.checkoutExists && state.registered) {
+												rolledBack.push(plan.checkoutPath)
+												return
+											}
+											if (state.checkoutExists || state.registered) {
+												manualRecovery.push(
+													`Restore ${plan.checkoutPath}; checkout path ${state.checkoutExists ? "exists" : "is missing"} and registration ${state.registered ? "exists" : "is missing"}`,
+												)
+												return
+											}
+											yield* fs.createDirectory(dirname(plan.checkoutPath))
+											const command = plan.branch
+												? [
+														"git",
+														"-C",
+														plan.repositoryPath,
+														"worktree",
+														"add",
+														plan.checkoutPath,
+														plan.branch,
+													]
+												: [
+														"git",
+														"-C",
+														plan.repositoryPath,
+														"worktree",
+														"add",
+														"--detach",
+														plan.checkoutPath,
+														plan.head!,
+													]
+											const restored = yield* fs.runCommand(command, {
+												captureOutput: true,
+											})
+											if (restored.exitCode === 0) {
+												rolledBack.push(plan.checkoutPath)
+											} else {
+												manualRecovery.push(
+													`Restore ${plan.checkoutPath}: ${restored.stderr.trim() || `git exited with code ${restored.exitCode}`}`,
+												)
+											}
+										}).pipe(
+											Effect.catchAll((recoveryCause) =>
+												Effect.sync(() => {
+													manualRecovery.push(
+														`Restore ${plan.checkoutPath}: ${describeError(recoveryCause)}`,
+													)
+												}),
+											),
+										)
+										yield* recovery
 									}
+									const causeMessage = describeError(cause)
 									return yield* new WorktreeError({
-										message: manualRecovery.length
-											? "Worktree removal failed and requires manual recovery"
-											: "Worktree removal failed; removed worktrees were restored",
-										completed: completed.map((plan) => plan.checkoutPath),
+										message:
+											completed.length === 0
+												? `${causeMessage}; no worktrees were removed`
+												: manualRecovery.length
+													? `${causeMessage}. Worktree removal requires manual recovery`
+													: `${causeMessage}. Removed worktrees were restored`,
+										completed: completed.map((plan) =>
+											plan.checkoutExists
+												? plan.checkoutPath
+												: plan.registeredPath,
+										),
 										rolledBack,
 										manualRecovery,
 										cause,

package/src/test-utils.ts

@@ -16,7 +16,6 @@ import { ArchiveService } from "./services/ArchiveService"
 import { IntegrationService } from "./services/IntegrationService"
 import { ContextService } from "./services/ContextService"
 import { GraphService } from "./services/GraphService"
-import { ClaimService } from "./services/ClaimService"
 import { SyncService } from "./services/SyncService"
 import { ReadinessService } from "./services/ReadinessService"
 import { GraphMutationService } from "./services/GraphMutationService"
@@ -48,7 +47,6 @@ const TestLayer = Layer.mergeAll(
 	IntegrationService.Default,
 	ContextService.Default,
 	GraphService.Default,
-	ClaimService.Default,
 	SyncService.Default,
 	ReadinessService.Default,
 	GraphMutationService.Default,

package/src/usage-log.test.ts

@@ -1,20 +1,36 @@
 import { afterEach, describe, expect, test } from "bun:test"
+import { Database } from "bun:sqlite"
 import { rm } from "node:fs/promises"
 import { join } from "node:path"
 import { cleanupTempDir, createTempDir } from "./test-utils"
-import { exportUsageEvents, recordUsageEvent } from "./usage-log"
+import {
+	exportUsageEvents,
+	recordUsageEvent,
+	usageOutcomeCode,
+} from "./usage-log"
 
 describe("usage logging", () => {
 	const tempDirs: string[] = []
 
 	afterEach(() => Promise.all(tempDirs.splice(0).map(cleanupTempDir)))
 
+	test("maps only reviewed failure categories", () => {
+		expect(usageOutcomeCode({ _tag: "WorkbaseNotFoundError" })).toBe(
+			"WORKBASE_NOT_FOUND",
+		)
+		expect(usageOutcomeCode({ _tag: "private-customer-id" })).toBe(
+			"COMMAND_FAILED",
+		)
+	})
+
 	test("stores versioned privacy-safe events in session order", async () => {
 		const state = await createTempDir()
 		tempDirs.push(state)
 		const env = {
 			XDG_STATE_HOME: state,
 			AGENCY_SESSION_ID: "session-1",
+			AGENCY_INVOCATION_SOURCE: "automation",
+			AGENCY_USAGE_TEST: "1",
 		} as NodeJS.ProcessEnv
 		for (const commandPath of ["worktree/prepare", "context"]) {
 			await recordUsageEvent(
@@ -23,6 +39,7 @@ describe("usage logging", () => {
 					flagNames: ["json", "task", "json"],
 					durationMs: 12.4,
 					outcome: "success",
+					outcomeCode: "SUCCESS",
 					exitStatus: 0,
 					...(commandPath === "context"
 						? {
@@ -40,26 +57,31 @@ describe("usage logging", () => {
 		expect(await Bun.file(join(state, "agency/usage.sqlite3")).exists()).toBe(
 			true,
 		)
-		expect(await exportUsageEvents(env)).toEqual([
+		const events = await exportUsageEvents(env)
+		expect(events).toEqual([
 			expect.objectContaining({
 				version: 2,
-				sessionId: "session-1",
-				sessionSequence: 1,
+				journeyId: expect.stringMatching(/^sha256:[a-f0-9]{64}$/),
+				journeySequence: 1,
+				invocationSource: "automation",
+				isTest: true,
 				agencyVersion: "1.2.3",
 				commandPath: "worktree/prepare",
 				flagNames: ["json", "task"],
 				durationMs: 12,
 				outcome: "success",
+				outcomeCode: "SUCCESS",
 				exitStatus: 0,
 			}),
 			expect.objectContaining({
-				sessionSequence: 2,
+				journeySequence: 2,
 				commandPath: "context",
 				vcs: "git",
 				terminalStage: "publish",
 				category: "success",
 			}),
 		])
+		expect(JSON.stringify(events)).not.toContain("session-1")
 	})
 
 	test("supports opt-out and ignores unavailable storage", async () => {
@@ -75,6 +97,7 @@ describe("usage logging", () => {
 				flagNames: [],
 				durationMs: 1,
 				outcome: "failure",
+				outcomeCode: "COMMAND_FAILED",
 				exitStatus: 1,
 			},
 			"1.2.3",
@@ -93,6 +116,7 @@ describe("usage logging", () => {
 					flagNames: [],
 					durationMs: 1,
 					outcome: "failure",
+					outcomeCode: "COMMAND_FAILED",
 					exitStatus: 1,
 				},
 				"1.2.3",
@@ -101,4 +125,64 @@ describe("usage logging", () => {
 		).resolves.toBeUndefined()
 		await rm(blocked)
 	})
+
+	test("prunes expired events on every database access", async () => {
+		const state = await createTempDir()
+		tempDirs.push(state)
+		const env = {
+			XDG_STATE_HOME: state,
+			AGENCY_USAGE_RETENTION_DAYS: "30",
+		} as NodeJS.ProcessEnv
+		await recordUsageEvent(
+			{
+				commandPath: "status",
+				flagNames: [],
+				durationMs: 1,
+				outcome: "success",
+				outcomeCode: "SUCCESS",
+				exitStatus: 0,
+			},
+			"1.2.3",
+			env,
+		)
+		const database = new Database(join(state, "agency/usage.sqlite3"))
+		database.run(
+			"UPDATE usage_events SET occurred_at = datetime('now', '-31 days')",
+		)
+		database.close()
+
+		expect(await exportUsageEvents(env)).toEqual([])
+	})
+
+	test("removes legacy events that may contain positional values", async () => {
+		const state = await createTempDir()
+		tempDirs.push(state)
+		const path = join(state, "usage.sqlite3")
+		const database = new Database(path, { create: true })
+		database.run(
+			"CREATE TABLE usage_events (id INTEGER PRIMARY KEY, command_path TEXT NOT NULL)",
+		)
+		database.run("INSERT INTO usage_events (command_path) VALUES (?)", [
+			"task/private-customer-id",
+		])
+		database.close()
+		const env = { AGENCY_USAGE_DB: path } as NodeJS.ProcessEnv
+
+		await recordUsageEvent(
+			{
+				commandPath: "task/show",
+				flagNames: [],
+				durationMs: 1,
+				outcome: "success",
+				outcomeCode: "SUCCESS",
+				exitStatus: 0,
+			},
+			"1.2.3",
+			env,
+		)
+
+		expect(await exportUsageEvents(env)).toEqual([
+			expect.objectContaining({ commandPath: "task/show", version: 2 }),
+		])
+	})
 })