@markjaquith/agency 3.9.3 → 3.9.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "3.9.3",
+  "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}`,
+		)
+	}
 }