@markjaquith/agency 2.69.1 → 2.71.0

package/README.md

@@ -21,6 +21,21 @@ bun install -g @markjaquith/agency
 
 For development, run `bun link` from this repository.
 
+## Local Usage Logging
+
+Agency records privacy-safe CLI usage events locally so command journeys,
+failures, and flag adoption can be analyzed. Events are stored in SQLite at
+`$XDG_STATE_HOME/agency/usage.sqlite3` (or
+`~/.local/state/agency/usage.sqlite3`) and retained for 90 days by default.
+Each event contains the normalized command path, flag names, timing, outcome,
+Agency version, and ordered `AGENCY_SESSION_ID` correlation. Raw arguments,
+flag values, free-form input, and the current directory are never recorded.
+
+Export events as JSON Lines with `agency usage export`. Set
+`AGENCY_NO_USAGE_LOG=1` to opt out, `AGENCY_USAGE_RETENTION_DAYS` to change
+retention, or `AGENCY_USAGE_DB` to select a different database path. Logging is
+best effort and never changes command output or exit behavior.
+
 ## Core Model
 
 - A **workbase** is the root containing durable documents and local repository
@@ -56,8 +71,6 @@ workbase/
     tui.jsonc              # managed TUI plugin registration
     plugins/agency-repository-skills.ts # managed workbase access and checkout skills
     tui/agency-debug.ts    # managed /agency-debug TUI diagnostic
-  .pi/
-    extensions/agency-workbase.ts # managed workbase context and checkout skills
   agency.json              # tracked config and portable repository declarations
   repos/                   # ignored local materializations
     frontend/              # bare Git repository or symlink
@@ -86,8 +99,8 @@ workbase/
 
 Agency keeps discovery and other observational commands read-only. Run
 `agency integration status` to inspect `.agency/AGENTS.md`, the managed
-OpenCode configuration and plugins, and `.pi/extensions/agency-workbase.ts`,
-then `agency integration sync` to create missing files or refresh checksum-safe
+OpenCode configuration and plugins, then `agency integration sync` to create
+missing files or refresh checksum-safe
 managed files. Customized files are reported but never overwritten. Sync also
 removes checksum-valid retired managed artifacts while
 preserving customized files at their former paths. The root
@@ -128,15 +141,15 @@ The plugin grants whole-workbase access dynamically, while the portable
 reference advertises that context to agents. Bash and Agency operations must
 still follow the write authority reported by `agency context`.
 
-Pi discovers the managed project extension automatically when launched from
-the workbase root after the project is trusted. When launching Pi from a task,
-phase, or epic directory, pass the managed file with `--extension`, for example
-`pi -e /path/to/workbase/.pi/extensions/agency-workbase.ts`. The extension loads
-the managed Agency instructions into Pi's system prompt, advertises the complete
-workbase, and exposes skills from the writable checkout's `.claude/skills`,
-`.agents/skills`, `.opencode/{skill,skills}`, and `.pi/skills` directories.
-Agency context still determines write authority; reference checkouts remain
-read-only.
+Agency's package lifecycle installs one Pi extension at
+`~/.pi/agent/extensions/agency.ts`. Pi loads it globally, so it works from
+workbase roots and nested epic, task, phase, or checkout directories without
+project trust or an explicit `--extension` flag. Outside an Agency workbase it
+registers no resources and changes no prompt. Inside one, it loads the managed
+Agency instructions, advertises the complete workbase, and exposes skills from
+the writable checkout's `.claude/skills`, `.agents/skills`,
+`.opencode/{skill,skills}`, and `.pi/skills` directories. `agency context`
+remains the authority for writes; reference checkouts remain read-only.
 
 Repository aliases, the version-control backend, and canonical fetch remotes are
 declared in tracked `agency.json`; local clones and symlinks remain ignored under
@@ -434,11 +447,11 @@ working directory so the workbase `AGENTS.md` and managed OpenCode config are
 discovered normally.
 Agency's managed OpenCode plugin grants the active workbase external-directory
 access and adds existing checkout-local `.claude/skills`, `.agents/skills`, and
