portable-agent-layer 0.88.1 → 0.89.1

package/src/hooks/lib/semi-static.ts

@@ -3,7 +3,7 @@
  *
  * One entry here = the only change needed to add a new source across all consumers:
  * CLAUDE.md @imports, opencode instructions[], Cursor .mdc, Copilot .instructions.md,
- * and the session-stop digest writer.
+ * Antigravity plugin rules, and the session-stop digest writer.
  */
 
 import { existsSync, readFileSync } from "node:fs";
@@ -22,9 +22,9 @@ interface SemiStaticSource {
   readonly writesDigest: boolean;
   /** Returns current content — builds fresh when writesDigest is true, reads the file otherwise. */
   load(): string;
-  /** Slug for ~/.cursor/rules/pal-${slug}.mdc and ~/.copilot/instructions/pal-${slug}.instructions.md */
+  /** Slug for the pal-${slug} rule/instruction files written for Cursor, Copilot and Antigravity. */
   readonly slug: string;
-  /** Human-readable description for Cursor .mdc frontmatter. */
+  /** Human-readable description for Cursor .mdc and Antigravity rule frontmatter. */
   readonly description: string;
 }
 
@@ -38,6 +38,16 @@ export function copilotFilename(src: SemiStaticSource): string {
   return `pal-${src.slug}.instructions.md`;
 }
 
