@fml-inc/fml 0.8.0-rc.2 → 0.8.0

package/dist/cli.js

@@ -10,7 +10,7 @@ import {
   isPidAlive,
   readObserverStateStatus,
   removeObserverStateIfOwned
-} from "./chunk-WZLLO563.js";
+} from "./chunk-7DWFJENY.js";
 import {
   readJsonFile,
   setHookCaptureDisabled,
@@ -24,7 +24,7 @@ import {
   isObserverHealth,
   readHookInboxStatus,
   readObserverAuthToken
-} from "./chunk-56TPYMNK.js";
+} from "./chunk-KBT5RMAU.js";
 import "./chunk-7V7G7NVF.js";
 import {
   claudeConfigDirectory,
@@ -124,7 +124,7 @@ var POLL_INTERVAL_MS = 50;
 var LOG_ROTATE_BYTES = 10 * 1024 * 1024;
 var LOG_ROTATE_FILES = 3;
 function expectedObserverVersion() {
-  return true ? "0.8.0-rc.2+bed6eaed" : "dev";
+  return true ? "0.8.0+246af775" : "dev";
 }
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -1062,9 +1062,9 @@ async function handleDoctor(opts) {
 }
 
 // src/commands/install.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import os5 from "os";
-import path21 from "path";
+import path22 from "path";
 import { fileURLToPath } from "url";
 
 // ../../packages/agent-targets/src/install/claude/index.ts
@@ -1305,21 +1305,166 @@ var CLAUDE_PLUGIN_INSTALLER = Object.freeze({
   })
 });
 
-// src/bin-utils.ts
+// ../../packages/agent-targets/src/install/pi/index.ts
 import fs3 from "fs";
 import path4 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+var FML_PI_EXTENSION_MARKER = "__FML_PI_EXTENSION_V1__";