-`.opencode/{skill,skills}` directories to `skills.paths`. The managed Pi
+`.opencode/{skill,skills}` directories to `skills.paths`. The global Pi
 extension provides equivalent whole-workbase context and additionally discovers
 checkout-local `.pi/skills` through Pi's `resources_discover` lifecycle.
-`agency work` supplies the checkout directly; plain OpenCode launches and Pi
-launches with the managed extension loaded resolve a materialized execution-unit
+`agency work` supplies the checkout directly; plain OpenCode and Pi launches
+resolve a materialized execution-unit
 checkout through `agency context`. A multi-phase
 task root has no single checkout, so launch from its phase directory when using
 plain OpenCode or Pi. Other checkout-local configuration is not composed.

package/cli-main.ts

@@ -67,6 +67,7 @@ import {
 	successEnvelope,
 	writeEnvelope,
 } from "./src/protocol"
+import { exportUsageEvents, recordUsageEvent } from "./src/usage-log"
 
 // Create CLI layer with all services
 const CliLayer = Layer.mergeAll(
@@ -176,6 +177,12 @@ const VERSION = packageJson.version
 
 // Define commands
 const commands: Record<string, Command> = {
+	usage: {
+		run: async () => {
+			for (const event of await exportUsageEvents())
+				console.log(JSON.stringify(event))
+		},
+	},
 	act: {
 		run: async (args: string[], options: Record<string, any>) => {
 			if (options.help) return console.log(actHelp)
@@ -785,6 +792,7 @@ Commands:
   init [path]            Initialize an Agency workbase
   workbase <subcommand>  Manage registered workbases
   integration <command> Inspect or sync managed integration files
+  usage export          Export local usage events as JSON Lines
   epic <subcommand>      Manage epics
   phase <subcommand>     Manage task phases
   claim <task> [phase]   Claim an execution unit
@@ -830,9 +838,30 @@ const machineMode = process.argv
 	.slice(2)
 	.some((argument) => argument === "--json" || argument === "--jsonl")
 
+const invocationStartedAt = performance.now()
+const rawArguments = process.argv.slice(2)
+let usageCommandPath = "invalid"
+let usageFlagNames = rawArguments
+	.filter((argument) => argument.startsWith("--"))
+	.map((argument) => argument.slice(2).split("=", 1)[0]!)
+
 try {
-	const args = process.argv.slice(2)
-	const { commandName, args: commandArgs, passthrough, values } = parseCli(args)
+	const {
+		commandName,
+		args: commandArgs,
+		passthrough,
+		values,
+	} = parseCli(rawArguments)
+	usageCommandPath =
+		[commandName, commandArgs[0]]
+			.filter(
+				(part): part is string =>
+					typeof part === "string" && part.length > 0 && !part.startsWith("-"),
+			)
+			.join("/") || "root"
+	usageFlagNames = Object.entries(values)
+		.filter(([, value]) => value !== undefined && value !== false)
+		.map(([name]) => name)
 
 	// Handle global flags
 	if (values.version) {
@@ -841,6 +870,16 @@ try {
 		} else {
 			console.log(`v${VERSION}`)
 		}
+		await recordUsageEvent(
+			{
+				commandPath: "version",
+				flagNames: usageFlagNames,
+				durationMs: performance.now() - invocationStartedAt,
+				outcome: "success",
+				exitStatus: 0,
+			},
+			VERSION,
+		)
 		process.exit(0)
 	}
 
@@ -848,7 +887,18 @@ try {
 	// Show help if no command
 	if (!commandName) {
 		showMainHelp()
-		process.exit(values.help ? 0 : 1)
+		const exitStatus = values.help ? 0 : 1
+		await recordUsageEvent(
+			{
+				commandPath: "help",
+				flagNames: usageFlagNames,
+				durationMs: performance.now() - invocationStartedAt,
+				outcome: exitStatus === 0 ? "success" : "failure",
+				exitStatus,
+			},
+			VERSION,
+		)
+		process.exit(exitStatus)
 	}
 
 	const command = commands[commandName]!
@@ -880,7 +930,28 @@ try {
 			passthrough,
 		})
 	}
+	const exitStatus = Number(process.exitCode ?? 0)
+	await recordUsageEvent(
+		{
+			commandPath: usageCommandPath,
+			flagNames: usageFlagNames,
+			durationMs: performance.now() - invocationStartedAt,
+			outcome: exitStatus === 0 ? "success" : "failure",
+			exitStatus,
+		},
+		VERSION,
+	)
 } catch (error) {
+	await recordUsageEvent(
+		{
+			commandPath: usageCommandPath,
+			flagNames: usageFlagNames,
+			durationMs: performance.now() - invocationStartedAt,
+			outcome: "failure",
+			exitStatus: 1,
+		},
+		VERSION,
+	)
 	if (machineMode) {
 		writeEnvelope(errorEnvelope(error))
 		process.exit(1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.69.1",
+  "version": "2.71.0",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -22,6 +22,8 @@
     "cli.ts",
     "cli-main.ts",
     "src",
+    "pi-extensions",
+    "scripts/install-pi-extension.ts",
     "schemas",
     "fixtures/protocol",
     "README.md",
@@ -61,6 +63,8 @@
     "tag": "latest"
   },
   "scripts": {
+    "postinstall": "bun scripts/install-pi-extension.ts install",
+    "preuninstall": "bun scripts/install-pi-extension.ts uninstall",
     "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/pi-extensions/agency.test.ts

@@ -0,0 +1,117 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { mkdir } from "node:fs/promises"
+import { join } from "node:path"
+import { cleanupTempDir, createTempDir } from "../src/test-utils"
+import agencyExtension from "./agency"
+
+describe("global Pi extension", () => {
+	let root: string
+
+	beforeEach(async () => {
+		root = await createTempDir()
+	})
+
+	afterEach(async () => cleanupTempDir(root))
+
+	const load = (response?: object) => {
+		const handlers = new Map<string, (...args: any[]) => any>()
+		const pi = {
+			exec: async () => ({
+				code: response ? 0 : 1,
+				stdout: response ? JSON.stringify(response) : "",
+				stderr: "",
+			}),
+			on: (name: string, handler: (...args: any[]) => any) => {
+				handlers.set(name, handler)
+			},
+		}
+		agencyExtension(pi as never)
+		return handlers
+	}
+
+	test("no-ops outside Agency workbases without invoking the CLI", async () => {
+		let executions = 0
+		const handlers = new Map<string, (...args: any[]) => any>()
+		agencyExtension({
+			exec: async () => {
+				executions += 1
+				return { code: 1, stdout: "", stderr: "" }
+			},
+			on: (name: string, handler: (...args: any[]) => any) => {
+				handlers.set(name, handler)
+			},
+		} as never)
+
+		expect(
+			await handlers.get("resources_discover")?.({ cwd: root }),
+		).toBeUndefined()
+		expect(
+			await handlers.get("before_agent_start")?.(
+				{ systemPrompt: "Base" },
+				{ cwd: root },
+			),
+		).toBeUndefined()
+		expect(executions).toBe(0)
+	})
+
+	test("uses CLI context from nested directories for skills and authority", async () => {
+		const task = join(root, "tasks", "example")
+		const nested = join(task, "code", "agency", "src")
+		const checkout = join(task, "code", "agency")
+		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
+		await mkdir(join(root, ".agency"), { recursive: true })
+		await Bun.write(
+			join(root, ".agency", "AGENTS.md"),
+			"# Managed instructions\n",
+		)
+		await mkdir(join(checkout, ".agents", "skills"), { recursive: true })
+		await mkdir(nested, { recursive: true })
+
+		const handlers = load({
+			ok: true,
+			result: {
+				workbase: { root },
+				target: {
+					kind: "task",
+					taskId: "example",
+					path: join(task, "TASK.md"),
+				},
+				authority: { mode: "execution", writable: { checkoutPath: checkout } },
+				documents: { task: { data: { status: "working" } } },
+				validation: { valid: true },
+			},
+		})
+		const resources = await handlers.get("resources_discover")?.({
+			cwd: nested,
+		})
+		expect(resources.skillPaths).toEqual([join(checkout, ".agents", "skills")])
+
+		const prompt = await handlers.get("before_agent_start")?.(
+			{ systemPrompt: "Base" },
+			{ cwd: nested },
+		)
+		expect(prompt.systemPrompt).toContain("# Managed instructions")
+		expect(prompt.systemPrompt).toContain(
+			`${checkout} as the default implementation directory`,
+		)
+	})
+
+	test("rejects CLI context for a different workbase", async () => {
+		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
+		const handlers = load({
+			ok: true,
+			result: {
+				workbase: { root: join(root, "other") },
+				target: { kind: "epic", epicId: "example" },
+				validation: { valid: true },
+			},
+		})
+
+		expect(
+			await handlers.get("before_agent_start")?.(
+				{ systemPrompt: "Base" },
+				{ cwd: root },
+			),
+		).toBeUndefined()
+	})
+})

package/pi-extensions/agency.ts

@@ -0,0 +1,141 @@
+import { existsSync, readFileSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+
+type ExtensionAPI = {
+	exec: (
+		command: string,
+		args: string[],
+		options: { timeout: number },
+	) => Promise<{ code: number; stdout: string }>
+	on: (
+		name: "resources_discover" | "before_agent_start",
+		handler: (...args: any[]) => unknown,
+	) => void
+}
+
+type AgencyContext = {
+	root?: string
+	checkout?: string
+	target?: string
+}
+
+const contextTarget = (result: Record<string, any>): string | undefined => {
+	const target = result.target
+	if (target?.kind === "epic") return `epic:${target.epicId}`
+	if (target?.kind === "phase") {
+		return `execution-unit:phase/${target.taskId}/${target.phaseId}`
+	}
+	if (target?.kind === "task") {
+		return result.authority?.mode === "execution"
+			? `execution-unit:task/${target.taskId}`
+			: `task:${target.taskId}`
+	}
+}
+
+const discoverWorkbase = (directory: string) => {
+	let current = resolve(directory)
+	while (true) {
+		if (existsSync(join(current, "agency.json"))) return current
+		const parent = dirname(current)
+		if (parent === current) return
+		current = parent
+	}
+}
+
+const agencyContext = async (
+	pi: ExtensionAPI,
+	directory: string,
+): Promise<AgencyContext | undefined> => {
+	const root = discoverWorkbase(directory)
+	if (!root) return
+
+	const command = await pi.exec(
+		"agency",
+		["context", directory, "--compact", "--json"],
+		{ timeout: 5000 },
+	)
+	if (command.code !== 0) return
+
+	const envelope = JSON.parse(command.stdout)
+	if (envelope.ok !== true) return
+	const result = envelope.result ?? {}
+	const target = contextTarget(result)
+	const status =
+		result.documents?.phase?.data?.status ??
+		result.documents?.task?.data?.status
+	if (
+		result.validation?.valid !== true ||
+		result.workbase?.root !== root ||
+		!target ||
+		(target.startsWith("execution-unit:") &&
+			(!result.authority?.writable?.checkoutPath || status !== "working"))
+	)
+		return
+
+	return {
+		root,
+		checkout: result.authority?.writable?.checkoutPath,
+		target,
+	}
+}
+
+export default function agencyExtension(pi: ExtensionAPI) {
+	const contexts = new Map<string, Promise<AgencyContext | undefined>>()
+	const runtimeContext = (directory: string) => {
+		const key = resolve(directory)
+		let context = contexts.get(key)
+		if (!context) {
+			context = agencyContext(pi, key).catch(() => undefined)
+			contexts.set(key, context)
+		}
+		return context
+	}
+
+	pi.on("resources_discover", async (event: { cwd: string }) => {
+		const context = await runtimeContext(event.cwd)
+		if (!context?.checkout) return
+
+		const skillPaths = [
+			join(context.checkout, ".claude", "skills"),
+			join(context.checkout, ".agents", "skills"),
+			join(context.checkout, ".opencode", "skill"),
+			join(context.checkout, ".opencode", "skills"),
+			join(context.checkout, ".pi", "skills"),
+		].filter(existsSync)
+		if (skillPaths.length > 0) return { skillPaths: [...new Set(skillPaths)] }
+	})
+
+	pi.on(
+		"before_agent_start",
+		async (event: { systemPrompt: string }, ctx: { cwd: string }) => {
+			const context = await runtimeContext(ctx.cwd)
+			if (!context?.root) return
+
+			const instructionsPath = join(context.root, ".agency", "AGENTS.md")
+			const instructions = existsSync(instructionsPath)
+				? readFileSync(instructionsPath, "utf8").trim()
+				: undefined
+			const activeTarget = process.env.AGENCY_TARGET
+			const worker =
+				activeTarget && context.target === activeTarget
+					? `Agency verified this Pi session as the active worker for ${activeTarget}. Perform the assigned work directly. Do not invoke agency work for this target or launch a replacement worker.`
+					: undefined
+			const access = `The complete Agency workbase is available at ${context.root}. Use absolute paths under that root when workbase context is needed. Agency context remains the authority for writes.`
+			const implementation = context.checkout
+				? `Pi remains rooted in the task or phase directory for Agency instructions and context. Treat ${context.checkout} as the default implementation directory for source reads, edits, repository status, builds, tests, formatting, and other repository-local commands. Run Agency lifecycle and context commands from the task or phase directory. Any reference checkouts reported by Agency context are read-only.`
+				: undefined
+
+			return {
+				systemPrompt: [
+					event.systemPrompt,
+					instructions,
+					access,
+					worker,
+					implementation,
+				]
+					.filter(Boolean)
+					.join("\n\n"),
+			}
+		},
+	)
+}

package/scripts/install-pi-extension.ts

@@ -0,0 +1,25 @@
+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}`)
+}

package/src/cli-parser.ts

@@ -136,6 +136,17 @@ const nonPrCompletionOptions = {
 } satisfies OptionConfig
 
 const commands = {
+	usage: {
+		usage: "agency usage export",
+		options: commonOptions,
+		subcommands: {
+			export: {
+				usage: "agency usage export",
+				minArgs: 0,
+				maxArgs: 0,
+			},
+		},
+	},
 	init: {
 		usage: "agency init [path] [--json]",
 		options: outputOptions,

package/src/cli.test.ts

@@ -36,6 +36,8 @@ async function runCli(
 		env: {
 			...process.env,
 			XDG_CONFIG_HOME: isolatedConfigHome,
+			XDG_STATE_HOME: isolatedConfigHome,
+			AGENCY_NO_USAGE_LOG: "1",
 			...env,
 		},
 		stdout: "pipe",
@@ -170,6 +172,44 @@ describe("CLI", () => {
 		expect(taggedError.stderr).not.toContain("An error has occurred")
 	})
 
+	test("records successful and failed invocations without argument values", async () => {
+		const state = await createTempDir()
+		tempDirs.push(state)
+		const env = {
+			XDG_STATE_HOME: state,
+			AGENCY_SESSION_ID: "cli-session",
+			AGENCY_NO_USAGE_LOG: "0",
+		}
+		expect((await runCli(["--version"], projectRoot, env)).exitCode).toBe(0)
+		expect(
+			(await runCli(["unknown", "--cwd", "/private/value"], projectRoot, env))
+				.exitCode,
+		).toBe(1)
+
+		const exported = await runCli(["usage", "export"], projectRoot, env)
+		expect(exported).toMatchObject({ exitCode: 0, stderr: "" })
+		const events = exported.stdout
+			.trim()
+			.split("\n")
+			.map((line) => JSON.parse(line))
+		expect(events).toEqual([
+			expect.objectContaining({
+				sessionId: "cli-session",
+				sessionSequence: 1,
+				commandPath: "version",
+				flagNames: ["version"],
+				outcome: "success",
+			}),
+			expect.objectContaining({
+				sessionSequence: 2,
+				commandPath: "invalid",
+				flagNames: ["cwd"],
+				outcome: "failure",
+			}),
+		])
+		expect(exported.stdout).not.toContain("/private/value")
+	})
+
 	test("coordinates claims through revision-guarded machine commands", async () => {
 		const root = await createTempDir()
 		tempDirs.push(root)
@@ -642,7 +682,6 @@ exit 23
 			{ name: "opencode-plugin", state: "managed" },
 			{ name: "opencode-tui", state: "managed" },
 			{ name: "opencode-tui-plugin", state: "managed" },
-			{ name: "pi-extension", state: "managed" },
 		])
 
 		const synced = parseJson(
@@ -654,7 +693,6 @@ exit 23
 			{ name: "opencode-plugin", state: "managed", changed: false },
 			{ name: "opencode-tui", state: "managed", changed: false },
 			{ name: "opencode-tui-plugin", state: "managed", changed: false },
-			{ name: "pi-extension", state: "managed", changed: false },
 		])
 	})
 

package/src/commands/init.test.ts

@@ -89,12 +89,9 @@ describe("init command", () => {
 		expect(tuiPlugin).toContain('slashName: "agency-debug"')
 		expect(tuiPlugin).toContain("api.ui.toast")
 		expect(tuiPlugin).not.toContain("chat.message")
-		const piExtension = await Bun.file(
-			join(root, ".pi/extensions/agency-workbase.ts"),
-		).text()
-		expect(piExtension).toContain('pi.on("resources_discover"')
-		expect(piExtension).toContain('pi.on("before_agent_start"')
-		expect(piExtension).toContain("AGENCY_WRITABLE_CHECKOUT")
+		expect(
+			await Bun.file(join(root, ".pi/extensions/agency-workbase.ts")).exists(),
+		).toBe(false)
 	})
 
 	test("preserves existing gitignore entries", async () => {

package/src/commands/integration.test.ts

@@ -51,11 +51,6 @@ describe("integration command", () => {
 					state: "missing",
 					remediation: expect.stringContaining("integration sync"),
 				},
-				{
-					name: "pi-extension",
-					state: "missing",
-					remediation: expect.stringContaining("integration sync"),
-				},
 			],
 		})
 	})
@@ -104,12 +99,7 @@ OpenCode TUI config: missing
 OpenCode /agency-debug: missing
   Path: .opencode/tui/agency-debug.ts
   The managed OpenCode TUI diagnostic companion needs synchronization.
-  Action: Run 'agency integration sync' to install /agency-debug.
-
-Pi workbase extension: missing
-  Path: .pi/extensions/agency-workbase.ts
-  The managed Pi workbase extension needs synchronization.
-  Action: Run 'agency integration sync' to provide workbase context and expose writable-checkout skills in Pi.`)
+  Action: Run 'agency integration sync' to install /agency-debug.`)
 	})
 
 	test("explicitly synchronizes integration files", async () => {
@@ -123,7 +113,6 @@ Pi workbase extension: missing
 			{ name: "opencode-plugin", state: "managed", changed: true },
 			{ name: "opencode-tui", state: "managed", changed: true },
 			{ name: "opencode-tui-plugin", state: "managed", changed: true },
-			{ name: "pi-extension", state: "managed", changed: true },
 		])
 		expect(await Bun.file(join(root, "AGENTS.md")).exists()).toBe(false)
 		expect(await Bun.file(join(root, ".agency/AGENTS.md")).exists()).toBe(true)
@@ -144,9 +133,6 @@ Pi workbase extension: missing
 		expect(
 			await Bun.file(join(root, ".opencode/tui/agency-debug.ts")).exists(),
 		).toBe(true)
-		expect(
-			await Bun.file(join(root, ".pi/extensions/agency-workbase.ts")).exists(),
-		).toBe(true)
 	})
 
 	test("formats integration sync results for people", async () => {
@@ -174,10 +160,6 @@ OpenCode TUI config: synced
 
 OpenCode /agency-debug: synced
   Path: .opencode/tui/agency-debug.ts
-  Agency's managed OpenCode TUI diagnostic companion is current.
-
-Pi workbase extension: synced
-  Path: .pi/extensions/agency-workbase.ts
-  Agency's managed Pi extension provides whole-workbase context and exposes writable-checkout skills.`)
+  Agency's managed OpenCode TUI diagnostic companion is current.`)
 	})
 })