@blackbelt-technology/pi-agent-dashboard 0.5.0 → 0.5.2

package/packages/shared/src/server-launcher.ts

@@ -0,0 +1,277 @@
+/**
+ * `launchDashboardServer` — single shared spawn primitive for the
+ * dashboard server. Used by every starter (Bridge, Standalone CLI,
+ * Electron). Owns:
+ *
+ *   - jiti loader resolution via `ToolResolver.resolveJiti({ anchor })`
+ *   - argv construction via `spawnNodeScript` (which delegates to
+ *     `buildNodeImportArgvParts` for the `--import` chunk)
+ *   - env merge: `ToolResolver.buildSpawnEnv()` ∪ caller `env`
+ *     (caller wins on conflict, e.g. `DASHBOARD_STARTER`)
+ *   - log-file policy: caller-owned absolute path; we mkdir, open in
+ *     append mode, write a header line, pass the fd, then close the
+ *     parent's copy after spawn.
+ *   - readiness policy: poll `isDashboardRunning(port)` and resolve /
+ *     reject on the first of: health-ok, port-conflict, child early
+ *     exit, or `healthTimeoutMs` elapsed.
+ *
+ * Does NOT own the log-file PATH — that's caller policy. Conventions:
+ *   - extension: `stdio: "ignore"`
+ *   - cli (`cmdStart`): `~/.pi/dashboard/server.log`
+ *   - electron: existing electron log path
+ *
+ * See change: unify-server-launch-ts-loader.
+ */
+import { dirname } from "node:path";
+import {
+  closeSync,
+  mkdirSync,
+  openSync,
+  writeSync,
+} from "node:fs";
+import type { ChildProcess, SpawnOptions } from "node:child_process"; // ban:child_process-ok — types only
+import { spawnNodeScript } from "./platform/node-spawn.js";
+import { ToolResolver } from "./platform/binary-lookup.js";
+import { isDashboardRunning } from "./server-identity.js";
+
+// ── Errors ──────────────────────────────────────────────────────────────────
+
+/** No jiti install resolved at any anchor. */
+export class JitiNotFoundError extends Error {
+  constructor(message =
+    "Cannot find pi's TypeScript loader (jiti). " +
+    "Is @earendil-works/pi-coding-agent or @mariozechner/pi-coding-agent installed?",
+  ) {
+    super(message);
+    this.name = "JitiNotFoundError";
+  }
+}
+
+/** Target port is occupied by a non-dashboard service. */
+export class PortConflictError extends Error {
+  readonly port: number;
+  constructor(port: number) {
+    super(`Port ${port} is occupied by a non-dashboard service`);
+    this.name = "PortConflictError";
+    this.port = port;
+  }
+}
+
+/** Spawned child exited before reaching health-ok. */
+export class EarlyExitError extends Error {
+  readonly code: number | null;
+  readonly signal: NodeJS.Signals | null;
+  constructor(code: number | null, signal: NodeJS.Signals | null = null) {
+    super(`Server child exited (code=${code}, signal=${signal}) before reaching health`);
+    this.name = "EarlyExitError";
+    this.code = code;
+    this.signal = signal;
+  }
+}
+
+// ── Options + result ────────────────────────────────────────────────────────
+
+export interface LaunchOpts {
+  /** Path to node binary. Defaults to `process.execPath`. */
+  nodeBin?: string;
+  /** Path to the dashboard server CLI script. */
+  cliPath: string;
+  /** Args appended after the entry script (e.g. `--port`, `--pi-port`, `start`). */
+  extraArgs?: readonly string[];
+  /** Caller-supplied jiti-resolution anchor (e.g. cliPath inside a node_modules tree). */
+  anchor?: string;
+  /**
+   * Caller env overrides merged ON TOP of `ToolResolver.buildSpawnEnv()`.
+   * Conflicting keys: caller wins. Pass `DASHBOARD_STARTER` here.
+   * Omit to fall back to the resolver-merged process env.
+   */
+  env?: Record<string, string | undefined>;
+  /**
+   * Stdio routing. `"ignore"` for fire-and-forget (extension); a
+   * `{ logFile }` object for caller-owned append-mode log capture.
+   */
+  stdio: "ignore" | { logFile: string };
+  /**
+   * Optional starter label written to the log header line and (when
+   * present) injected as `DASHBOARD_STARTER` env var if `env` does not
+   * already supply it. Plain string ("Bridge", "Standalone", "Electron").
+   */
+  starter?: string;
+  /** Health-check timeout in milliseconds. */
+  healthTimeoutMs: number;
+  /** Port to probe via `isDashboardRunning(port)`. */
+  port: number;
+  /**
+   * Whether the spawned server detaches from the parent's process
+   * group / Windows Job Object. Default: `true` (server outlives the
+   * launcher — correct for Bridge auto-spawn and Standalone CLI).
+   *
+   * Pass `false` when the caller deliberately ties the server's
+   * lifecycle to its own (Electron — server should die when Electron
+   * quits unless Electron explicitly decides to keep it).
+   */
+  detach?: boolean;
+  /**
+   * Working directory for the spawned process. Defaults to the
+   * launcher's own cwd. Electron passes the project directory.
+   */
+  cwd?: string;
+  // ── Test seams (production omits) ────────────────────────────────────────
+  /** Replace `ToolResolver.resolveJiti` (returns loader URL or null). */
+  _resolveJiti?: () => string | null;
+  /** Replace `spawnNodeScript` (returns ChildProcess). */
+  _spawnNodeScript?: typeof spawnNodeScript;
+  /** Replace `isDashboardRunning`. */
+  _isDashboardRunning?: typeof isDashboardRunning;
+  /** Replace fs primitives used for log-file handling. */
+  _fs?: {
+    mkdirSync?: typeof mkdirSync;
+    openSync?: typeof openSync;
+    closeSync?: typeof closeSync;
+    writeSync?: typeof writeSync;
+  };
+  /** Override poll interval (ms). Default 300. */
+  _pollIntervalMs?: number;
+  /** Override `Date.now` for deterministic timeout testing. */
+  _now?: () => number;
+  /** Override the sleep function used between polls. */
+  _sleep?: (ms: number) => Promise<void>;
+}
+
+export interface LaunchResult {
+  /** Spawned process pid (always present once spawn succeeded). */
+  childPid: number;
+  /** PID reported by `/api/health` (matches `dashboard.pid`); null if unavailable. */
+  reportedPid: number | null;
+  /** Always true when this resolves — readiness was confirmed. */
+  healthOk: true;
+}
+
+// ── Implementation ──────────────────────────────────────────────────────────
+
+const DEFAULT_POLL_MS = 300;
+
+function defaultSleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+/**
+ * Filter out `undefined` values from an env-record (NodeJS.ProcessEnv
+ * tolerates undefined; child_process.spawn does not).
+ */
+function compactEnv(base: NodeJS.ProcessEnv): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [k, v] of Object.entries(base)) {
+    if (typeof v === "string") out[k] = v;
+  }
+  return out;
+}
+
+/**
+ * Spawn the dashboard server and wait for `/api/health` to confirm
+ * identity. Resolves with `{ childPid, reportedPid, healthOk: true }`
+ * on success; rejects with `JitiNotFoundError` / `PortConflictError`
+ * / `EarlyExitError` / readiness-timeout `Error` per the spec.
+ */
+export async function launchDashboardServer(opts: LaunchOpts): Promise<LaunchResult> {
+  const nodeBin = opts.nodeBin ?? process.execPath;
+  const resolveJiti = opts._resolveJiti ?? (() => new ToolResolver({ processExecPath: nodeBin }).resolveJiti({ anchor: opts.anchor }));
+  const spawn = opts._spawnNodeScript ?? spawnNodeScript;
+  const probe = opts._isDashboardRunning ?? isDashboardRunning;
+  const pollIntervalMs = opts._pollIntervalMs ?? DEFAULT_POLL_MS;
+  const now = opts._now ?? Date.now;
+  const sleep = opts._sleep ?? defaultSleep;
+  const fsMkdir = opts._fs?.mkdirSync ?? mkdirSync;
+  const fsOpen = opts._fs?.openSync ?? openSync;
+  const fsClose = opts._fs?.closeSync ?? closeSync;
+  const fsWrite = opts._fs?.writeSync ?? writeSync;
+
+  // 1. Loader resolution.
+  const loader = resolveJiti();
+  if (!loader) throw new JitiNotFoundError();
+
+  // 2. Env: ToolResolver.buildSpawnEnv() merged with caller env (caller wins).
+  const baseEnv = new ToolResolver({ processExecPath: nodeBin }).buildSpawnEnv(process.env);
+  const env: Record<string, string> = compactEnv(baseEnv);
+  if (opts.starter && !(opts.env && "DASHBOARD_STARTER" in opts.env)) {
+    env["DASHBOARD_STARTER"] = opts.starter;
+  }
+  if (opts.env) {
+    for (const [k, v] of Object.entries(opts.env)) {
+      if (typeof v === "string") env[k] = v;
+      else if (v === undefined) delete env[k];
+    }
+  }
+
+  // 3. Stdio + log header.
+  let logFd: number | undefined;
+  let stdio: SpawnOptions["stdio"];
+  if (opts.stdio === "ignore") {
+    stdio = "ignore";
+  } else {
+    const { logFile } = opts.stdio;
+    fsMkdir(dirname(logFile), { recursive: true });
+    logFd = fsOpen(logFile, "a");
+    const header = `[${new Date().toISOString()}] ${opts.starter ?? "dashboard"} launch (parent pid ${process.pid}, port ${opts.port}, cli ${opts.cliPath})\n`;
+    try { fsWrite(logFd, header); } catch { /* best-effort */ }
+    stdio = ["ignore", logFd, logFd];
+  }
+
+  // 4. Spawn. spawnNodeScript handles --import URL-wrapping + entry rule.
+  let child: ChildProcess;
+  try {
+    child = spawn({
+      nodeBin,
+      loader,
+      entry: opts.cliPath,
+      args: opts.extraArgs ? [...opts.extraArgs] : undefined,
+      spawnOptions: {
+        detached: opts.detach ?? true,
+        stdio,
+        env,
+        cwd: opts.cwd,
+        windowsHide: true,
+      },
+    });
+  } finally {
+    // Always close the parent's copy of the log fd; the child has its own.
+    if (logFd !== undefined) {
+      try { fsClose(logFd); } catch { /* ignore */ }
+    }
+  }
+
+  try { child.unref(); } catch { /* ignore */ }
+
+  if (!child.pid) {
+    throw new EarlyExitError(child.exitCode ?? null, child.signalCode ?? null);
+  }
+
+  // 5. Readiness loop.
+  const deadline = now() + opts.healthTimeoutMs;
+  while (true) {
+    // Early-exit detection (beats timeout per spec).
+    if (child.exitCode !== null) {
+      throw new EarlyExitError(child.exitCode, child.signalCode ?? null);
+    }
+    let status;
+    try {
+      status = await probe(opts.port);
+    } catch {
+      status = { running: false } as const;
+    }
+    if (status.running) {
+      return {
+        childPid: child.pid,
+        reportedPid: status.pid ?? null,
+        healthOk: true,
+      };
+    }
+    if (status.portConflict) {
+      throw new PortConflictError(opts.port);
+    }
+    if (now() >= deadline) {
+      throw new Error("readiness timeout");
+    }
+    await sleep(pollIntervalMs);
+  }
+}

