hotmilk 0.1.11 → 0.1.13

package/src/bootstrap/extensions.ts

@@ -72,11 +72,25 @@ export async function registerBundledExtensions(
 
   if (enabledIds.has("agent-dashboard")) {
     enabledIds.delete("agent-dashboard");
-    const { ensureDashboardWarmStarted } = await import("./dashboard.ts");
-    await ensureDashboardWarmStarted();
+    const { ensureDashboardWarmStarted, logHotmilkDashboardDoctorHint } =
+      await import("./dashboard.ts");
+    const warmStart = await ensureDashboardWarmStarted();
+    if (warmStart.status === "failed" || warmStart.status === "skipped-conflict") {
+      const detail = warmStart.message ?? `port ${warmStart.port}`;
+      console.warn(`[hotmilk] Dashboard warm-start ${warmStart.status}: ${detail}`);
+    } else {
+      logHotmilkDashboardDoctorHint(warmStart);
+    }
     await registerOne(pi, "agent-dashboard");
   }
 
+  if (enabledIds.has("btw")) {
+    const { setHotmilkBtwConfig } = await import("./btw.ts");
+    setHotmilkBtwConfig({ extensionToggles: enabled });
+    await registerOne(pi, "btw");
+    enabledIds.delete("btw");
+  }
+
   await Promise.all([...enabledIds].map((id) => registerOne(pi, id)));
 
   return { globalSkips: appliedSkips };

package/src/bootstrap/resolve-bundled.ts

@@ -1,9 +1,43 @@
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
+const HOTMILK_MODULE_PREFIX = "hotmilk/";
+
+function findHotmilkPackageRoot(fromModuleUrl: string): string {
+  let dir = dirname(fileURLToPath(fromModuleUrl));
+
+  while (true) {
+    const pkgJsonPath = join(dir, "package.json");
+    if (existsSync(pkgJsonPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8")) as { name?: string };
+        if (pkg.name === "hotmilk") {
+          return dir;
+        }
+      } catch {
+        // ignore invalid package.json while walking up
+      }
+    }
+
+    const parent = dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+
+  throw new Error("Cannot locate hotmilk package root");
+}
+
 /** Split `pkg/subpath` — supports scoped packages (`@scope/name/...`). */
 export function parseBundledModulePath(relativePath: string): { pkgName: string; subpath: string } {
+  if (relativePath.startsWith(HOTMILK_MODULE_PREFIX)) {
+    return {
+      pkgName: "hotmilk",
+      subpath: relativePath.slice(HOTMILK_MODULE_PREFIX.length),
+    };
+  }
   if (relativePath.startsWith("@")) {
     const parts = relativePath.split("/");
     return { pkgName: `${parts[0]}/${parts[1]}`, subpath: parts.slice(2).join("/") };
@@ -23,6 +57,16 @@ export function resolveBundledModule(
   relativePath: string,
   fromModuleUrl = import.meta.url,
 ): string {
+  if (relativePath.startsWith(HOTMILK_MODULE_PREFIX)) {
+    const local = join(
+      findHotmilkPackageRoot(fromModuleUrl),
+      relativePath.slice(HOTMILK_MODULE_PREFIX.length),
+    );
+    if (existsSync(local)) {
+      return local;
+    }
+  }
+
   const { pkgName, subpath } = parseBundledModulePath(relativePath);
   let dir = dirname(fileURLToPath(fromModuleUrl));
 
@@ -39,6 +83,13 @@ export function resolveBundledModule(
       }
     }
 
+    if (pkgName === "hotmilk") {
+      const inTree = join(dir, subpath);
+      if (existsSync(inTree)) {
+        return inTree;
+      }
+    }
+
     const parent = dirname(dir);
     if (parent === dir) {
       break;

package/src/bootstrap/subagents-doctor.ts

@@ -0,0 +1,109 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { bundledImportUrl } from "./resolve-bundled.ts";
+
+function ensureAccessibleDir(dirPath: string): void {
+  fs.mkdirSync(dirPath, { recursive: true });
+  fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
+}
+
+/** pi-subagents creates async/results on init but not chain-runs until the first /chain. */
+async function ensureChainRunsDir(): Promise<void> {
+  const types = (await import(
+    bundledImportUrl("pi-subagents/src/shared/types.ts")
+  )) as typeof import("pi-subagents/src/shared/types.ts");
+  ensureAccessibleDir(types.CHAIN_RUNS_DIR);
+}
+
+type DoctorModule = typeof import("pi-subagents/src/extension/doctor.ts");
+type ConfigModule = typeof import("pi-subagents/src/extension/config.ts");
+type IntercomModule = typeof import("pi-subagents/src/intercom/intercom-bridge.ts");
+type SubagentState = import("pi-subagents/src/shared/types.ts").SubagentState;
+
+function expandTilde(value: string): string {
+  return value.startsWith("~/") ? path.join(os.homedir(), value.slice(2)) : value;
+}
+
+function buildDirectDoctorReport(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  deps: {
+    buildDoctorReport: DoctorModule["buildDoctorReport"];
+    loadConfig: ConfigModule["loadConfig"];
+    resolveIntercomSessionTarget: IntercomModule["resolveIntercomSessionTarget"];
+  },
+): string {
+  const config = deps.loadConfig();
+  let currentSessionFile: string | null = null;
+  let currentSessionId: string | null = null;
+  let sessionError: string | undefined;
+
+  try {
+    currentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
+    currentSessionId = ctx.sessionManager.getSessionId();
+  } catch (error) {
+    sessionError = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+  }
+
+  let orchestratorTarget: string | undefined;
+  try {
+    orchestratorTarget = deps.resolveIntercomSessionTarget(
+      pi.getSessionName(),
+      ctx.sessionManager.getSessionId(),
+    );
+  } catch {
+    // Intercom target is optional for the report.
+  }
+
+  return deps.buildDoctorReport({
+    cwd: ctx.cwd,
+    config,
+    state: {
+      baseCwd: ctx.cwd,
+      currentSessionId,
+    } as SubagentState,
+    currentSessionFile,
+    currentSessionId,
+    orchestratorTarget,
+    sessionError,
+    expandTilde,
+  });
+}
+
+/**
+ * pi-subagents registers `/subagents-doctor` through the slash event bridge, which
+ * reads `state.lastUiContext` instead of the command handler's `ctx`. After `/reload`
+ * that context can be unset while the command still runs — override with a direct report.
+ */
+export async function registerSubagentsDoctorCommand(pi: ExtensionAPI): Promise<void> {
+  await ensureChainRunsDir();
+
+  const [doctorMod, configMod, intercomMod] = await Promise.all([
+    import(bundledImportUrl("pi-subagents/src/extension/doctor.ts")) as Promise<DoctorModule>,
+    import(bundledImportUrl("pi-subagents/src/extension/config.ts")) as Promise<ConfigModule>,
+    import(
+      bundledImportUrl("pi-subagents/src/intercom/intercom-bridge.ts")
+    ) as Promise<IntercomModule>,
+  ]);
+
+  const deps = {
+    buildDoctorReport: doctorMod.buildDoctorReport,
+    loadConfig: configMod.loadConfig,
+    resolveIntercomSessionTarget: intercomMod.resolveIntercomSessionTarget,
+  };
+
+  pi.registerCommand("subagents-doctor", {
+    description: "Show subagent diagnostics",
+    handler: async (_args, ctx) => {
+      await ensureChainRunsDir();
+      const report = buildDirectDoctorReport(pi, ctx, deps);
+      pi.sendMessage({
+        customType: "hotmilk-subagents-doctor",
+        content: report,
+        display: true,
+      });
+    },
+  });
+}

package/src/config/bundled-extensions.ts

@@ -100,7 +100,7 @@ export const BUNDLED_EXTENSION_DEFINITIONS = [
   {
     id: "btw",
     package: { packageName: "pi-btw" },
-    module: "pi-btw/extensions/btw.ts",
+    module: "hotmilk/src/extensions/btw.ts",
     group: "Integrations",
   },
   {

package/src/extensions/btw.ts

@@ -0,0 +1,17 @@
+/**
+ * hotmilk shim for pi-btw: patches createAgentSession before upstream loads so BTW
+ * sub-sessions get lighter prompts, read-biased tools when subagents are on, and
+ * optional graphify_query — without vendoring pi-btw (~2k lines).
+ */
+import type { ExtensionAPI, ExtensionFactory } from "@earendil-works/pi-coding-agent";
+import { installHotmilkBtwSessionHook } from "../bootstrap/btw.ts";
+import { bundledImportUrl } from "../bootstrap/resolve-bundled.ts";
+
+installHotmilkBtwSessionHook();
+
+const upstreamModule = await import(bundledImportUrl("pi-btw/extensions/btw.ts"));
+const upstream = upstreamModule.default as ExtensionFactory;
+
+export default async function hotmilkBtw(pi: ExtensionAPI): Promise<void> {
+  await upstream(pi);
+}

package/src/index.ts

@@ -11,18 +11,24 @@ import { registerGraphHandlers } from "./bootstrap/graph.ts";
 import { registerSessionHandlers } from "./bootstrap/session.ts";
 import { registerInputCommands, routeInputCommand } from "./controller/input.ts";
 import { registerHotmilkSessionLogo } from "./ui/session-logo.ts";
+import { installHotmilkCtxSearchCapture } from "./bootstrap/btw.ts";
+import { registerSubagentsDoctorCommand } from "./bootstrap/subagents-doctor.ts";
 
 export default async function registerHotmilk(pi: ExtensionAPI): Promise<void> {
   const runtime = createHotmilkRuntime();
 
   // Register before bundled imports so session_start handlers exist when bindExtensions emits.
   registerHotmilkSessionLogo(pi);
+  installHotmilkCtxSearchCapture(pi);
 
   prepareContextStack(runtime.extensionToggles);
 
   const bundled = await registerBundledExtensions(pi, runtime.extensionToggles, {
     cwd: process.cwd(),
   });
+  if (runtime.extensionToggles.subagents === true) {
+    await registerSubagentsDoctorCommand(pi);
+  }
   runtime.globalExtensionSkips = bundled.globalSkips;
   registerGraphHandlers(pi, runtime.graph);
   registerDefaultsHandlers(pi, runtime.defaults);

package/src/ui/github-user.ts

@@ -13,7 +13,9 @@ function githubUserFromEnv(env: NodeJS.ProcessEnv): string | undefined {
   return env.GITHUB_USER?.trim() || env.GH_USER?.trim() || undefined;
 }
 
-function githubUsernameCommands(cwd: string): Array<{ file: string; args: string[]; cwd?: string }> {
+function githubUsernameCommands(
+  cwd: string,
+): Array<{ file: string; args: string[]; cwd?: string }> {
   return [
     { file: "gh", args: ["api", "user", "-q", ".login"] },
     { file: "git", args: ["config", "--global", "github.user"] },