@markjaquith/agency 2.71.4 → 2.71.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.4",
+  "version": "2.71.6",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -21,9 +21,8 @@
     "index.ts",
     "cli.ts",
     "cli-main.ts",
-    "src",
     "pi-extensions",
-    "scripts/install-pi-extension.ts",
+    "src",
     "schemas",
     "fixtures/protocol",
     "README.md",
@@ -65,7 +64,9 @@
   "scripts": {
     "postinstall": "bun scripts/install-pi-extension.ts install",
     "preuninstall": "bun scripts/install-pi-extension.ts uninstall",
+    "benchmark:status": "bun scripts/benchmark-status.ts",
     "benchmark:workbase": "bun scripts/benchmark-workbase.ts",
+    "benchmark:doctor": "bun scripts/benchmark-doctor.ts",
     "benchmark:context": "bun scripts/benchmark-context.ts",
     "benchmark:sync": "bun scripts/benchmark-sync.ts",
     "benchmark:task": "bun scripts/benchmark-task.ts",

package/src/commands/doctor.test.ts

@@ -100,10 +100,6 @@ status: open
 					id: "ref.agency.main",
 					status: "pass",
 				}),
-				expect.objectContaining({
-					id: "worktree.task.example",
-					status: "pass",
-				}),
 			]),
 		)
 		for (const check of report.checks) {

package/src/services/DoctorService.ts

@@ -2,12 +2,11 @@ import { Effect, Either } from "effect"
 import { constants } from "node:fs"
 import { access } from "node:fs/promises"
 import { isAbsolute, join, resolve } from "node:path"
-import { EpicService } from "./EpicService"
 import { FileSystemService } from "./FileSystemService"
 import { IntegrationService } from "./IntegrationService"
-import { PhaseService } from "./PhaseService"
+import type { PhaseRecord } from "./PhaseService"
 import { RepositoryService } from "./RepositoryService"
-import { TaskService } from "./TaskService"
+import type { TaskRecord } from "./TaskService"
 import { WorkbaseService } from "./WorkbaseService"
 import { WorktreeService } from "./WorktreeService"
 import { VersionControlService } from "./VersionControlService"
@@ -80,12 +79,9 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 		sync: () => ({
 			inspect: (startPath: string = process.cwd()) =>
 				Effect.gen(function* () {
-					const epics = yield* EpicService
 					const fs = yield* FileSystemService
 					const integrations = yield* IntegrationService
-					const phases = yield* PhaseService
 					const repositories = yield* RepositoryService
-					const tasks = yield* TaskService
 					const workbases = yield* WorkbaseService
 					const worktrees = yield* WorktreeService
 					const versionControl = yield* VersionControlService
@@ -105,49 +101,60 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 									: null,
 						})
 
-					const tool = function* (
+					const tool = (
 						id: string,
 						executable: string,
 						level: DoctorCheckLevel,
 						label: string,
-					) {
-						const available = yield* executableAvailable(executable, root)
-						add({
-							id,
-							category: id.startsWith("tool.") ? "tool" : "integration",
-							level,
-							status: available ? "pass" : "fail",
-							message: available
-								? `${label} executable '${executable}' is available`
-								: `${label} executable '${executable}' is unavailable`,
-							remediation:
-								level === "optional"
-									? `Install '${executable}' to enable ${label.toLowerCase()}, or leave it unavailable if unused.`
-									: `Install '${executable}' and ensure it is executable on PATH.`,
+					) =>
+						Effect.gen(function* () {
+							const available = yield* executableAvailable(executable, root)
+							add({
+								id,
+								category: id.startsWith("tool.") ? "tool" : "integration",
+								level,
+								status: available ? "pass" : "fail",
+								message: available
+									? `${label} executable '${executable}' is available`
+									: `${label} executable '${executable}' is unavailable`,
+								remediation:
+									level === "optional"
+										? `Install '${executable}' to enable ${label.toLowerCase()}, or leave it unavailable if unused.`
+										: `Install '${executable}' and ensure it is executable on PATH.`,
+							})
+							return available
 						})
-						return available
-					}
 
-					const gitAvailable = yield* tool("tool.git", "git", "error", "Git")
-					const jjAvailable = yield* tool(
-						"tool.jj",
-						"jj",
-						config.vcs === "jj" ? "error" : "optional",
-						"Jujutsu",
+					const [gitAvailable, jjAvailable] = yield* Effect.all(
+						[
+							tool("tool.git", "git", "error", "Git"),
+							tool(
+								"tool.jj",
+								"jj",
+								config.vcs === "jj" ? "error" : "optional",
+								"Jujutsu",
+							),
+						],
+						{ concurrency: "unbounded", batching: true },
 					)
 					const versionControlAvailable =
 						gitAvailable && (config.vcs !== "jj" || jjAvailable)
-					yield* tool(
-						"capability.agent.opencode",
-						"opencode",
-						"optional",
-						"OpenCode agent",
-					)
-					yield* tool(
-						"capability.agent.claude",
-						"claude",
-						"optional",
-						"Claude agent",
+					yield* Effect.all(
+						[
+							tool(
+								"capability.agent.opencode",
+								"opencode",
+								"optional",
+								"OpenCode agent",
+							),
+							tool(
+								"capability.agent.claude",
+								"claude",
+								"optional",
+								"Claude agent",
+							),
+						],
+						{ concurrency: "unbounded", batching: true },
 					)
 
 					const configuredCommands: readonly (readonly [
@@ -250,11 +257,16 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 								]
 							: []),
 					]
-					for (const [id, command, label] of configuredCommands) {
-						yield* tool(id, command[0]!, "error", label)
-					}
+					yield* Effect.all(
+						configuredCommands.map(([id, command, label]) =>
+							tool(id, command[0]!, "error", label),
+						),
+						{ concurrency: 16, batching: true },
+					)
 
-					const validation = yield* workbases.validate(root)
+					const validation = yield* workbases.validate(root, {
+						includeDocuments: true,
+					})
 					add({
 						id: "workbase.validation",
 						category: "workbase",
@@ -267,7 +279,7 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 							"Run 'agency validate' and correct every reported issue.",
 					})
 
-					for (const [id, mode, level, label, remediation] of [
+					const permissionChecks = [
 						[
 							"permission.workbase.read",
 							constants.R_OK,
@@ -282,8 +294,16 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 							"writable",
 							`Grant the current user write access to ${root} before running mutation commands.`,
 						],
-					] as const) {
-						const available = yield* permissionAvailable(root, mode)
+					] as const
+					const permissionResults = yield* Effect.all(
+						permissionChecks.map(([, mode]) => permissionAvailable(root, mode)),
+						{ concurrency: "unbounded", batching: true },
+					)
+					for (const [
+						index,
+						[id, , level, label, remediation],
+					] of permissionChecks.entries()) {
+						const available = permissionResults[index]!
 						add({
 							id,
 							category: "permission",
@@ -321,12 +341,12 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 						values.add(ref)
 						refs.set(repo, values)
 					}
-					if (validation.valid) {
-						for (const epic of yield* epics.list(root)) {
+					if (validation.valid && validation.documents) {
+						for (const epic of validation.documents.epics) {
 							for (const reference of epic.data.repos)
 								declareRef(reference.repo, reference.ref)
 						}
-						for (const task of yield* tasks.list(root)) {
+						for (const task of validation.documents.tasks) {
 							if ("review" in task.data) {
 								declareRef(task.data.review.repo, task.data.review.commit)
 								reviewSources.push({
@@ -344,7 +364,9 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 								for (const reference of task.data.repos ?? [])
 									declareRef(reference.repo, reference.ref)
 							} else {
-								for (const phase of yield* phases.list(task.id, root)) {
+								for (const phase of validation.documents.phasesByTask.get(
+									task.id,
+								) ?? []) {
 									declareRef(phase.data.repo, phase.data.base)
 									for (const reference of phase.data.repos ?? [])
 										declareRef(reference.repo, reference.ref)
@@ -442,7 +464,36 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 					}
 
 					if (validation.valid && versionControlAvailable) {
-						const inspected = yield* Effect.either(worktrees.list(root))
+						const tasks = validation.documents?.tasks.map(
+							(record) =>
+								({ ...record, content: "", revision: "" }) satisfies TaskRecord,
+						)
+						const phasesByTask = validation.documents
+							? new Map(
+									[...validation.documents.phasesByTask].map(
+										([taskId, records]) =>
+											[
+												taskId,
+												records.map(
+													(record) =>
+														({
+															...record,
+															taskId,
+															content: "",
+															revision: "",
+														}) satisfies PhaseRecord,
+												),
+											] as const,
+									),
+								)
+							: undefined
+						const inspected = yield* Effect.either(
+							worktrees.list(root, {
+								materializedOnly: true,
+								tasks,
+								phasesByTask,
+							}),
+						)
 						if (Either.isLeft(inspected)) {
 							add({
 								id: "worktree.inspection",

package/src/services/GraphService.ts

@@ -277,6 +277,13 @@ export class GraphService extends Effect.Service<GraphService>()(
 					}
 
 					const taskDeclarations = new Map<string, Dependency>()
+					const phasesByTask = new Map<string, Document<PhaseData>[]>()
+					for (const [key, phase] of phases) {
+						const taskId = key.slice(0, key.indexOf("/"))
+						const values = phasesByTask.get(taskId) ?? []
+						values.push(phase)
+						phasesByTask.set(taskId, values)
+					}
 					for (const epic of epics.values()) {
 						for (const declaration of epic.data.tasks) {
 							taskDeclarations.set(declaration.id, declaration)
@@ -294,8 +301,14 @@ export class GraphService extends Effect.Service<GraphService>()(
 								)
 							: [task.data.status]
 					}
-					const taskStatus = (taskId: string) =>
-						aggregateProgress(taskLeafStatuses(taskId)).status
+					const taskStatuses = new Map<string, WorkStatus>()
+					const taskStatus = (taskId: string) => {
+						const cached = taskStatuses.get(taskId)
+						if (cached) return cached
+						const status = aggregateProgress(taskLeafStatuses(taskId)).status
+						taskStatuses.set(taskId, status)
+						return status
+					}
 					const dependencyBlockers = (
 						dependencies: readonly string[],
 						toId: (id: string) => string,
@@ -320,16 +333,20 @@ export class GraphService extends Effect.Service<GraphService>()(
 
 					const validation =
 						options.validation ?? (yield* workbase.validate(root))
+					const validationIssuesByPath = Map.groupBy(
+						validation.issues,
+						(issue) => issue.path,
+					)
 					const validationBlockers = (
 						paths: readonly string[],
 					): GraphBlocker[] =>
-						validation.issues
-							.filter((issue) => paths.includes(issue.path))
-							.map((issue) => ({
+						paths.flatMap((path) =>
+							(validationIssuesByPath.get(path) ?? []).map((issue) => ({
 								kind: "validation" as const,
 								id: issue.path,
 								reason: issue.message,
-							}))
+							})),
+						)
 					const uniqueBlockers = (blockers: readonly GraphBlocker[]) => [
 						...new Map(
 							blockers.map((item) => [
@@ -339,7 +356,9 @@ export class GraphService extends Effect.Service<GraphService>()(
 						).values(),
 					]
 
-					const phaseState = (taskId: string, phaseId: string) => {
+					type PhaseState = ReturnType<typeof createPhaseState>
+					const phaseStates = new Map<string, PhaseState>()
+					function createPhaseState(taskId: string, phaseId: string) {
 						const task = tasks.get(taskId)
 						const phase = phases.get(`${taskId}/${phaseId}`)
 						const parentEpic = task?.data.epic
@@ -386,8 +405,18 @@ export class GraphService extends Effect.Service<GraphService>()(
 							},
 						}
 					}
+					const phaseState = (taskId: string, phaseId: string) => {
+						const key = `${taskId}/${phaseId}`
+						const cached = phaseStates.get(key)
+						if (cached) return cached
+						const state = createPhaseState(taskId, phaseId)
+						phaseStates.set(key, state)
+						return state
+					}
 
-					const taskState = (taskId: string) => {
+					type TaskState = ReturnType<typeof createTaskState>
+					const taskStates = new Map<string, TaskState>()
+					function createTaskState(taskId: string) {
 						const task = tasks.get(taskId)
 						const parentEpic = task?.data.epic
 							? epics.get(task.data.epic)
@@ -398,9 +427,9 @@ export class GraphService extends Effect.Service<GraphService>()(
 							? [
 									relative(root, task.path),
 									...(parentEpic ? [relative(root, parentEpic.path)] : []),
-									...[...phases.entries()]
-										.filter(([key]) => key.startsWith(`${taskId}/`))
-										.map(([, phase]) => relative(root, phase.path)),
+									...(phasesByTask.get(taskId) ?? []).map((phase) =>
+										relative(root, phase.path),
+									),
 								]
 							: []
 						const blockers = [
@@ -461,6 +490,13 @@ export class GraphService extends Effect.Service<GraphService>()(
 							},
 						}
 					}
+					const taskState = (taskId: string) => {
+						const cached = taskStates.get(taskId)
+						if (cached) return cached
+						const state = createTaskState(taskId)
+						taskStates.set(taskId, state)
+						return state
+					}
 
 					const epicState = (epicId: string) => {
 						const epic = epics.get(epicId)
@@ -475,9 +511,9 @@ export class GraphService extends Effect.Service<GraphService>()(
 										const task = tasks.get(item.id)
 										return [
 											...(task ? [relative(root, task.path)] : []),
-											...[...phases.entries()]
-												.filter(([key]) => key.startsWith(`${item.id}/`))
-												.map(([, phase]) => relative(root, phase.path)),
+											...(phasesByTask.get(item.id) ?? []).map((phase) =>
+												relative(root, phase.path),
+											),
 										]
 									}),
 								]
@@ -761,6 +797,36 @@ export class GraphService extends Effect.Service<GraphService>()(
 							return result
 						})
 
+					const executionDetailsByKey = new Map<
+						string,
+						Effect.Effect.Success<ReturnType<typeof executionDetails>>
+					>()
+					const executionDocuments: readonly (readonly [
+						string,
+						string,
+						ExecutionData,
+					])[] = [
+						...[...tasks.values()].flatMap((task) =>
+							"phases" in task.data
+								? []
+								: ([[task.id, task.path, task.data]] as const),
+						),
+						...[...phases].map(
+							([key, phase]) => [key, phase.path, phase.data] as const,
+						),
+					]
+					const inspectedExecutions = yield* Effect.all(
+						executionDocuments.map(([key, path, data]) =>
+							executionDetails(path, data).pipe(
+								Effect.map((details) => [key, details] as const),
+							),
+						),
+						{ concurrency: 16 },
+					)
+					for (const [key, details] of inspectedExecutions) {
+						executionDetailsByKey.set(key, details)
+					}
+
 					const nodes: GraphNode[] = []
 					for (const epic of epics.values()) {
 						const state = epicState(epic.id)
@@ -805,7 +871,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 								dependents: dependents(taskNodeId(task.id)),
 								repositories,
 								data: { taskId: task.id, ...task.data },
-								...(yield* executionDetails(task.path, task.data)),
+								...executionDetailsByKey.get(task.id),
 							})
 						}
 					}
@@ -830,7 +896,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 							dependents: dependents(phaseNodeId(taskId, phase.id)),
 							repositories,
 							data: { taskId, phaseId: phase.id, ...phase.data },
-							...(yield* executionDetails(phase.path, phase.data)),
+							...executionDetailsByKey.get(key),
 						})
 					}
 					for (const repository of [...repositoryRecords.values()].sort(

package/src/services/RepositoryService.ts

@@ -520,62 +520,64 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 						...Object.keys(config.repositories ?? {}),
 						...local.keys(),
 					])
-					const repositories: RepositoryInfo[] = []
-
-					for (const alias of [...aliases].sort()) {
-						const path = join(reposPath, alias)
-						const entry = local.get(alias)
-						const declaredRemote = config.repositories?.[alias]?.remote ?? null
-						if (!entry) {
-							repositories.push({
-								alias,
-								path,
-								kind: null,
-								remote: null,
-								declaredRemote,
-								target: null,
-								states: ["declared", "missing"],
-							})
-							continue
-						}
-						if (!entry.isDirectory && !entry.isSymlink) {
-							repositories.push({
-								alias,
-								path,
-								kind: null,
-								remote: null,
-								declaredRemote,
-								target: null,
-								states: [
-									...(declaredRemote ? (["declared"] as const) : []),
-									"invalid",
-								],
-							})
-							continue
-						}
-						const target = entry.isSymlink
-							? yield* fs.readSymlinkTarget(path)
-							: null
-						const inspection = yield* backend.inspectRepository(path)
-						const remote = inspection?.remote ?? null
-						const states: RepositoryState[] = []
-						if (declaredRemote) states.push("declared")
-						states.push(entry.isSymlink ? "linked" : "materialized")
-						if (!inspection) states.push("invalid")
-						if (declaredRemote && remote !== declaredRemote)
-							states.push("remote-drifted")
-						repositories.push({
-							alias,
-							path,
-							kind: entry.isSymlink
-								? "symlink"
-								: (inspection?.kind ?? "repository"),
-							remote,
-							declaredRemote,
-							target,
-							states,
-						})
-					}
+					const repositories = yield* Effect.all(
+						[...aliases].sort().map((alias) =>
+							Effect.gen(function* () {
+								const path = join(reposPath, alias)
+								const entry = local.get(alias)
+								const declaredRemote =
+									config.repositories?.[alias]?.remote ?? null
+								if (!entry) {
+									return {
+										alias,
+										path,
+										kind: null,
+										remote: null,
+										declaredRemote,
+										target: null,
+										states: ["declared", "missing"] as RepositoryState[],
+									} satisfies RepositoryInfo
+								}
+								if (!entry.isDirectory && !entry.isSymlink) {
+									return {
+										alias,
+										path,
+										kind: null,
+										remote: null,
+										declaredRemote,
+										target: null,
+										states: [
+											...(declaredRemote ? (["declared"] as const) : []),
+											"invalid",
+										] as RepositoryState[],
+									} satisfies RepositoryInfo
+								}
+								const target = entry.isSymlink
+									? yield* fs.readSymlinkTarget(path)
+									: null
+								const inspection = yield* backend.inspectRepository(path)
+								const remote = inspection?.remote ?? null
+								const states: RepositoryState[] = []
+								if (declaredRemote) states.push("declared")
+								states.push(entry.isSymlink ? "linked" : "materialized")
+								if (!inspection) states.push("invalid")
+								if (declaredRemote && remote !== declaredRemote)
+									states.push("remote-drifted")
+								return {
+									alias,
+									path,
+									kind: entry.isSymlink
+										? "symlink"
+										: (inspection?.kind ?? "repository"),
+									remote,
+									declaredRemote,
+									target,
+									states,
+								} satisfies RepositoryInfo
+							}),
+						),
+						{ concurrency: 4 },
+					)
 					return repositories
 				}),
 

package/src/services/WorkbaseService.ts

@@ -56,6 +56,7 @@ export interface ValidationReport {
 	readonly taskCount: number
 	readonly phaseCount: number
 	readonly valid: boolean
+	readonly documents?: ValidationDocuments
 }
 
 interface DocumentRecord<T> {
@@ -64,6 +65,15 @@ interface DocumentRecord<T> {
 	readonly data: T
 }
 
+interface ValidationDocuments {
+	readonly epics: readonly DocumentRecord<EpicData>[]
+	readonly tasks: readonly DocumentRecord<TaskData>[]
+	readonly phasesByTask: ReadonlyMap<
+		string,
+		readonly DocumentRecord<PhaseData>[]
+	>
+}
+
 type DecodeResult<T> =
 	| { readonly success: true; readonly value: T }
 	| { readonly success: false; readonly error: string }
@@ -653,7 +663,10 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 					),
 				),
 
-			validate: (startPath: string = process.cwd()) =>
+			validate: (
+				startPath: string = process.cwd(),
+				options: { readonly includeDocuments?: boolean } = {},
+			) =>
 				Effect.gen(function* () {
 					const service = yield* WorkbaseService
 					const fs = yield* FileSystemService
@@ -959,6 +972,14 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 							: a.path.localeCompare(b.path),
 					)
 
+					const phasesByTask = new Map<string, DocumentRecord<PhaseData>[]>()
+					for (const [key, phase] of phases) {
+						const taskId = key.slice(0, key.indexOf("/"))
+						const records = phasesByTask.get(taskId) ?? []
+						records.push(phase)
+						phasesByTask.set(taskId, records)
+					}
+
 					return {
 						root,
 						issues,
@@ -966,6 +987,15 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 						taskCount: tasks.size,
 						phaseCount: phases.size,
 						valid: issues.length === 0,
+						...(options.includeDocuments
+							? {
+									documents: {
+										epics: [...epics.values()],
+										tasks: [...tasks.values()],
+										phasesByTask,
+									},
+								}
+							: {}),
 					} satisfies ValidationReport
 				}),
 		}),

package/src/work-view.ts

@@ -211,27 +211,34 @@ export const getWorkViews = (options: WorkViewOptions = {}) =>
 			(node): node is ExecutionNode => node.kind === "execution-unit",
 		)
 		const taskOrder = orderedTasks(epics, tasks)
-		const phaseOrder = taskOrder.flatMap((task) => orderedPhases(task, phases))
+		const phasesByTask = new Map(
+			taskOrder.map((task) => [task.key, orderedPhases(task, phases)]),
+		)
+		const phaseOrder = taskOrder.flatMap(
+			(task) => phasesByTask.get(task.key) ?? [],
+		)
+		const executionsByTask = new Map<string, ExecutionNode[]>()
+		const executionsByPhase = new Map<string, ExecutionNode[]>()
+		for (const execution of executions) {
+			const taskExecutions = executionsByTask.get(execution.data.taskId) ?? []
+			taskExecutions.push(execution)
+			executionsByTask.set(execution.data.taskId, taskExecutions)
+			if ("phaseId" in execution.data) {
+				const key = `${execution.data.taskId}/${execution.data.phaseId}`
+				const phaseExecutions = executionsByPhase.get(key) ?? []
+				phaseExecutions.push(execution)
+				executionsByPhase.set(key, phaseExecutions)
+			}
+		}
 		const executionsFor = (node: EntityNode) => {
 			if (node.kind === "phase") {
-				const separator = node.key.indexOf("/")
-				const taskId = node.key.slice(0, separator)
-				const phaseId = node.key.slice(separator + 1)
-				return executions.filter(
-					(execution) =>
-						execution.data.taskId === taskId &&
-						"phaseId" in execution.data &&
-						execution.data.phaseId === phaseId,
-				)
+				return executionsByPhase.get(node.key) ?? []
 			}
 			if (node.kind === "task") {
-				return executions.filter(
-					(execution) => execution.data.taskId === node.key,
-				)
+				return executionsByTask.get(node.key) ?? []
 			}
-			const taskIds = new Set(node.data.tasks.map((item) => item.id))
-			return executions.filter((execution) =>
-				taskIds.has(execution.data.taskId),
+			return node.data.tasks.flatMap(
+				(item) => executionsByTask.get(item.id) ?? [],
 			)
 		}
 		const makeRows = (nodes: readonly EntityNode[]) =>
@@ -257,7 +264,7 @@ export const getWorkViews = (options: WorkViewOptions = {}) =>
 		const phaseRows = filterRows(makeRows(phaseOrder))
 		const executionEntities: EntityNode[] = []
 		for (const task of taskOrder) {
-			const taskPhases = orderedPhases(task, phases)
+			const taskPhases = phasesByTask.get(task.key) ?? []
 			executionEntities.push(...(taskPhases.length > 0 ? taskPhases : [task]))
 		}
 		const executionRows = filterRows(makeRows(executionEntities))

package/scripts/install-pi-extension.ts

@@ -1,25 +0,0 @@
-import { cp, mkdir, rm } from "node:fs/promises"
-import { homedir } from "node:os"
-import { dirname, join } from "node:path"
-
-export const piExtensionPath = (home = homedir()) =>
-	join(home, ".pi", "agent", "extensions", "agency.ts")
-
-export const installPiExtension = async (
-	source = join(import.meta.dir, "..", "pi-extensions", "agency.ts"),
-	destination = piExtensionPath(),
-) => {
-	await mkdir(dirname(destination), { recursive: true })
-	await cp(source, destination)
-}
-
-export const uninstallPiExtension = async (destination = piExtensionPath()) => {
-	await rm(destination, { force: true })
-}
-
-if (import.meta.main) {
-	const command = process.argv[2] ?? "install"
-	if (command === "install") await installPiExtension()
-	else if (command === "uninstall") await uninstallPiExtension()
-	else throw new Error(`Unknown Pi extension lifecycle command: ${command}`)
-}