package/packages/shared/src/skill-block-parser.ts

@@ -1,7 +1,7 @@
 /**
  * Skill block parser & builder.
  *
- * Pi's `_expandSkillCommand` (in `@mariozechner/pi-coding-agent`) wraps skill
+ * Pi's `_expandSkillCommand` (in `@earendil-works/pi-coding-agent`) wraps skill
  * expansions in a `<skill name="..." location="...">…</skill>\n\nargs` envelope.
  * The dashboard's bridge expander (`packages/extension/src/prompt-expander.ts`)
  * aligns to the same byte format. This module is the single source of truth for

package/packages/shared/src/tool-registry/__tests__/pi-ai-registration.test.ts

@@ -0,0 +1,124 @@
+/**
+ * Registration and resolution tests for the `pi-ai` module-kind tool.
+ *
+ * Verifies:
+ * - Registry resolves pi-ai when ~/.pi-dashboard/node_modules/@mariozechner/pi-ai/dist/index.js exists (managed)
+ * - Falls back to npmGlobalStrategy when only globally installed
+ * - Returns failed resolution with diagnostic trail when none match
+ * - Override takes precedence
+ *
+ * Note: bareImportStrategy uses real module resolution (createRequire) and
+ * cannot be injected via StrategyDeps.resolveModule in moduleDefWithAliases.
+ * It is implicitly tested (fails gracefully when pi-ai isn't a project dep).
+ *
+ * See change: add-dashboard-model-proxy (task 2.1).
+ */
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+  ToolRegistry,
+  registerDefaultTools,
+  OverridesStore,
+} from "../index.js";
+
+const HOME = os.homedir();
+const MANAGED_PATH = path.join(
+  HOME,
+  ".pi-dashboard",
+  "node_modules",
+  "@mariozechner",
+  "pi-ai",
+  "dist",
+  "index.js",
+);
+
+function freshRegistry(opts: {
+  exists?: (p: string) => boolean;
+  which?: (name: string) => string | null;
+  npmRootGlobal?: () => string;
+  overrides?: Record<string, string>;
+}) {
+  const store = new OverridesStore({
+    filePath: path.join(os.tmpdir(), `pi-ai-test-${Math.random()}.json`),
+    warn: () => {},
+  });
+  for (const [k, v] of Object.entries(opts.overrides ?? {})) store.set(k, v);
+
+  const r = new ToolRegistry({
+    overrides: store,
+    platform: "linux",
+  });
+  registerDefaultTools(r, {
+    exists: opts.exists ?? (() => false),
+    which: opts.which ?? (() => null),
+    npmRootGlobal: opts.npmRootGlobal ?? (() => ""),
+  });
+  return r;
+}
+
+describe("pi-ai: module registration", () => {
+  it("resolves via managed path when ~/.pi-dashboard/node_modules/@mariozechner/pi-ai exists", () => {
+    const r = freshRegistry({
+      exists: (p) => p === MANAGED_PATH,
+    });
+    const result = r.resolve("pi-ai");
+    expect(result.ok).toBe(true);
+    expect(result.path).toBe(MANAGED_PATH);
+    expect(result.source).toBe("managed");
+  });
+
+  it("falls back to npm-global when only globally installed", () => {
+    const globalRoot = "/usr/lib/node_modules";
+    const globalPath = path.join(
+      globalRoot,
+      "@mariozechner",
+      "pi-ai",
+      "dist",
+      "index.js",
+    );
+    const r = freshRegistry({
+      exists: (p) => p === globalPath,
+      npmRootGlobal: () => globalRoot,
+    });
+    const result = r.resolve("pi-ai");
+    expect(result.ok).toBe(true);
+    expect(result.path).toBe(globalPath);
+    expect(result.source).toBe("npm-global");
+  });
+
+  it("returns failed resolution with diagnostic trail when none match", () => {
+    const r = freshRegistry({});
+    const result = r.resolve("pi-ai");
+    expect(result.ok).toBe(false);
+    expect(result.tried).toBeDefined();
+    expect(result.tried!.length).toBeGreaterThan(0);
+    // Should have tried override, bare-import, managed, npm-global
+    const strategyNames = result.tried!.map((t) => t.strategy);
+    expect(strategyNames).toContain("override");
+    expect(strategyNames).toContain("bare-import");
+    expect(strategyNames).toContain("managed");
+    expect(strategyNames).toContain("npm-global");
+  });
+
+  it("override takes precedence over managed", () => {
+    const overridePath = "/custom/pi-ai/dist/index.js";
+    const r = freshRegistry({
+      exists: (p) => p === overridePath || p === MANAGED_PATH,
+      overrides: { "pi-ai": overridePath },
+    });
+    const result = r.resolve("pi-ai");
+    expect(result.ok).toBe(true);
+    expect(result.path).toBe(overridePath);
+    expect(result.source).toBe("override");
+  });
+
+  it("is registered and resolvable by name", () => {
+    const r = freshRegistry({
+      exists: (p) => p === MANAGED_PATH,
+    });
+    const result = r.resolve("pi-ai");
+    expect(result.name).toBe("pi-ai");
+    expect(result.ok).toBe(true);
+  });
+});

