@markjaquith/agency 3.9.2 → 3.9.4

package/package.json

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

package/pi-extensions/agency.ts

@@ -7,10 +7,20 @@ type ExtensionAPI = {
 		args: string[],
 		options: { timeout: number },
 	) => Promise<{ code: number; stdout: string }>
-	on: (
-		name: "resources_discover" | "before_agent_start",
-		handler: (...args: any[]) => unknown,
-	) => void
+	on(name: "session_start", handler: () => void): void
+	on(
+		name: "resources_discover",
+		handler: (event: {
+			cwd: string
+		}) => Promise<{ skillPaths: string[] } | undefined>,
+	): void
+	on(
+		name: "before_agent_start",
+		handler: (
+			event: { systemPrompt: string },
+			ctx: { cwd: string },
+		) => Promise<{ systemPrompt: string } | undefined>,
+	): void
 }
 
 type AgencyContext = {
@@ -80,15 +90,38 @@ const agencyContext = async (
 }
 
 export default function agencyExtension(pi: ExtensionAPI) {
-	const contexts = new Map<string, Promise<AgencyContext | undefined>>()
+	const contexts = new Map<
+		string,
+		{
+			promise: Promise<AgencyContext | undefined>
+			expiresAt: number
+			retryDelay: number
+		}
+	>()
+	// Pi emits session_start for startup, reload, new, resume, and fork.
+	// Resource discovery follows it and must share the same cached lookup.
+	pi.on("session_start", () => contexts.clear())
+
 	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)
+		const previous = contexts.get(key)
+		if (previous && Date.now() < previous.expiresAt) return previous.promise
+
+		const entry = {
+			promise: agencyContext(pi, key)
+				.catch(() => undefined)
+				.then((context) => {
+					entry.retryDelay = context
+						? 0
+						: Math.min((previous?.retryDelay || 500) * 2, 30_000)
+					entry.expiresAt = Date.now() + (context ? 60_000 : entry.retryDelay)
+					return context
+				}),
+			expiresAt: Infinity,
+			retryDelay: 0,
 		}
-		return context
+		contexts.set(key, entry)
+		return entry.promise
 	}
 
 	pi.on("resources_discover", async (event: { cwd: string }) => {

package/scripts/install-pi-extension.ts

@@ -1,25 +1,146 @@
-import { cp, mkdir, rm } from "node:fs/promises"
+import { createHash } from "node:crypto"
+import { constants } from "node:fs"
+import {
+	copyFile,
+	lstat,
+	mkdir,
+	readFile,
+	rm,
+	writeFile,
+} from "node:fs/promises"
 import { homedir } from "node:os"
 import { dirname, join } from "node:path"
 
+const ownershipVersion = 1
+
+type LifecycleResult = {
+	status: "installed" | "updated" | "removed" | "absent" | "skipped"
+	destination: string
+}
+
+type Ownership = {
+	version: typeof ownershipVersion
+	sha256: string
+}
+
 export const piExtensionPath = (home = homedir()) =>
 	join(home, ".pi", "agent", "extensions", "agency.ts")
 
+export const piExtensionOwnershipPath = (destination = piExtensionPath()) =>
+	`${destination}.agency-managed.json`
+
+const digest = (contents: Uint8Array) =>
+	createHash("sha256").update(contents).digest("hex")
+
+const readOwnership = async (
+	destination: string,
+): Promise<Ownership | undefined> => {
+	try {
+		const marker = await lstat(piExtensionOwnershipPath(destination))
+		if (!marker.isFile() || marker.isSymbolicLink()) return
+		const ownership = JSON.parse(
+			await readFile(piExtensionOwnershipPath(destination), "utf8"),
+		) as Partial<Ownership>
+		if (
+			ownership.version === ownershipVersion &&
+			typeof ownership.sha256 === "string"
+		)
+			return ownership as Ownership
+	} catch {
+		return
+	}
+}
+
+const writeOwnership = async (
+	destination: string,
+	sha256: string,
+	exclusive = false,
+) => {
+	await writeFile(
+		piExtensionOwnershipPath(destination),
+		`${JSON.stringify({ version: ownershipVersion, sha256 })}\n`,
+		exclusive ? { flag: "wx" } : undefined,
+	)
+}
+
 export const installPiExtension = async (
 	source = join(import.meta.dir, "..", "pi-extensions", "agency.ts"),
 	destination = piExtensionPath(),
-) => {
+): Promise<LifecycleResult> => {
 	await mkdir(dirname(destination), { recursive: true })
-	await cp(source, destination)
+	const sourceContents = await readFile(source)
+	const sourceDigest = digest(sourceContents)
+
+	try {
+		await copyFile(source, destination, constants.COPYFILE_EXCL)
+		try {
+			await writeOwnership(destination, sourceDigest, true)
+		} catch (error) {
+			await rm(destination, { force: true })
+			if ((error as NodeJS.ErrnoException).code === "EEXIST") {
+				return { status: "skipped", destination }
+			}
+			throw error
+		}
+		return { status: "installed", destination }
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error
+	}
+
+	const ownership = await readOwnership(destination)
+	const destinationFile = await lstat(destination)
+	if (!destinationFile.isFile() || destinationFile.isSymbolicLink()) {
+		return { status: "skipped", destination }
+	}
+	const destinationDigest = digest(await readFile(destination))
+	if (!ownership || ownership.sha256 !== destinationDigest) {
+		return { status: "skipped", destination }
+	}
+
+	await copyFile(source, destination)
+	await writeOwnership(destination, sourceDigest)
+	return { status: "updated", destination }
 }
 
-export const uninstallPiExtension = async (destination = piExtensionPath()) => {
-	await rm(destination, { force: true })
+export const uninstallPiExtension = async (
+	destination = piExtensionPath(),
+): Promise<LifecycleResult> => {
+	const ownership = await readOwnership(destination)
+	let destinationContents: Buffer
+	try {
+		const destinationFile = await lstat(destination)
+		if (!destinationFile.isFile() || destinationFile.isSymbolicLink()) {
+			return { status: "skipped", destination }
+		}
+		destinationContents = await readFile(destination)
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error
+		await rm(piExtensionOwnershipPath(destination), { force: true })
+		return { status: "absent", destination }
+	}
+
+	if (!ownership || ownership.sha256 !== digest(destinationContents)) {
+		return { status: "skipped", destination }
+	}
+
+	await rm(destination)
+	await rm(piExtensionOwnershipPath(destination), { force: true })
+	return { status: "removed", destination }
 }
 
 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}`)
+	const result =
+		command === "install"
+			? await installPiExtension()
+			: command === "uninstall"
+				? await uninstallPiExtension()
+				: undefined
+	if (!result)
+		throw new Error(`Unknown Pi extension lifecycle command: ${command}`)
+	if (result.status === "skipped") {
+		console.warn(
+			`Agency left the existing Pi extension unchanged because it cannot prove ownership: ${result.destination}`,
+		)
+	}
 }

package/src/services/PushService.ts

@@ -5,6 +5,7 @@ import { PhaseService } from "./PhaseService"
 import { TaskService } from "./TaskService"
 import { WorkbaseService } from "./WorkbaseService"
 import { parseGitCommits, type PushCommitMetadata } from "./push-validation"
+import { isDirtyGitStatus } from "./VersionControlService"
 
 type PushCategory =
 	| "precondition"
@@ -374,11 +375,11 @@ const publishGit = (
 		const status = yield* git(
 			fs,
 			checkout,
-			["status", "--porcelain=v1"],
+			["status", "--porcelain=v1", "-z", "--untracked-files=all"],
 			"Failed to inspect Git status",
 			"inspect",
 		)
-		if (status.stdout.length > 0) {
+		if (isDirtyGitStatus(status.stdout)) {
 			return yield* pushError(
 				"Cannot publish a dirty Git worktree; commit or discard changes first",
 				"precondition",

package/src/services/VersionControlService.ts

@@ -58,6 +58,17 @@ export interface VersionControlBackend {
 	) => Effect.Effect<void, unknown, any>
 }
 
+const ignoredUntrackedGitPath = /^(?:.*\/)?\.DS_Store$/
+
+export const isDirtyGitStatus = (output: string): boolean =>
+	(output.includes("\0") ? output.split("\0") : output.split(/\r?\n/)).some(
+		(line) => {
+			if (!line) return false
+			if (!line.startsWith("?? ")) return true
+			return !ignoredUntrackedGitPath.test(line.slice(3))
+		},
+	)
+
 class VersionControlError extends Data.TaggedError("VersionControlError")<{
 	readonly message: string
 }> {}
@@ -267,10 +278,20 @@ export class GitVersionControlService extends Effect.Service<GitVersionControlSe
 					Effect.gen(function* () {
 						const fs = yield* FileSystemService
 						const result = yield* fs.runCommand(
-							["git", "-C", workspacePath, "status", "--porcelain"],
+							[
+								"git",
+								"-C",
+								workspacePath,
+								"status",
+								"--porcelain=v1",
+								"-z",
+								"--untracked-files=all",
+							],
 							{ captureOutput: true },
 						)
-						return result.exitCode === 0 ? result.stdout.length > 0 : null
+						return result.exitCode === 0
+							? isDirtyGitStatus(result.stdout)
+							: null
 					}),
 				fetch: (repositoryPath, remote = "origin", branch) =>
 					Effect.gen(function* () {

package/src/services/WorktreeService.ts

@@ -18,7 +18,10 @@ import type { BaseCommandOptions } from "../utils/command"
 import { createLoggers } from "../utils/effect"
 import { createProgress } from "../utils/progress"
 import { withWorktreeLocks } from "./WorktreeLock"
-import { VersionControlService } from "./VersionControlService"
+import {
+	isDirtyGitStatus,
+	VersionControlService,
+} from "./VersionControlService"
 import type {
 	RegisteredWorkspace,
 	VersionControlBackend,
@@ -75,7 +78,7 @@ interface GitWorktree {
 	readonly branch?: string
 }
 
-const managedWorktreeIgnorePatterns = ["/.worktree.lock"] as const
+const managedWorktreeIgnorePatterns = ["/.worktree.lock", ".DS_Store"] as const
 const vcs = "git" as const
 
 interface WorktreeOwner {
@@ -550,13 +553,21 @@ const inspectExecution = (
 			const status =
 				actual && actualExists
 					? yield* fs.runCommand(
-							["git", "-C", actual.path, "status", "--porcelain"],
+							[
+								"git",
+								"-C",
+								actual.path,
+								"status",
+								"--porcelain=v1",
+								"-z",
+								"--untracked-files=all",
+							],
 							{ captureOutput: true },
 						)
 					: null
 			const dirty = status
 				? status.exitCode === 0
-					? status.stdout.length > 0
+					? isDirtyGitStatus(status.stdout)
 					: null
 				: null
 			const expectedRef = "branch" in checkout ? checkout.branch : checkout.ref
@@ -2076,7 +2087,15 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 							}
 							if (checkoutExists) {
 								const status = yield* fs.runCommand(
-									["git", "-C", checkoutPath, "status", "--porcelain"],
+									[
+										"git",
+										"-C",
+										checkoutPath,
+										"status",
+										"--porcelain=v1",
+										"-z",
+										"--untracked-files=all",
+									],
 									{ captureOutput: true },
 								)
 								if (status.exitCode !== 0) {
@@ -2084,7 +2103,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 										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()) {
+								if (isDirtyGitStatus(status.stdout)) {
 									return yield* new WorktreeError({
 										message: `Failed to remove worktree for '${alias}': checkout has uncommitted changes`,
 									})