@jmylchreest/aide-plugin 0.0.65 → 0.1.0

package/src/hooks/context-guard.ts

@@ -15,6 +15,7 @@ import { readStdin } from "../lib/hook-utils.js";
 import { debug } from "../lib/logger.js";
 import { checkContextGuard, checkSmartReadHint } from "../core/context-guard.js";
 import { findAideBinary } from "../core/aide-client.js";
+import { emitInjectionEvent } from "../core/read-tracking.js";
 
 const SOURCE = "context-guard";
 
@@ -54,9 +55,28 @@ async function main(): Promise<void> {
     const sessionId = data.session_id || "unknown";
 
     const result = checkContextGuard(toolName, toolInput, cwd, sessionId);
+    const binary = findAideBinary({
+      cwd,
+      pluginRoot:
+        process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
+    });
 
     if (result.shouldAdvise && result.advisory) {
       debug(SOURCE, `Advising on large file read`);
+      if (binary) {
+        try {
+          emitInjectionEvent(binary, cwd, {
+            source: SOURCE,
+            subtype: "guard",
+            name: "large-file-advisory",
+            content: result.advisory,
+            sessionId,
+            attrs: { tool: toolName },
+          });
+        } catch {
+          // Non-fatal
+        }
+      }
       const output: HookOutput = {
         continue: true,
         hookSpecificOutput: {
@@ -67,14 +87,23 @@ async function main(): Promise<void> {
       console.log(JSON.stringify(output));
     } else {
       // Smart read hint: suggest code index for re-reads of unchanged files
-      const binary = findAideBinary({
-        cwd,
-        pluginRoot:
-          process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
-      });
       const hintResult = checkSmartReadHint(toolName, toolInput, cwd, binary);
       if (hintResult.shouldHint && hintResult.hint) {
         debug(SOURCE, `Smart read hint triggered`);
+        if (binary) {
+          try {
+            emitInjectionEvent(binary, cwd, {
+              source: SOURCE,
+              subtype: "guard",
+              name: "smart-read-hint",
+              content: hintResult.hint,
+              sessionId,
+              attrs: { tool: toolName },
+            });
+          } catch {
+            // Non-fatal
+          }
+        }
         const output: HookOutput = {
           continue: true,
           hookSpecificOutput: {

package/src/hooks/context-pruning.ts

@@ -21,6 +21,8 @@ import type { ToolRecord } from "../core/context-pruning/types.js";
 import { tmpdir } from "os";
 import { join } from "path";
 import { existsSync, readFileSync, writeFileSync } from "fs";
+import { findAideBinary } from "../core/aide-client.js";
+import { emitInjectionEvent } from "../core/read-tracking.js";
 
 const SOURCE = "context-pruning";
 
@@ -184,6 +186,31 @@ async function main(): Promise<void> {
         saveHistory(sessionId, tracker.getHistory(), explained);
       }
 
+      try {
+        const binary = findAideBinary({
+          cwd,
+          pluginRoot:
+            process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
+        });
+        const injected = output.hookSpecificOutput?.additionalContext;
+        if (binary && injected) {
+          emitInjectionEvent(binary, cwd, {
+            source: SOURCE,
+            subtype: "pruning",
+            name: result.strategy || "prune",
+            content: injected,
+            sessionId,
+            attrs: {
+              tool: toolName,
+              strategy: result.strategy ?? "",
+              bytes_saved: String(result.bytesSaved ?? 0),
+            },
+          });
+        }
+      } catch {
+        // Non-fatal
+      }
+
       console.log(JSON.stringify(output));
     } else {
       console.log(JSON.stringify({ continue: true }));

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,12 +24,14 @@ 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 { recordTokenEvent } from "../core/read-tracking.js";
+import { findProjectRoot } from "../lib/project-root.js";
+import { emitInjectionEvent } from "../core/read-tracking.js";
 import {
   ensureDirectories as coreEnsureDirectories,
   loadConfig as coreLoadConfig,
+  loadGlobalConfig as coreLoadGlobalConfig,
   initializeSession as coreInitializeSession,
   cleanupStaleStateFiles as coreCleanupStaleStateFiles,
   resetHudState as coreResetHudState,
@@ -340,13 +342,35 @@ async function main(): Promise<void> {
     }
 
     const data: HookInput = JSON.parse(input);
-    const cwd = data.cwd || process.cwd();
+    const launchedCwd = data.cwd || process.cwd();
     const sessionId = data.session_id || "unknown";
 
+    // Resolve the project root so we never plant a sibling .aide/ in a
+    // subdirectory of a git repo. Mirrors the Go binary's findProjectRoot().
+    const { root: resolvedRoot, hasMarker } = findProjectRoot(launchedCwd);
+    if (!hasMarker) {
+      const requireGit = coreLoadGlobalConfig().requireGit ?? true;
+      if (requireGit) {
+        process.stderr.write(
+          `[aide] No .git/ or .aide/ found walking up from ${launchedCwd}. ` +
+            `Set \`requireGit\`: false in ~/.aide/config/aide.json to allow ` +
+            `init in arbitrary directories. Skipping AIDE bootstrap.\n`,
+        );
+        console.log(JSON.stringify({ continue: true }));
+        return;
+      }
+      process.stderr.write(
+        `[aide] No project root found, falling back to ${launchedCwd} (requireGit=false).\n`,
+      );
+    }
+    const cwd = hasMarker ? resolvedRoot : launchedCwd;
+
     // Switch debug logging to project-local logs
     setDebugCwd(cwd);
 
-    debugLog(`Parsed input: cwd=${cwd}, sessionId=${sessionId.slice(0, 8)}`);
+    debugLog(
+      `Parsed input: cwd=${cwd}, launchedCwd=${launchedCwd}, sessionId=${sessionId.slice(0, 8)}`,
+    );
 
     // Initialize logger
     log = new Logger("session-start", cwd);
@@ -365,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...");
@@ -459,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));