+var LEGACY_PI_EXTENSION_MARKER = "__panopticonPiExtensionTest";
+var LEGACY_PI_EXTENSION_SIGNATURES = Object.freeze([
+  "PANOPTICON_PORT",
+  '"/hooks"',
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "SessionEnd"
+]);
+function pathApiFor(platform) {
+  return platform === "win32" ? path4.win32 : path4.posix;
+}
+function resolvePiAgentDir(context, pathApi) {
+  const configured = context.env.PI_CODING_AGENT_DIR?.trim();
+  if (!configured) {
+    return pathApi.join(context.homeDir, ".pi", "agent");
+  }
+  if (configured === "~") return context.homeDir;
+  if (configured.startsWith("~/") || configured.startsWith("~\\")) {
+    return pathApi.join(context.homeDir, configured.slice(2));
+  }
+  return pathApi.normalize(configured);
+}
+function readFileIfPresent(filePath) {
+  try {
+    return fs3.readFileSync(filePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function isOwnedExtension(source, legacy = false) {
+  return source.includes(FML_PI_EXTENSION_MARKER) || legacy && (source.includes(LEGACY_PI_EXTENSION_MARKER) || LEGACY_PI_EXTENSION_SIGNATURES.every(
+    (signature) => source.includes(signature)
+  ));
+}
+function removeLegacyExtension(filePath) {
+  const source = readFileIfPresent(filePath);
+  if (source === null) return { removed: false, preserved: false };
+  if (!isOwnedExtension(source, true)) {
+    return { removed: false, preserved: true };
+  }
+  fs3.rmSync(filePath);
+  return { removed: true, preserved: false };
+}
+function writeExtensionAtomically(filePath, source) {
+  fs3.mkdirSync(path4.dirname(filePath), { recursive: true, mode: 448 });
+  const temporaryPath = path4.join(
+    path4.dirname(filePath),
+    `.${path4.basename(filePath)}.${process.pid}.${randomUUID2()}.tmp`
+  );
+  try {
+    fs3.writeFileSync(temporaryPath, source, { encoding: "utf8", mode: 384 });
+    if (process.platform === "win32" && fs3.existsSync(filePath)) {
+      fs3.rmSync(filePath);
+    }
+    fs3.renameSync(temporaryPath, filePath);
+  } finally {
+    fs3.rmSync(temporaryPath, { force: true });
+  }
+}
+var PI_EXTENSION_INSTALLER = Object.freeze({
+  resolvePaths(context) {
+    const pathApi = pathApiFor(context.platform);
+    const extensionsDir = pathApi.join(
+      resolvePiAgentDir(context, pathApi),
+      "extensions"
+    );
+    return {
+      sourcePath: pathApi.join(
+        context.packageRoot,
+        "dist",
+        "pi",
+        "extension.js"
+      ),
+      extensionsDir,
+      destinationPath: pathApi.join(extensionsDir, "fml.js"),
+      legacyDestinationPath: pathApi.join(extensionsDir, "panopticon.js")
+    };
+  },
+  install(paths) {
+    const source = fs3.readFileSync(paths.sourcePath, "utf8");
+    if (!source.includes(FML_PI_EXTENSION_MARKER)) {
+      throw new Error(
+        `Packaged Pi extension is invalid: ${paths.sourcePath} does not contain the FML ownership marker`
+      );
+    }
+    const existing = readFileIfPresent(paths.destinationPath);
+    if (existing !== null && !isOwnedExtension(existing)) {
+      const legacy2 = removeLegacyExtension(paths.legacyDestinationPath);
+      return {
+        status: "preserved",
+        destinationPath: paths.destinationPath,
+        reason: "an extension not managed by FML already exists at this path",
+        legacyRemoved: legacy2.removed,
+        legacyPreserved: legacy2.preserved
+      };
+    }
+    const status = existing === null ? "installed" : existing === source ? "unchanged" : "updated";
+    if (status !== "unchanged") {
+      writeExtensionAtomically(paths.destinationPath, source);
+    }
+    const legacy = removeLegacyExtension(paths.legacyDestinationPath);
+    return {
+      status,
+      destinationPath: paths.destinationPath,
+      legacyRemoved: legacy.removed,
+      legacyPreserved: legacy.preserved
+    };
+  },
+  uninstall(paths) {
+    const existing = readFileIfPresent(paths.destinationPath);
+    const legacy = removeLegacyExtension(paths.legacyDestinationPath);
+    if (existing === null) {
+      return {
+        status: "absent",
+        destinationPath: paths.destinationPath,
+        legacyRemoved: legacy.removed,
+        legacyPreserved: legacy.preserved
+      };
+    }
+    if (!isOwnedExtension(existing)) {
+      return {
+        status: "preserved",
+        destinationPath: paths.destinationPath,
+        reason: "the existing extension is not managed by FML",
+        legacyRemoved: legacy.removed,
+        legacyPreserved: legacy.preserved
+      };
+    }
+    fs3.rmSync(paths.destinationPath);
+    return {
+      status: "removed",
+      destinationPath: paths.destinationPath,
+      legacyRemoved: legacy.removed,
+      legacyPreserved: legacy.preserved
+    };
+  }
+});
+
+// src/bin-utils.ts
+import fs4 from "fs";
+import path5 from "path";
 import { execFileSync, execSync } from "child_process";
 var IS_WIN = process.platform === "win32";
 var DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD";
 function resolveBin(name) {
-  const pathDirs = (process.env.PATH ?? "").split(path4.delimiter).filter(Boolean);
-  const hasExt = path4.extname(name) !== "";
+  const pathDirs = (process.env.PATH ?? "").split(path5.delimiter).filter(Boolean);
+  const hasExt = path5.extname(name) !== "";
   const exts = !IS_WIN || hasExt ? [""] : (process.env.PATHEXT ?? DEFAULT_PATHEXT).split(";").filter(Boolean);
   for (const dir of pathDirs) {
     for (const ext of exts) {
-      const candidate = path4.join(dir, name + ext);
+      const candidate = path5.join(dir, name + ext);
       try {
-        if (fs3.statSync(candidate).isFile()) return candidate;
+        if (fs4.statSync(candidate).isFile()) return candidate;
       } catch {
       }
     }
@@ -1351,18 +1496,18 @@ function execBinSync(bin, args, opts = {}) {
 }
 
 // src/managed-directories.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import os from "os";
-import path5 from "path";
+import path6 from "path";
 var FML_MANAGED_DIRECTORY_MARKER = ".fml-managed-root";
 var FML_MANAGED_DIRECTORY_MARKER_CONTENT = "fml-managed-directory-v1\n";
 function comparisonPathApi(platform, targetPaths) {
   if (platform === "win32" && targetPaths.some(
     (targetPath) => /^[A-Za-z]:[\\/]/u.test(targetPath) || targetPath.startsWith("\\\\") || targetPath.startsWith("//")
   )) {
-    return path5.win32;
+    return path6.win32;
   }
-  return path5;
+  return path6;
 }
 function resolveComparisonPath(targetPath, platform) {
   return comparisonPathApi(platform, [targetPath]).resolve(targetPath);
@@ -1435,7 +1580,7 @@ function configuredManagedRoots(platform = process.platform) {
   );
 }
 function managedDirectoryMarker(directory) {
-  return path5.join(directory, FML_MANAGED_DIRECTORY_MARKER);
+  return path6.join(directory, FML_MANAGED_DIRECTORY_MARKER);
 }
 function ownershipStatus(stats, platform) {
   if (platform === "win32") return "unverifiable";
@@ -1446,8 +1591,8 @@ function ownershipStatus(stats, platform) {
 function hasManagedDirectoryMarkerContents(directory) {
   const marker = managedDirectoryMarker(directory);
   try {
-    const stats = fs4.lstatSync(marker);
-    return stats.isFile() && fs4.readFileSync(marker, "utf8") === FML_MANAGED_DIRECTORY_MARKER_CONTENT;
+    const stats = fs5.lstatSync(marker);
+    return stats.isFile() && fs5.readFileSync(marker, "utf8") === FML_MANAGED_DIRECTORY_MARKER_CONTENT;
   } catch {
     return false;
   }
@@ -1455,11 +1600,11 @@ function hasManagedDirectoryMarkerContents(directory) {
 function hasManagedDirectoryMarker(directory, platform = process.platform) {
   const marker = managedDirectoryMarker(directory);
   try {
-    const stats = fs4.lstatSync(marker);
+    const stats = fs5.lstatSync(marker);
     if (!stats.isFile() || ownershipStatus(stats, platform) !== "owned") {
       return false;
     }
-    return fs4.readFileSync(marker, "utf8") === FML_MANAGED_DIRECTORY_MARKER_CONTENT;
+    return fs5.readFileSync(marker, "utf8") === FML_MANAGED_DIRECTORY_MARKER_CONTENT;
   } catch {
     return false;
   }
@@ -1467,7 +1612,7 @@ function hasManagedDirectoryMarker(directory, platform = process.platform) {
 function writeManagedDirectoryMarker(directory, platform) {
   const marker = managedDirectoryMarker(directory);
   try {
-    fs4.writeFileSync(marker, FML_MANAGED_DIRECTORY_MARKER_CONTENT, {
+    fs5.writeFileSync(marker, FML_MANAGED_DIRECTORY_MARKER_CONTENT, {
       encoding: "utf8",
       flag: "wx",
       mode: 384
@@ -1492,23 +1637,23 @@ function prepareManagedDirectory(root, platform = process.platform) {
   let created = false;
   let existingStats = null;
   try {
-    existingStats = fs4.lstatSync(root.directory);
+    existingStats = fs5.lstatSync(root.directory);
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
     existed = false;
   }
   if (!existed) {
-    fs4.mkdirSync(path5.dirname(root.directory), {
+    fs5.mkdirSync(path6.dirname(root.directory), {
       recursive: true,
       mode: 448
     });
     try {
-      fs4.mkdirSync(root.directory, { mode: 448 });
+      fs5.mkdirSync(root.directory, { mode: 448 });
       created = true;
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       existed = true;
-      existingStats = fs4.lstatSync(root.directory);
+      existingStats = fs5.lstatSync(root.directory);
     }
   }
   if (hasSymlinkedParentBelowTrustedAnchor(root.directory, platform)) {
@@ -1518,7 +1663,7 @@ function prepareManagedDirectory(root, platform = process.platform) {
       markerCreated: false
     };
   }
-  const directoryStats = existingStats ?? fs4.lstatSync(root.directory);
+  const directoryStats = existingStats ?? fs5.lstatSync(root.directory);
   const ownership = ownershipStatus(directoryStats, platform);
   const recognizedWindowsMarker = platform === "win32" && hasManagedDirectoryMarkerContents(root.directory);
   if (directoryStats.isSymbolicLink() || !directoryStats.isDirectory() || ownership === "foreign" || !root.nativeDefault && ownership !== "owned" && !(created && ownership === "unverifiable") && !recognizedWindowsMarker) {
@@ -1542,7 +1687,7 @@ function prepareManagedDirectory(root, platform = process.platform) {
       markerCreated: false
     };
   }
-  const mayClaim = fs4.readdirSync(root.directory).length === 0;
+  const mayClaim = fs5.readdirSync(root.directory).length === 0;
   if (!mayClaim) {
     return {
       directory: root.directory,
@@ -1601,7 +1746,7 @@ function hasSymlinkedParentBelowTrustedAnchor(targetPath, platform = process.pla
   for (const component of relativeParent.split(pathApi.sep)) {
     current = pathApi.join(current, component);
     try {
-      if (fs4.lstatSync(current).isSymbolicLink()) return true;
+      if (fs5.lstatSync(current).isSymbolicLink()) return true;
     } catch (error) {
       if (error.code === "ENOENT") return false;
       return true;
@@ -1626,7 +1771,7 @@ function unsafePurgeRoots(roots, platform = process.platform) {
     }
     let stats;
     try {
-      stats = fs4.lstatSync(root.directory);
+      stats = fs5.lstatSync(root.directory);
     } catch (error) {
       if (error.code === "ENOENT") continue;
       unsafe.push({
@@ -1675,14 +1820,14 @@ function unsafePurgeRoots(roots, platform = process.platform) {
 }
 
 // src/commands/hook-config.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import os2 from "os";
-import path10 from "path";
+import path11 from "path";
 
 // ../../packages/agent-targets/src/install/hooks/codex.ts
 import { createHash } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
-import path7 from "path";
+import path8 from "path";
 import { parse as parse2 } from "smol-toml";
 
 // ../../packages/agent-targets/src/toml.ts
@@ -1692,7 +1837,7 @@ function asRecord2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function singlePath(value) {
-  const path29 = [];
+  const path30 = [];
   let current = value;
   while (true) {
     if (Array.isArray(current) && current.length === 1) {
@@ -1700,13 +1845,13 @@ function singlePath(value) {
       continue;
     }
     const record = asRecord2(current);
-    if (!record) return path29;
+    if (!record) return path30;
     const keys = Object.keys(record);
-    if (keys.length === 0) return path29;
+    if (keys.length === 0) return path30;
     if (keys.length !== 1) throw new Error("ambiguous TOML statement path");
     const key = keys[0];
     if (key === void 0) throw new Error("missing TOML statement key");
-    path29.push(key);
+    path30.push(key);
     current = record[key];
   }
 }
@@ -1788,8 +1933,8 @@ function scanStatements(source) {
   }
   return statements;
 }
-function startsWithPath(path29, prefix) {
-  return prefix.every((part, index) => path29[index] === part);
+function startsWithPath(path30, prefix) {
+  return prefix.every((part, index) => path30[index] === part);
 }
 function pathsEqual(left, right) {
   return left.length === right.length && left.every((part, index) => part === right[index]);
@@ -1815,9 +1960,9 @@ function appendToml(source, addition) {
 function hasOwn(record, key) {
   return Object.prototype.hasOwnProperty.call(record, key);
 }
-function updatedValueAtPath(updated, path29) {
+function updatedValueAtPath(updated, path30) {
   let current = updated;
-  for (const part of path29) {
+  for (const part of path30) {
     const record = asRecord2(current);
     if (!record || !hasOwn(record, part)) return { exists: false };
     current = record[part];
@@ -1831,22 +1976,22 @@ function normalizedPaths(updates) {
       throw new Error("TOML update path cannot be empty");
     }
     if (paths.some(
-      (path29) => pathsEqual(path29, update.path) || startsWithPath(update.path, path29)
+      (path30) => pathsEqual(path30, update.path) || startsWithPath(update.path, path30)
     )) {
       continue;
     }
     for (let index = paths.length - 1; index >= 0; index -= 1) {
-      const path29 = paths[index];
-      if (path29 && startsWithPath(path29, update.path)) paths.splice(index, 1);
+      const path30 = paths[index];
+      if (path30 && startsWithPath(path30, update.path)) paths.splice(index, 1);
     }
     paths.push([...update.path]);
   }
   return paths;
 }
-function valueDocument(path29, value) {
+function valueDocument(path30, value) {
   let nested = value;
-  for (let index = path29.length - 1; index >= 0; index -= 1) {
-    const part = path29[index];
+  for (let index = path30.length - 1; index >= 0; index -= 1) {
+    const part = path30[index];
     if (part === void 0) throw new Error("TOML update path is invalid");
     nested = { [part]: nested };
   }
@@ -1865,12 +2010,12 @@ function insertAfterStatement(source, statement, addition) {
   const separator = before.endsWith(eol) ? "" : eol;
   return `${before}${separator}${normalized}${eol}${source.slice(statement.end)}`;
 }
-function insertUpdatedValue(source, path29, value) {
-  const key = path29.at(-1);
+function insertUpdatedValue(source, path30, value) {
+  const key = path30.at(-1);
   if (key === void 0) throw new Error("TOML update path cannot be empty");
   const assignment = localAssignment(key, value);
   if (assignment !== null) {
-    const parent = path29.slice(0, -1);
+    const parent = path30.slice(0, -1);
     const parentTables = scanStatements(source).filter(
       (statement) => statement.isTable && pathsEqual(statement.path, parent)
     );
@@ -1884,17 +2029,17 @@ function insertUpdatedValue(source, path29, value) {
       return insertAfterStatement(source, parentTable, assignment);
     }
   }
-  return appendToml(source, stringify(valueDocument(path29, value)));
+  return appendToml(source, stringify(valueDocument(path30, value)));
 }
 function updateTomlPaths(source, updated, updates) {
   const paths = normalizedPaths(updates);
   if (paths.length === 0) return source;
   const stripped = removeStatements(source, scanStatements(source), paths);
   let result = stripped;
-  for (const path29 of paths) {
-    const next = updatedValueAtPath(updated, path29);
+  for (const path30 of paths) {
+    const next = updatedValueAtPath(updated, path30);
     if (!next.exists) continue;
-    result = insertUpdatedValue(result, path29, next.value);
+    result = insertUpdatedValue(result, path30, next.value);
   }
   let reparsed;
   try {
@@ -1913,7 +2058,7 @@ function updateTomlPaths(source, updated, updates) {
 }
 
 // ../../packages/agent-targets/src/install/hooks/shared.ts
-import path6 from "path";
+import path7 from "path";
 function asRecord3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -1973,7 +2118,7 @@ function changedMutation(snapshot, after) {
   return before === after ? null : { path: snapshot.path, before, after };
 }
 function fmlHookCommand(pluginRoot, target2) {
-  const handlerPath = path6.join(pluginRoot, "bin", "hook-handler");
+  const handlerPath = path7.join(pluginRoot, "bin", "hook-handler");
   const encodedPath = Buffer.from(handlerPath, "utf8").toString("base64url");
   return `node -e "${FML_HOOK_LOADER}" ${encodedPath} ${target2}`;
 }
@@ -2086,11 +2231,11 @@ function uniquePaths(paths) {
 function codexPaths(context) {
   const configuredHome = context.env.CODEX_HOME;
   const trimmedHome = typeof configuredHome === "string" ? configuredHome.trim() : "";
-  const dir = path7.resolve(
-    trimmedHome.length > 0 ? trimmedHome : path7.join(context.homeDir, ".codex")
+  const dir = path8.resolve(
+    trimmedHome.length > 0 ? trimmedHome : path8.join(context.homeDir, ".codex")
   );
-  const configPath4 = path7.join(dir, "config.toml");
-  const hooksPath = path7.join(dir, "hooks.json");
+  const configPath4 = path8.join(dir, "config.toml");
+  const hooksPath = path8.join(dir, "hooks.json");
   return {
     configPath: configPath4,
     hooksPath,
@@ -2522,7 +2667,7 @@ function codexConfigUpdatePaths(original, updated) {
       }
     }
   }
-  return paths.map((path29) => ({ path: path29 }));
+  return paths.map((path30) => ({ path: path30 }));
 }
 function updateCodexConfigToml(source, original, updated) {
   return updateTomlPaths(
@@ -2972,7 +3117,7 @@ var CODEX_HOOK_INSTALLER = Object.freeze({
 
 // ../../packages/agent-targets/src/install/hooks/gemini.ts
 import { isDeepStrictEqual as isDeepStrictEqual4 } from "util";
-import path8 from "path";
+import path9 from "path";
 
 // ../../packages/agent-targets/src/mcp/jsonc.ts
 import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
@@ -3028,7 +3173,7 @@ function longestCommonArraySubsequence(original, updated) {
   }
   return matches;
 }
-function arrayDiff(original, updated, path29) {
+function arrayDiff(original, updated, path30) {
   const updates = [];
   const matches = longestCommonArraySubsequence(original, updated);
   let originalStart = 0;
@@ -3046,19 +3191,19 @@ function arrayDiff(original, updated, path29) {
         ...jsoncUpdatesForObjectDiff(
           original[originalStart + offset],
           updated[updatedStart + offset],
-          [...path29, currentIndex + offset]
+          [...path30, currentIndex + offset]
         )
       );
     }
     for (let offset = pairedCount; offset < originalCount; offset += 1) {
       updates.push({
-        path: [...path29, currentIndex + pairedCount],
+        path: [...path30, currentIndex + pairedCount],
         value: void 0
       });
     }
     for (let offset = pairedCount; offset < updatedCount; offset += 1) {
       updates.push({
-        path: [...path29, currentIndex + offset],
+        path: [...path30, currentIndex + offset],
         value: updated[updatedStart + offset],
         isArrayInsertion: true
       });
@@ -3071,21 +3216,21 @@ function arrayDiff(original, updated, path29) {
   }
   return updates;
 }
-function jsoncUpdatesForObjectDiff(original, updated, path29 = []) {
+function jsoncUpdatesForObjectDiff(original, updated, path30 = []) {
   if (isDeepStrictEqual3(original, updated)) return [];
   if (Array.isArray(original) && Array.isArray(updated)) {
-    return arrayDiff(original, updated, path29);
+    return arrayDiff(original, updated, path30);
   }
   const originalObject = asObject(original);
   const updatedObject = asObject(updated);
-  if (!originalObject || !updatedObject) return [{ path: path29, value: updated }];
+  if (!originalObject || !updatedObject) return [{ path: path30, value: updated }];
   const keys = /* @__PURE__ */ new Set([
     ...Object.keys(originalObject),
     ...Object.keys(updatedObject)
   ]);
   return [...keys].flatMap(
     (key) => jsoncUpdatesForObjectDiff(originalObject[key], updatedObject[key], [
-      ...path29,
+      ...path30,
       key
     ])
   );
@@ -3133,7 +3278,7 @@ var TARGET_ID3 = TARGET3.id;
 var DISPLAY_NAME3 = TARGET3.displayName;
 var MANAGED_HOOK_NAME = "fml-capture";
 function settingsPath(context) {
-  return path8.join(geminiConfigDirectory(context), "settings.json");
+  return path9.join(geminiConfigDirectory(context), "settings.json");
 }
 function readGeminiSettings(snapshot) {
   const failure = snapshotError(snapshot);
@@ -3366,15 +3511,15 @@ var GEMINI_HOOK_INSTALLER = Object.freeze({
 });
 
 // ../../packages/agent-targets/src/install/hooks/grok.ts
-import path9 from "path";
+import path10 from "path";
 var TARGET4 = agentTarget("grok");
 var TARGET_ID4 = TARGET4.id;
 var DISPLAY_NAME4 = TARGET4.displayName;
 var HOOK_TIMEOUT_SECONDS2 = 10;
 function grokHooksPath(context) {
   const configuredHome = context.env.GROK_HOME?.trim();
-  const grokHome = configuredHome ? path9.resolve(configuredHome) : path9.join(context.homeDir, ".grok");
-  return path9.join(grokHome, "hooks", "fml.json");
+  const grokHome = configuredHome ? path10.resolve(configuredHome) : path10.join(context.homeDir, ".grok");
+  return path10.join(grokHome, "hooks", "fml.json");
 }
 function planInstall3(context) {
   const configPath4 = grokHooksPath(context);
@@ -3493,14 +3638,14 @@ var HOOK_REGISTRATION_CAPABILITIES = Object.freeze([
 ]);
 
 // src/commands/hook-config.ts
-var DEFAULT_CODEX_HOOK_OWNERSHIP_STATE_PATH = path10.join(
+var DEFAULT_CODEX_HOOK_OWNERSHIP_STATE_PATH = path11.join(
   FML_DATA_DIR,
   "codex-hook-install.json"
 );
 function readHookFile(filePath) {
   let stat;
   try {
-    stat = fs5.lstatSync(filePath);
+    stat = fs6.lstatSync(filePath);
   } catch (error) {
     if (error.code === "ENOENT") {
       return { path: filePath, kind: "missing" };
@@ -3529,7 +3674,7 @@ function readHookFile(filePath) {
     return {
       path: filePath,
       kind: "file",
-      contents: fs5.readFileSync(filePath, "utf8")
+      contents: fs6.readFileSync(filePath, "utf8")
     };
   } catch (error) {
     return {
@@ -3541,17 +3686,17 @@ function readHookFile(filePath) {
 }
 function canonicalizePath(filePath) {
   try {
-    return fs5.realpathSync(filePath);
+    return fs6.realpathSync(filePath);
   } catch {
     const missingSegments = [];
     let ancestor = filePath;
     while (true) {
-      const parent = path10.dirname(ancestor);
+      const parent = path11.dirname(ancestor);
       if (parent === ancestor) return filePath;
-      missingSegments.unshift(path10.basename(ancestor));
+      missingSegments.unshift(path11.basename(ancestor));
       ancestor = parent;
       try {
-        return path10.join(fs5.realpathSync(ancestor), ...missingSegments);
+        return path11.join(fs6.realpathSync(ancestor), ...missingSegments);
       } catch {
       }
     }
@@ -3570,7 +3715,7 @@ function assertMutationPrecondition(mutation) {
 }
 function applyMutation(mutation) {
   if (mutation.after === null) {
-    fs5.rmSync(mutation.path);
+    fs6.rmSync(mutation.path);
   } else {
     writeTextFileAtomic(mutation.path, mutation.after);
   }
@@ -3583,7 +3728,7 @@ function rollbackMutation(mutation) {
   };
   assertMutationPrecondition(inverse);
   if (inverse.after === null) {
-    fs5.rmSync(inverse.path);
+    fs6.rmSync(inverse.path);
   } else {
     writeTextFileAtomic(inverse.path, inverse.after);
   }
@@ -3651,7 +3796,7 @@ function applyPlan(plan, warn, onFailure) {
   };
 }
 function plannerContext(packageRoot, options) {
-  const ownershipStatePath = options.ownershipStatePath ?? (options.homeDir ? path10.join(options.homeDir, ".fml", "codex-hook-install.json") : DEFAULT_CODEX_HOOK_OWNERSHIP_STATE_PATH);
+  const ownershipStatePath = options.ownershipStatePath ?? (options.homeDir ? path11.join(options.homeDir, ".fml", "codex-hook-install.json") : DEFAULT_CODEX_HOOK_OWNERSHIP_STATE_PATH);
   return {
     packageRoot,
     homeDir: options.homeDir ?? os2.homedir(),
@@ -3682,10 +3827,10 @@ function removeFmlHooks(options = {}) {
 }
 
 // src/commands/marketplace-link.ts
-import fs6 from "fs";
+import fs7 from "fs";
 function existingPathKind(linkPath) {
   try {
-    return fs6.lstatSync(linkPath).isSymbolicLink() ? "symlink" : "other";
+    return fs7.lstatSync(linkPath).isSymbolicLink() ? "symlink" : "other";
   } catch (error) {
     if (error.code === "ENOENT") return "missing";
     throw error;
@@ -3694,15 +3839,15 @@ function existingPathKind(linkPath) {
 function replaceMarketplaceLink(linkPath, targetPath, type) {
   const existing = existingPathKind(linkPath);
   if (existing === "other") return "preserved";
-  if (existing === "symlink") fs6.unlinkSync(linkPath);
-  fs6.symlinkSync(targetPath, linkPath, type);
+  if (existing === "symlink") fs7.unlinkSync(linkPath);
+  fs7.symlinkSync(targetPath, linkPath, type);
   return existing === "symlink" ? "replaced" : "created";
 }
 function removeMarketplaceLink(linkPath) {
   const existing = existingPathKind(linkPath);
   if (existing === "missing") return "missing";
   if (existing === "other") return "preserved";
-  fs6.unlinkSync(linkPath);
+  fs7.unlinkSync(linkPath);
   return "removed";
 }
 
@@ -3797,10 +3942,10 @@ function configRecord(value) {
 }
 
 // ../../packages/agent-targets/src/mcp/targets/claude-desktop.ts
-import path12 from "path";
+import path13 from "path";
 
 // ../../packages/agent-targets/src/mcp/capability.ts
-import path11 from "path";
+import path12 from "path";
 import { parse as parse4 } from "smol-toml";
 
 // ../../packages/agent-targets/src/mcp/toml.ts
@@ -3906,7 +4051,7 @@ function changedConfigPlan(target2, current, before, data) {
 function generatedServer(target2, context) {
   return fmlMcpServerConfig(
     target2.command,
-    path11.join(context.packageRoot, "bin", "mcp-server")
+    path12.join(context.packageRoot, "bin", "mcp-server")
   );
 }
 function planInstall4(target2, context) {
@@ -3986,7 +4131,7 @@ var CLAUDE_DESKTOP_DIRECT_MCP = createDirectMcpCapability({
   configKey: "mcpServers",
   configPath: ({ env, homeDir, platform }) => {
     if (platform === "darwin") {
-      return path12.join(
+      return path13.join(
         homeDir,
         "Library",
         "Application Support",
@@ -3995,14 +4140,14 @@ var CLAUDE_DESKTOP_DIRECT_MCP = createDirectMcpCapability({
       );
     }
     if (platform === "win32") {
-      return path12.join(
-        env.APPDATA ?? path12.join(homeDir, "AppData", "Roaming"),
+      return path13.join(
+        env.APPDATA ?? path13.join(homeDir, "AppData", "Roaming"),
         "Claude",
         "claude_desktop_config.json"
       );
     }
-    return path12.join(
-      env.XDG_CONFIG_HOME ?? path12.join(homeDir, ".config"),
+    return path13.join(
+      env.XDG_CONFIG_HOME ?? path13.join(homeDir, ".config"),
       "Claude",
       "claude_desktop_config.json"
     );
@@ -4011,7 +4156,7 @@ var CLAUDE_DESKTOP_DIRECT_MCP = createDirectMcpCapability({
 });
 
 // ../../packages/agent-targets/src/mcp/targets/codex.ts
-import path13 from "path";
+import path14 from "path";
 var TARGET6 = agentTarget("codex");
 var CODEX_DIRECT_MCP = createDirectMcpCapability({
   targetId: TARGET6.id,
@@ -4020,26 +4165,26 @@ var CODEX_DIRECT_MCP = createDirectMcpCapability({
   configKey: "mcp_servers",
   configPath: ({ env, homeDir }) => {
     const configuredHome = env.CODEX_HOME;
-    const codexHome = typeof configuredHome === "string" && configuredHome.length > 0 ? path13.resolve(configuredHome) : path13.join(homeDir, ".codex");
-    return path13.join(codexHome, "config.toml");
+    const codexHome = typeof configuredHome === "string" && configuredHome.length > 0 ? path14.resolve(configuredHome) : path14.join(homeDir, ".codex");
+    return path14.join(codexHome, "config.toml");
   },
   command: () => "node"
 });
 
 // ../../packages/agent-targets/src/mcp/targets/gemini.ts
-import path14 from "path";
+import path15 from "path";
 var TARGET7 = agentTarget("gemini");
 var GEMINI_DIRECT_MCP = createDirectMcpCapability({
   targetId: TARGET7.id,
   displayName: TARGET7.displayName,
   configFormat: "json",
   configKey: "mcpServers",
-  configPath: (context) => path14.join(geminiConfigDirectory(context), "settings.json"),
+  configPath: (context) => path15.join(geminiConfigDirectory(context), "settings.json"),
   command: () => "node"
 });
 
 // ../../packages/agent-targets/src/mcp/targets/grok.ts
-import path15 from "path";
+import path16 from "path";
 var TARGET8 = agentTarget("grok");
 var GROK_DIRECT_MCP = createDirectMcpCapability({
   targetId: TARGET8.id,
@@ -4048,8 +4193,8 @@ var GROK_DIRECT_MCP = createDirectMcpCapability({
   configKey: "mcp_servers",
   configPath: ({ env, homeDir }) => {
     const configuredHome = env.GROK_HOME;
-    const grokHome = typeof configuredHome === "string" && configuredHome.length > 0 ? path15.resolve(configuredHome) : path15.join(homeDir, ".grok");
-    return path15.join(grokHome, "config.toml");
+    const grokHome = typeof configuredHome === "string" && configuredHome.length > 0 ? path16.resolve(configuredHome) : path16.join(homeDir, ".grok");
+    return path16.join(grokHome, "config.toml");
   },
   command: () => "node"
 });
@@ -4063,7 +4208,7 @@ var DIRECT_MCP_CAPABILITIES = Object.freeze([
 ]);
 
 // src/commands/mcp-config.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import os3 from "os";
 function resolutionContext(options) {
   return {
@@ -4076,7 +4221,7 @@ function resolutionContext(options) {
 function readMcpFile(filePath) {
   let stat;
   try {
-    stat = fs7.lstatSync(filePath);
+    stat = fs8.lstatSync(filePath);
   } catch (error) {
     if (error.code === "ENOENT") {
       return { path: filePath, kind: "missing" };
@@ -4105,7 +4250,7 @@ function readMcpFile(filePath) {
     return {
       path: filePath,
       kind: "file",
-      contents: fs7.readFileSync(filePath, "utf8")
+      contents: fs8.readFileSync(filePath, "utf8")
     };
   } catch (error) {
     return {
@@ -4141,14 +4286,14 @@ function preflightMutation(mutation) {
 }
 function writeMutation(mutation) {
   if (mutation.after === null) {
-    fs7.rmSync(mutation.path, { force: true });
+    fs8.rmSync(mutation.path, { force: true });
     return;
   }
   writeTextFileAtomic(mutation.path, mutation.after);
 }
 function rollbackMutation2(mutation) {
   if (mutation.before === null) {
-    fs7.rmSync(mutation.path, { force: true });
+    fs8.rmSync(mutation.path, { force: true });
     return;
   }
   writeTextFileAtomic(mutation.path, mutation.before);
@@ -4238,13 +4383,13 @@ function removeFmlDirectMcp(target2 = "all", options = {}) {
 }
 
 // src/commands/agent-skills.ts
-import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
-import fs8 from "fs";
+import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
+import fs9 from "fs";
 import os4 from "os";
-import path20 from "path";
+import path21 from "path";
 
 // ../../packages/agent-targets/src/install/surfaces/capability.ts
-import path16 from "path";
+import path17 from "path";
 var SOURCE_PATH_SEGMENTS = ["agent-assets", "fml", "SKILL.md"];
 var DESTINATION_PATH_SEGMENTS = ["skills", "fml", "SKILL.md"];
 function createAgentSkillCapability(definition) {
@@ -4257,8 +4402,8 @@ function createAgentSkillCapability(definition) {
     resolve: (context) => Object.freeze({
       targetId: definition.targetId,
       displayName: definition.displayName,
-      sourcePath: path16.join(context.packageRoot, ...SOURCE_PATH_SEGMENTS),
-      destinationPath: path16.join(
+      sourcePath: path17.join(context.packageRoot, ...SOURCE_PATH_SEGMENTS),
+      destinationPath: path17.join(
         definition.destinationRoot(context),
         ...DESTINATION_PATH_SEGMENTS
       ),
@@ -4281,7 +4426,7 @@ var CLAUDE_AGENT_SKILL = createAgentSkillCapability({
 });
 
 // ../../packages/agent-targets/src/install/surfaces/targets/codex.ts
-import path17 from "path";
+import path18 from "path";
 var TARGET10 = agentTarget("codex");
 var CODEX_AGENT_SKILL = createAgentSkillCapability({
   targetId: TARGET10.id,
@@ -4289,11 +4434,11 @@ var CODEX_AGENT_SKILL = createAgentSkillCapability({
   invocation: "$fml",
   deliveryMode: "instruction-read",
   argumentMode: "user-input",
-  destinationRoot: ({ homeDir }) => path17.join(homeDir, ".agents")
+  destinationRoot: ({ homeDir }) => path18.join(homeDir, ".agents")
 });
 
 // ../../packages/agent-targets/src/install/surfaces/targets/gemini.ts
-import path18 from "path";
+import path19 from "path";
 var TARGET11 = agentTarget("gemini");
 var GEMINI_AGENT_SKILL = createAgentSkillCapability({
   targetId: TARGET11.id,
@@ -4303,13 +4448,13 @@ var GEMINI_AGENT_SKILL = createAgentSkillCapability({
   argumentMode: "post-submit-prompt",
   destinationRoot: ({ env, homeDir }) => {
     const configuredHome = env.GEMINI_CLI_HOME?.trim();
-    const homeRoot = configuredHome ? path18.resolve(configuredHome) : homeDir;
-    return path18.join(homeRoot, ".agents");
+    const homeRoot = configuredHome ? path19.resolve(configuredHome) : homeDir;
+    return path19.join(homeRoot, ".agents");
   }
 });
 
 // ../../packages/agent-targets/src/install/surfaces/targets/grok.ts
-import path19 from "path";
+import path20 from "path";
 var TARGET12 = agentTarget("grok");
 var GROK_AGENT_SKILL = createAgentSkillCapability({
   targetId: TARGET12.id,
@@ -4317,7 +4462,7 @@ var GROK_AGENT_SKILL = createAgentSkillCapability({
   invocation: "/fml",
   deliveryMode: "prompt-expansion",
   argumentMode: "template-or-append",
-  destinationRoot: ({ homeDir }) => path19.join(homeDir, ".agents")
+  destinationRoot: ({ homeDir }) => path20.join(homeDir, ".agents")
 });
 
 // ../../packages/agent-targets/src/install/surfaces/registry.ts
@@ -4331,7 +4476,7 @@ var AGENT_SKILL_CAPABILITIES = Object.freeze([
 // src/commands/agent-skills.ts
 var FML_AGENT_SKILL_MARKER = "<!-- fml-managed-agent-surface:v1 -->";
 var AGENT_SKILL_STATE_SCHEMA_VERSION = 1;
-var DEFAULT_STATE_PATH = path20.join(FML_DATA_DIR, "agent-skills.json");
+var DEFAULT_STATE_PATH = path21.join(FML_DATA_DIR, "agent-skills.json");
 function emptyState() {
   return Object.freeze({
     schemaVersion: AGENT_SKILL_STATE_SCHEMA_VERSION,
@@ -4344,7 +4489,7 @@ function sha256(contents) {
 function readSkillFile(filePath) {
   let stat;
   try {
-    stat = fs8.lstatSync(filePath);
+    stat = fs9.lstatSync(filePath);
   } catch (error) {
     if (error.code === "ENOENT") {
       return { kind: "missing" };
@@ -4367,7 +4512,7 @@ function readSkillFile(filePath) {
     };
   }
   try {
-    const contents = fs8.readFileSync(filePath, "utf8");
+    const contents = fs9.readFileSync(filePath, "utf8");
     return { kind: "file", contents, sha256: sha256(contents) };
   } catch (error) {
     return {
@@ -4436,7 +4581,7 @@ function parseState(source, statePath) {
     }
     entries.push(
       Object.freeze({
-        path: path20.resolve(entry.path),
+        path: path21.resolve(entry.path),
         sha256: entry.sha256,
         targetIds: Object.freeze([...entry.targetIds])
       })
@@ -4462,7 +4607,7 @@ function loadState(statePath) {
 }
 function serializeState(entries) {
   const sorted = [...entries].map((entry) => ({
-    path: path20.resolve(entry.path),
+    path: path21.resolve(entry.path),
     sha256: entry.sha256,
     targetIds: [...entry.targetIds].sort()
   })).sort((left, right) => left.path.localeCompare(right.path));
@@ -4501,7 +4646,7 @@ function resolvedGroups(pluginRoot, options) {
   const groups = /* @__PURE__ */ new Map();
   for (const capability of AGENT_SKILL_CAPABILITIES) {
     const resolved = capability.resolve(context);
-    const destinationPath = path20.resolve(resolved.destinationPath);
+    const destinationPath = path21.resolve(resolved.destinationPath);
     const key = process.platform === "win32" ? destinationPath.toLowerCase() : destinationPath;
     const current = groups.get(key) ?? [];
     current.push({ ...resolved, destinationPath });
@@ -4538,10 +4683,10 @@ function resultFor(group, status, reason) {
   });
 }
 function destinationDirectoryIssue(destinationPath, requireEmpty) {
-  const skillDir = path20.dirname(destinationPath);
+  const skillDir = path21.dirname(destinationPath);
   let stat;
   try {
-    stat = fs8.lstatSync(skillDir);
+    stat = fs9.lstatSync(skillDir);
   } catch (error) {
     if (error.code === "ENOENT") return null;
     return error instanceof Error ? error.message : String(error);
@@ -4549,7 +4694,7 @@ function destinationDirectoryIssue(destinationPath, requireEmpty) {
   if (stat.isSymbolicLink()) return "skill directory is a symbolic link";
   if (!stat.isDirectory()) return "skill directory is not a directory";
   try {
-    if (!requireEmpty || fs8.readdirSync(skillDir).length === 0) return null;
+    if (!requireEmpty || fs9.readdirSync(skillDir).length === 0) return null;
     return "skill directory contains unmanaged files";
   } catch (error) {
     return error instanceof Error ? error.message : String(error);
@@ -4566,9 +4711,9 @@ function rollbackSkillWrite(destinationPath, before) {
     writeTextFileAtomic(destinationPath, before.contents);
     return;
   }
-  fs8.rmSync(destinationPath, { force: true });
+  fs9.rmSync(destinationPath, { force: true });
   try {
-    fs8.rmdirSync(path20.dirname(destinationPath));
+    fs9.rmdirSync(path21.dirname(destinationPath));
   } catch {
   }
 }
@@ -4611,12 +4756,12 @@ function installManagedAgentSkills(pluginRoot, options = {}) {
   const loaded = loadState(statePath);
   let stateSource = loaded.source;
   const entries = new Map(
-    loaded.state.entries.map((entry) => [path20.resolve(entry.path), entry])
+    loaded.state.entries.map((entry) => [path21.resolve(entry.path), entry])
   );
   const results = [];
   for (const group of resolvedGroups(pluginRoot, options)) {
     const source = sourceSkill(group.sourcePath);
-    const destinationPath = path20.resolve(group.destinationPath);
+    const destinationPath = path21.resolve(group.destinationPath);
     const current = readSkillFile(destinationPath);
     const previous = entries.get(destinationPath);
     const nextEntry = stateEntryFor(
@@ -4701,11 +4846,11 @@ function removeSkillFile(args) {
       `Agent skill changed before ${args.destinationPath} could be removed.`
     );
   }
-  const backupPath = path20.join(
-    path20.dirname(args.destinationPath),
-    `.${path20.basename(args.destinationPath)}.${process.pid}.${randomUUID2()}.bak`
+  const backupPath = path21.join(
+    path21.dirname(args.destinationPath),
+    `.${path21.basename(args.destinationPath)}.${process.pid}.${randomUUID3()}.bak`
   );
-  fs8.renameSync(args.destinationPath, backupPath);
+  fs9.renameSync(args.destinationPath, backupPath);
   let stateSource;
   try {
     stateSource = writeState(
@@ -4715,7 +4860,7 @@ function removeSkillFile(args) {
     );
   } catch (error) {
     try {
-      fs8.renameSync(backupPath, args.destinationPath);
+      fs9.renameSync(backupPath, args.destinationPath);
     } catch (rollbackError) {
       const message = error instanceof Error ? error.message : String(error);
       const rollbackMessage = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
@@ -4727,12 +4872,12 @@ function removeSkillFile(args) {
   }
   let warning;
   try {
-    fs8.rmSync(backupPath, { force: true });
+    fs9.rmSync(backupPath, { force: true });
   } catch (error) {
     warning = `agent skill removal was committed, but backup cleanup failed at ${backupPath}: ${error instanceof Error ? error.message : String(error)}`;
   }
   try {
-    fs8.rmdirSync(path20.dirname(args.destinationPath));
+    fs9.rmdirSync(path21.dirname(args.destinationPath));
   } catch {
   }
   return { stateSource, ...warning ? { warning } : {} };
@@ -4742,16 +4887,16 @@ function removeManagedAgentSkills(pluginRoot, options = {}) {
   const loaded = loadState(statePath);
   let stateSource = loaded.source;
   const entries = new Map(
-    loaded.state.entries.map((entry) => [path20.resolve(entry.path), entry])
+    loaded.state.entries.map((entry) => [path21.resolve(entry.path), entry])
   );
   const candidates = /* @__PURE__ */ new Map();
   const currentGroups = resolvedGroups(pluginRoot, options);
-  const packagedSourcePath = currentGroups[0]?.sourcePath ?? path20.join(pluginRoot, "agent-assets", "fml", "SKILL.md");
+  const packagedSourcePath = currentGroups[0]?.sourcePath ?? path21.join(pluginRoot, "agent-assets", "fml", "SKILL.md");
   for (const group of currentGroups) {
-    candidates.set(path20.resolve(group.destinationPath), group);
+    candidates.set(path21.resolve(group.destinationPath), group);
   }
   for (const entry of entries.values()) {
-    const destinationPath = path20.resolve(entry.path);
+    const destinationPath = path21.resolve(entry.path);
     if (candidates.has(destinationPath)) continue;
     const targets = entry.targetIds.filter(isAgentSkillTargetId).map(targetForId);
     if (targets.length === 0) continue;
@@ -4766,7 +4911,7 @@ function removeManagedAgentSkills(pluginRoot, options = {}) {
   for (const group of [...candidates.values()].sort(
     (left, right) => left.destinationPath.localeCompare(right.destinationPath)
   )) {
-    const destinationPath = path20.resolve(group.destinationPath);
+    const destinationPath = path21.resolve(group.destinationPath);
     const current = readSkillFile(destinationPath);
     const previous = entries.get(destinationPath);
     if (current.kind === "missing") {
@@ -4824,13 +4969,13 @@ function removeManagedAgentSkills(pluginRoot, options = {}) {
 }
 
 // src/commands/install.ts
-function resolvePluginRoot(startDir = path21.dirname(fileURLToPath(import.meta.url))) {
+function resolvePluginRoot(startDir = path22.dirname(fileURLToPath(import.meta.url))) {
   let directory = startDir;
   while (true) {
-    if (fs9.existsSync(path21.join(directory, "package.json")) && fs9.existsSync(path21.join(directory, "bin"))) {
+    if (fs10.existsSync(path22.join(directory, "package.json")) && fs10.existsSync(path22.join(directory, "bin"))) {
       return directory;
     }
-    const parent = path21.dirname(directory);
+    const parent = path22.dirname(directory);
     if (parent === directory) {
       throw new Error(
         `Could not locate the FML package root: no ancestor of ${startDir} contains both package.json and bin/. Reinstall @fml-inc/fml and retry.`
@@ -4845,7 +4990,7 @@ function getPluginRoot() {
 function readJsonFileForUpdate(filePath) {
   let source;
   try {
-    source = fs9.readFileSync(filePath, "utf8");
+    source = fs10.readFileSync(filePath, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return { ok: true, exists: false, data: {} };
@@ -4909,9 +5054,9 @@ async function handleInstall(opts = {}) {
     FML_LOG_DIR,
     FML_OBSERVER_DIR
   ])) {
-    fs9.mkdirSync(directory, { recursive: true, mode: 448 });
+    fs10.mkdirSync(directory, { recursive: true, mode: 448 });
   }
-  initializeSyncSettings(path21.join(FML_OBSERVER_DIR, "sync.json"));
+  initializeSyncSettings(path22.join(FML_OBSERVER_DIR, "sync.json"));
   let skillReady = false;
   try {
     const skillResults = installManagedAgentSkills(pluginRoot);
@@ -4930,7 +5075,35 @@ async function handleInstall(opts = {}) {
       `Warning: agent-native skill setup could not be completed: ${message}`
     );
   }
-  const packageJson = readJsonFile(path21.join(pluginRoot, "package.json"));
+  let piExtensionReady = false;
+  try {
+    const piPaths = PI_EXTENSION_INSTALLER.resolvePaths({
+      env: process.env,
+      homeDir: os5.homedir(),
+      packageRoot: pluginRoot,
+      platform: process.platform
+    });
+    const piResult = PI_EXTENSION_INSTALLER.install(piPaths);
+    piExtensionReady = piResult.status !== "preserved";
+    if (piResult.status === "preserved") {
+      console.log(
+        `      warn: preserved ${piResult.destinationPath} for Pi: ${piResult.reason}`
+      );
+    }
+    if (piResult.legacyRemoved) {
+      console.log("      Removed the legacy Panopticon Pi extension");
+    } else if (piResult.legacyPreserved) {
+      console.log(
+        `      warn: preserved unrecognized Pi extension ${piPaths.legacyDestinationPath}; inspect and remove it if it belongs to Panopticon`
+      );
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.log(
+      `      warn: Pi extension setup could not be completed: ${message}`
+    );
+  }
+  const packageJson = readJsonFile(path22.join(pluginRoot, "package.json"));
   const generatedManifest = readJsonFile(paths.pluginManifestPath);
   const version = typeof generatedManifest?.version === "string" ? generatedManifest.version : typeof packageJson?.version === "string" ? packageJson.version : "0.0.0-dev";
   writeJsonFile(
@@ -4947,7 +5120,7 @@ async function handleInstall(opts = {}) {
       `Warning: preserved unreadable marketplace config ${paths.marketplaceManifestPath}: ${marketplaceResult.error}`
     );
   } else {
-    fs9.mkdirSync(paths.marketplaceDir, { recursive: true, mode: 448 });
+    fs10.mkdirSync(paths.marketplaceDir, { recursive: true, mode: 448 });
     const linkUpdate = replaceMarketplaceLink(
       paths.marketplaceLinkPath,
       pluginRoot,
@@ -5027,9 +5200,9 @@ async function handleInstall(opts = {}) {
       }
     });
   }
-  if (!skillReady || !marketplaceReady || !settingsReady || !hooksReady) {
+  if (!skillReady || !piExtensionReady || !marketplaceReady || !settingsReady || !hooksReady) {
     throw new Error(
-      "FML install is incomplete: repair the preserved agent skill, hook configuration, Claude plugin path, or configuration reported above, then run `fml install` again."
+      "FML install is incomplete: repair the preserved agent skill, Pi extension, hook configuration, Claude plugin path, or configuration reported above, then run `fml install` again."
     );
   }
   try {
@@ -5056,12 +5229,12 @@ async function handleInstall(opts = {}) {
 import { statSync } from "fs";
 
 // src/commands/otel-config.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import os6 from "os";
-import path26 from "path";
+import path27 from "path";
 
 // ../../packages/agent-targets/src/install/otel/claude.ts
-import path22 from "path";
+import path23 from "path";
 
 // ../../packages/agent-targets/src/install/otel/shared.ts
 import { isDeepStrictEqual as isDeepStrictEqual7 } from "util";
@@ -5198,9 +5371,9 @@ var MANAGED_MARKER = "FML_OTEL_MANAGED";
 var CLAUDE_OTEL_SOURCE_LIMITATION = "Claude Code may truncate inline raw API bodies and tool content at 60 KiB and redact extended-thinking content before export";
 function configPath(context) {
   if (context.configPathOverride) {
-    return path22.resolve(context.configPathOverride);
+    return path23.resolve(context.configPathOverride);
   }
-  return path22.join(
+  return path23.join(
     claudeConfigDirectory({ env: context.env, homeDir: context.homeDir }),
     "settings.json"
   );
@@ -5371,7 +5544,7 @@ var CLAUDE_OTEL_INSTALLER = Object.freeze({
 
 // ../../packages/agent-targets/src/install/otel/codex.ts
 import { isDeepStrictEqual as isDeepStrictEqual8 } from "util";
-import path23 from "path";
+import path24 from "path";
 import { parse as parse5 } from "smol-toml";
 var TARGET14 = agentTarget("codex");
 var TARGET_ID6 = TARGET14.id;
@@ -5380,13 +5553,13 @@ var AUTHENTICATION2 = "bearer-header";
 var CODEX_OTEL_SOURCE_LIMITATION = "Codex OTel has no documented raw API body or full tool-content export switch; tool-result content is an output snippet";
 function configPath2(context) {
   if (context.configPathOverride) {
-    return path23.resolve(context.configPathOverride);
+    return path24.resolve(context.configPathOverride);
   }
   const configuredHome = context.env.CODEX_HOME;
-  const codexHome = path23.resolve(
-    typeof configuredHome === "string" && configuredHome.trim().length > 0 ? configuredHome : path23.join(context.homeDir, ".codex")
+  const codexHome = path24.resolve(
+    typeof configuredHome === "string" && configuredHome.trim().length > 0 ? configuredHome : path24.join(context.homeDir, ".codex")
   );
-  return path23.join(codexHome, "config.toml");
+  return path24.join(codexHome, "config.toml");
 }
 function readToml(snapshot) {
   const failure = snapshotError2(snapshot);
@@ -5606,7 +5779,7 @@ var CODEX_OTEL_INSTALLER = Object.freeze({
 });
 
 // ../../packages/agent-targets/src/install/otel/gemini.ts
-import path24 from "path";
+import path25 from "path";
 var TARGET15 = agentTarget("gemini");
 var TARGET_ID7 = TARGET15.id;
 var DISPLAY_NAME7 = TARGET15.displayName;
@@ -5614,9 +5787,9 @@ var AUTHENTICATION3 = "path-token";
 var GEMINI_OTEL_SOURCE_LIMITATION = "Gemini CLI has no documented OTLP header setting; FML uses an observer-local tokenized loopback path";
 function configPath3(context) {
   if (context.configPathOverride) {
-    return path24.resolve(context.configPathOverride);
+    return path25.resolve(context.configPathOverride);
   }
-  return path24.join(geminiConfigDirectory(context), "settings.json");
+  return path25.join(geminiConfigDirectory(context), "settings.json");
 }
 function managedTelemetry(context) {
   const destination = resolveDestination(context.observer);
@@ -5770,8 +5943,8 @@ var OTEL_INSTALLER_CAPABILITIES = Object.freeze([
 ]);
 
 // src/commands/otel-config-state.ts
-import fs10 from "fs";
-import path25 from "path";
+import fs11 from "fs";
+import path26 from "path";
 var OTEL_CONFIG_STATE_SCHEMA_VERSION = 1;
 function emptyState2() {
   return Object.freeze({
@@ -5785,12 +5958,12 @@ function invalidState2(statePath, reason) {
   );
 }
 function enforceOwnerOnlyMode(statePath) {
-  if (process.platform !== "win32") fs10.chmodSync(statePath, 384);
+  if (process.platform !== "win32") fs11.chmodSync(statePath, 384);
 }
 function readStateFile(statePath) {
   let stat;
   try {
-    stat = fs10.lstatSync(statePath);
+    stat = fs11.lstatSync(statePath);
   } catch (error) {
     if (error.code === "ENOENT") {
       return { kind: "missing" };
@@ -5808,7 +5981,7 @@ function readStateFile(statePath) {
   }
   try {
     enforceOwnerOnlyMode(statePath);
-    return { kind: "file", contents: fs10.readFileSync(statePath, "utf8") };
+    return { kind: "file", contents: fs11.readFileSync(statePath, "utf8") };
   } catch (error) {
     return {
       kind: "invalid",
@@ -5817,7 +5990,7 @@ function readStateFile(statePath) {
   }
 }
 function otelConfigStateEntryKey(targetId, configPath4) {
-  const resolved = path25.resolve(configPath4);
+  const resolved = path26.resolve(configPath4);
   const pathKey = process.platform === "win32" ? resolved.toLowerCase() : resolved;
   return `${targetId}\0${pathKey}`;
 }
@@ -5853,7 +6026,7 @@ function parseState2(source, statePath) {
     if (typeof observerRecord.baseUrl !== "string" || observerRecord.baseUrl.length === 0 || typeof observerRecord.authToken !== "string" || observerRecord.authToken.length === 0) {
       throw invalidState2(statePath, "contains an invalid observer destination");
     }
-    const resolvedPath = path25.resolve(entry.path);
+    const resolvedPath = path26.resolve(entry.path);
     const key = otelConfigStateEntryKey(entry.targetId, resolvedPath);
     if (keys.has(key)) {
       throw invalidState2(statePath, "contains duplicate entries");
@@ -5891,7 +6064,7 @@ function loadFmlOtelConfigState(statePath) {
 function serializeState2(entries) {
   const sorted = [...entries].map((entry) => ({
     targetId: entry.targetId,
-    path: path25.resolve(entry.path),
+    path: path26.resolve(entry.path),
     observer: {
       baseUrl: entry.observer.baseUrl,
       authToken: entry.observer.authToken
@@ -5928,7 +6101,7 @@ function isKnownOtelTargetId(targetId) {
 }
 
 // src/commands/otel-config.ts
-var DEFAULT_OTEL_CONFIG_STATE_PATH = path26.join(
+var DEFAULT_OTEL_CONFIG_STATE_PATH = path27.join(
   FML_DATA_DIR,
   "otel-config.json"
 );
@@ -5937,7 +6110,7 @@ function readLocalObserverOtelDestination(options) {
   if (!authToken) return null;
   try {
     const parsed = JSON.parse(
-      fs11.readFileSync(options.endpointFile, "utf8")
+      fs12.readFileSync(options.endpointFile, "utf8")
     );
     const endpoint = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
     const host = endpoint?.host;
@@ -5954,7 +6127,7 @@ function readLocalObserverOtelDestination(options) {
 function readOtelFile(filePath) {
   let stat;
   try {
-    stat = fs11.lstatSync(filePath);
+    stat = fs12.lstatSync(filePath);
   } catch (error) {
     if (error.code === "ENOENT") {
       return { path: filePath, kind: "missing" };
@@ -5983,7 +6156,7 @@ function readOtelFile(filePath) {
     return {
       path: filePath,
       kind: "file",
-      contents: fs11.readFileSync(filePath, "utf8")
+      contents: fs12.readFileSync(filePath, "utf8")
     };
   } catch (error) {
     return {
@@ -6005,7 +6178,7 @@ function assertMutationPrecondition2(mutation) {
   throw new Error(`configuration changed while planning ${mutation.path}`);
 }
 function applyMutation2(mutation) {
-  if (mutation.after === null) fs11.rmSync(mutation.path);
+  if (mutation.after === null) fs12.rmSync(mutation.path);
   else writeTextFileAtomic(mutation.path, mutation.after);
 }
 function enforceOwnerOnlyConfigPermissions(filePath) {
@@ -6018,7 +6191,7 @@ function enforceOwnerOnlyConfigPermissions(filePath) {
     );
   }
   try {
-    fs11.chmodSync(filePath, 384);
+    fs12.chmodSync(filePath, 384);
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
     throw new Error(
@@ -6113,7 +6286,7 @@ function plannerContext3(observer, options, configPathOverride, configOwnershipR
     observer,
     homeDir: options.homeDir ?? os6.homedir(),
     env: options.env ?? process.env,
-    ...configPathOverride ? { configPathOverride: path26.resolve(configPathOverride) } : {},
+    ...configPathOverride ? { configPathOverride: path27.resolve(configPathOverride) } : {},
     ...configOwnershipRecorded ? { configOwnershipRecorded: true } : {},
     readFile: readOtelFile
   };
@@ -6156,7 +6329,7 @@ function commitStateEntry(state, key, next) {
 function stateEntry(plan, observer) {
   return Object.freeze({
     targetId: plan.targetId,
-    path: path26.resolve(plan.configPath),
+    path: path27.resolve(plan.configPath),
     observer: Object.freeze({
       baseUrl: observer.baseUrl,
       authToken: observer.authToken
@@ -6714,8 +6887,8 @@ async function canOpenBrowser() {
   if (process.env.CODESPACES) return false;
   if (process.env.REMOTE_CONTAINERS) return false;
   try {
-    const fs13 = await import("fs");
-    if (fs13.existsSync("/.dockerenv")) return false;
+    const fs14 = await import("fs");
+    if (fs14.existsSync("/.dockerenv")) return false;
   } catch {
   }
   return true;
@@ -7274,9 +7447,9 @@ async function handleSetup(dependencies = defaultDependencies) {
 }
 
 // src/commands/uninstall.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import os7 from "os";
-import path27 from "path";
+import path28 from "path";
 import readline from "readline/promises";
 var PURGE_WARNING = "This deletes FML credentials for ALL environments, logs, sync state, and every pending best-effort OTLP envelope.";
 function tryDisableHookCapture() {
@@ -7292,19 +7465,19 @@ function tryDisableHookCapture() {
   }
 }
 function resolvePreservedPaths(preservedFile) {
-  const logicalPath = path27.resolve(preservedFile);
+  const logicalPath = path28.resolve(preservedFile);
   try {
-    const canonicalPath = fs12.realpathSync(preservedFile);
+    const canonicalPath = fs13.realpathSync(preservedFile);
     return pathsAreSame(canonicalPath, logicalPath) ? [logicalPath] : [logicalPath, canonicalPath];
   } catch {
     return [logicalPath];
   }
 }
 function purgeDirectoryPreservingPaths(directory, preservedPaths, configuredRoot = false) {
-  const resolvedDirectory = path27.resolve(directory);
+  const resolvedDirectory = path28.resolve(directory);
   let directoryStats;
   try {
-    directoryStats = fs12.lstatSync(directory);
+    directoryStats = fs13.lstatSync(directory);
   } catch (error) {
     if (error.code === "ENOENT") return true;
     throw error;
@@ -7315,14 +7488,14 @@ function purgeDirectoryPreservingPaths(directory, preservedPaths, configuredRoot
       (preservedPath) => pathContains(resolvedDirectory, preservedPath)
     );
     if (!containsLogicalMarker) {
-      fs12.rmSync(directory, { force: true });
+      fs13.rmSync(directory, { force: true });
       return true;
     }
     return false;
   }
   const directoryPaths = [resolvedDirectory];
   try {
-    const canonicalDirectory = fs12.realpathSync(directory);
+    const canonicalDirectory = fs13.realpathSync(directory);
     if (!pathsAreSame(canonicalDirectory, resolvedDirectory)) {
       directoryPaths.push(canonicalDirectory);
     }
@@ -7334,26 +7507,26 @@ function purgeDirectoryPreservingPaths(directory, preservedPaths, configuredRoot
     )
   );
   if (!containsPreservedPath) {
-    fs12.rmSync(directory, { recursive: true, force: true });
+    fs13.rmSync(directory, { recursive: true, force: true });
     return true;
   }
   const isPreservedPath = directoryPaths.some(
     (directoryPath) => preservedPaths.some(
-      (preservedPath) => pathsAreSame(directoryPath, path27.resolve(preservedPath))
+      (preservedPath) => pathsAreSame(directoryPath, path28.resolve(preservedPath))
     )
   );
   if (isPreservedPath) return true;
   if (!directoryStats.isDirectory()) return false;
   let entries;
   try {
-    entries = fs12.readdirSync(directory);
+    entries = fs13.readdirSync(directory);
   } catch (error) {
     if (error.code === "ENOENT") return true;
     throw error;
   }
   let complete = true;
   for (const entry of entries) {
-    const entryPath = path27.join(directory, entry);
+    const entryPath = path28.join(directory, entry);
     if (!purgeDirectoryPreservingPaths(entryPath, preservedPaths, false)) {
       complete = false;
     }
@@ -7372,13 +7545,13 @@ function purgeDirectoryPreservingFiles(directory, preservedFiles) {
 }
 function finishCustomRootPurge(directory) {
   const marker = managedDirectoryMarker(directory);
-  fs12.rmSync(marker, { force: true });
+  fs13.rmSync(marker, { force: true });
   try {
-    fs12.rmdirSync(directory);
+    fs13.rmdirSync(directory);
   } catch (error) {
     if (error.code === "ENOENT") return;
     try {
-      fs12.writeFileSync(marker, FML_MANAGED_DIRECTORY_MARKER_CONTENT, {
+      fs13.writeFileSync(marker, FML_MANAGED_DIRECTORY_MARKER_CONTENT, {
         encoding: "utf8",
         flag: "wx",
         mode: 384
@@ -7476,7 +7649,7 @@ async function handleUninstall(opts) {
       return;
     }
     for (const root of purgeRoots) {
-      if (!fs12.existsSync(root.directory) && pathContains(root.directory, FML_OBSERVER_DIR)) {
+      if (!fs13.existsSync(root.directory) && pathContains(root.directory, FML_OBSERVER_DIR)) {
         prepareManagedDirectory(root);
       }
     }
@@ -7552,6 +7725,38 @@ async function handleUninstall(opts) {
     );
   }
   let integrationsRemoved = true;
+  try {
+    const piPaths = PI_EXTENSION_INSTALLER.resolvePaths({
+      env: process.env,
+      homeDir: os7.homedir(),
+      packageRoot: resolvePackageRoot(),
+      platform: process.platform
+    });
+    const piResult = PI_EXTENSION_INSTALLER.uninstall(piPaths);
+    if (piResult.status === "preserved") {
+      integrationsRemoved = false;
+      process.exitCode = 1;
+      console.warn(
+        `Warning: Preserved ${piResult.destinationPath} for Pi: ${piResult.reason}`
+      );
+    }
+    if (piResult.legacyRemoved) {
+      console.log("Removed the legacy Panopticon Pi extension");
+    } else if (piResult.legacyPreserved) {
+      integrationsRemoved = false;
+      process.exitCode = 1;
+      console.warn(
+        `Warning: Preserved unrecognized Pi extension ${piPaths.legacyDestinationPath}; inspect and remove it if it belongs to Panopticon`
+      );
+    }
+  } catch (error) {
+    integrationsRemoved = false;
+    process.exitCode = 1;
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(
+      `Warning: Pi extension cleanup could not be completed: ${message}`
+    );
+  }
   if (removeMarketplaceLink(paths.marketplaceLinkPath) === "preserved") {
     integrationsRemoved = false;
     console.warn(
@@ -7568,7 +7773,7 @@ async function handleUninstall(opts) {
       )
     );
   }
-  fs12.rmSync(paths.pluginCacheDir, { recursive: true, force: true });
+  fs13.rmSync(paths.pluginCacheDir, { recursive: true, force: true });
   const reportIntegrationWarning = (message) => {
     integrationsRemoved = false;
     console.warn(message.replace(/^warn:/u, "Warning:"));
@@ -7690,7 +7895,7 @@ async function handleUninstall(opts) {
 // src/commands/update.ts
 var SEMVER_PATTERN = /^(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 function getCurrentVersion() {
-  return true ? "0.8.0-rc.2+bed6eaed" : "unknown";
+  return true ? "0.8.0+246af775" : "unknown";
 }
 function resolveUpdateChannel(version) {
   const match = SEMVER_PATTERN.exec(version);
@@ -8723,8 +8928,8 @@ async function handleConfigDetail(opts) {
 
 // src/commands/tools.ts
 import { readFileSync } from "fs";
-import path28 from "path";
-var pluginVersion = true ? "0.8.0-rc.2+bed6eaed" : void 0;
+import path29 from "path";
+var pluginVersion = true ? "0.8.0+246af775" : void 0;
 async function getApi() {
   const api = await getAuthenticatedClient();
   if (!api) {
@@ -8831,7 +9036,7 @@ async function handleToolsCall(name, opts) {
   }
   const raw = opts.file ? (() => {
     try {
-      return readFileSync(path28.resolve(opts.file), "utf8");
+      return readFileSync(path29.resolve(opts.file), "utf8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       console.error(`Could not read args file: ${msg}`);
@@ -8881,7 +9086,7 @@ if (process.argv.length <= 2 || process.argv.includes("--help") || process.argv.
   printBanner();
 }
 var program = new Command().name("fml").description("FML CLI and agent tools").version(
-  true ? "0.8.0-rc.2+bed6eaed" : "dev"
+  true ? "0.8.0+246af775" : "dev"
 );
 function formatCommandInventory(cmd, prefix = "") {
   const name = prefix ? `${prefix} ${cmd.name()}` : cmd.name();