@jmylchreest/aide-plugin 0.0.66 → 0.1.1

package/src/hooks/pre-tool-enforcer.ts

@@ -14,6 +14,7 @@ import { readStdin } from "../lib/hook-utils.js";
 import { debug } from "../lib/logger.js";
 import { evaluateToolUse } from "../core/tool-enforcement.js";
 import { findAideBinary, getState } from "../core/aide-client.js";
+import { emitInjectionEvent } from "../core/read-tracking.js";
 
 const SOURCE = "pre-tool-enforcer";
 
@@ -49,17 +50,19 @@ async function main(): Promise<void> {
     const toolName = data.tool_name || "";
     const agentName = data.agent_name || "";
     const cwd = data.cwd || process.cwd();
+    const sessionId = data.session_id || "";
 
     // Resolve active mode from aide binary (source of truth: BBolt store)
     let activeMode: string | null = null;
+    let aideBinary: string | null = null;
     try {
-      const binary = findAideBinary({
+      aideBinary = findAideBinary({
         cwd,
         pluginRoot:
           process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
       });
-      if (binary) {
-        activeMode = getState(binary, cwd, "mode");
+      if (aideBinary) {
+        activeMode = getState(aideBinary, cwd, "mode");
       }
     } catch (err) {
       debug(SOURCE, `Failed to resolve active mode (non-fatal): ${err}`);
@@ -81,6 +84,23 @@ async function main(): Promise<void> {
     }
 
     if (result.reminder) {
+      if (aideBinary) {
+        try {
+          emitInjectionEvent(aideBinary, cwd, {
+            source: SOURCE,
+            subtype: "guard",
+            content: result.reminder,
+            sessionId,
+            attrs: {
+              tool: toolName,
+              ...(agentName ? { agent: agentName } : {}),
+              ...(activeMode ? { mode: activeMode } : {}),
+            },
+          });
+        } catch {
+          // Non-fatal — telemetry must not block tool use
+        }
+      }
       const output: HookOutput = {
         continue: true,
         hookSpecificOutput: {

package/src/hooks/reflect.ts

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * Reflect Hook (Stop)
+ *
+ * Runs the instinct parser catalogue against the session's observe events
+ * when AIDE_REFLECT is truthy (1/true/on/yes). Off by default.
+ *
+ * Fire-and-forget: never blocks Stop, never returns an error to the harness.
+ */
+
+import { execFileSync } from "child_process";
+import { readStdin } from "../lib/hook-utils.js";
+import { findAideBinary } from "../core/aide-client.js";
+import { debug } from "../lib/logger.js";
+
+const SOURCE = "reflect";
+
+interface HookInput {
+  hook_event_name: string;
+  session_id: string;
+  cwd: string;
+}
+
+async function main(): Promise<void> {
+  try {
+    // The CLI itself checks env + .aide/config/aide.json reflect.enabled
+    // and no-ops when disabled, so the hook can invoke unconditionally. This
+    // is a 1-process spawn at session end — negligible overhead even when
+    // disabled.
+
+    const input = await readStdin();
+    if (!input.trim()) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    const data: HookInput = JSON.parse(input);
+    const cwd = data.cwd || process.cwd();
+    const sessionID = data.session_id;
+    if (!sessionID) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    const binary = findAideBinary({ cwd });
+    if (!binary) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    try {
+      execFileSync(binary, ["reflect", "run", `--session=${sessionID}`], {
+        cwd,
+        timeout: 10000,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      debug(SOURCE, `reflect run session=${sessionID} ok`);
+    } catch (err) {
+      debug(SOURCE, `reflect run failed (non-fatal): ${err}`);
+    }
+
+    console.log(JSON.stringify({}));
+  } catch (err) {
+    debug(SOURCE, `error: ${err}`);
+    console.log(JSON.stringify({}));
+  }
+}
+
+void main();

package/src/hooks/search-enrichment.ts

@@ -15,7 +15,7 @@ import { readStdin } from "../lib/hook-utils.js";
 import { debug } from "../lib/logger.js";
 import { checkSearchEnrichment } from "../core/search-enrichment.js";
 import { findAideBinary } from "../core/aide-client.js";
-import { recordTokenEvent } from "../core/read-tracking.js";
+import { emitInjectionEvent } from "../core/read-tracking.js";
 
 const SOURCE = "search-enrichment";
 
@@ -50,6 +50,7 @@ async function main(): Promise<void> {
     const toolName = data.tool_name || "";
     const toolInput = data.tool_input || {};
     const cwd = data.cwd || process.cwd();
+    const sessionId = data.session_id || "";
 
     const binary = findAideBinary({
       cwd,
@@ -62,11 +63,18 @@ async function main(): Promise<void> {
     if (result.shouldEnrich && result.enrichment) {
       debug(SOURCE, `Enriching grep with code index context`);
 
-      // Record token event for search enrichment
       if (binary) {
         try {
-          const tokens = Math.round(result.enrichment.length / 3.0);
-          recordTokenEvent(binary, cwd, "context_injected", "enrichment", "search-enrichment", tokens);
+          // `name: "enrichment"` is load-bearing: the TokensPage by_delivery
+          // rollup keys on Event.Name via observeToTokenEvent.
+          emitInjectionEvent(binary, cwd, {
+            source: SOURCE,
+            subtype: "enrichment",
+            name: "enrichment",
+            content: result.enrichment,
+            sessionId,
+            attrs: { tool: toolName },
+          });
         } catch {
           // Non-fatal
         }

package/src/hooks/session-end.ts

@@ -27,10 +27,41 @@ const T0 = performance.now();
 console.log(JSON.stringify({ continue: true }));
 
 const { spawn, execFileSync } = require("child_process") as typeof import("child_process");
-const { existsSync, realpathSync, appendFileSync, mkdirSync, readFileSync } = require("fs") as typeof import("fs");
-const { join } = require("path") as typeof import("path");
+const { existsSync, realpathSync, appendFileSync, mkdirSync, readFileSync, statSync } = require("fs") as typeof import("fs");
+const { join, dirname } = require("path") as typeof import("path");
 const whichSync = (require("which") as typeof import("which")).sync;
 
+/**
+ * Inline walk-up for project root — mirrors lib/project-root.ts logic
+ * (priority: both markers > VCS > .aide/-only > cwd). Inlined here to keep
+ * this hook's startup cheap (no extra ES imports).
+ */
+function resolveRoot(cwd: string): string {
+  const override = process.env.AIDE_PROJECT_ROOT;
+  if (override) {
+    try {
+      if (statSync(override).isDirectory()) return override;
+    } catch { /* fall through */ }
+  }
+  const candidates: { dir: string; hasAide: boolean; hasVCS: boolean }[] = [];
+  let dir = cwd;
+  for (;;) {
+    const hasAide = existsSync(join(dir, ".aide"));
+    let hasVCS = false;
+    for (const m of [".git", ".hg", ".svn", ".bzr", ".fossil"]) {
+      if (existsSync(join(dir, m))) { hasVCS = true; break; }
+    }
+    if (hasAide || hasVCS) candidates.push({ dir, hasAide, hasVCS });
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  for (const c of candidates) if (c.hasAide && c.hasVCS) return c.dir;
+  for (const c of candidates) if (c.hasVCS) return c.dir;
+  for (const c of candidates) if (c.hasAide) return c.dir;
+  return cwd;
+}
+
 const SESSION_ID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
 
 /** Elapsed ms since T0. */
@@ -44,7 +75,7 @@ function ms(): string {
  */
 function log(cwd: string, msg: string): void {
   try {
-    const logDir = join(cwd, ".aide", "_logs");
+    const logDir = join(resolveRoot(cwd), ".aide", "_logs");
     if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
     const line = `[${new Date().toISOString()}] [session-end] ${ms()} ${msg}\n`;
     appendFileSync(join(logDir, "session-end.log"), line);
@@ -61,7 +92,7 @@ function findBinary(cwd?: string): string | null {
     if (existsSync(p)) return p;
   }
   if (cwd) {
-    const p = join(cwd, ".aide", "bin", "aide");
+    const p = join(resolveRoot(cwd), ".aide", "bin", "aide");
     if (existsSync(p)) return p;
   }
   try {

package/src/hooks/session-start.ts

@@ -24,10 +24,10 @@ import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { homedir } from "os";
 import { Logger, debug, setDebugCwd } from "../lib/logger.js";
-import { readStdin, detectPlatform } from "../lib/hook-utils.js";
+import { readStdin, detectPlatform, isFalsy } from "../lib/hook-utils.js";
 import { findAideBinary, ensureAideBinary } from "../lib/aide-downloader.js";
 import { findProjectRoot } from "../lib/project-root.js";
-import { recordTokenEvent } from "../core/read-tracking.js";
+import { emitInjectionEvent } from "../core/read-tracking.js";
 import {
   ensureDirectories as coreEnsureDirectories,
   loadConfig as coreLoadConfig,
@@ -389,32 +389,38 @@ async function main(): Promise<void> {
     installHudWrapper(log);
     debugLog(`installHudWrapper complete (${Date.now() - hookStart}ms)`);
 
-    // Sync MCP server configs across assistants (FS only, fast)
-    debugLog("mcpSync starting...");
-    log.start("mcpSync");
-    try {
-      const mcpResult = syncMcpServers(detectPlatform(), cwd);
-      const totalImported =
-        mcpResult.user.imported + mcpResult.project.imported;
-      const totalWritten =
-        mcpResult.user.serversWritten + mcpResult.project.serversWritten;
-      const totalSkipped = mcpResult.user.skipped + mcpResult.project.skipped;
-      log.end("mcpSync", {
-        userServers: mcpResult.user.serversWritten,
-        projectServers: mcpResult.project.serversWritten,
-        imported: totalImported,
-        skipped: totalSkipped,
-      });
-      if (totalImported > 0) {
-        debugLog(
-          `mcp-sync: imported ${totalImported} server(s), ${totalWritten} total`,
-        );
+    // Sync MCP server configs across assistants (FS only, fast).
+    // Opt-out via AIDE_MCP_SYNC=0 (defaults to enabled).
+    if (isFalsy(process.env.AIDE_MCP_SYNC)) {
+      debugLog("mcpSync disabled via AIDE_MCP_SYNC");
+      log.info("MCP sync disabled (AIDE_MCP_SYNC falsy)");
+    } else {
+      debugLog("mcpSync starting...");
+      log.start("mcpSync");
+      try {
+        const mcpResult = syncMcpServers(detectPlatform(), cwd);
+        const totalImported =
+          mcpResult.user.imported + mcpResult.project.imported;
+        const totalWritten =
+          mcpResult.user.serversWritten + mcpResult.project.serversWritten;
+        const totalSkipped = mcpResult.user.skipped + mcpResult.project.skipped;
+        log.end("mcpSync", {
+          userServers: mcpResult.user.serversWritten,
+          projectServers: mcpResult.project.serversWritten,
+          imported: totalImported,
+          skipped: totalSkipped,
+        });
+        if (totalImported > 0) {
+          debugLog(
+            `mcp-sync: imported ${totalImported} server(s), ${totalWritten} total`,
+          );
+        }
+      } catch (err) {
+        log.warn("MCP sync failed (non-fatal)", err);
+        log.end("mcpSync", { success: false, error: String(err) });
       }
-    } catch (err) {
-      log.warn("MCP sync failed (non-fatal)", err);
-      log.end("mcpSync", { success: false, error: String(err) });
+      debugLog(`mcpSync complete (${Date.now() - hookStart}ms)`);
     }
-    debugLog(`mcpSync complete (${Date.now() - hookStart}ms)`);
 
     // Check that aide binary is available (auto-downloads if missing/outdated)
     debugLog("checkAideBinary starting...");
@@ -483,26 +489,30 @@ async function main(): Promise<void> {
     log.end("buildWelcomeContext");
     debugLog(`buildWelcomeContext complete (${Date.now() - hookStart}ms)`);
 
-    // Record token events for context injection
     try {
       const binary = findAideBinary(cwd);
-      if (binary && context) {
-        const memoryTokens = Math.round(
-          ([...memories.static.global, ...memories.static.project, ...memories.dynamic.sessions]
-            .join("").length) / 3.0
-        );
-        const decisionTokens = Math.round(
-          memories.static.decisions.join("").length / 3.0
-        );
-        if (memoryTokens > 0) {
-          recordTokenEvent(binary, cwd, "context_injected", "memory", "session-start", memoryTokens);
-        }
-        if (decisionTokens > 0) {
-          recordTokenEvent(binary, cwd, "context_injected", "decision", "session-start", decisionTokens);
+      if (binary && context && memories.sources) {
+        for (const src of memories.sources) {
+          const attrs: Record<string, string> = { scope: src.scope };
+          if (src.category) attrs.category = src.category;
+          if (src.tags && src.tags.length > 0) attrs.tags = src.tags.join(",");
+          if (src.sessionId) attrs.source_session_id = src.sessionId;
+          if (typeof src.score === "number") {
+            attrs.score_at_injection = src.score.toFixed(2);
+          }
+
+          emitInjectionEvent(binary, cwd, {
+            source: SOURCE,
+            subtype: src.kind,
+            name: src.name,
+            content: src.content,
+            sessionId,
+            attrs: { ...attrs, source_id: src.id },
+          });
         }
       }
     } catch {
-      // Non-fatal — don't break session start for token tracking
+      // Non-fatal — don't break session start for telemetry
     }
 
     log.end("total");

package/src/hooks/skill-injector.ts

@@ -19,6 +19,7 @@ import { existsSync, mkdirSync } from "fs";
 import { join } from "path";
 import { Logger, debug, setDebugCwd } from "../lib/logger.js";
 import { readStdin, detectPlatform } from "../lib/hook-utils.js";
+import { findProjectRoot } from "../lib/project-root.js";
 import {
   discoverSkills as coreDiscoverSkills,
   matchSkills as coreMatchSkills,
@@ -26,7 +27,12 @@ import {
 } from "../core/skill-matcher.js";
 import type { Skill } from "../core/types.js";
 import { findAideBinary } from "../core/aide-client.js";
-import { recordObserveEvent } from "../core/read-tracking.js";
+import {
+  recordObserveEvent,
+  previewContent,
+  emitInjectionEvent,
+} from "../core/read-tracking.js";
+import { reflectEnabled } from "../lib/hook-utils.js";
 
 const SOURCE = "skill-injector";
 
@@ -57,12 +63,15 @@ let log: Logger | null = null;
  * Ensure .aide directories exist (minimal version for skill-injector)
  */
 function ensureDirectories(cwd: string): void {
+  // Resolve to the canonical project root so we don't plant a stray .aide/
+  // in a subdir the harness happened to launch from. See lib/project-root.ts.
+  const { root } = findProjectRoot(cwd);
   const dirs = [
-    join(cwd, ".aide"),
-    join(cwd, ".aide", "skills"),
-    join(cwd, ".aide", "config"),
-    join(cwd, ".aide", "state"),
-    join(cwd, ".aide", "memory"),
+    join(root, ".aide"),
+    join(root, ".aide", "skills"),
+    join(root, ".aide", "config"),
+    join(root, ".aide", "state"),
+    join(root, ".aide", "memory"),
   ];
 
   for (const dir of dirs) {
@@ -156,6 +165,7 @@ async function main(): Promise<void> {
     const data: HookInput = JSON.parse(input);
     const prompt = data.prompt || "";
     const cwd = data.cwd || process.cwd();
+    const sessionId = data.session_id || "";
 
     // Switch debug logging to project-local logs
     setDebugCwd(cwd);
@@ -175,6 +185,27 @@ async function main(): Promise<void> {
     log.end("ensureDirectories");
     debugLog(`ensureDirectories complete (${Date.now() - hookStart}ms)`);
 
+    // Emit a user-prompt observe event so the convergence detector can find
+    // corrective markers near edit sequences. Gated behind AIDE_REFLECT so
+    // sessions that aren't running reflect don't accrue extra events.
+    if (prompt && reflectEnabled(cwd)) {
+      try {
+        const binary = findAideBinary({ cwd });
+        if (binary) {
+          recordObserveEvent(binary, cwd, {
+            kind: "hook",
+            name: "user_prompt",
+            category: "input",
+            tokens: Math.round(prompt.length / 3.0),
+            session: sessionId,
+            attrs: { text: previewContent(prompt, 2000) },
+          });
+        }
+      } catch {
+        // Non-fatal
+      }
+    }
+
     if (!prompt) {
       debugLog("No prompt provided, exiting");
       log.info("No prompt provided");
@@ -215,14 +246,12 @@ async function main(): Promise<void> {
         if (binary) {
           for (const skill of matched) {
             const text = `### ${skill.name}\n${skill.description ?? ""}\n${skill.content}`;
-            const tokens = Math.round(text.length / 3.0);
-            recordObserveEvent(binary, cwd, {
-              kind: "injection",
-              name: skill.name,
-              category: "inject",
+            emitInjectionEvent(binary, cwd, {
+              source: SOURCE,
               subtype: "skill",
-              tokens,
-              file: SOURCE,
+              name: skill.name,
+              content: text,
+              sessionId,
             });
           }
         }

package/src/hooks/subagent-tracker.ts

@@ -17,8 +17,9 @@
 import { execFileSync } from "child_process";
 import { basename } from "path";
 import { Logger } from "../lib/logger.js";
-import { readStdin, setMemoryState } from "../lib/hook-utils.js";
+import { readStdin, setMemoryState, isFalsy } from "../lib/hook-utils.js";
 import { findAideBinary } from "../core/aide-client.js";
+import { emitInjectionEvent } from "../core/read-tracking.js";
 import { refreshHud } from "../lib/hud.js";
 
 // Global logger instance
@@ -112,8 +113,7 @@ function fetchSubagentMemories(cwd: string): {
     decisions: [] as string[],
   };
 
-  // Check for disable flag
-  if (process.env.AIDE_MEMORY_INJECT === "0") {
+  if (isFalsy(process.env.AIDE_MEMORY_INJECT)) {
     return result;
   }
 
@@ -315,6 +315,11 @@ async function processSubagentStart(
   setAgentState(cwd, agent_id, "type", type);
   setAgentState(cwd, agent_id, "startedAt", new Date().toISOString());
   setAgentState(cwd, agent_id, "session", session_id); // Track which session owns this agent
+  // Parent linkage for swarm queries: the orchestrator (session_id) spawned
+  // this subagent (agent_id). Watch filters key off parent_session.
+  // namespace stamps swarm-scoped memories the subagent creates.
+  setAgentState(cwd, agent_id, "parent_session", session_id);
+  setAgentState(cwd, agent_id, "namespace", `swarm:${session_id}`);
   log?.end("registerAgent");
 
   // Refresh HUD to show the new running agent
@@ -406,6 +411,31 @@ async function main(): Promise<void> {
         hookEventName: "SubagentStart",
         additionalContext,
       };
+      try {
+        const binary = findAideBinary({
+          cwd,
+          pluginRoot:
+            process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
+        });
+        if (binary) {
+          const startData = data as SubagentStartInput;
+          emitInjectionEvent(binary, cwd, {
+            source: "subagent-tracker",
+            subtype: "signal",
+            name: "subagent-priming",
+            content: additionalContext,
+            sessionId: startData.session_id,
+            attrs: {
+              ...(startData.agent_id ? { agent_id: startData.agent_id } : {}),
+              ...(startData.agent_type
+                ? { agent_type: startData.agent_type }
+                : {}),
+            },
+          });
+        }
+      } catch {
+        // Non-fatal
+      }
     }
 
     console.log(JSON.stringify(output));

package/src/hooks/write-guard.ts

@@ -12,6 +12,8 @@
 import { readStdin } from "../lib/hook-utils.js";
 import { debug } from "../lib/logger.js";
 import { checkWriteGuard } from "../core/write-guard.js";
+import { findAideBinary } from "../core/aide-client.js";
+import { emitInjectionEvent } from "../core/read-tracking.js";
 
 const SOURCE = "write-guard";
 
@@ -48,14 +50,35 @@ async function main(): Promise<void> {
     const toolName = data.tool_name || "";
     const toolInput = data.tool_input || {};
     const cwd = data.cwd || process.cwd();
+    const sessionId = data.session_id || "";
 
     const result = checkWriteGuard(toolName, toolInput, cwd);
 
     if (!result.allowed) {
-      debug(
-        SOURCE,
-        `Advisory: Write to existing file: ${toolInput.file_path || toolInput.filePath || toolInput.path}`,
-      );
+      const filePath =
+        (toolInput.file_path as string) ||
+        (toolInput.filePath as string) ||
+        (toolInput.path as string) ||
+        "";
+      debug(SOURCE, `Advisory: Write to existing file: ${filePath}`);
+      try {
+        const binary = findAideBinary({
+          cwd,
+          pluginRoot:
+            process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
+        });
+        if (binary && result.message) {
+          emitInjectionEvent(binary, cwd, {
+            source: SOURCE,
+            subtype: "guard",
+            content: result.message,
+            sessionId,
+            attrs: { tool: toolName, ...(filePath ? { file: filePath } : {}) },
+          });
+        }
+      } catch {
+        // Non-fatal
+      }
       const output: HookOutput = {
         continue: true,
         hookSpecificOutput: {

package/src/lib/hook-utils.ts

@@ -93,6 +93,69 @@ export function detectPlatform(): "claude-code" | "codex" {
   return "claude-code";
 }
 
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { findProjectRoot } from "./project-root.js";
+
+const TRUTHY = new Set(["1", "true", "on", "yes"]);
+const FALSY = new Set(["0", "false", "off", "no"]);
+
+/**
+ * isTruthy reports whether an env-var value should be treated as "on".
+ * Accepts the same set as the Go config helper: 1/true/on/yes
+ * (case-insensitive, whitespace-trimmed). Use for opt-in flags.
+ */
+export function isTruthy(v: string | undefined): boolean {
+  if (!v) return false;
+  return TRUTHY.has(v.trim().toLowerCase());
+}
+
+/**
+ * isFalsy reports whether an env-var value was explicitly set to disable.
+ * Accepts 0/false/off/no. Unset/empty/unknown values return false so the
+ * caller's default-on behaviour wins. Use for opt-out flags.
+ */
+export function isFalsy(v: string | undefined): boolean {
+  if (!v) return false;
+  return FALSY.has(v.trim().toLowerCase());
+}
+
+/**
+ * reflectEnabled mirrors the Go-side config.ResolveReflectEnabled precedence
+ * so TS hooks that need to gate on the reflect setting see the same answer
+ * as `aide reflect run`. Precedence:
+ *
+ *   1. AIDE_REFLECT env (recognised truthy/falsy values win)
+ *   2. .aide/config/aide.json `reflect.enabled` at the resolved project
+ *      root (walks up from cwd via findProjectRoot — does NOT just look
+ *      at cwd/.aide/)
+ *   3. default false
+ *
+ * Used by skill-injector.ts and opencode/hooks.ts to gate the user_prompt
+ * observe-event emit that convergence detection depends on.
+ */
+export function reflectEnabled(cwd: string): boolean {
+  const env = process.env.AIDE_REFLECT;
+  if (env !== undefined && env !== "") {
+    const norm = env.trim().toLowerCase();
+    if (TRUTHY.has(norm)) return true;
+    if (FALSY.has(norm)) return false;
+  }
+  try {
+    const { root } = findProjectRoot(cwd);
+    const cfgPath = join(root, ".aide", "config", "aide.json");
+    if (existsSync(cfgPath)) {
+      const cfg = JSON.parse(readFileSync(cfgPath, "utf-8")) as {
+        reflect?: { enabled?: boolean };
+      };
+      return cfg?.reflect?.enabled === true;
+    }
+  } catch {
+    // Unreadable / malformed config — treat as unset.
+  }
+  return false;
+}
+
 /**
  * Get the plugin root directory from environment variables.
  */

package/src/lib/hud.ts

@@ -9,6 +9,7 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
 import { execFileSync } from "child_process";
 import { runAide, findAideBinary } from "./hook-utils.js";
+import { findProjectRoot } from "./project-root.js";
 
 // Cache the aide version for the session (won't change)
 let aideVersionCache: string | null = null;
@@ -149,7 +150,8 @@ export function getAgentStates(cwd: string): AgentState[] {
  * Load HUD configuration
  */
 export function loadHudConfig(cwd: string): HudConfig {
-  const configPath = join(cwd, ".aide", "config", "hud.json");
+  const { root } = findProjectRoot(cwd);
+  const configPath = join(root, ".aide", "config", "hud.json");
 
   if (existsSync(configPath)) {
     try {
@@ -444,7 +446,8 @@ export function formatHud(
  * Write HUD output to state file
  */
 export function writeHudOutput(cwd: string, output: string): void {
-  const stateDir = join(cwd, ".aide", "state");
+  const { root } = findProjectRoot(cwd);
+  const stateDir = join(root, ".aide", "state");
   if (!existsSync(stateDir)) {
     try {
       mkdirSync(stateDir, { recursive: true });