portable-agent-layer 0.96.0 → 0.97.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portable-agent-layer",
-  "version": "0.96.0",
+  "version": "0.97.0",
   "description": "PAL — Portable Agent Layer: persistent personal context for AI coding assistants",
   "type": "module",
   "bin": {
@@ -37,7 +37,7 @@
   },
   "scripts": {
     "type-check": "tsc --noEmit",
-    "test": "bun test --randomize --isolate",
+    "test": "bun .agents/scripts/test.ts",
     "test:mutate": "stryker run",
     "test:mutate:diff": "bun .agents/scripts/mutate-diff.ts",
     "format": "biome format",

package/src/cli/install-flow.ts

@@ -198,8 +198,8 @@ async function finishShared(docs: number): Promise<Done> {
  */
 async function refreshControlRoom(): Promise<Done | null> {
   const { isRepoMode } = await import("../hooks/handlers/update-check");
-  const { buildPage } = await import("../tools/control-room/static");
-  const rebuilt = isRepoMode() ? buildPage() : null;
+  const { refreshPage } = await import("../tools/control-room/static");
+  const rebuilt = refreshPage(isRepoMode());
   if (rebuilt === false)
     return {
       detail: ["page not rebuilt"],

package/src/hooks/lib/invocation-context.ts

@@ -15,6 +15,7 @@ import { latestUserRequest } from "./antigravity-transcript";
 import { autoUpdateOnStart } from "./auto-update";
 import { regenerateIfNeeded } from "./claude-md";
 import { buildSystemReminder } from "./context";
+import { startHookTiming } from "./hook-timing";
 import { type HookTurnPayload, hookSessionId } from "./hook-turn";
 import { logContextSnapshot, logError, logPromptSnapshot } from "./log";
 import { paths } from "./paths";
@@ -89,11 +90,18 @@ export async function invocationContext(
   const prompt = latestUserRequest(payload.transcriptPath);
   if (prompt === null) return null;
 
+  const timing = startHookTiming("prompt");
+  const sessionContext = claimConversationStart(conversationId)
+    ? await timing.time("session-context", sessionStartReminder)
+    : null;
   const parts = [
-    claimConversationStart(conversationId) ? sessionStartReminder() : null,
-    await promptReminder(prompt, conversationId),
+    sessionContext,
+    await timing.time("inject-context", () => promptReminder(prompt, conversationId)),
   ].filter((part): part is string => Boolean(part));
-  await capturePrompt(prompt, conversationId, sentAt, "InvocationContext");
+  await timing.time("capture", () =>
+    capturePrompt(prompt, conversationId, sentAt, "InvocationContext")
+  );
+  timing.log(conversationId);
 
   return parts.length > 0 ? injectedStep(parts.join("\n\n")) : null;
 }

package/src/hooks/lib/opencode-events.ts

@@ -25,7 +25,26 @@ interface OpencodePermissionReply {
   reply?: string;
 }
 
+interface OpencodeToolPart {
+  type?: string;
+  callID?: string;
+  sessionID?: string;
+  tool?: string;
+  state?: {
+    status?: string;
+    input?: unknown;
+    error?: string;
+    time?: { start?: number; end?: number };
+  };
+}
+
+// opencode's PermissionV1 error messages: RejectedError / CorrectedError for a
+// prompt the user refused, DeniedError for a configured rule.
+const USER_REJECTED = "The user rejected permission";
+const RULE_DENIED = "The user has specified a rule which prevents";
+
 const askedTools = new Map<string, string>();
+const loggedFailures = new Set<string>();
 
 export function logOpencodeSessionCreated(session: OpencodeSession | undefined): void {
   if (!session?.id || session.parentID) return;
@@ -57,3 +76,33 @@ export function logOpencodePermissionReply(reply: OpencodePermissionReply): void
     session_id: reply.sessionID,
   });
 }
+
+function durationOf(part: OpencodeToolPart): number | null {
+  const { start, end } = part.state?.time ?? {};
+  return start !== undefined && end !== undefined ? end - start : null;
+}
+
+function firstFailureOf(part: OpencodeToolPart | undefined): part is OpencodeToolPart {
+  if (part?.type !== "tool" || part.state?.status !== "error" || !part.callID)
+    return false;
+  if (loggedFailures.has(part.callID)) return false;
+  loggedFailures.add(part.callID);
+  return true;
+}
+
+/** A tool that threw never reaches tool.execute.after; its part turning to error is the only trace. */
+export function logOpencodeToolFailure(part: OpencodeToolPart | undefined): void {
+  if (!firstFailureOf(part)) return;
+  const error = part.state?.error ?? "";
+  if (error.startsWith(USER_REJECTED)) return;
+  logToolCall({
+    hook_event_name: error.startsWith(RULE_DENIED)
+      ? "PermissionDenied"
+      : "PostToolUseFailure",
+    tool_name: part.tool,
+    tool_input: part.state?.input,
+    session_id: part.sessionID,
+    error,
+    duration_ms: durationOf(part),
+  });
+}

package/src/targets/opencode/plugin.ts

@@ -69,6 +69,7 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
     logOpencodeCompaction,
     logOpencodePermissionReply,
     logOpencodeSessionCreated,
+    logOpencodeToolFailure,
     rememberAskedTool,
   } = await lib<typeof import("../../hooks/lib/opencode-events")>("opencode-events.ts");
   const { captureSessionName } = await lib<
@@ -153,6 +154,8 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
         logOpencodeCompaction(event.properties.sessionID);
       if (event.type === "permission.replied")
         logOpencodePermissionReply(event.properties);
+      if (event.type === "message.part.updated")
+        logOpencodeToolFailure(event.properties.part);
 
       if (event.type === "session.created" || event.type === "session.updated") {
         const { regenerateIfNeeded } =

package/src/tools/control-room/static.ts

@@ -5,35 +5,110 @@
  */
 
 import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 import { isInside } from "../../hooks/lib/paths";
 
-const UI_DIST = resolve(import.meta.dir, "ui", "dist");
+const REPO_ROOT = resolve(import.meta.dir, "..", "..", "..");
+const UI_ROOT = resolve(import.meta.dir, "ui");
+const UI_DIST = resolve(UI_ROOT, "dist");
+const UI_INDEX = resolve(UI_DIST, "index.html");
+export const ABANDONED_LOCK_MS = 120_000;
 
 export const BUILD_COMMAND = "bun run build:ui";
 
+/** Where the page is built from and to, and how; tests point it at a sandbox. */
+export interface PageBuild {
+  sources: string;
+  lockfile: string;
+  dist: string;
+  lock: string;
+  build: () => boolean;
+}
+
+const THE_PAGE: PageBuild = {
+  sources: resolve(REPO_ROOT, "src"),
+  lockfile: resolve(REPO_ROOT, "bun.lock"),
+  dist: UI_DIST,
+  lock: resolve(UI_ROOT, "dist.lock"),
+  build: runViteBuild,
+};
+
 export function isBuilt(): boolean {
-  return existsSync(resolve(UI_DIST, "index.html"));
+  return existsSync(UI_INDEX);
 }
 
-/**
- * A clone has vite; a published install has the prepacked dist and never needs
- * it. Either way the page is there by the time the server answers.
- */
-export function buildPage(): boolean {
-  const repoRoot = resolve(import.meta.dir, "..", "..", "..");
+function newestSourceChange(page: PageBuild): number {
+  const sources = readdirSync(page.sources, { recursive: true, withFileTypes: true })
+    .filter((entry) => entry.isFile() && !isInside(page.dist, entry.parentPath))
+    .map((entry) => resolve(entry.parentPath, entry.name));
+  if (existsSync(page.lockfile)) sources.push(page.lockfile);
+  return Math.max(...sources.map((file) => statSync(file).mtimeMs));
+}
+
+export function isUpToDate(page: PageBuild = THE_PAGE): boolean {
+  const index = resolve(page.dist, "index.html");
+  return existsSync(index) && statSync(index).mtimeMs >= newestSourceChange(page);
+}
+
+function clearAbandonedLock(lock: string): void {
+  try {
+    if (Date.now() - statSync(lock).mtimeMs > ABANDONED_LOCK_MS)
+      rmSync(lock, { recursive: true, force: true });
+  } catch {}
+}
+
+function tryTakeBuildLock(lock: string): boolean {
+  try {
+    mkdirSync(lock);
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "EEXIST") return false;
+    throw error;
+  }
+}
+
+function whileHoldingBuildLock(lock: string, build: () => boolean): boolean {
+  while (!tryTakeBuildLock(lock)) {
+    clearAbandonedLock(lock);
+    Bun.sleepSync(50);
+  }
+  try {
+    return build();
+  } finally {
+    rmSync(lock, { recursive: true, force: true });
+  }
+}
+
+/** A clone has vite; a published install has the prepacked dist and never needs it. */
+function runViteBuild(): boolean {
   // node_modules/.bin/vite is a shell shim that Windows cannot spawn directly;
   // the package's own JS entry runs the same build under any runtime.
-  const vite = resolve(repoRoot, "node_modules", "vite", "bin", "vite.js");
+  const vite = resolve(REPO_ROOT, "node_modules", "vite", "bin", "vite.js");
   if (!existsSync(vite)) return false;
   const built = spawnSync(process.execPath, [vite, "build"], {
-    cwd: resolve(import.meta.dir, "ui"),
+    cwd: UI_ROOT,
     encoding: "utf-8",
   });
   return built.status === 0 && isBuilt();
 }
 
+/**
+ * vite empties dist before writing it, so one build at a time, and none once
+ * another process has already brought it up to date.
+ */
+export function buildPage(page: PageBuild = THE_PAGE): boolean {
+  return whileHoldingBuildLock(page.lock, () => isUpToDate(page) || page.build());
+}
+
+/** A checkout's dist is whatever was built last, so an install rebuilds it if the sources moved on. */
+export function refreshPage(
+  inCheckout: boolean,
+  page: PageBuild = THE_PAGE
+): boolean | null {
+  return inCheckout && !isUpToDate(page) ? buildPage(page) : null;
+}
+
 function unbuiltPage(): Response {
   return new Response(
     `<!doctype html><meta charset="utf-8"><title>PAL control room</title>` +