package/packages/shared/src/tool-registry/definitions.ts

@@ -60,7 +60,7 @@ function binaryDef(binaryName: string, deps?: StrategyDeps): ToolDefinition {
 
 // ── Module definitions ──────────────────────────────────────────────────────
 
-/** Sibling probe for an aliased package name (pi: `@mariozechner/*` + `@oh-my-pi/*`). */
+/** Sibling probe for an aliased package name (pi: `@earendil-works/*` + `@mariozechner/*`). */
 function moduleDefWithAliases(
   canonicalName: string,
   pkgNames: readonly string[],
@@ -188,7 +188,7 @@ const nodeScriptToArgv: ToolDefinition["toArgv"] = (resolvedPath, { platform, re
  * On Unix, the chain finds `pi` on PATH; argv = [pi].
  */
 function piExecutorDef(deps?: StrategyDeps): ToolDefinition {
-  const piPkgAliases = ["@mariozechner/pi-coding-agent", "@oh-my-pi/pi-coding-agent"];
+  const piPkgAliases = ["@earendil-works/pi-coding-agent", "@mariozechner/pi-coding-agent"];
   const cliEntry = path.join("dist", "cli.js");
 
   const winStrategies = [
@@ -413,7 +413,19 @@ export function registerDefaultTools(registry: ToolRegistry, deps?: StrategyDeps
   registry.register(
     moduleDefWithAliases(
       "pi-coding-agent",
-      ["@mariozechner/pi-coding-agent", "@oh-my-pi/pi-coding-agent"],
+      ["@earendil-works/pi-coding-agent", "@mariozechner/pi-coding-agent"],
+      path.join("dist", "index.js"),
+      deps,
+    ),
+  );
+
+  // pi-ai module — used by model-proxy to call upstream LLM providers.
+  // Aliases: @earendil-works/pi-ai (preferred) + @mariozechner/pi-ai (legacy fallback).
+  // See change: add-dashboard-model-proxy.
+  registry.register(
+    moduleDefWithAliases(
+      "pi-ai",
+      ["@earendil-works/pi-ai", "@mariozechner/pi-ai"],
       path.join("dist", "index.js"),
       deps,
     ),

package/packages/shared/src/types.ts

@@ -404,6 +404,40 @@ export interface OpenSpecChange {
    * "Archive anyway" escape hatch when artifacts are authored but tasks remain unchecked.
    */
   isComplete?: boolean;
+  /**
+   * Group assignment joined server-side from `<cwd>/openspec/groups/groups.json`.
+   * `null` or absent means Ungrouped. Clients SHALL NOT recompute the join.
+   * See change: add-openspec-change-grouping.
+   */
+  groupId?: string | null;
+}
+
+/** Schema version for the per-repo OpenSpec groups file at
+ *  `<cwd>/openspec/groups/groups.json`. Bumped only on incompatible shape changes.
+ *  See change: add-openspec-change-grouping. */
+export const OPENSPEC_GROUPS_SCHEMA_VERSION = 1 as const;
+
+/** A user-defined group of OpenSpec changes within a single repo.
+ *  See change: add-openspec-change-grouping. */
+export interface OpenSpecGroup {
+  /** Server-generated slug from `name` plus collision suffix. Stable across rename. */
+  id: string;
+  /** User-visible label; editable. */
+  name: string;
+  /** Optional CSS hex color (`#RRGGBB`). Clients fall back to a default palette when omitted. */
+  color?: string;
+  /** Display order; server keeps values contiguous `0..groups.length - 1` after every reorder. */
+  order: number;
+}
+
+/** Shape of the on-disk groups file at `<cwd>/openspec/groups/groups.json`.
+ *  Single combined file for groups + assignments — one read, one write, atomic.
+ *  See change: add-openspec-change-grouping. */
+export interface OpenSpecGroupsFile {
+  schemaVersion: number;
+  groups: OpenSpecGroup[];
+  /** `changeName` → `groupId`. Unassigned changes have no entry. */
+  assignments: Record<string, string>;
 }
 
 /** Lifecycle state of an OpenSpec change, derived from artifacts + task status */
@@ -425,6 +459,12 @@ export function deriveChangeState(change: OpenSpecChange): ChangeState {
 
 /** OpenSpec data for a session's project */
 export interface OpenSpecData {
+  /**
+   * `openspec list` returned authoritative data for this cwd. Requires both
+   * `<cwd>/openspec/` AND `<cwd>/openspec/changes/` to exist AND the CLI to
+   * succeed. Does NOT distinguish "openspec project, no changes yet" from
+   * "truly not an openspec project" — see `hasOpenspecDir` for that.
+   */
   initialized: boolean;
   changes: OpenSpecChange[];
   /**
@@ -440,6 +480,21 @@ export interface OpenSpecData {
    * See change: fix-cold-boot-openspec-protocol.
    */
   pending?: boolean;
+  /**
+   * Whether `<cwd>/openspec/` directory exists. Strictly weaker than
+   * `initialized`: this can be `true` while `initialized` is `false` when
+   * the project is OpenSpec-initialized (`openspec init` was run) but
+   * `openspec/changes/` doesn't exist yet (no proposals authored). In that
+   * case `openspec list` errors out and `initialized` stays `false`, but
+   * the session card should still show the OPENSPEC subcard as an
+   * init/attach affordance.
+   *
+   * Optional for backwards compatibility — absence means "unknown, fall
+   * back to `initialized || pending`" on the client side.
+   *
+   * See change: auto-hide-empty-session-subcards.
+   */
+  hasOpenspecDir?: boolean;
 }
 
 /** OpenSpec workflow phase detected from tool calls */
@@ -649,4 +704,11 @@ export interface ApiResponse<T = unknown> {
   success: boolean;
   data?: T;
   error?: string;
+  /**
+   * Optional structured failure-classifier code paired with `error`.
+   * Lets clients render specific UI for known failure modes
+   * (e.g., `"FORK_EMPTY_SESSION"`).
+   * See change: fix-fork-empty-session-silent-timeout.
+   */
+  code?: string;
 }

package/packages/shared/src/__tests__/resolve-jiti.test.ts

@@ -1,53 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { buildJitiRegisterUrl, resolveJitiImport } from "../resolve-jiti.js";
-
-describe("buildJitiRegisterUrl", () => {
-  // Pure function: given a jiti package.json path, return the file:// URL of
-  // its register hook. The URL contract is the critical invariant — Node's
-  // --import on Windows rejects raw drive-letter paths (parses "C:" as a
-  // URL scheme). See change: fix-windows-server-parity.
-
-  it("returns a file:// URL", () => {
-    const url = buildJitiRegisterUrl("/usr/lib/node_modules/@mariozechner/jiti/package.json");
-    expect(url.startsWith("file://")).toBe(true);
-  });
-
-  it("URL is parseable by new URL() without throwing", () => {
-    const url = buildJitiRegisterUrl("/usr/lib/node_modules/@mariozechner/jiti/package.json");
-    expect(() => new URL(url)).not.toThrow();
-  });
-
-  it("points at lib/jiti-register.mjs under the package dir", () => {
-    const url = buildJitiRegisterUrl("/usr/lib/node_modules/@mariozechner/jiti/package.json");
-    expect(url.endsWith("/lib/jiti-register.mjs")).toBe(true);
-  });
-
-  it("handles Windows drive-letter paths (regression for ERR_UNSUPPORTED_ESM_URL_SCHEME)", () => {
-    // This is the exact shape that crashed pre-fix: a raw path with a
-    // drive letter was passed to `node --import` and Node parsed "B:" as
-    // a URL scheme. A file:// URL sidesteps the parser entirely.
-    const url = buildJitiRegisterUrl("B:\\Dev\\Nodejs\\global\\node_modules\\@mariozechner\\jiti\\package.json");
-    expect(url.startsWith("file:///")).toBe(true);
-    expect(() => new URL(url)).not.toThrow();
-    expect(new URL(url).protocol).toBe("file:");
-    // The drive letter survives as part of the pathname, not as a protocol
-    expect(url.toLowerCase()).toContain("/b:/");
-    expect(url.endsWith("/lib/jiti-register.mjs")).toBe(true);
-  });
-
-});
-
-describe("resolveJitiImport", () => {
-  // Integration-lite: in vitest context (not inside pi's jiti loader),
-  // process.argv[1] points at the test runner, not pi — so peer-dep
-  // resolution fails and the function throws a helpful error. The
-  // URL-contract behavior is covered by buildJitiRegisterUrl above.
-
-  it("throws with clear error when pi-coding-agent is not resolvable", () => {
-    expect(() => resolveJitiImport()).toThrow("Cannot find pi's TypeScript loader");
-  });
-
-  it("error message mentions pi-coding-agent", () => {
-    expect(() => resolveJitiImport()).toThrow("pi-coding-agent");
-  });
-});