+/** Returns the Antigravity plugin rule filename for a source. */
+export function antigravityFilename(src: SemiStaticSource): string {
+  return `pal-${src.slug}.md`;
+}
+
+/** An Antigravity rule file; a rule without a valid `trigger` is silently discarded. */
+export function antigravityRule(description: string, content: string): string {
+  return `---\ntrigger: always_on\ndescription: ${description}\n---\n\n${content}`;
+}
+
 function readFileSafe(path: string): string {
   try {
     if (!existsSync(path)) return "";

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

@@ -7,6 +7,8 @@
  * context for weeks — and none of it was reachable from a test.
  */
 
+import type { AgentName } from "./agent-registry";
+
 export interface ContextEnvelope {
   /** Whether the agent parses stdout as JSON or reads it as raw text. */
   kind: "json" | "text";
@@ -31,7 +33,7 @@ export type SessionStartContext = "full" | "without-handoff" | "none";
  * is resumed. Copilot does not document it, and has shipped a release that
  * dropped startup context, so it keeps getting the full context on resume.
  */
-const RESUME_KEEPS_CONTEXT: ReadonlySet<string> = new Set(["claude", "codex"]);
+const RESUME_KEEPS_CONTEXT: ReadonlySet<string> = new Set<AgentName>(["claude", "codex"]);
 
 /**
  * After a compaction, CompactRecover restores the last exchange, so the

package/src/hooks/lib/stop.ts

@@ -43,6 +43,7 @@ export interface StopTurnPayload extends HookTurnPayload {
   transcriptPath?: string | null;
   stop_hook_active?: boolean;
   loop_count?: number;
+  executionNum?: number;
 }
 
 type Transcript = ReturnType<typeof readTranscriptFile>;

package/src/hooks/lib/transcript.ts

@@ -4,6 +4,7 @@
  */
 
 import { readFileSync } from "node:fs";
+import { antigravityMessage } from "./antigravity-transcript";
 
 interface Message {
   role: string;
@@ -61,7 +62,8 @@ function codexMessage(payload: CodexPayload | undefined): Message | null {
 // Claude Code tags transcript lines `type: "user"|"assistant"` with the text
 // under `message.content`. VS Code Copilot's own event log instead uses
 // `type: "user.message"|"assistant.message"` with a flat `data.content`
-// string. Codex nests each message as a `response_item` payload.
+// string. Codex nests each message as a `response_item` payload. Antigravity
+// writes one step per line, `type: "USER_INPUT"|"PLANNER_RESPONSE"|…`.
 function parseTranscriptEntry(entry: {
   type?: string;
   message?: { content?: unknown };
@@ -78,14 +80,15 @@ function parseTranscriptEntry(entry: {
     const role = entry.type === "user.message" ? "user" : "assistant";
     return typeof text === "string" && text ? { role, content: text } : null;
   }
-  return null;
+  return antigravityMessage(entry);
 }
 
 /**
  * Read an agent transcript JSONL file and extract user/assistant messages.
  * Supports Claude Code's `{type:"user"|"assistant", message:{content}}` shape
  * VS Code Copilot's `{type:"user.message"|"assistant.message", data:{content}}` shape,
- * and Codex's `{type:"response_item", payload:{type:"message", role, content}}` shape.
+ * Codex's `{type:"response_item", payload:{type:"message", role, content}}` shape,
+ * and Antigravity's `{type:"USER_INPUT"|"PLANNER_RESPONSE", source, content}` steps.
  */
 export function readTranscriptFile(path: string): Message[] {
   try {

package/src/targets/agent-render.ts

@@ -5,17 +5,17 @@
 
 import {
   type AgentDefinition,
-  type AgentPlatform,
   parseAgentDefinition,
 } from "../hooks/lib/agent-definition";
+import type { AgentName } from "../hooks/lib/agent-registry";
 
 const CODEX_OWNED_KEYS = new Set(["name", "description", "developer_instructions"]);
 
-export function agentFileName(stem: string, platform: AgentPlatform): string {
+export function agentFileName(stem: string, platform: AgentName): string {
   return `${stem}.${platform === "codex" ? "toml" : "md"}`;
 }
 
-export function renderAgentForPlatform(content: string, platform: AgentPlatform): string {
+export function renderAgentForPlatform(content: string, platform: AgentName): string {
   const definition = parseAgentDefinition(content);
   if (platform === "codex") return renderCodexAgent(definition);
   if (!definition.hasFrontmatter) return content;

package/src/targets/antigravity/install.ts

@@ -0,0 +1,68 @@
+/**
+ * PAL — Antigravity CLI target installer
+ * Rules, hooks, skills and subagents live in one plugin, ~/.gemini/config/plugins/pal/.
+ * A plugin cannot carry permissions or a status line, so the command allowlist and
+ * the statusLine are merged into agy's settings.json; the user's own hooks.json is
+ * never touched.
+ */
+
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { skillsDirOf } from "../../hooks/lib/agent-registry";
+import { ensureAntigravityRule } from "../../hooks/lib/claude-md";
+import { assets, palPkg, platform } from "../../hooks/lib/paths";
+import {
+  addStatuslineConfig,
+  copyAgentsForAntigravity,
+  copySkills,
+  copyStatusline,
+  countSkills,
+  loadHooksTemplate,
+  loadSettingsTemplate,
+  log,
+  mergeSettings,
+  nativeAgentsDir,
+  readJson,
+  writeJson,
+} from "../lib";
+
+const PLUGIN_DIR = platform.antigravityPluginDir();
+
+mkdirSync(PLUGIN_DIR, { recursive: true });
+writeJson(resolve(PLUGIN_DIR, "plugin.json"), {
+  name: "pal",
+  description: "Portable Agent Layer — personal context, skills and hooks",
+});
+log.success(`PAL plugin → ${PLUGIN_DIR}`);
+
+ensureAntigravityRule();
+log.success(
+  "PAL instructions → rules/pal.md (context rules follow from the shared digests)"
+);
+
+const PKG_ROOT = palPkg().replaceAll("\\", "/");
+writeJson(
+  resolve(PLUGIN_DIR, "hooks.json"),
+  loadHooksTemplate(assets.antigravityHooksTemplate(), PKG_ROOT, "Antigravity CLI")
+);
+log.success("PAL hooks → hooks.json");
+
+const SETTINGS = platform.antigravitySettings();
+mkdirSync(dirname(SETTINGS), { recursive: true });
+if (existsSync(SETTINGS)) copyFileSync(SETTINGS, `${SETTINGS}.bak.${Date.now()}`);
+writeJson(
+  SETTINGS,
+  addStatuslineConfig(
+    mergeSettings(
+      readJson(SETTINGS, {}),
+      loadSettingsTemplate(assets.antigravitySettingsTemplate(), PKG_ROOT)
+    ),
+    "antigravity"
+  )
+);
+log.success("PAL command allowlist and statusLine → antigravity-cli/settings.json");
+copyStatusline("antigravity");
+
+copySkills(skillsDirOf("antigravity"));
+const agentCount = copyAgentsForAntigravity(nativeAgentsDir("antigravity"));
+log.success(`${countSkills()} skills · ${agentCount} agents → ${PLUGIN_DIR}`);

package/src/targets/antigravity/uninstall.ts

@@ -0,0 +1,66 @@
+/**
+ * PAL — Antigravity CLI uninstaller
+ * Removes the PAL plugin, ~/.gemini/config/plugins/pal/, exactly the allowlist
+ * entries PAL merged into agy's settings.json, and PAL's statusLine and script. Skill links are unlinked first so
+ * removing the folder never walks into the skills they point at.
+ */
+
+import {
+  copyFileSync,
+  existsSync,
+  lstatSync,
+  readdirSync,
+  rmSync,
+  unlinkSync,
+} from "node:fs";
+import { resolve } from "node:path";
+import { skillsDirOf } from "../../hooks/lib/agent-registry";
+import { assets, palPkg, platform } from "../../hooks/lib/paths";
+import {
+  loadSettingsTemplate,
+  log,
+  readJson,
+  removeStatusline,
+  removeStatuslineConfig,
+  unmergeSettings,
+  writeJson,
+} from "../lib";
+
+function unlinkSkillLinks(dir: string): string[] {
+  if (!existsSync(dir)) return [];
+  const links = readdirSync(dir).filter((name) =>
+    lstatSync(resolve(dir, name)).isSymbolicLink()
+  );
+  for (const name of links) unlinkSync(resolve(dir, name));
+  return links;
+}
+
+const PLUGIN_DIR = platform.antigravityPluginDir();
+
+if (existsSync(PLUGIN_DIR)) {
+  const removed = unlinkSkillLinks(skillsDirOf("antigravity"));
+  rmSync(PLUGIN_DIR, { recursive: true, force: true });
+  log.success(`Removed the PAL plugin and ${removed.length} skill link(s)`);
+} else {
+  log.info("No PAL plugin found");
+}
+
+const SETTINGS = platform.antigravitySettings();
+if (existsSync(SETTINGS)) {
+  copyFileSync(SETTINGS, `${SETTINGS}.bak.${Date.now()}`);
+  const template = loadSettingsTemplate(
+    assets.antigravitySettingsTemplate(),
+    palPkg().replaceAll("\\", "/")
+  );
+  writeJson(
+    SETTINGS,
+    removeStatuslineConfig(
+      unmergeSettings(readJson(SETTINGS, {}), template),
+      "antigravity"
+    )
+  );
+  log.success(
+    "Removed the PAL command allowlist and statusLine from antigravity-cli/settings.json"
+  );
+}
+removeStatusline("antigravity");

package/src/targets/lib.ts

@@ -18,8 +18,13 @@ import {
 } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, resolve, sep } from "node:path";
-import { AGENT_PLATFORMS, type AgentPlatform } from "../hooks/lib/agent-definition";
-import { assets, palHome, platform } from "../hooks/lib/paths";
+import {
+  AGENT_NAMES,
+  AGENT_REGISTRY,
+  type AgentName,
+  skillsDirOf,
+} from "../hooks/lib/agent-registry";
+import { agentDirOverrides, assets, palHome, platform } from "../hooks/lib/paths";
 import { declaredTriggers } from "../hooks/lib/skill-triggers";
 import { agentFileName, renderAgentForPlatform } from "./agent-render";
 
@@ -844,20 +849,10 @@ function pruneStaleSkillLinks(agentSkillsDir: string): string[] {
   return removed;
 }
 
-/**
- * Agent skills directories that need a per-skill discovery link.
- *
- * opencode is intentionally absent: it discovers the whole ~/.pal/skills/ tree
- * via the ~/.agents/skills → ~/.pal/skills symlink, so any personal skill is
- * picked up without a per-skill link.
- */
 function perSkillAgentDirs(): { agent: string; dir: string }[] {
-  return [
-    { agent: "claude", dir: resolve(platform.claudeDir(), "skills") },
-    { agent: "cursor", dir: resolve(platform.cursorDir(), "skills") },
-    { agent: "copilot", dir: resolve(platform.copilotDir(), "skills") },
-    { agent: "codex", dir: resolve(platform.codexDir(), "skills") },
-  ];
+  return AGENT_NAMES.filter(
+    (agent) => AGENT_REGISTRY[agent].skills === "own-skills-dir"
+  ).map((agent) => ({ agent, dir: skillsDirOf(agent) }));
 }
 
 /**
@@ -890,15 +885,9 @@ export function linkPersonalSkill(name: string): string[] {
  * PAL_*_DIR vars at a sandbox silently rewires their real setup.
  */
 function realAgentRoots(): string[] {
-  const h = homedir();
   return [
-    resolve(h, ".pal"),
-    resolve(h, ".claude"),
-    resolve(h, ".cursor"),
-    resolve(h, ".copilot"),
-    resolve(h, ".codex"),
-    resolve(h, ".agents"),
-    resolve(h, ".config", "opencode"),
+    resolve(homedir(), ".pal"),
+    ...agentDirOverrides().map(({ realDir }) => realDir),
   ];
 }
 
@@ -917,8 +906,9 @@ function assertInsideTestSandbox(link: string): void {
   if (!escaped) return;
   throw new Error(
     `Refusing to write ${link}: outside the test sandbox (${escaped} is a real agent directory). ` +
-      "Point PAL_CLAUDE_DIR, PAL_CURSOR_DIR, PAL_COPILOT_DIR, PAL_CODEX_DIR, " +
-      "PAL_OPENCODE_DIR and PAL_AGENTS_DIR at a temp directory in this test."
+      `Point ${agentDirOverrides()
+        .map(({ env }) => env)
+        .join(", ")} at a temp directory in this test.`
   );
 }
 
@@ -1044,7 +1034,7 @@ const shippedAgentSource = (stem: string) =>
   readFileSync(resolve(assets.agents(), `${stem}.md`), "utf-8");
 
 /** Install agents for a platform into a target directory. Always overwrites. */
-function installAgents(targetDir: string, platform: AgentPlatform): number {
+function installAgents(targetDir: string, platform: AgentName): number {
   if (!existsSync(assets.agents())) return 0;
 
   mkdirSync(targetDir, { recursive: true });
@@ -1064,7 +1054,7 @@ function installAgents(targetDir: string, platform: AgentPlatform): number {
 }
 
 /** Shipped agents in targetDir that differ from what installAgents would write there. */
-export function staleShippedAgents(targetDir: string, agent: AgentPlatform): string[] {
+export function staleShippedAgents(targetDir: string, agent: AgentName): string[] {
   if (!existsSync(assets.agents())) return [];
   const isStale = (stem: string) => {
     const installed = resolve(targetDir, agentFileName(stem, agent));
@@ -1078,7 +1068,7 @@ export function staleShippedAgents(targetDir: string, agent: AgentPlatform): str
 }
 
 /** Remove PAL agents from a directory. */
-function uninstallAgents(targetDir: string, platform: AgentPlatform): string[] {
+function uninstallAgents(targetDir: string, platform: AgentName): string[] {
   if (!existsSync(assets.agents())) return [];
 
   const removed: string[] = [];
@@ -1113,6 +1103,10 @@ export function copyAgentsForCodex(codexAgentsDir: string): number {
   return installAgents(codexAgentsDir, "codex");
 }
 
+export function copyAgentsForAntigravity(pluginAgentsDir: string): number {
+  return installAgents(pluginAgentsDir, "antigravity");
+}
+
 export function removeAgentsFromCursor(cursorAgentsDir: string): string[] {
   return uninstallAgents(cursorAgentsDir, "cursor");
 }
@@ -1138,20 +1132,13 @@ const palAgentsStore = () => resolve(palHome(), "agents");
  * written into. An agent counts as installed when its agents directory already
  * exists (mirrors linkPersonalSkill's per-agent gate).
  */
-function personalSubagentTargets(): { agent: AgentPlatform; dir: string }[] {
-  return AGENT_PLATFORMS.map((agent) => ({ agent, dir: nativeAgentsDir(agent) }));
+function personalSubagentTargets(): { agent: AgentName; dir: string }[] {
+  return AGENT_NAMES.map((agent) => ({ agent, dir: nativeAgentsDir(agent) }));
 }
 
 /** The directory each agent reads its subagent definitions from. */
-export function nativeAgentsDir(agent: AgentPlatform): string {
-  const home = {
-    claude: platform.claudeDir,
-    opencode: platform.opencodeDir,
-    cursor: platform.cursorDir,
-    copilot: platform.copilotDir,
-    codex: platform.codexDir,
-  }[agent];
-  return resolve(home(), "agents");
+export function nativeAgentsDir(agent: AgentName): string {
+  return resolve(AGENT_REGISTRY[agent].home(), "agents");
 }
 
 /** Names of the subagents PAL ships (assets/agents/*.md). */
@@ -1203,7 +1190,7 @@ export function installPersonalSubagent(name: string): string[] {
   return renders.map(({ agent }) => agent);
 }
 
-function renderForPersonalSubagent(content: string, agent: AgentPlatform): string {
+function renderForPersonalSubagent(content: string, agent: AgentName): string {
   try {
     return renderAgentForPlatform(content, agent);
   } catch (e) {
@@ -1211,8 +1198,12 @@ function renderForPersonalSubagent(content: string, agent: AgentPlatform): strin
   }
 }
 
-/** Load and resolve the Copilot hooks template, substituting PKG_ROOT */
-export function loadCopilotHooksTemplate(templatePath: string, pkgRoot: string): unknown {
+/** Any agent's hooks template with PKG_ROOT filled in, parsed. */
+export function loadHooksTemplate(
+  templatePath: string,
+  pkgRoot: string,
+  agentLabel: string
+): unknown {
   const resolved = readFileSync(templatePath, "utf-8").replaceAll(
     "{{PKG_ROOT}}",
     pkgRoot
@@ -1220,37 +1211,64 @@ export function loadCopilotHooksTemplate(templatePath: string, pkgRoot: string):
   try {
     return JSON.parse(resolved);
   } catch (e) {
-    throw new Error(`Failed to parse Copilot hooks template at ${templatePath}: ${e}`);
+    throw new Error(
+      `Failed to parse ${agentLabel} hooks template at ${templatePath}: ${e}`
+    );
   }
 }
 
+/** Load and resolve the Copilot hooks template, substituting PKG_ROOT */
+export function loadCopilotHooksTemplate(templatePath: string, pkgRoot: string): unknown {
+  return loadHooksTemplate(templatePath, pkgRoot, "Copilot");
+}
+
 // --- Statusline ---
 
-export type StatuslineTarget = "claude" | "cursor";
+export type StatuslineTarget = Extract<AgentName, "claude" | "cursor" | "antigravity">;
+
+interface StatuslineSlot {
+  dir: () => string;
+  /** The script path as the agent's own config spells it, without the extension. */
+  script: string;
+  powershellFlags: string;
+  extra?: Record<string, unknown>;
+}
+
+const STATUSLINE: Record<StatuslineTarget, StatuslineSlot> = {
+  claude: {
+    dir: platform.claudeDir,
+    script: "~/.claude/statusline",
+    powershellFlags: "-NoProfile -ExecutionPolicy Bypass",
+  },
+  cursor: {
+    dir: platform.cursorDir,
+    script: "~/.cursor/statusline",
+    powershellFlags: "-NoProfile",
+    extra: { updateIntervalMs: 300, timeoutMs: 2000 },
+  },
+  antigravity: {
+    dir: platform.antigravityCliDir,
+    script: "~/.gemini/antigravity-cli/statusline",
+    powershellFlags: "-NoProfile -ExecutionPolicy Bypass",
+  },
+};
 
 function statuslineAgentDir(target: StatuslineTarget): string {
-  return target === "claude" ? platform.claudeDir() : platform.cursorDir();
+  return STATUSLINE[target].dir();
 }
 
 function statuslineCommand(target: StatuslineTarget): string {
-  const isPlatformWin32 = process.platform === "win32";
-  if (target === "cursor") {
-    return isPlatformWin32
-      ? "powershell -NoProfile -File ~/.cursor/statusline.ps1"
-      : "~/.cursor/statusline.sh";
-  }
-  return isPlatformWin32
-    ? "powershell -NoProfile -ExecutionPolicy Bypass -File ~/.claude/statusline.ps1"
-    : "~/.claude/statusline.sh";
+  const { script, powershellFlags } = STATUSLINE[target];
+  return process.platform === "win32"
+    ? `powershell ${powershellFlags} -File ${script}.ps1`
+    : `${script}.sh`;
 }
 
 function isPalStatuslineCommand(cmd: string, target: StatuslineTarget): boolean {
-  return target === "claude"
-    ? cmd.includes(".claude/statusline")
-    : cmd.includes(".cursor/statusline");
+  return cmd.includes(STATUSLINE[target].script.slice(2));
 }
 
-/** Copy statusline script to ~/.claude/ or ~/.cursor/ for the current platform */
+/** Copy the statusline script into the agent's config dir for the current platform */
 export function copyStatusline(target: StatuslineTarget = "claude"): boolean {
   const agentDir = statuslineAgentDir(target);
   mkdirSync(agentDir, { recursive: true });
@@ -1282,7 +1300,7 @@ export function copyStatusline(target: StatuslineTarget = "claude"): boolean {
   }
 }
 
-/** Remove statusline script from ~/.claude/ or ~/.cursor/ */
+/** Remove the statusline script from the agent's config dir */
 export function removeStatusline(target: StatuslineTarget = "claude"): boolean {
   const isPlatformWin32 = process.platform === "win32";
   const scriptName = isPlatformWin32 ? "statusline.ps1" : "statusline.sh";
@@ -1333,8 +1351,7 @@ export function addStatuslineConfig(
       if (!claudeStatuslineNeedsRefresh(cmd)) {
         return settings;
       }
-    } else if (!isPalStatuslineCommand(cmd, "cursor")) {
-      // Cursor: preserve user-defined statusLine commands
+    } else if (!isPalStatuslineCommand(cmd, target)) {
       return settings;
     }
   }
@@ -1344,13 +1361,13 @@ export function addStatuslineConfig(
     type: "command",
     command,
     padding: 2,
-    ...(target === "cursor" ? { updateIntervalMs: 300, timeoutMs: 2000 } : {}),
+    ...STATUSLINE[target].extra,
   };
 
   return settings;
 }
 
-/** Remove statusLine config from settings (PAL-owned only for Cursor) */
+/** Remove statusLine config from settings (PAL-owned only, except for Claude) */
 export function removeStatuslineConfig(
   settings: Record<string, unknown>,
   target: StatuslineTarget = "claude"
@@ -1366,7 +1383,7 @@ export function removeStatuslineConfig(
   }
 
   const cmd = statusLine.command as string | undefined;
-  if (cmd && isPalStatuslineCommand(cmd, "cursor")) {
+  if (cmd && isPalStatuslineCommand(cmd, target)) {
     delete settings.statusLine;
   }
   return settings;

package/src/targets/opencode/install.ts

@@ -8,6 +8,7 @@ import { resolve } from "node:path";
 import { palPkg, platform } from "../../hooks/lib/paths";
 import { getSemiStaticSources } from "../../hooks/lib/semi-static";
 import { copyAgentsForOpencode, copySkills, countSkills, log, writeJson } from "../lib";
+import { allowPalHome, palHomePattern } from "./permission";
 
 const PKG_ROOT = palPkg();
 const OC_GLOBAL_DIR = platform.opencodeDir();
@@ -63,4 +64,5 @@ const existingInstructions = Array.isArray(ocConfig.instructions)
   ? (ocConfig.instructions as string[])
   : [];
 ocConfig.instructions = [...new Set([...existingInstructions, ...staticFiles])];
+ocConfig = allowPalHome(ocConfig, palHomePattern());
 writeFileSync(configPath, `${JSON.stringify(ocConfig, null, 2)}\n`, "utf-8");

package/src/targets/opencode/permission.ts

@@ -0,0 +1,39 @@
+import { palHome } from "../../hooks/lib/paths";
+
+type OpencodeConfig = Record<string, unknown>;
+type Rules = Record<string, string>;
+
+export function palHomePattern(): string {
+  return `${palHome().replaceAll("\\", "/")}/**`;
+}
+
+function externalDirectoryRules(config: OpencodeConfig): Rules {
+  const permission = (config.permission ?? {}) as Record<string, unknown>;
+  const rules = permission.external_directory;
+  if (typeof rules === "string") return { "*": rules };
+  return { ...((rules ?? {}) as Rules) };
+}
+
+function withExternalDirectoryRules(
+  config: OpencodeConfig,
+  rules: Rules
+): OpencodeConfig {
+  const permission = { ...((config.permission ?? {}) as Record<string, unknown>) };
+  if (Object.keys(rules).length > 0) permission.external_directory = rules;
+  else delete permission.external_directory;
+  const { permission: _previous, ...rest } = config;
+  return Object.keys(permission).length > 0 ? { ...rest, permission } : rest;
+}
+
+export function allowPalHome(config: OpencodeConfig, pattern: string): OpencodeConfig {
+  const { [pattern]: _previous, ...rules } = externalDirectoryRules(config);
+  return withExternalDirectoryRules(config, { ...rules, [pattern]: "allow" });
+}
+
+export function removePalHomeAllow(
+  config: OpencodeConfig,
+  pattern: string
+): OpencodeConfig {
+  const { [pattern]: _removed, ...rules } = externalDirectoryRules(config);
+  return withExternalDirectoryRules(config, rules);
+}

package/src/targets/opencode/uninstall.ts

@@ -8,6 +8,7 @@ import { resolve } from "node:path";
 import { platform } from "../../hooks/lib/paths";
 import { getSemiStaticSources } from "../../hooks/lib/semi-static";
 import { log, removeAgentsFromOpencode, removePalDocs, removeSkills } from "../lib";
+import { palHomePattern, removePalHomeAllow } from "./permission";
 
 const OC_GLOBAL_DIR = platform.opencodeDir() || "";
 
@@ -58,14 +59,14 @@ try {
   /* gone */
 }
 
-// --- Remove PAL entries from config.json instructions[] ---
+// --- Remove PAL entries from config.json instructions[] and permission ---
 const configPath = resolve(OC_GLOBAL_DIR, "config.json");
 if (existsSync(configPath) && statSync(configPath).size > 0) {
   try {
-    const ocConfig = JSON.parse(readFileSync(configPath, "utf-8")) as Record<
-      string,
-      unknown
-    >;
+    const ocConfig = removePalHomeAllow(
+      JSON.parse(readFileSync(configPath, "utf-8")) as Record<string, unknown>,
+      palHomePattern()
+    );
     if (Array.isArray(ocConfig.instructions)) {
       const palFiles = new Set(getSemiStaticSources().map((s) => s.path));
       const filtered = (ocConfig.instructions as string[]).filter(
@@ -76,11 +77,11 @@ if (existsSync(configPath) && statSync(configPath).size > 0) {
       } else {
         ocConfig.instructions = filtered;
       }
-      writeFileSync(configPath, `${JSON.stringify(ocConfig, null, 2)}\n`, "utf-8");
-      log.success("Removed PAL entries from config.json instructions[]");
     }
+    writeFileSync(configPath, `${JSON.stringify(ocConfig, null, 2)}\n`, "utf-8");
+    log.success("Removed PAL entries from config.json");
   } catch {
-    log.warn("Could not clean config.json instructions[] — check manually");
+    log.warn("Could not clean config.json — check manually");
   }
 }