@cortexkit/aft-pi 0.22.1 → 0.24.0

package/dist/index.js

@@ -30623,6 +30623,8 @@ class BinaryBridge {
   onConfigureWarnings;
   onBashCompletion;
   onBashLongRunning;
+  cachedStatus = null;
+  statusListeners = new Set;
   configureWarningClients = new Map;
   restartResetTimer = null;
   errorPrefix;
@@ -30671,6 +30673,21 @@ class BinaryBridge {
   hasPendingRequests() {
     return this.pending.size > 0;
   }
+  getCachedStatus() {
+    return this.cachedStatus;
+  }
+  subscribeStatus(listener) {
+    this.statusListeners.add(listener);
+    if (this.cachedStatus !== null) {
+      this.deliverStatusSnapshot(listener, this.cachedStatus);
+    }
+    return () => {
+      this.statusListeners.delete(listener);
+    };
+  }
+  cacheStatusSnapshot(snapshot) {
+    this.cachedStatus = snapshot;
+  }
   async send(command, params = {}, options) {
     if (this._shuttingDown) {
       throw new Error(`${this.errorPrefix} Bridge is shutting down, cannot send "${command}"`);
@@ -30807,6 +30824,23 @@ class BinaryBridge {
       }
     }
   }
+  handleStatusChangedFrame(frame) {
+    const snapshot = frame.snapshot;
+    if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot))
+      return;
+    this.cachedStatus = snapshot;
+    log("Received status_changed push frame; cached AFT status snapshot");
+    for (const listener of this.statusListeners) {
+      this.deliverStatusSnapshot(listener, this.cachedStatus);
+    }
+  }
+  deliverStatusSnapshot(listener, snapshot) {
+    try {
+      listener(snapshot);
+    } catch (err) {
+      warn(`status listener threw: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
   async shutdown() {
     this._shuttingDown = true;
     this.clearRestartResetTimer();
@@ -31011,6 +31045,10 @@ class BinaryBridge {
           });
           continue;
         }
+        if (response.type === "status_changed") {
+          this.handleStatusChangedFrame(response);
+          continue;
+        }
         const id = response.id;
         if (id && this.pending.has(id)) {
           const entry = this.pending.get(id);
@@ -31972,9 +32010,9 @@ import { chmodSync as chmodSync3, copyFileSync as copyFileSync2, existsSync as e
 import { createRequire as createRequire2 } from "node:module";
 import { homedir as homedir4 } from "node:os";
 import { join as join4 } from "node:path";
-function copyToVersionedCache(npmBinaryPath) {
+function readBinaryVersion(binaryPath) {
   try {
-    const result = spawnSync(npmBinaryPath, ["--version"], {
+    const result = spawnSync(binaryPath, ["--version"], {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000
@@ -31982,7 +32020,16 @@ function copyToVersionedCache(npmBinaryPath) {
     const rawVersion = result.stdout?.trim();
     if (!rawVersion)
       return null;
-    const version = rawVersion.replace(/^aft\s+/, "");
+    return rawVersion.replace(/^aft\s+/, "");
+  } catch {
+    return null;
+  }
+}
+function copyToVersionedCache(npmBinaryPath, knownVersion) {
+  try {
+    const version = knownVersion ?? readBinaryVersion(npmBinaryPath);
+    if (!version)
+      return null;
     const tag = version.startsWith("v") ? version : `v${version}`;
     const cacheDir = getCacheDir();
     const versionedDir = join4(cacheDir, tag);
@@ -32037,8 +32084,13 @@ function findBinarySync(expectedVersion) {
     const req = createRequire2(import.meta.url);
     const resolved = req.resolve(packageBin);
     if (existsSync3(resolved)) {
-      const copied = copyToVersionedCache(resolved);
-      return copied ?? resolved;
+      const npmVersion = readBinaryVersion(resolved);
+      if (pluginVersion && npmVersion && npmVersion !== pluginVersion) {
+        warn(`npm platform package binary v${npmVersion} does not match plugin v${pluginVersion}; skipping (continuing to PATH lookup)`);
+      } else {
+        const copied = copyToVersionedCache(resolved, npmVersion ?? undefined);
+        return copied ?? resolved;
+      }
     }
   } catch {}
   try {
@@ -32736,8 +32788,6 @@ async function handleTurnEndBgCompletions(drainContext) {
 }
 async function triggerWakeIfPending(drainContext, skipDrain) {
   const state = stateFor(drainContext.sessionID);
-  if (drainContext.isActive?.())
-    return;
   if (!skipDrain && state.outstandingTaskIds.size > 0) {
     await drainCompletions(drainContext);
   }
@@ -32781,9 +32831,8 @@ ${formatLongRunningReminder(longRunning)}`;
 async function drainCompletions({ ctx, directory, sessionID }) {
   try {
     const bridge = ctx.pool.getActiveBridgeForRoot(directory) ?? ctx.pool.getBridge(directory);
-    if (!sessionID)
-      return;
-    const response = await bridge.send("bash_drain_completions", { session_id: sessionID });
+    const params = sessionID ? { session_id: sessionID } : {};
+    const response = await bridge.send("bash_drain_completions", params);
     if (response.success === false) {
       sessionWarn2(sessionID ?? "", `${LOG_PREFIX} drain failed: ${String(response.message ?? "unknown error")}`);
       return;
@@ -32941,6 +32990,74 @@ function shorten(value, limit) {
   return value.length <= limit ? value : `${value.slice(0, limit - 1)}…`;
 }
 
+// src/dialogs/status-dialog.ts
+import {
+  matchesKey,
+  truncateToWidth,
+  visibleWidth
+} from "@earendil-works/pi-tui";
+// package.json
+var package_default = {
+  name: "@cortexkit/aft-pi",
+  version: "0.24.0",
+  type: "module",
+  description: "Pi coding agent extension for Agent File Tools (AFT) — tree-sitter and LSP-powered code analysis",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/cortexkit/aft"
+  },
+  files: [
+    "dist",
+    "README.md"
+  ],
+  scripts: {
+    build: "bun build src/index.ts --outdir dist --target node --format esm --external @earendil-works/pi-coding-agent --external @earendil-works/pi-ai --external @earendil-works/pi-tui --external typebox --external diff && tsc --emitDeclarationOnly",
+    typecheck: "tsc --noEmit",
+    test: "bun test src/__tests__/",
+    lint: "biome check src",
+    prepublishOnly: "bun run build"
+  },
+  dependencies: {
+    "@cortexkit/aft-bridge": "0.24.0",
+    typebox: "^1.1.24",
+    "comment-json": "^5.0.0",
+    diff: "^8.0.4",
+    zod: "^4.1.8"
+  },
+  optionalDependencies: {
+    "@cortexkit/aft-darwin-arm64": "0.24.0",
+    "@cortexkit/aft-darwin-x64": "0.24.0",
+    "@cortexkit/aft-linux-arm64": "0.24.0",
+    "@cortexkit/aft-linux-x64": "0.24.0",
+    "@cortexkit/aft-win32-x64": "0.24.0"
+  },
+  devDependencies: {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-tui": "*",
+    "@types/node": "^22.0.0",
+    typescript: "^5.8.0"
+  },
+  peerDependencies: {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    }
+  },
+  pi: {
+    extensions: [
+      "./dist/index.js"
+    ]
+  }
+};
+
 // src/shared/status.ts
 function asRecord(value) {
   return typeof value === "object" && value !== null ? value : {};
@@ -32989,9 +33106,12 @@ function coerceAftStatus(response) {
   };
   const disk = asRecord(response.disk);
   const symbolCache = asRecord(response.symbol_cache);
+  const session = asRecord(response.session);
   return {
     version: readString(response.version, "unknown"),
     project_root: readNullableString(response.project_root),
+    canonical_root: readNullableString(response.canonical_root),
+    cache_role: readString(response.cache_role, "not_initialized"),
     features: {
       format_on_edit: readBoolean(features.format_on_edit),
       validate_on_edit: readString(features.validate_on_edit, "off"),
@@ -33026,13 +33146,21 @@ function coerceAftStatus(response) {
       local_entries: readNumber(symbolCache.local_entries),
       warm_entries: readNumber(symbolCache.warm_entries)
     },
-    storage_dir: readNullableString(response.storage_dir)
+    storage_dir: readNullableString(response.storage_dir),
+    checkpoints_total: readNumber(response.checkpoints_total),
+    session: {
+      id: readString(session.id, "__default__"),
+      tracked_files: readNumber(session.tracked_files),
+      checkpoints: readNumber(session.checkpoints)
+    }
   };
 }
 function formatStatusDialogMessage(status) {
   const lines = [
     `AFT version: ${status.version}`,
     `Project root: ${status.project_root ?? "(not configured)"}`,
+    `Canonical root: ${status.canonical_root ?? "(not configured)"}`,
+    `Cache role: ${status.cache_role}`,
     "",
     "Enabled features",
     `- format_on_edit: ${formatFlag(status.features.format_on_edit)}`,
@@ -33125,26 +33253,261 @@ function textResult(text, details) {
   };
 }
 
+// src/dialogs/status-dialog.ts
+var REFRESH_INTERVAL_MS = 1500;
+var OVERLAY_WIDTH = 84;
+async function showAftStatusDialog(pi, extCtx, pluginCtx) {
+  await extCtx.ui.custom((tui, theme, _keybindings, done) => new AftStatusDialogComponent({
+    pi,
+    extCtx,
+    pluginCtx,
+    theme,
+    tui,
+    done
+  }), {
+    overlay: true,
+    overlayOptions: { anchor: "center", width: OVERLAY_WIDTH }
+  });
+}
+
+class AftStatusDialogComponent {
+  props;
+  snapshot = null;
+  errorMessage = null;
+  refreshTimer = null;
+  closed = false;
+  constructor(props) {
+    this.props = props;
+    this.fetchOnce();
+    this.refreshTimer = setInterval(() => {
+      if (this.closed)
+        return;
+      this.fetchOnce();
+    }, REFRESH_INTERVAL_MS);
+  }
+  async fetchOnce() {
+    try {
+      const bridge = bridgeFor(this.props.pluginCtx, this.props.extCtx.cwd);
+      const cached = bridge.getCachedStatus();
+      const response = cached ? { success: true, ...cached } : await callBridge(bridge, "status", {}, this.props.extCtx);
+      if (!cached) {
+        bridge.cacheStatusSnapshot(response);
+      }
+      if (this.closed)
+        return;
+      this.snapshot = coerceAftStatus(response);
+      this.errorMessage = null;
+      this.props.tui.requestRender();
+    } catch (err) {
+      if (this.closed)
+        return;
+      this.errorMessage = err instanceof Error ? err.message : String(err);
+      this.props.tui.requestRender();
+    }
+  }
+  handleInput(data) {
+    if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c") || matchesKey(data, "return")) {
+      this.close();
+    }
+  }
+  close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+    this.props.done(undefined);
+  }
+  invalidate() {}
+  render(width) {
+    const innerWidth = Math.max(40, width - 4);
+    const inner = renderInner(this.snapshot, this.errorMessage, this.props.theme, innerWidth);
+    return drawBorder(inner, width, this.props.theme);
+  }
+  dispose() {
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+  }
+}
+function renderInner(s, error3, theme, innerWidth) {
+  const lines = [];
+  lines.push(`${theme.fg("accent", theme.bold("⚡ AFT Status"))}   ${theme.fg("muted", `v${s?.version ?? package_default.version}`)}`);
+  lines.push("");
+  if (error3 && !s) {
+    lines.push(theme.fg("warning", error3));
+    lines.push("");
+    lines.push(theme.fg("muted", "Press Escape to close"));
+    return lines;
+  }
+  if (!s) {
+    lines.push(theme.fg("muted", "Connecting to AFT…"));
+    return lines;
+  }
+  lines.push(rowFull("Project root", s.project_root ?? "(not configured)", theme, innerWidth));
+  lines.push(rowFull("Canonical root", s.canonical_root ?? "(not configured)", theme, innerWidth));
+  const cacheTone = s.cache_role === "main" ? "accent" : s.cache_role === "worktree" ? "warning" : "muted";
+  lines.push(rowFull("Cache role", theme.fg(cacheTone, s.cache_role), theme, innerWidth));
+  lines.push("");
+  const colWidth = Math.floor((innerWidth - 2) / 2);
+  const left = [];
+  const right = [];
+  left.push(theme.fg("muted", "Search index"));
+  left.push(kv("status", colorStatus(s.search_index.status, theme), theme));
+  left.push(kv("files", formatCountShort(s.search_index.files), theme));
+  left.push(kv("trigrams", formatCountShort(s.search_index.trigrams), theme));
+  left.push(kv("disk", formatBytes(s.disk.trigram_disk_bytes), theme));
+  right.push(theme.fg("muted", "Semantic index"));
+  right.push(kv("status", colorStatus(s.semantic_index.status, theme), theme));
+  right.push(kv("entries", formatCountShort(s.semantic_index.entries), theme));
+  if (s.semantic_index.backend)
+    right.push(kv("backend", s.semantic_index.backend, theme));
+  if (s.semantic_index.model)
+    right.push(kv("model", s.semantic_index.model, theme));
+  if (s.semantic_index.dimension != null) {
+    right.push(kv("dimension", String(s.semantic_index.dimension), theme));
+  }
+  right.push(kv("disk", formatBytes(s.disk.semantic_disk_bytes), theme));
+  for (const line of renderColumns(left, right, colWidth))
+    lines.push(line);
+  lines.push("");
+  const left2 = [];
+  const right2 = [];
+  left2.push(theme.fg("muted", "Runtime"));
+  left2.push(kv("LSP servers", String(s.lsp_servers), theme));
+  left2.push(kv("symbol cache", `${formatCountShort(s.symbol_cache.local_entries)} local · ${formatCountShort(s.symbol_cache.warm_entries)} warm`, theme));
+  right2.push(theme.fg("muted", "Current session"));
+  right2.push(kv("tracked files", String(s.session.tracked_files), theme));
+  right2.push(kv("checkpoints", String(s.session.checkpoints), theme));
+  right2.push(kv("all-session", String(s.checkpoints_total), theme));
+  for (const line of renderColumns(left2, right2, colWidth))
+    lines.push(line);
+  lines.push("");
+  lines.push(theme.fg("muted", "Features"));
+  lines.push(`  ${featureBadge("format_on_edit", s.features.format_on_edit, theme)}  ${featureBadge("search_index", s.features.search_index, theme)}  ${featureBadge("semantic_search", s.features.semantic_search, theme)}`);
+  if (s.semantic_index.stage) {
+    lines.push("");
+    lines.push(theme.fg("muted", "Semantic build progress"));
+    lines.push(kv("stage", s.semantic_index.stage, theme));
+    if (s.semantic_index.files != null) {
+      lines.push(kv("files seen", formatCountShort(s.semantic_index.files), theme));
+    }
+    if (s.semantic_index.entries_done != null || s.semantic_index.entries_total != null) {
+      lines.push(kv("progress", `${formatCountShort(s.semantic_index.entries_done ?? null)} / ${formatCountShort(s.semantic_index.entries_total ?? null)}`, theme));
+    }
+  }
+  if (s.semantic_index.error) {
+    lines.push("");
+    lines.push(theme.fg("error", `⚠ ${s.semantic_index.error}`));
+  }
+  if (error3) {
+    lines.push("");
+    lines.push(theme.fg("warning", `⚠ ${error3}`));
+  }
+  lines.push("");
+  lines.push(theme.fg("muted", "Press Escape to close"));
+  return lines;
+}
+function colorStatus(status, theme) {
+  switch (status) {
+    case "ready":
+      try {
+        return theme.fg("success", status);
+      } catch {
+        return theme.fg("accent", status);
+      }
+    case "loading":
+    case "building":
+      return theme.fg("warning", status);
+    case "failed":
+    case "error":
+      return theme.fg("error", status);
+    case "disabled":
+      return theme.fg("muted", status);
+    default:
+      return status;
+  }
+}
+function featureBadge(name, enabled, theme) {
+  const indicator = enabled ? theme.fg("accent", "●") : theme.fg("muted", "○");
+  const label = enabled ? name : theme.fg("muted", name);
+  return `${indicator} ${label}`;
+}
+function kv(label, value, theme) {
+  return `  ${theme.fg("muted", `${label}:`)} ${value}`;
+}
+function rowFull(label, value, theme, innerWidth) {
+  const labelText = `${label}: `;
+  const remaining = Math.max(10, innerWidth - visibleWidth(labelText));
+  const truncated = truncateToWidth(value, remaining, "…");
+  return `${theme.fg("muted", labelText)}${truncated}`;
+}
+function renderColumns(left, right, colWidth) {
+  const rows = Math.max(left.length, right.length);
+  const out = [];
+  for (let i = 0;i < rows; i++) {
+    const l = left[i] ?? "";
+    const r = right[i] ?? "";
+    const visible = visibleWidth(l);
+    const pad = " ".repeat(Math.max(0, colWidth - visible));
+    out.push(`${l}${pad}  ${r}`);
+  }
+  return out;
+}
+function drawBorder(inner, width, theme) {
+  const innerWidth = Math.max(40, width - 4);
+  const border = (s) => theme.fg("borderMuted", s);
+  const top = border(`╭${"─".repeat(innerWidth + 2)}╮`);
+  const bottom = border(`╰${"─".repeat(innerWidth + 2)}╯`);
+  const side = border("│");
+  const out = [];
+  out.push(top);
+  for (const raw of inner) {
+    const line = truncateToWidth(raw, innerWidth, "…");
+    const visible = visibleWidth(line);
+    const pad = " ".repeat(Math.max(0, innerWidth - visible));
+    out.push(`${side} ${line}${pad} ${side}`);
+  }
+  out.push(bottom);
+  return out;
+}
+function formatCountShort(value) {
+  if (value == null || !Number.isFinite(value))
+    return "—";
+  if (value >= 1e6)
+    return `${(value / 1e6).toFixed(1)}M`;
+  if (value >= 1000)
+    return `${Math.round(value / 1000)}K`;
+  return String(value);
+}
+
 // src/commands/aft-status.ts
 function registerStatusCommand(pi, ctx) {
   pi.registerCommand("aft-status", {
     description: "Show AFT plugin status (search/semantic indexes, LSP, storage)",
     handler: async (_args, extCtx) => {
       try {
+        if (extCtx.hasUI) {
+          await showAftStatusDialog(pi, extCtx, ctx);
+          return;
+        }
         const bridge = bridgeFor(ctx, extCtx.cwd);
-        const response = await callBridge(bridge, "status", {}, extCtx);
+        const cached = bridge.getCachedStatus();
+        const response = cached ? { success: true, ...cached } : await callBridge(bridge, "status", {}, extCtx);
+        if (!cached) {
+          bridge.cacheStatusSnapshot(response);
+        }
         const snapshot = coerceAftStatus(response);
         const text = formatStatusDialogMessage(snapshot);
-        if (extCtx.hasUI) {
-          await extCtx.ui.input("AFT Status", text);
-        } else {
-          extCtx.ui.notify(text, "info");
-        }
+        extCtx.ui.notify(text, "info");
       } catch (err) {
         const message = `AFT status failed: ${err instanceof Error ? err.message : String(err)}`;
-        if (extCtx.hasUI) {
+        try {
           extCtx.ui.notify(message, "error");
-        } else {
+        } catch {
           console.error(`[aft-plugin] ${message}`);
         }
       }
@@ -48890,13 +49253,13 @@ function registerShutdownCleanup(fn) {
 }
 
 // src/tools/ast.ts
-import { StringEnum } from "@mariozechner/pi-ai";
-import { Type } from "@sinclair/typebox";
+import { StringEnum } from "@earendil-works/pi-ai";
+import { Type } from "typebox";
 
 // src/tools/render-helpers.ts
 import { homedir as homedir7 } from "node:os";
-import { renderDiff } from "@mariozechner/pi-coding-agent";
-import { Container, Spacer, Text } from "@mariozechner/pi-tui";
+import { renderDiff } from "@earendil-works/pi-coding-agent";
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
 function reuseText(last) {
   return last instanceof Text ? last : new Text("", 0, 0);
 }
@@ -49290,8 +49653,8 @@ function registerAstTools(pi, ctx, surface) {
 }
 
 // src/tools/bash.ts
-import { Container as Container2, Spacer as Spacer2, Text as Text2 } from "@mariozechner/pi-tui";
-import { Type as Type2 } from "@sinclair/typebox";
+import { Container as Container2, Spacer as Spacer2, Text as Text2 } from "@earendil-works/pi-tui";
+import { Type as Type2 } from "typebox";
 var FOREGROUND_WAIT_WINDOW_MS = 5000;
 var FOREGROUND_POLL_INTERVAL_MS = 100;
 var BASH_TRANSPORT_TIMEOUT_MS = 30000;
@@ -49625,7 +49988,7 @@ function shortenCommand(command) {
 }
 
 // src/tools/conflicts.ts
-import { Type as Type3 } from "@sinclair/typebox";
+import { Type as Type3 } from "typebox";
 var ConflictsParams = Type3.Object({});
 function renderConflictCall(theme, context) {
   return renderToolCall("conflicts", undefined, theme, context);
@@ -49674,7 +50037,7 @@ function registerConflictsTool(pi, ctx) {
 }
 
 // src/tools/fs.ts
-import { Type as Type4 } from "@sinclair/typebox";
+import { Type as Type4 } from "typebox";
 var DeleteParams = Type4.Object({
   files: Type4.Array(Type4.String(), {
     description: "Paths to delete (one or more). Single-file callers pass a single-element array.",
@@ -49796,12 +50159,12 @@ function registerFsTools(pi, ctx, surface) {
 // src/tools/hoisted.ts
 import { stat } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { resolve as resolve3 } from "node:path";
+import { isAbsolute, relative as relative3, resolve as resolve3 } from "node:path";
 import {
   renderDiff as renderDiff2
-} from "@mariozechner/pi-coding-agent";
-import { Container as Container3, Spacer as Spacer3, Text as Text3 } from "@mariozechner/pi-tui";
-import { Type as Type5 } from "@sinclair/typebox";
+} from "@earendil-works/pi-coding-agent";
+import { Container as Container3, Spacer as Spacer3, Text as Text3 } from "@earendil-works/pi-tui";
+import { Type as Type5 } from "typebox";
 
 // src/tools/diff-format.ts
 import { diffLines } from "diff";
@@ -49906,6 +50269,21 @@ function formatDiffForPi(oldContent, newContent, contextLines = DEFAULT_CONTEXT_
 }
 
 // src/tools/hoisted.ts
+function containsPath(parent, child) {
+  const rel = relative3(parent, child);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+async function assertExternalDirectoryPermission(extCtx, target, action = "modify") {
+  if (!target)
+    return;
+  const absoluteTarget = isAbsolute(target) ? target : resolve3(extCtx.cwd, target);
+  if (containsPath(extCtx.cwd, absoluteTarget))
+    return;
+  const confirmed = await extCtx.ui?.confirm?.("Allow external directory access?", `AFT wants to ${action} outside the project: ${absoluteTarget}`);
+  if (confirmed === true)
+    return;
+  throw new Error("Permission denied: external directory access was cancelled.");
+}
 var ReadParams = Type5.Object({
   path: Type5.String({ description: "Path to the file to read (relative or absolute)" }),
   offset: Type5.Optional(Type5.Number({ description: "Line number to start reading from (1-indexed)" })),
@@ -49977,6 +50355,7 @@ function registerHoistedTools(pi, ctx, surface) {
       promptGuidelines: ["Use write only for new files or complete rewrites."],
       parameters: WriteParams,
       async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
+        await assertExternalDirectoryPermission(extCtx, params.filePath);
         const bridge = bridgeFor(ctx, extCtx.cwd);
         const response = await callBridge(bridge, "write", {
           file: params.filePath,
@@ -50007,6 +50386,7 @@ function registerHoistedTools(pi, ctx, surface) {
       ],
       parameters: EditParams,
       async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
+        await assertExternalDirectoryPermission(extCtx, params.filePath);
         const bridge = bridgeFor(ctx, extCtx.cwd);
         if (typeof params.appendContent === "string") {
           const req2 = {
@@ -50052,8 +50432,10 @@ function registerHoistedTools(pi, ctx, surface) {
       async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
         const bridge = bridgeFor(ctx, extCtx.cwd);
         const req = { pattern: params.pattern };
-        if (params.path)
+        if (params.path) {
+          await assertExternalDirectoryPermission(extCtx, params.path, "search");
           req.path = await resolvePathArg(extCtx.cwd, params.path);
+        }
         if (params.include)
           req.include = splitIncludeGlobs(params.include);
         if (params.caseSensitive !== undefined)
@@ -50265,8 +50647,8 @@ function formatReadFooter(agentSpecifiedRange, data) {
 }
 
 // src/tools/imports.ts
-import { StringEnum as StringEnum2 } from "@mariozechner/pi-ai";
-import { Type as Type6 } from "@sinclair/typebox";
+import { StringEnum as StringEnum2 } from "@earendil-works/pi-ai";
+import { Type as Type6 } from "typebox";
 var ImportParams = Type6.Object({
   op: StringEnum2(["add", "remove", "organize"], { description: "Import operation" }),
   filePath: Type6.String({ description: "Path to the file" }),
@@ -50363,8 +50745,8 @@ function registerImportTools(pi, ctx) {
 }
 
 // src/tools/lsp.ts
-import { StringEnum as StringEnum3 } from "@mariozechner/pi-ai";
-import { Type as Type7 } from "@sinclair/typebox";
+import { StringEnum as StringEnum3 } from "@earendil-works/pi-ai";
+import { Type as Type7 } from "typebox";
 var LspDiagnosticsParams = Type7.Object({
   filePath: Type7.Optional(Type7.String({ description: "File to get diagnostics for (mutually exclusive with directory)" })),
   directory: Type7.Optional(Type7.String({
@@ -50457,8 +50839,8 @@ function registerLspTools(pi, ctx) {
 }
 
 // src/tools/navigate.ts
-import { StringEnum as StringEnum4 } from "@mariozechner/pi-ai";
-import { Type as Type8 } from "@sinclair/typebox";
+import { StringEnum as StringEnum4 } from "@earendil-works/pi-ai";
+import { Type as Type8 } from "typebox";
 function navigateParamsSchema() {
   return Type8.Object({
     op: StringEnum4(["call_tree", "callers", "trace_to", "impact", "trace_data"], {
@@ -50620,7 +51002,7 @@ function registerNavigateTool(pi, ctx) {
 // src/tools/reading.ts
 import { stat as stat2 } from "node:fs/promises";
 import { resolve as resolve4 } from "node:path";
-import { Type as Type9 } from "@sinclair/typebox";
+import { Type as Type9 } from "typebox";
 var OutlineParams = Type9.Object({
   target: Type9.Union([Type9.String(), Type9.Array(Type9.String())], {
     description: "What to outline: a file path, directory path, URL (http:// or https://), or array of file paths. The mode is auto-detected: URLs by `http://`/`https://` prefix, directories by stat, arrays as multi-file. Directory walks cap at 200 files."
@@ -50880,8 +51262,8 @@ ${lines}`;
 }
 
 // src/tools/refactor.ts
-import { StringEnum as StringEnum5 } from "@mariozechner/pi-ai";
-import { Type as Type10 } from "@sinclair/typebox";
+import { StringEnum as StringEnum5 } from "@earendil-works/pi-ai";
+import { Type as Type10 } from "typebox";
 var RefactorParams = Type10.Object({
   op: StringEnum5(["move", "extract", "inline"], { description: "Refactoring operation" }),
   filePath: Type10.String({ description: "Source file" }),
@@ -50977,8 +51359,8 @@ function registerRefactorTool(pi, ctx) {
 }
 
 // src/tools/safety.ts
-import { StringEnum as StringEnum6 } from "@mariozechner/pi-ai";
-import { Type as Type11 } from "@sinclair/typebox";
+import { StringEnum as StringEnum6 } from "@earendil-works/pi-ai";
+import { Type as Type11 } from "typebox";
 var SafetyParams = Type11.Object({
   op: StringEnum6(["undo", "history", "checkpoint", "restore", "list"], {
     description: "Safety operation"
@@ -51110,7 +51492,7 @@ function registerSafetyTool(pi, ctx) {
 }
 
 // src/tools/semantic.ts
-import { Type as Type12 } from "@sinclair/typebox";
+import { Type as Type12 } from "typebox";
 var SearchParams2 = Type12.Object({
   query: Type12.String({
     description: "Concept or capability to find, phrased as a programmer would describe the code. Examples: 'fuzzy match with whitespace tolerance', 'undo backup before edit', 'retry failed network request'."
@@ -51139,6 +51521,16 @@ function buildSemanticSections(args, payload, theme) {
     const lines = [theme.fg("accent", shortenPath(file2))];
     fileResults.forEach((result) => {
       const score = asNumber(result.score);
+      const source = asString(result.source);
+      if (source === "lexical") {
+        lines.push(`  ↳ ${theme.fg("muted", `[lexical match${score !== undefined ? ` — score ${score.toFixed(3)}` : ""}]`)}`);
+        const snippet2 = asString(result.snippet);
+        if (snippet2) {
+          lines.push(...snippet2.split(`
+`).map((line) => `     ${line}`));
+        }
+        return;
+      }
       const startLine = asNumber(result.start_line);
       const endLine = asNumber(result.end_line);
       const range = startLine !== undefined ? `${startLine}${endLine && endLine !== startLine ? `-${endLine}` : ""}` : "?";
@@ -51169,21 +51561,21 @@ function registerSemanticTool(pi, ctx) {
     name: "aft_search",
     label: "semantic search",
     description: [
-      "Find symbols by concept when grep keywords fall short. Returns ranked code matches with similarity scores.",
+      "Find symbols by concept using hybrid semantic + lexical search. Returns ranked code matches with similarity scores and provenance tags.",
       "",
       "When to reach for it:",
       "- Exploring an unfamiliar area: 'where is rate limiting handled', 'how does auth flow work'",
       "- Concept doesn't appear as a literal string: 'retry logic', 'cache invalidation', 'graceful shutdown'",
+      "- Filename-shaped concepts: 'the bridge spawn helper', 'the session detection module'",
       "- After 2+ grep attempts that came back empty or noisy",
       "- You know roughly what the function does but not what it's named",
       "",
       "When NOT to use:",
-      "- You have a specific symbol name → use grep",
       "- You have an error message or stack trace → use grep",
       "- You want the file/module structure → use aft_outline",
       "- You're following a call chain → use aft_navigate",
       "",
-      "Scores below ~0.4 are usually weak matches; treat them as 'maybe relevant' and verify with read."
+      "Each result tags `source` as one of: 'semantic' (embedding match only), 'lexical' (trigram exact-token match the embedding lane missed), or 'hybrid' (both lanes agreed — strongest signal)."
     ].join(`
 `),
     parameters: SearchParams2,
@@ -51205,8 +51597,8 @@ function registerSemanticTool(pi, ctx) {
 }
 
 // src/tools/structure.ts
-import { StringEnum as StringEnum7 } from "@mariozechner/pi-ai";
-import { Type as Type13 } from "@sinclair/typebox";
+import { StringEnum as StringEnum7 } from "@earendil-works/pi-ai";
+import { Type as Type13 } from "typebox";
 var TransformParams = Type13.Object({
   op: StringEnum7(["add_member", "add_derive", "wrap_try_catch", "add_decorator", "add_struct_tags"], { description: "Transformation operation" }),
   filePath: Type13.String({ description: "Path to the source file" }),
@@ -51344,8 +51736,8 @@ function buildWorkflowHints(opts) {
     sections.push(`**Web/URL access**: \`aft_outline({ url })\` first for structure, then \`aft_zoom({ url, symbol: "<heading>" })\` for the specific section.`);
   }
   if (hasOutline && hasZoom && (hasGrep || hasSearch)) {
-    const locator = hasGrep && hasSearch ? `\`${grepName}\` or \`aft_search\`` : hasGrep ? `\`${grepName}\`` : "`aft_search`";
-    sections.push(`**Code exploration**: ${locator} to locate → \`aft_outline\` for structure → \`aft_zoom\` for symbol(s).`);
+    const locator = hasGrep ? `\`${grepName}\`` : "`aft_search`";
+    sections.push(hasGrep && hasSearch ? `**Code exploration**: For exact identifiers (\`useState\`, function names, env vars), error messages, or path-shaped queries → \`${grepName}\` first. For broad concepts ('where is X handled', 'how does Y work') → \`aft_search\`. Then use \`aft_outline\` for structure → \`aft_zoom\` for symbol(s).` : `**Code exploration**: ${locator} to locate → \`aft_outline\` for structure → \`aft_zoom\` for symbol(s).`);
   }
   if (hasNavigate) {
     sections.push([
@@ -51546,7 +51938,7 @@ async function src_default(pi) {
   log2(`AFT extension loading (plugin v${PLUGIN_VERSION})`);
   let binaryPath;
   try {
-    binaryPath = await findBinary();
+    binaryPath = await findBinary(PLUGIN_VERSION);
   } catch (err) {
     warn2(`Failed to resolve AFT binary: ${err instanceof Error ? err.message : String(err)}. ` + "Tools will not be registered.");
     return;
@@ -51662,22 +52054,20 @@ ${lines}
         pluginVersion: PLUGIN_VERSION
       });
     },
-    onBashCompletion: (completion, bridge) => {
+    onBashCompletion: (completion) => {
       handlePushedBgCompletion({
         ctx,
         directory: process.cwd(),
         sessionID: completion.session_id,
-        runtime: pi,
-        isActive: () => bridge.hasPendingRequests()
+        runtime: pi
       }, completion);
     },
-    onBashLongRunning: (reminder, bridge) => {
+    onBashLongRunning: (reminder) => {
       handlePushedBgLongRunning({
         ctx,
         directory: process.cwd(),
         sessionID: reminder.session_id,
-        runtime: pi,
-        isActive: () => bridge.hasPendingRequests()
+        runtime: pi
       }, reminder);
     }
   };
@@ -51702,6 +52092,12 @@ ${lines}
         log2(`Eager configure skipped: cwd=${cwd} is the user home directory. ` + `The first real tool call will warm the correct project bridge.`);
         return;
       }
+      if (onnxRuntimePromise) {
+        await Promise.race([
+          onnxRuntimePromise,
+          new Promise((resolve5) => setTimeout(() => resolve5(null), 60000))
+        ]);
+      }
       const bridge = pool.getBridge(cwd);
       await bridge.send("status", {});
     } catch (err) {