@jyork0828/pi-pilot 0.0.1

package/dist/index.js

@@ -0,0 +1,2395 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { existsSync } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import { dirname as dirname5, extname, join as join8, resolve as resolve5, sep as sep3 } from "path";
+import { fileURLToPath } from "url";
+import { serve } from "@hono/node-server";
+import { Hono as Hono4 } from "hono";
+import { cors } from "hono/cors";
+
+// src/config.ts
+import { homedir } from "os";
+import { join } from "path";
+var config = {
+  /** HTTP + WS port. */
+  port: Number(process.env.PI_PILOT_PORT ?? 5174),
+  /** Bind address. Hard-coded localhost; do NOT make this configurable
+   * without first reviewing the security implications of exposing bash. */
+  host: "127.0.0.1",
+  /** Where pi-pilot stores its own (non-pi) state. */
+  dataDir: process.env.PI_PILOT_DATA_DIR ?? join(homedir(), ".pi", "webui"),
+  /** Dev origin allowed by CORS for /api. The Vite dev server. */
+  corsOrigin: process.env.PI_PILOT_CORS_ORIGIN ?? "http://localhost:5173"
+};
+
+// src/api/workspaces.ts
+import { stat as stat2 } from "fs/promises";
+import { basename as basename2, isAbsolute as isAbsolute3, resolve as resolve3 } from "path";
+import { Hono } from "hono";
+
+// src/storage/resource-writer.ts
+import {
+  mkdir,
+  readFile,
+  rm,
+  stat,
+  unlink,
+  writeFile
+} from "fs/promises";
+import { dirname, isAbsolute, join as join2, resolve, sep } from "path";
+var SKILL_NAME_RE = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
+var PROMPT_NAME_RE = /^[a-z0-9_](?:[a-z0-9_-]{0,62}[a-z0-9_])?$/;
+function ensureSkillName(name) {
+  if (!SKILL_NAME_RE.test(name)) {
+    throw new HttpError(400, "skill name must be lowercase a-z/0-9/hyphens, 1-64 chars, no leading/trailing/double hyphens");
+  }
+}
+function ensurePromptName(name) {
+  if (!PROMPT_NAME_RE.test(name)) {
+    throw new HttpError(400, "prompt name must be lowercase a-z/0-9/hyphens/underscores, 1-64 chars");
+  }
+}
+function assertUnder(target, roots) {
+  const t = resolve(target);
+  const ok = roots.some((root) => {
+    const r = resolve(root);
+    return t === r || t.startsWith(r + sep);
+  });
+  if (!ok) {
+    throw new HttpError(500, `refusing to touch path outside managed roots: ${target}`);
+  }
+}
+function skillDirFor(scope, name, roots) {
+  ensureSkillName(name);
+  const base = scope === "user" ? roots.userSkills : roots.projectSkills;
+  return join2(base, name);
+}
+function promptFileFor(scope, name, roots) {
+  ensurePromptName(name);
+  const base = scope === "user" ? roots.userPrompts : roots.projectPrompts;
+  return join2(base, `${name}.md`);
+}
+function resolveResourceRoots(opts) {
+  return {
+    userSkills: join2(opts.agentDir, "skills"),
+    projectSkills: join2(opts.workspaceCwd, ".pi", "skills"),
+    userPrompts: join2(opts.agentDir, "prompts"),
+    projectPrompts: join2(opts.workspaceCwd, ".pi", "prompts")
+  };
+}
+function scopeFor(absPath, roots) {
+  const p = resolve(absPath);
+  for (const [root, scope] of [
+    [roots.userSkills, "user"],
+    [roots.projectSkills, "project"],
+    [roots.userPrompts, "user"],
+    [roots.projectPrompts, "project"]
+  ]) {
+    const r = resolve(root);
+    if (p === r || p.startsWith(r + sep)) return scope;
+  }
+  return void 0;
+}
+function parseFile(content) {
+  const rawLines = content.split(/\r?\n/);
+  if (rawLines[0] !== "---") {
+    return { frontmatter: {}, lines: [], body: content };
+  }
+  const fm = {};
+  const lines = [];
+  let i = 1;
+  while (i < rawLines.length && rawLines[i] !== "---") {
+    const line = rawLines[i] ?? "";
+    const m = line.match(/^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*?)\s*$/);
+    if (m) {
+      const key = m[1];
+      const rawVal = m[2] ?? "";
+      const value = parseScalar(rawVal);
+      fm[key] = value;
+      lines.push({ key, value, raw: line });
+    }
+    i++;
+  }
+  if (i >= rawLines.length) {
+    return { frontmatter: {}, lines: [], body: content };
+  }
+  const body = rawLines.slice(i + 1).join("\n");
+  return { frontmatter: fm, lines, body };
+}
+function extraLines(lines, knownKeys) {
+  const known = new Set(knownKeys);
+  return lines.filter((l) => !known.has(l.key)).map((l) => l.raw);
+}
+function parseScalar(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw.startsWith('"') && raw.endsWith('"') && raw.length >= 2) {
+    return raw.slice(1, -1).replace(/\\(["\\])/g, "$1");
+  }
+  if (raw.startsWith("'") && raw.endsWith("'") && raw.length >= 2) {
+    return raw.slice(1, -1).replace(/''/g, "'");
+  }
+  return raw;
+}
+function buildFile(fields, body, extras = []) {
+  const out = ["---"];
+  for (const [key, value] of fields) {
+    if (value === void 0 || value === "") continue;
+    if (typeof value === "boolean") {
+      out.push(`${key}: ${value ? "true" : "false"}`);
+    } else {
+      out.push(`${key}: ${formatString(value)}`);
+    }
+  }
+  for (const raw of extras) out.push(raw);
+  out.push("---");
+  const trimmedBody = body.replace(/\s+$/, "");
+  const text = `${out.join("\n")}
+${trimmedBody}
+`;
+  return text;
+}
+var SKILL_KNOWN_KEYS = ["name", "description", "disable-model-invocation"];
+var PROMPT_KNOWN_KEYS = ["description", "argument-hint"];
+function formatString(value) {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
+async function createSkill(opts) {
+  const dir = skillDirFor(opts.scope, opts.name, opts.roots);
+  assertUnder(dir, [opts.roots.userSkills, opts.roots.projectSkills]);
+  if (await exists(dir)) {
+    throw new HttpError(409, `skill already exists at ${dir}`);
+  }
+  const file = join2(dir, "SKILL.md");
+  const text = buildFile(
+    [
+      ["name", opts.name],
+      ["description", opts.description],
+      ["disable-model-invocation", opts.disableModelInvocation]
+    ],
+    opts.body
+  );
+  await mkdir(dir, { recursive: true });
+  await writeFile(file, text, "utf8");
+  return file;
+}
+async function updateSkill(opts) {
+  if (!isAbsolute(opts.filePath)) {
+    throw new HttpError(400, "filePath must be absolute");
+  }
+  assertUnder(opts.filePath, [opts.roots.userSkills, opts.roots.projectSkills]);
+  if (!await exists(opts.filePath)) {
+    throw new HttpError(404, `skill file not found: ${opts.filePath}`);
+  }
+  const existing = await readFile(opts.filePath, "utf8");
+  const extras = extraLines(parseFile(existing).lines, SKILL_KNOWN_KEYS);
+  const text = buildFile(
+    [
+      ["name", opts.name],
+      ["description", opts.description],
+      ["disable-model-invocation", opts.disableModelInvocation]
+    ],
+    opts.body,
+    extras
+  );
+  await writeFile(opts.filePath, text, "utf8");
+  return opts.filePath;
+}
+async function deleteSkill(filePath, roots) {
+  if (!isAbsolute(filePath)) {
+    throw new HttpError(400, "filePath must be absolute");
+  }
+  assertUnder(filePath, [roots.userSkills, roots.projectSkills]);
+  if (!await exists(filePath)) {
+    throw new HttpError(404, `skill file not found: ${filePath}`);
+  }
+  const dir = dirname(filePath);
+  const parentIsRoot = resolve(dir) === resolve(roots.userSkills) || resolve(dir) === resolve(roots.projectSkills);
+  if (parentIsRoot) {
+    await unlink(filePath);
+    return;
+  }
+  assertUnder(dir, [roots.userSkills, roots.projectSkills]);
+  await rm(dir, { recursive: true, force: true });
+}
+async function createPrompt(opts) {
+  const file = promptFileFor(opts.scope, opts.name, opts.roots);
+  assertUnder(file, [opts.roots.userPrompts, opts.roots.projectPrompts]);
+  if (await exists(file)) {
+    throw new HttpError(409, `prompt already exists at ${file}`);
+  }
+  const text = buildFile(
+    [
+      ["description", opts.description],
+      ["argument-hint", opts.argumentHint]
+    ],
+    opts.body
+  );
+  await mkdir(dirname(file), { recursive: true });
+  await writeFile(file, text, "utf8");
+  return file;
+}
+async function updatePrompt(opts) {
+  if (!isAbsolute(opts.filePath)) {
+    throw new HttpError(400, "filePath must be absolute");
+  }
+  assertUnder(opts.filePath, [opts.roots.userPrompts, opts.roots.projectPrompts]);
+  if (!await exists(opts.filePath)) {
+    throw new HttpError(404, `prompt file not found: ${opts.filePath}`);
+  }
+  ensurePromptName(opts.name);
+  const dir = dirname(opts.filePath);
+  const newPath = join2(dir, `${opts.name}.md`);
+  assertUnder(newPath, [opts.roots.userPrompts, opts.roots.projectPrompts]);
+  const existing = await readFile(opts.filePath, "utf8");
+  const extras = extraLines(parseFile(existing).lines, PROMPT_KNOWN_KEYS);
+  const text = buildFile(
+    [
+      ["description", opts.description],
+      ["argument-hint", opts.argumentHint]
+    ],
+    opts.body,
+    extras
+  );
+  if (resolve(newPath) !== resolve(opts.filePath)) {
+    if (await exists(newPath)) {
+      throw new HttpError(409, `prompt already exists at ${newPath}`);
+    }
+    await writeFile(newPath, text, "utf8");
+    try {
+      await unlink(opts.filePath);
+    } catch (err) {
+      await unlink(newPath).catch(() => void 0);
+      throw err;
+    }
+    return newPath;
+  }
+  await writeFile(opts.filePath, text, "utf8");
+  return opts.filePath;
+}
+async function deletePrompt(filePath, roots) {
+  if (!isAbsolute(filePath)) {
+    throw new HttpError(400, "filePath must be absolute");
+  }
+  assertUnder(filePath, [roots.userPrompts, roots.projectPrompts]);
+  if (!await exists(filePath)) {
+    throw new HttpError(404, `prompt file not found: ${filePath}`);
+  }
+  await unlink(filePath);
+}
+async function readSkillFile(filePath, roots) {
+  assertUnder(filePath, [roots.userSkills, roots.projectSkills]);
+  const text = await readFile(filePath, "utf8");
+  const { frontmatter, body } = parseFile(text);
+  return {
+    body,
+    name: stringOr(frontmatter.name, ""),
+    description: stringOr(frontmatter.description, ""),
+    disableModelInvocation: booleanOr(frontmatter["disable-model-invocation"], void 0)
+  };
+}
+async function readPromptFile(filePath, roots) {
+  assertUnder(filePath, [roots.userPrompts, roots.projectPrompts]);
+  const text = await readFile(filePath, "utf8");
+  const { frontmatter, body } = parseFile(text);
+  const stem = basename(filePath).replace(/\.md$/, "");
+  return {
+    body,
+    name: stem,
+    description: stringOr(frontmatter.description, ""),
+    argumentHint: stringOr(frontmatter["argument-hint"], void 0)
+  };
+}
+function basename(p) {
+  const parts = p.split(sep);
+  return parts.at(-1) || p;
+}
+function stringOr(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}
+function booleanOr(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+async function exists(p) {
+  try {
+    await stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+
+// src/storage/workspace-registry.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join as join3 } from "path";
+import { randomUUID } from "crypto";
+var REGISTRY_PATH = join3(config.dataDir, "workspaces.json");
+var cache;
+async function load() {
+  if (cache) return cache;
+  try {
+    const raw = await readFile2(REGISTRY_PATH, "utf8");
+    cache = JSON.parse(raw);
+    if (!Array.isArray(cache.workspaces)) cache = { workspaces: [] };
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      cache = { workspaces: [] };
+    } else {
+      throw err;
+    }
+  }
+  return cache;
+}
+async function save() {
+  if (!cache) return;
+  await mkdir2(dirname2(REGISTRY_PATH), { recursive: true });
+  await writeFile2(REGISTRY_PATH, JSON.stringify(cache, null, 2), "utf8");
+}
+async function listWorkspaces() {
+  const r = await load();
+  return [...r.workspaces];
+}
+async function getWorkspace(id) {
+  const r = await load();
+  return r.workspaces.find((w) => w.id === id);
+}
+async function addWorkspace(input) {
+  const r = await load();
+  const existing = r.workspaces.find((w) => w.path === input.path);
+  if (existing) return existing;
+  const ws = {
+    id: randomUUID(),
+    name: input.name,
+    path: input.path,
+    addedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  r.workspaces.push(ws);
+  await save();
+  return ws;
+}
+async function removeWorkspace(id) {
+  const r = await load();
+  const before = r.workspaces.length;
+  r.workspaces = r.workspaces.filter((w) => w.id !== id);
+  if (r.workspaces.length === before) return false;
+  await save();
+  return true;
+}
+
+// src/storage/workspace-stats.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execFile);
+var CACHE_TTL_MS = 3e4;
+var cache2 = /* @__PURE__ */ new Map();
+var inflight = /* @__PURE__ */ new Map();
+async function enrichWorkspace(ws) {
+  const stats = await getStats(ws.path);
+  return {
+    id: ws.id,
+    name: ws.name,
+    path: ws.path,
+    addedAt: ws.addedAt,
+    gitBranch: stats.gitBranch,
+    fileCount: stats.fileCount
+  };
+}
+async function getStats(path) {
+  const now = Date.now();
+  const cached = cache2.get(path);
+  if (cached && cached.expiresAt > now) return cached;
+  const pending = inflight.get(path);
+  if (pending) return pending;
+  const probe = probeStats(path).then((stats) => {
+    const entry = {
+      ...stats,
+      expiresAt: Date.now() + CACHE_TTL_MS
+    };
+    cache2.set(path, entry);
+    return entry;
+  }).finally(() => {
+    inflight.delete(path);
+  });
+  inflight.set(path, probe);
+  return probe;
+}
+async function probeStats(path) {
+  const [branchResult, filesResult] = await Promise.allSettled([
+    runGit(path, ["rev-parse", "--abbrev-ref", "HEAD"]),
+    runGit(path, [
+      "ls-files",
+      "--cached",
+      "--others",
+      "--exclude-standard"
+    ])
+  ]);
+  let gitBranch = null;
+  if (branchResult.status === "fulfilled") {
+    const out = branchResult.value.trim();
+    if (out && out !== "HEAD") {
+      gitBranch = out;
+    } else if (out === "HEAD") {
+      try {
+        const sha = (await runGit(path, ["rev-parse", "--short", "HEAD"])).trim();
+        gitBranch = sha ? `@${sha}` : null;
+      } catch {
+        gitBranch = null;
+      }
+    }
+  }
+  let fileCount = null;
+  if (filesResult.status === "fulfilled") {
+    const out = filesResult.value;
+    if (out) {
+      let n = 0;
+      for (let i = 0; i < out.length; i++) {
+        if (out.charCodeAt(i) === 10) n++;
+      }
+      if (out.length > 0 && out.charCodeAt(out.length - 1) !== 10) n++;
+      fileCount = n;
+    } else {
+      fileCount = 0;
+    }
+  }
+  return { gitBranch, fileCount };
+}
+async function runGit(cwd, args) {
+  const { stdout } = await exec("git", args, {
+    cwd,
+    timeout: 2e3,
+    maxBuffer: 5 * 1024 * 1024,
+    // Don't inherit GIT_DIR / GIT_WORK_TREE from the server process —
+    // could leak the server's own repo into a workspace probe.
+    env: { ...process.env, GIT_DIR: void 0, GIT_WORK_TREE: void 0 }
+  });
+  return stdout;
+}
+
+// src/workspace-manager.ts
+import { unlink as unlink2 } from "fs/promises";
+import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
+import {
+  createAgentSessionFromServices,
+  createAgentSessionRuntime,
+  createAgentSessionServices,
+  getAgentDir,
+  SessionManager
+} from "@earendil-works/pi-coding-agent";
+
+// src/ws/extension-ui.ts
+var ExtensionUIBridge = class {
+  /** Symmetric with the old bridge so workspace-manager's dispose path
+   *  can call it uniformly. There is no state to release. */
+  dispose() {
+  }
+  // ============== dialog methods (resolve to default) ==============
+  select() {
+    return Promise.resolve(void 0);
+  }
+  confirm() {
+    return Promise.resolve(false);
+  }
+  input() {
+    return Promise.resolve(void 0);
+  }
+  editor() {
+    return Promise.resolve(void 0);
+  }
+  // ============== fire-and-forget methods (no-op) ==============
+  notify() {
+  }
+  setStatus() {
+  }
+  setWidget() {
+  }
+  setTitle() {
+  }
+  setEditorText() {
+  }
+  pasteToEditor() {
+  }
+  // ============== TUI-only methods (no-op / defaults) ==============
+  onTerminalInput() {
+    return () => {
+    };
+  }
+  setWorkingMessage() {
+  }
+  setWorkingVisible() {
+  }
+  setWorkingIndicator() {
+  }
+  setHiddenThinkingLabel() {
+  }
+  setFooter() {
+  }
+  setHeader() {
+  }
+  async custom() {
+    return void 0;
+  }
+  getEditorText() {
+    return "";
+  }
+  addAutocompleteProvider() {
+  }
+  setEditorComponent() {
+  }
+  getEditorComponent() {
+    return void 0;
+  }
+  get theme() {
+    return void 0;
+  }
+  getAllThemes() {
+    return [];
+  }
+  getTheme() {
+    return void 0;
+  }
+  setTheme() {
+    return { success: false, error: "Theme switching not supported in pi-pilot" };
+  }
+  getToolsExpanded() {
+    return false;
+  }
+  setToolsExpanded() {
+  }
+};
+
+// src/workspace-manager.ts
+var EXTENSIONS_ENABLED = process.env.PI_PILOT_ENABLE_EXTENSIONS === "1";
+var createRuntime = async ({
+  cwd,
+  sessionManager,
+  sessionStartEvent
+}) => {
+  const services = await createAgentSessionServices({
+    cwd,
+    resourceLoaderOptions: EXTENSIONS_ENABLED ? void 0 : { noExtensions: true }
+  });
+  const sessionResult = await createAgentSessionFromServices({
+    services,
+    sessionManager,
+    sessionStartEvent
+  });
+  return {
+    ...sessionResult,
+    services,
+    diagnostics: services.diagnostics
+  };
+};
+var WorkspaceManager = class {
+  states = /* @__PURE__ */ new Map();
+  /**
+   * Subscribers live independently of `states` so the hub can register a
+   * WebSocket *before* `getOrCreate` triggers a runtime build (which may
+   * fire `session_start` synchronously, and any UI request from a
+   * session_start handler would otherwise broadcast to an empty set).
+   */
+  subscribers = /* @__PURE__ */ new Map();
+  /** Per-workspace lock to serialize concurrent creations. */
+  pending = /* @__PURE__ */ new Map();
+  rebindListeners = /* @__PURE__ */ new Map();
+  getOrCreateSubscriberSet(workspaceId) {
+    let set = this.subscribers.get(workspaceId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.subscribers.set(workspaceId, set);
+    }
+    return set;
+  }
+  async getOrCreate(workspaceId) {
+    const existing = this.states.get(workspaceId);
+    if (existing) return existing.runtime;
+    const inflight3 = this.pending.get(workspaceId);
+    if (inflight3) return (await inflight3).runtime;
+    const p = this.build(workspaceId);
+    this.pending.set(workspaceId, p);
+    try {
+      const state = await p;
+      this.states.set(workspaceId, state);
+      return state.runtime;
+    } finally {
+      this.pending.delete(workspaceId);
+    }
+  }
+  async build(workspaceId) {
+    const ws = await getWorkspace(workspaceId);
+    if (!ws) throw new Error(`Workspace not found: ${workspaceId}`);
+    const sessionManager = SessionManager.continueRecent(ws.path);
+    const runtime = await createAgentSessionRuntime(createRuntime, {
+      cwd: ws.path,
+      agentDir: getAgentDir(),
+      sessionManager
+    });
+    const subscribers = this.getOrCreateSubscriberSet(workspaceId);
+    const bridge = new ExtensionUIBridge();
+    const onError = (err) => {
+      const msg = {
+        type: "extension_error",
+        workspaceId,
+        extensionPath: err.extensionPath,
+        event: err.event,
+        message: err.error
+      };
+      broadcastTo(subscribers, msg);
+      console.error(
+        `[ext-error] ${workspaceId} ${err.extensionPath}@${err.event}: ${err.error}` + (err.stack ? `
+${err.stack}` : "")
+      );
+    };
+    await runtime.session.bindExtensions({ uiContext: bridge, onError });
+    runtime.setRebindSession(async () => {
+      await runtime.session.bindExtensions({ uiContext: bridge, onError });
+      this.notifySessionReplaced(workspaceId);
+    });
+    return { runtime, bridge };
+  }
+  get(workspaceId) {
+    return this.states.get(workspaceId)?.runtime;
+  }
+  /**
+   * Register a WS connection as a subscriber for `workspaceId`. Safe to
+   * call before `getOrCreate`; the set is lazily created so the bridge,
+   * when later built, sees the same Set instance and any pre-existing
+   * subscribers.
+   */
+  addSubscriber(workspaceId, ws) {
+    this.getOrCreateSubscriberSet(workspaceId).add(ws);
+  }
+  removeSubscriber(workspaceId, ws) {
+    const set = this.subscribers.get(workspaceId);
+    if (!set) return;
+    set.delete(ws);
+    if (set.size === 0) this.subscribers.delete(workspaceId);
+  }
+  /**
+   * Fan a server-initiated message out to every WS subscribed to the
+   * workspace. Used by API handlers that mutate runtime state and need
+   * to refresh derived snapshots (e.g. `context_usage` after `setModel`,
+   * which pi's event stream doesn't surface unless thinking-level also
+   * clamps).
+   */
+  broadcast(workspaceId, msg) {
+    const set = this.subscribers.get(workspaceId);
+    if (!set || set.size === 0) return;
+    broadcastTo(set, msg);
+  }
+  onSessionReplaced(workspaceId, listener) {
+    let listeners = this.rebindListeners.get(workspaceId);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.rebindListeners.set(workspaceId, listeners);
+    }
+    listeners.add(listener);
+    return () => {
+      const current = this.rebindListeners.get(workspaceId);
+      if (!current) return;
+      current.delete(listener);
+      if (current.size === 0) {
+        this.rebindListeners.delete(workspaceId);
+      }
+    };
+  }
+  notifySessionReplaced(workspaceId) {
+    const listeners = this.rebindListeners.get(workspaceId);
+    if (!listeners) return;
+    for (const listener of [...listeners]) {
+      try {
+        listener();
+      } catch (e) {
+        console.error(`[wm] rebind listener for ${workspaceId} failed:`, e);
+      }
+    }
+  }
+  async listSessions(workspaceId) {
+    const ws = await getWorkspace(workspaceId);
+    if (!ws) throw new Error(`Workspace not found: ${workspaceId}`);
+    const sessions = await SessionManager.list(ws.path);
+    return sessions.slice().sort((a, b) => b.modified.getTime() - a.modified.getTime()).map(toSessionSummary);
+  }
+  getSessionHistory(workspaceId, sessionPath) {
+    const runtime = this.states.get(workspaceId)?.runtime;
+    if (!runtime) return { items: [], isStreaming: false };
+    if (sessionPath) {
+      const activeFile = runtime.session.sessionFile ? resolve2(runtime.session.sessionFile) : void 0;
+      if (activeFile !== resolve2(sessionPath)) {
+        return { items: [], isStreaming: false };
+      }
+    }
+    const isStreaming = runtime.session.isStreaming ?? false;
+    const branch = runtime.session.sessionManager.getBranch();
+    const items = [];
+    const argsByCallId = /* @__PURE__ */ new Map();
+    for (const entry of branch) {
+      if (entry.type !== "message") continue;
+      const msg = entry.message;
+      const role = msg.role;
+      if (role === "user") {
+        const text = extractUserText(msg);
+        if (text) items.push({ kind: "user", text });
+      } else if (role === "assistant") {
+        const { text, thinking, toolCalls } = extractAssistantContent(
+          msg
+        );
+        for (const tc of toolCalls) {
+          argsByCallId.set(tc.id, tc.args);
+        }
+        if (text || thinking) items.push({ kind: "assistant", text, thinking });
+      } else if (role === "toolResult") {
+        const tr = msg;
+        items.push({
+          kind: "tool",
+          toolCallId: tr.toolCallId,
+          toolName: tr.toolName,
+          args: argsByCallId.get(tr.toolCallId) ?? "",
+          text: extractContentText(tr.content),
+          isError: tr.isError
+        });
+      } else if (role === "bashExecution") {
+        const be = msg;
+        items.push({
+          kind: "bash",
+          command: be.command,
+          output: be.output,
+          exitCode: be.exitCode
+        });
+      }
+    }
+    return { items, isStreaming };
+  }
+  /**
+   * Delete a session JSONL file belonging to this workspace.
+   *
+   * Errors are tagged with HTTP semantics via HttpError so the route layer
+   * can map them to the right status code:
+   *   - 400: sessionPath not absolute
+   *   - 404: workspace gone, or session not in this workspace's list
+   *   - 409: file is the currently-active session (caller must switch first)
+   *
+   * Idempotent on ENOENT: if the file is missing at unlink time (e.g. a
+   * concurrent external delete between list and unlink), we treat it as
+   * success — the goal state has been reached.
+   */
+  async deleteSession(workspaceId, sessionPath) {
+    const ws = await getWorkspace(workspaceId);
+    if (!ws) throw new HttpError(404, `Workspace not found: ${workspaceId}`);
+    if (!isAbsolute2(sessionPath)) {
+      throw new HttpError(400, "Session path must be absolute");
+    }
+    const sessions = await SessionManager.list(ws.path);
+    const resolved = resolve2(sessionPath);
+    const target = sessions.find((session) => resolve2(session.path) === resolved);
+    if (!target) {
+      throw new HttpError(404, `Session not found: ${sessionPath}`);
+    }
+    const runtime = this.states.get(workspaceId)?.runtime;
+    const activePath = runtime?.session.sessionFile ? resolve2(runtime.session.sessionFile) : void 0;
+    if (activePath === resolved) {
+      throw new HttpError(
+        409,
+        "Cannot delete the currently active session \u2014 switch to another session first"
+      );
+    }
+    try {
+      await unlink2(resolved);
+    } catch (err) {
+      if (err?.code === "ENOENT") {
+        console.warn(
+          `[wm] deleteSession: ${resolved} was already gone at unlink time`
+        );
+        return;
+      }
+      throw err;
+    }
+  }
+  async switchSession(workspaceId, sessionPath) {
+    const ws = await getWorkspace(workspaceId);
+    if (!ws) throw new Error(`Workspace not found: ${workspaceId}`);
+    if (!isAbsolute2(sessionPath)) {
+      throw new Error("Session path must be absolute");
+    }
+    const sessions = await SessionManager.list(ws.path);
+    const resolved = resolve2(sessionPath);
+    const target = sessions.find((session) => resolve2(session.path) === resolved);
+    if (!target) {
+      throw new Error(`Session not found: ${sessionPath}`);
+    }
+    const runtime = await this.getOrCreate(workspaceId);
+    const currentPath = runtime.session.sessionFile ? resolve2(runtime.session.sessionFile) : void 0;
+    if (currentPath === resolved) return false;
+    if (runtime.session.isStreaming) {
+      throw new Error("Cannot switch sessions while the agent is streaming");
+    }
+    const result = await runtime.switchSession(resolved, { cwdOverride: ws.path });
+    return !result.cancelled;
+  }
+  async dispose(workspaceId) {
+    const state = this.states.get(workspaceId);
+    if (!state) return;
+    this.states.delete(workspaceId);
+    this.rebindListeners.delete(workspaceId);
+    this.subscribers.delete(workspaceId);
+    try {
+      state.bridge.dispose();
+    } catch (e) {
+      console.error(`[wm] dispose bridge ${workspaceId} failed:`, e);
+    }
+    try {
+      state.runtime.session.dispose();
+    } catch (e) {
+      console.error(`[wm] dispose ${workspaceId} failed:`, e);
+    }
+  }
+  async disposeAll() {
+    const ids = [...this.states.keys()];
+    await Promise.all(ids.map((id) => this.dispose(id)));
+  }
+};
+function toSessionSummary(info) {
+  const preview = info.firstMessage.replace(/\s+/g, " ").trim();
+  return {
+    path: info.path,
+    name: info.name,
+    updatedAt: info.modified.toISOString(),
+    preview: preview ? preview.slice(0, 160) : void 0
+  };
+}
+function extractUserText(msg) {
+  if (typeof msg.content === "string") return msg.content;
+  return extractContentText(msg.content);
+}
+function extractAssistantContent(msg) {
+  const textParts = [];
+  const thinkingParts = [];
+  const toolCalls = [];
+  for (const block of msg.content ?? []) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string") textParts.push(b.text);
+    else if (b.type === "thinking" && typeof b.thinking === "string") thinkingParts.push(b.thinking);
+    else if (b.type === "toolCall" && typeof b.id === "string") {
+      toolCalls.push({
+        id: b.id,
+        args: b.arguments != null ? JSON.stringify(b.arguments) : ""
+      });
+    }
+  }
+  return { text: textParts.join(""), thinking: thinkingParts.join(""), toolCalls };
+}
+function extractContentText(content) {
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const block of content) {
+    if (block && typeof block === "object" && block.type === "text") {
+      const text = block.text;
+      if (typeof text === "string") parts.push(text);
+    }
+  }
+  return parts.join("");
+}
+var workspaceManager = new WorkspaceManager();
+function broadcastTo(subscribers, msg) {
+  const wire = JSON.stringify(msg);
+  for (const ws of subscribers) {
+    if (ws.readyState !== ws.OPEN) continue;
+    try {
+      ws.send(wire);
+    } catch {
+    }
+  }
+}
+
+// src/api/config.ts
+function buildConfigResponse(workspaceId) {
+  const runtime = workspaceManager.get(workspaceId);
+  if (!runtime) throw new Error("runtime not initialized");
+  const session = runtime.session;
+  const model = session.model;
+  const currentModel = model ? {
+    provider: model.provider,
+    modelId: model.id,
+    name: model.name,
+    reasoning: model.reasoning
+  } : null;
+  const availableModels = session.modelRegistry.getAvailable().map((m) => ({
+    provider: m.provider,
+    modelId: m.id,
+    name: m.name,
+    reasoning: m.reasoning
+  }));
+  const allTools = session.getAllTools().map((t) => ({
+    name: t.name,
+    description: t.description
+  }));
+  return {
+    currentModel,
+    thinkingLevel: session.thinkingLevel,
+    availableThinkingLevels: session.getAvailableThinkingLevels(),
+    activeTools: session.getActiveToolNames(),
+    availableModels,
+    allTools
+  };
+}
+async function requireWorkspace(c, id) {
+  const ws = await getWorkspace(id);
+  if (!ws) {
+    c.status(404);
+    c.header("Content-Type", "application/json");
+    return false;
+  }
+  return true;
+}
+function rejectIfStreaming(c, workspaceId) {
+  const runtime = workspaceManager.get(workspaceId);
+  if (runtime?.session.isStreaming) {
+    return true;
+  }
+  return false;
+}
+function broadcastContextUsage(workspaceId, runtime) {
+  const usage = runtime.session.getContextUsage();
+  if (!usage) return;
+  const payload = {
+    kind: "context_usage",
+    tokens: usage.tokens,
+    contextWindow: usage.contextWindow,
+    percent: usage.percent
+  };
+  workspaceManager.broadcast(workspaceId, {
+    type: "event",
+    workspaceId,
+    sessionPath: runtime.session.sessionFile ?? null,
+    payload
+  });
+}
+function mountConfigRoutes(app2) {
+  app2.get("/:id/config", async (c) => {
+    const id = c.req.param("id");
+    const exists2 = await requireWorkspace(c, id);
+    if (!exists2) return c.json({ ok: false, error: "not found" }, 404);
+    try {
+      await workspaceManager.getOrCreate(id);
+      return c.json(buildConfigResponse(id));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ ok: false, error: message }, 500);
+    }
+  });
+  app2.put("/:id/config/model", async (c) => {
+    const id = c.req.param("id");
+    const exists2 = await requireWorkspace(c, id);
+    if (!exists2) return c.json({ ok: false, error: "not found" }, 404);
+    const body = await c.req.json();
+    if (!body?.provider || !body?.modelId) {
+      return c.json({ ok: false, error: "provider and modelId are required" }, 400);
+    }
+    try {
+      const runtime = await workspaceManager.getOrCreate(id);
+      if (rejectIfStreaming(c, id)) {
+        return c.json({ ok: false, error: "cannot change model while the agent is streaming" }, 409);
+      }
+      const model = runtime.session.modelRegistry.getAvailable().find(
+        (m) => m.provider === body.provider && m.id === body.modelId
+      );
+      if (!model) {
+        return c.json({ ok: false, error: `model not found or no auth: ${body.provider}/${body.modelId}` }, 404);
+      }
+      await runtime.session.setModel(model);
+      broadcastContextUsage(id, runtime);
+      return c.json(buildConfigResponse(id));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ ok: false, error: message }, 500);
+    }
+  });
+  app2.put("/:id/config/thinking-level", async (c) => {
+    const id = c.req.param("id");
+    const exists2 = await requireWorkspace(c, id);
+    if (!exists2) return c.json({ ok: false, error: "not found" }, 404);
+    const body = await c.req.json();
+    const validLevels = ["off", "minimal", "low", "medium", "high", "xhigh"];
+    if (!body?.level || !validLevels.includes(body.level)) {
+      return c.json({ ok: false, error: `level must be one of: ${validLevels.join(", ")}` }, 400);
+    }
+    try {
+      await workspaceManager.getOrCreate(id);
+      if (rejectIfStreaming(c, id)) {
+        return c.json({ ok: false, error: "cannot change thinking level while the agent is streaming" }, 409);
+      }
+      const runtime = workspaceManager.get(id);
+      if (!runtime) {
+        return c.json({ ok: false, error: "runtime not initialized" }, 500);
+      }
+      runtime.session.setThinkingLevel(body.level);
+      return c.json(buildConfigResponse(id));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ ok: false, error: message }, 500);
+    }
+  });
+  app2.put("/:id/config/tools", async (c) => {
+    const id = c.req.param("id");
+    const exists2 = await requireWorkspace(c, id);
+    if (!exists2) return c.json({ ok: false, error: "not found" }, 404);
+    const body = await c.req.json();
+    if (!body?.tools || !Array.isArray(body.tools)) {
+      return c.json({ ok: false, error: "tools must be an array of tool names" }, 400);
+    }
+    try {
+      await workspaceManager.getOrCreate(id);
+      if (rejectIfStreaming(c, id)) {
+        return c.json({ ok: false, error: "cannot change tools while the agent is streaming" }, 409);
+      }
+      const runtime = workspaceManager.get(id);
+      if (!runtime) {
+        return c.json({ ok: false, error: "runtime not initialized" }, 500);
+      }
+      runtime.session.setActiveToolsByName(body.tools);
+      return c.json(buildConfigResponse(id));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ ok: false, error: message }, 500);
+    }
+  });
+}
+
+// src/api/files.ts
+import { execFile as execFile2 } from "child_process";
+import { readdir } from "fs/promises";
+import { join as join4, relative, sep as sep2 } from "path";
+import { promisify as promisify2 } from "util";
+var exec2 = promisify2(execFile2);
+var LIST_TTL_MS = 1e4;
+var MAX_CACHED_WORKSPACES = 16;
+var MAX_FILES_TRACKED = 2e4;
+var DEFAULT_LIMIT = 30;
+var MAX_LIMIT = 100;
+var WALK_MAX_DEPTH = 8;
+var WALK_IGNORES = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  ".next",
+  ".turbo",
+  ".cache",
+  ".vite",
+  "out",
+  "coverage",
+  "target",
+  "venv",
+  ".venv",
+  "__pycache__",
+  ".DS_Store"
+]);
+var listCache = /* @__PURE__ */ new Map();
+var inflight2 = /* @__PURE__ */ new Map();
+async function getFileList(workspacePath) {
+  const now = Date.now();
+  const cached = listCache.get(workspacePath);
+  if (cached && cached.expiresAt > now) return cached.files;
+  const pending = inflight2.get(workspacePath);
+  if (pending) return (await pending).files;
+  const probe = probeFileList(workspacePath).then((files) => {
+    const entry = {
+      files,
+      expiresAt: Date.now() + LIST_TTL_MS
+    };
+    listCache.delete(workspacePath);
+    listCache.set(workspacePath, entry);
+    while (listCache.size > MAX_CACHED_WORKSPACES) {
+      const oldest = listCache.keys().next().value;
+      if (!oldest) break;
+      listCache.delete(oldest);
+    }
+    return entry;
+  }).finally(() => inflight2.delete(workspacePath));
+  inflight2.set(workspacePath, probe);
+  return (await probe).files;
+}
+async function probeFileList(workspacePath) {
+  try {
+    const { stdout } = await exec2(
+      "git",
+      ["ls-files", "--cached", "--others", "--exclude-standard"],
+      {
+        cwd: workspacePath,
+        timeout: 3e3,
+        maxBuffer: 16 * 1024 * 1024,
+        env: { ...process.env, GIT_DIR: void 0, GIT_WORK_TREE: void 0 }
+      }
+    );
+    const lines = stdout.split("\n");
+    const out2 = [];
+    for (const line of lines) {
+      if (!line) continue;
+      out2.push(line);
+      if (out2.length >= MAX_FILES_TRACKED) break;
+    }
+    return out2;
+  } catch {
+  }
+  const out = [];
+  await walkDir(workspacePath, workspacePath, 0, out);
+  return out;
+}
+async function walkDir(root, dir, depth, out) {
+  if (out.length >= MAX_FILES_TRACKED) return;
+  if (depth > WALK_MAX_DEPTH) return;
+  let dirents;
+  try {
+    dirents = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const d of dirents) {
+    if (out.length >= MAX_FILES_TRACKED) return;
+    if (WALK_IGNORES.has(d.name)) continue;
+    const abs = join4(dir, d.name);
+    if (d.isDirectory()) {
+      await walkDir(root, abs, depth + 1, out);
+    } else if (d.isFile()) {
+      out.push(relative(root, abs).split(sep2).join("/"));
+    }
+  }
+}
+function scoreMatch(relPath, q) {
+  const lower = relPath.toLowerCase();
+  const slash = lower.lastIndexOf("/");
+  const base = slash >= 0 ? lower.slice(slash + 1) : lower;
+  if (base.startsWith(q)) return 1e3 - relPath.length;
+  const baseIdx = base.indexOf(q);
+  if (baseIdx >= 0) return 800 - baseIdx - relPath.length * 0.01;
+  const pathIdx = lower.indexOf(q);
+  if (pathIdx >= 0) return 500 - pathIdx - relPath.length * 0.01;
+  return null;
+}
+async function ensureWorkspaceExists(id) {
+  const ws = await getWorkspace(id);
+  return ws ? ws.path : null;
+}
+function mountFilesRoute(app2) {
+  app2.get("/:id/files/search", async (c) => {
+    const id = c.req.param("id");
+    const workspacePath = await ensureWorkspaceExists(id);
+    if (!workspacePath) return c.json({ ok: false, error: "not found" }, 404);
+    const qRaw = (c.req.query("q") ?? "").trim();
+    const limitRaw = c.req.query("limit");
+    let limit = limitRaw ? Number(limitRaw) : DEFAULT_LIMIT;
+    if (!Number.isFinite(limit) || limit <= 0) limit = DEFAULT_LIMIT;
+    if (limit > MAX_LIMIT) limit = MAX_LIMIT;
+    try {
+      const all = await getFileList(workspacePath);
+      let entries;
+      let truncated = false;
+      if (!qRaw) {
+        const slice = all.slice(0, limit);
+        entries = slice.map((relPath) => ({
+          path: join4(workspacePath, relPath),
+          relPath
+        }));
+        truncated = all.length > limit;
+      } else {
+        const q = qRaw.toLowerCase();
+        const scored = [];
+        let matchCount = 0;
+        for (const relPath of all) {
+          const score = scoreMatch(relPath, q);
+          if (score === null) continue;
+          matchCount++;
+          scored.push({ relPath, score });
+        }
+        scored.sort((a, b) => b.score - a.score);
+        const top = scored.slice(0, limit);
+        entries = top.map((e) => ({
+          path: join4(workspacePath, e.relPath),
+          relPath: e.relPath
+        }));
+        truncated = matchCount > limit;
+      }
+      const body = { workspacePath, entries, truncated };
+      return c.json(body);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[api/files] search for ${id} failed:`, err);
+      return c.json({ ok: false, error: message }, 500);
+    }
+  });
+}
+
+// src/api/resources.ts
+import { readdir as readdir2 } from "fs/promises";
+import { join as join5 } from "path";
+import { getAgentDir as getAgentDir2 } from "@earendil-works/pi-coding-agent";
+function toResourceSource(info) {
+  return {
+    scope: info.scope,
+    label: info.source,
+    path: info.path
+  };
+}
+async function scanExtensionDirs(workspaceCwd) {
+  const dirs = [join5(getAgentDir2(), "extensions"), join5(workspaceCwd, ".pi", "extensions")];
+  const found = [];
+  for (const dir of dirs) {
+    try {
+      const entries = await readdir2(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js"))) {
+          found.push(join5(dir, entry.name));
+        } else if (entry.isDirectory()) {
+          found.push(join5(dir, entry.name));
+        }
+      }
+    } catch {
+    }
+  }
+  return found;
+}
+async function snapshot(workspaceId, roots, workspaceCwd) {
+  const runtime = workspaceManager.get(workspaceId);
+  if (!runtime) throw new HttpError(500, "runtime not initialized");
+  const loader = runtime.services.resourceLoader;
+  const { skills } = loader.getSkills();
+  const { prompts } = loader.getPrompts();
+  const extResult = loader.getExtensions();
+  const skillsOut = skills.map((s) => ({
+    name: s.name,
+    description: s.description,
+    filePath: s.filePath,
+    disableModelInvocation: s.disableModelInvocation,
+    source: toResourceSource(s.sourceInfo),
+    managed: scopeFor(s.filePath, roots) !== void 0
+  }));
+  const promptsOut = prompts.map((p) => ({
+    name: p.name,
+    description: p.description,
+    argumentHint: p.argumentHint,
+    filePath: p.filePath,
+    content: p.content,
+    source: toResourceSource(p.sourceInfo),
+    managed: scopeFor(p.filePath, roots) !== void 0
+  }));
+  const extensionsOut = extResult.extensions.map((e) => ({
+    path: e.path,
+    resolvedPath: e.resolvedPath,
+    source: toResourceSource(e.sourceInfo),
+    tools: [...e.tools.keys()],
+    commands: [...e.commands.keys()],
+    flags: [...e.flags.keys()],
+    shortcuts: [...e.shortcuts.keys()]
+  }));
+  const extensionErrors = extResult.errors.map((err) => ({
+    path: err.path,
+    error: err.error
+  }));
+  const disabledExtensions = EXTENSIONS_ENABLED ? [] : await scanExtensionDirs(workspaceCwd);
+  return {
+    skills: skillsOut,
+    prompts: promptsOut,
+    extensionsEnabled: EXTENSIONS_ENABLED,
+    extensions: extensionsOut,
+    extensionErrors,
+    disabledExtensions
+  };
+}
+async function rootsFor(workspaceId) {
+  const ws = await getWorkspace(workspaceId);
+  if (!ws) throw new HttpError(404, "workspace not found");
+  const roots = resolveResourceRoots({ agentDir: getAgentDir2(), workspaceCwd: ws.path });
+  return { roots, workspaceCwd: ws.path };
+}
+function respondError(c, err) {
+  if (err instanceof HttpError) {
+    return c.json({ ok: false, error: err.message }, err.status);
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(`[api/resources] unexpected error:`, err);
+  return c.json({ ok: false, error: message }, 500);
+}
+async function reload(workspaceId) {
+  const runtime = workspaceManager.get(workspaceId);
+  if (!runtime) throw new HttpError(500, "runtime not initialized");
+  await runtime.services.resourceLoader.reload();
+}
+function mountResourcesRoute(app2) {
+  app2.get("/:id/resources", async (c) => {
+    const id = c.req.param("id");
+    const ws = await getWorkspace(id);
+    if (!ws) return c.json({ ok: false, error: "not found" }, 404);
+    try {
+      await workspaceManager.getOrCreate(id);
+      const { roots, workspaceCwd } = await rootsFor(id);
+      return c.json(await snapshot(id, roots, workspaceCwd));
+    } catch (err) {
+      return respondError(c, err);
+    }
+  });
+  app2.post("/:id/resources/reload", async (c) => {
+    const id = c.req.param("id");
+    const ws = await getWorkspace(id);
+    if (!ws) return c.json({ ok: false, error: "not found" }, 404);
+    try {
+      await workspaceManager.getOrCreate(id);
+      await reload(id);
+      const { roots, workspaceCwd } = await rootsFor(id);
+      return c.json(await snapshot(id, roots, workspaceCwd));
+    } catch (err) {
+      return respondError(c, err);
+    }
+  });
+  app2.get("/:id/resources/skill", async (c) => {
+    const id = c.req.param("id");
+    const ws = await getWorkspace(id);
+    if (!ws) return c.json({ ok: false, error: "not found" }, 404);
+    const filePath = c.req.query("path");
+    if (!filePath) return c.json({ ok: false, error: "path query is required" }, 400);
+    try {
+      const { roots } = await rootsFor(id);
+      const scope = scopeFor(filePath, roots);
+      if (scope === void 0) {
+        return c.json({ ok: false, error: "skill file is not under a managed root" }, 400);
+      }
+      const data = await readSkillFile(filePath, roots);
+      const body = {
+        filePath,
+        scope,
+        name: data.name,
+        description: data.description,
+        disableModelInvocation: data.disableModelInvocation,
+        body: data.body
+      };
+      return c.json(body);
+    } catch (err) {
+      return respondError(c, err);
+    }
+  });
+  app2.post("/:id/resources/skills", async (c) => {
+    const id = c.req.param("id");
+    const ws = await getWorkspace(id);
+    if (!ws) return c.json({ ok: false, error: "not found" }, 404);
+    const body = await c.req.json().catch(() => null);
+    if (!body || !isScope(body.scope) || typeof body.name !== "string" || typeof body.description !== "string" || typeof body.body !== "string") {
+      return c.json({ ok: false, error: "scope, name, description, body are required" }, 400);
+    }
+    try {
+      await workspaceManager.getOrCreate(id);
+      const { roots, workspaceCwd } = await rootsFor(id);
+      await createSkill({
+        roots,
+        scope: body.scope,
+        name: body.name,
+        description: body.description,
+        body: body.body,
+        disableModelInvocation: body.disableModelInvocation
+      });
+      await reload(id);
+      return c.json(await snapshot(id, roots, workspaceCwd));
+    } catch (err) {
+      return respondError(c, err);
+    }
+  });
+  app2.put("/:id/resources/skills", async (c) => {
+    const id = c.req.param("id");
+    const ws = await getWorkspace(id);
+    if (!ws) return c.json({ ok: false, error: "not found" }, 404);
+    const body = await c.req.json().catch(() => null);
+    if (!body || typeof body.filePath !== "string" || typeof body.name !== "string" || typeof body.description !== "string" || typeof body.body !== "string") {
+      return c.json({ ok: false, error: "filePath, name, description, body are required" }, 400);
+    }
+    try {
+      await workspaceManager.getOrCreate(id);
+      const { roots, workspaceCwd } = await rootsFor(id);
+      await updateSkill({
+        roots,
+        filePath: body.filePath,
+        name: body.name,
+        description: body.description,
+        body: body.body,
+        disableModelInvocation: body.disableModelInvocation
+      });
+      await reload(id);
+      return c.json(await snapshot(id, roots, workspaceCwd));
+    } catch (err) {
+      return respondError(c, err);
+    }
+  });
+  app2.delete("/:id/resources/skills", async (c) => {
+    const id = c.req.param("id");
+    const ws = await getWorkspace(id);
+    if (!ws) return c.json({ ok: false, error: "not found" }, 404);
+    const filePath = c.req.query("path");
+    if (!filePath) return c.json({ ok: false, error: "path query is required" }, 400);
+    try {
+      await workspaceManager.getOrCreate(id);
+      const { roots, workspaceCwd } = await rootsFor(id);
+      await deleteSkill(filePath, roots);
+      await reload(id);
+      return c.json(await snapshot(id, roots, workspaceCwd));
+    } catch (err) {
+      return respondError(c, err);
+    }
+  });
+  app2.get("/:id/resources/prompt", async (c) => {
+    const id = c.req.param("id");
+    const ws = await getWorkspace(id);
+    if (!ws) return c.json({ ok: false, error: "not found" }, 404);
+    const filePath = c.req.query("path");
+    if (!filePath) return c.json({ ok: false, error: "path query is required" }, 400);
+    try {
+      const { roots } = await rootsFor(id);
+      const scope = scopeFor(filePath, roots);
+      if (scope === void 0) {
+        return c.json({ ok: false, error: "prompt file is not under a managed root" }, 400);
+      }
+      const data = await readPromptFile(filePath, roots);
+      const body = {
+        filePath,
+        scope,
+        name: data.name,
+        description: data.description,
+        argumentHint: data.argumentHint,
+        body: data.body
+      };
+      return c.json(body);
+    } catch (err) {
+      return respondError(c, err);
+    }
+  });
+  app2.post("/:id/resources/prompts", async (c) => {
+    const id = c.req.param("id");
+    const ws = await getWorkspace(id);
+    if (!ws) return c.json({ ok: false, error: "not found" }, 404);
+    const body = await c.req.json().catch(() => null);
+    if (!body || !isScope(body.scope) || typeof body.name !== "string" || typeof body.description !== "string" || typeof body.body !== "string") {
+      return c.json({ ok: false, error: "scope, name, description, body are required" }, 400);
+    }
+    try {
+      await workspaceManager.getOrCreate(id);
+      const { roots, workspaceCwd } = await rootsFor(id);
+      await createPrompt({
+        roots,
+        scope: body.scope,
+        name: body.name,
+        description: body.description,
+        argumentHint: body.argumentHint,
+        body: body.body
+      });
+      await reload(id);
+      return c.json(await snapshot(id, roots, workspaceCwd));
+    } catch (err) {
+      return respondError(c, err);
+    }
+  });
+  app2.put("/:id/resources/prompts", async (c) => {
+    const id = c.req.param("id");
+    const ws = await getWorkspace(id);
+    if (!ws) return c.json({ ok: false, error: "not found" }, 404);
+    const body = await c.req.json().catch(() => null);
+    if (!body || typeof body.filePath !== "string" || typeof body.name !== "string" || typeof body.description !== "string" || typeof body.body !== "string") {
+      return c.json({ ok: false, error: "filePath, name, description, body are required" }, 400);
+    }
+    try {
+      await workspaceManager.getOrCreate(id);
+      const { roots, workspaceCwd } = await rootsFor(id);
+      await updatePrompt({
+        roots,
+        filePath: body.filePath,
+        name: body.name,
+        description: body.description,
+        argumentHint: body.argumentHint,
+        body: body.body
+      });
+      await reload(id);
+      return c.json(await snapshot(id, roots, workspaceCwd));
+    } catch (err) {
+      return respondError(c, err);
+    }
+  });
+  app2.delete("/:id/resources/prompts", async (c) => {
+    const id = c.req.param("id");
+    const ws = await getWorkspace(id);
+    if (!ws) return c.json({ ok: false, error: "not found" }, 404);
+    const filePath = c.req.query("path");
+    if (!filePath) return c.json({ ok: false, error: "path query is required" }, 400);
+    try {
+      await workspaceManager.getOrCreate(id);
+      const { roots, workspaceCwd } = await rootsFor(id);
+      await deletePrompt(filePath, roots);
+      await reload(id);
+      return c.json(await snapshot(id, roots, workspaceCwd));
+    } catch (err) {
+      return respondError(c, err);
+    }
+  });
+}
+function isScope(value) {
+  return value === "user" || value === "project";
+}
+
+// src/api/workspaces.ts
+var workspacesRoute = new Hono();
+workspacesRoute.get("/", async (c) => {
+  const raw = await listWorkspaces();
+  const workspaces = await Promise.all(raw.map(enrichWorkspace));
+  const body = { workspaces };
+  return c.json(body);
+});
+workspacesRoute.get("/:id/sessions", async (c) => {
+  const id = c.req.param("id");
+  const existed = await getWorkspace(id);
+  if (!existed) return c.json({ ok: false, error: "not found" }, 404);
+  try {
+    const sessions = await workspaceManager.listSessions(id);
+    const body = { sessions };
+    return c.json(body);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[api] list sessions for ${id} failed:`, err);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+workspacesRoute.delete("/:id/sessions", async (c) => {
+  const id = c.req.param("id");
+  const existed = await getWorkspace(id);
+  if (!existed) return c.json({ ok: false, error: "not found" }, 404);
+  const sessionPath = c.req.query("path");
+  if (!sessionPath) {
+    return c.json({ ok: false, error: "path query is required" }, 400);
+  }
+  try {
+    await workspaceManager.deleteSession(id, sessionPath);
+    const body = { ok: true };
+    return c.json(body);
+  } catch (err) {
+    if (err instanceof HttpError) {
+      return c.json(
+        { ok: false, error: err.message },
+        err.status
+      );
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[api] delete session for ${id} failed:`, err);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+workspacesRoute.get("/:id/fork-points", async (c) => {
+  const id = c.req.param("id");
+  const existed = await getWorkspace(id);
+  if (!existed) return c.json({ ok: false, error: "not found" }, 404);
+  try {
+    const runtime = await workspaceManager.getOrCreate(id);
+    const raw = runtime.session.getUserMessagesForForking();
+    const points = raw.map((p) => ({
+      entryId: p.entryId,
+      text: p.text.length > 120 ? p.text.slice(0, 120) + "\u2026" : p.text
+    }));
+    const body = { points };
+    return c.json(body);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[api] fork-points for ${id} failed:`, err);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+workspacesRoute.get("/:id/history", async (c) => {
+  const id = c.req.param("id");
+  const existed = await getWorkspace(id);
+  if (!existed) return c.json({ ok: false, error: "not found" }, 404);
+  try {
+    await workspaceManager.getOrCreate(id);
+    const sessionPath = c.req.query("sessionPath");
+    const body = workspaceManager.getSessionHistory(id, sessionPath);
+    return c.json(body);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[api] history for ${id} failed:`, err);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+workspacesRoute.post("/", async (c) => {
+  const body = await c.req.json();
+  if (!body?.path || typeof body.path !== "string") {
+    return c.json({ ok: false, error: "path is required" }, 400);
+  }
+  if (!isAbsolute3(body.path)) {
+    return c.json({ ok: false, error: "path must be absolute" }, 400);
+  }
+  const resolved = resolve3(body.path);
+  try {
+    const st = await stat2(resolved);
+    if (!st.isDirectory()) {
+      return c.json({ ok: false, error: "path is not a directory" }, 400);
+    }
+  } catch {
+    return c.json({ ok: false, error: "path does not exist" }, 400);
+  }
+  const stored = await addWorkspace({
+    path: resolved,
+    name: body.name?.trim() || basename2(resolved) || resolved
+  });
+  const ws = await enrichWorkspace(stored);
+  const res = { workspace: ws };
+  return c.json(res);
+});
+workspacesRoute.delete("/:id", async (c) => {
+  const id = c.req.param("id");
+  const existed = await getWorkspace(id);
+  if (!existed) return c.json({ ok: false, error: "not found" }, 404);
+  await workspaceManager.dispose(id);
+  await removeWorkspace(id);
+  const body = { ok: true };
+  return c.json(body);
+});
+mountConfigRoutes(workspacesRoute);
+mountResourcesRoute(workspacesRoute);
+mountFilesRoute(workspacesRoute);
+
+// src/api/fs.ts
+import { readdir as readdir3 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname3, isAbsolute as isAbsolute4, join as join6, resolve as resolve4 } from "path";
+import { Hono as Hono2 } from "hono";
+var fsRoute = new Hono2();
+fsRoute.get("/browse", async (c) => {
+  const rawPath = c.req.query("path");
+  const showHidden = c.req.query("showHidden") === "1";
+  const target = rawPath && isAbsolute4(rawPath) ? resolve4(rawPath) : homedir2();
+  let dirents;
+  try {
+    dirents = await readdir3(target, { withFileTypes: true });
+  } catch (err) {
+    const code = err.code;
+    const msg = code === "EACCES" ? "permission denied" : code === "ENOENT" ? "not found" : "read failed";
+    return c.json({ ok: false, error: msg, path: target }, 400);
+  }
+  const entries = dirents.filter((d) => d.isDirectory()).filter((d) => showHidden || !d.name.startsWith(".")).map((d) => ({
+    name: d.name,
+    path: join6(target, d.name),
+    type: "dir"
+  })).sort((a, b) => a.name.localeCompare(b.name));
+  const parent = (() => {
+    const p = dirname3(target);
+    return p === target ? null : p;
+  })();
+  const body = { path: target, parent, entries };
+  return c.json(body);
+});
+
+// src/api/model-configs.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname4, join as join7 } from "path";
+import { Hono as Hono3 } from "hono";
+import {
+  getAgentDir as getAgentDir3
+} from "@earendil-works/pi-coding-agent";
+var modelConfigsRoute = new Hono3();
+var writeLock = Promise.resolve();
+function withWriteLock(fn) {
+  const next = writeLock.then(fn, fn);
+  writeLock = next.then(() => {
+  }, () => {
+  });
+  return next;
+}
+function modelsPath() {
+  return join7(getAgentDir3(), "models.json");
+}
+async function readModelsJson() {
+  try {
+    const raw = await readFile3(modelsPath(), "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      return { providers: {} };
+    }
+    throw err;
+  }
+}
+async function writeModelsJson(config2) {
+  const p = modelsPath();
+  await mkdir3(dirname4(p), { recursive: true });
+  await writeFile3(p, JSON.stringify(config2, null, 2), "utf-8");
+}
+var ValidationError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+function refreshRegistry(workspaceId) {
+  if (!workspaceId) return;
+  const runtime = workspaceManager.get(workspaceId);
+  if (runtime) {
+    try {
+      runtime.session.modelRegistry.refresh();
+    } catch (e) {
+      console.error(`[model-configs] refresh registry for ${workspaceId} failed:`, e);
+    }
+  }
+}
+modelConfigsRoute.get("/", async (c) => {
+  try {
+    const config2 = await readModelsJson();
+    const body = { config: config2 };
+    return c.json(body);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+modelConfigsRoute.put("/", async (c) => {
+  const body = await c.req.json();
+  if (!body?.config?.providers) {
+    return c.json({ ok: false, error: "config.providers is required" }, 400);
+  }
+  try {
+    await withWriteLock(async () => {
+      await writeModelsJson(body.config);
+    });
+    const workspaceId = c.req.query("workspaceId");
+    refreshRegistry(workspaceId ?? void 0);
+    const resp = { config: body.config };
+    return c.json(resp);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+modelConfigsRoute.post("/providers", async (c) => {
+  const body = await c.req.json();
+  if (!body?.name || !body?.provider) {
+    return c.json({ ok: false, error: "name and provider are required" }, 400);
+  }
+  if (!body.provider.baseUrl || !body.provider.api || !body.provider.apiKey) {
+    return c.json({ ok: false, error: "provider must have baseUrl, api, and apiKey" }, 400);
+  }
+  if (!Array.isArray(body.provider.models)) {
+    return c.json({ ok: false, error: "provider.models must be an array" }, 400);
+  }
+  try {
+    const config2 = await withWriteLock(async () => {
+      const cfg = await readModelsJson();
+      cfg.providers[body.name] = body.provider;
+      await writeModelsJson(cfg);
+      return cfg;
+    });
+    const workspaceId = c.req.query("workspaceId");
+    refreshRegistry(workspaceId ?? void 0);
+    const resp = { config: config2 };
+    return c.json(resp);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+modelConfigsRoute.delete("/providers", async (c) => {
+  const name = c.req.query("name");
+  if (!name) {
+    return c.json({ ok: false, error: "name query param is required" }, 400);
+  }
+  try {
+    const config2 = await withWriteLock(async () => {
+      const cfg = await readModelsJson();
+      if (!cfg.providers[name]) {
+        throw new ValidationError(`provider "${name}" not found`, 404);
+      }
+      delete cfg.providers[name];
+      await writeModelsJson(cfg);
+      return cfg;
+    });
+    const workspaceId = c.req.query("workspaceId");
+    refreshRegistry(workspaceId ?? void 0);
+    const resp = { config: config2 };
+    return c.json(resp);
+  } catch (err) {
+    if (err instanceof ValidationError) {
+      return c.json({ ok: false, error: err.message }, err.status);
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+modelConfigsRoute.post("/providers/:provider/models", async (c) => {
+  const provider = c.req.param("provider");
+  const body = await c.req.json();
+  if (!body?.model?.id || !body?.model?.name) {
+    return c.json({ ok: false, error: "model.id and model.name are required" }, 400);
+  }
+  try {
+    const config2 = await withWriteLock(async () => {
+      const cfg = await readModelsJson();
+      if (!cfg.providers[provider]) {
+        throw new ValidationError(`provider "${provider}" not found`, 404);
+      }
+      const existing = cfg.providers[provider].models.find((m) => m.id === body.model.id);
+      if (existing) {
+        throw new ValidationError(`model "${body.model.id}" already exists in provider "${provider}"`, 409);
+      }
+      cfg.providers[provider].models.push(body.model);
+      await writeModelsJson(cfg);
+      return cfg;
+    });
+    const workspaceId = c.req.query("workspaceId");
+    refreshRegistry(workspaceId ?? void 0);
+    const resp = { config: config2 };
+    return c.json(resp);
+  } catch (err) {
+    if (err instanceof ValidationError) {
+      return c.json({ ok: false, error: err.message }, err.status);
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+modelConfigsRoute.put("/providers/:provider/models/:modelId", async (c) => {
+  const provider = c.req.param("provider");
+  const modelId = c.req.param("modelId");
+  const body = await c.req.json();
+  if (!body?.model) {
+    return c.json({ ok: false, error: "model is required" }, 400);
+  }
+  if (body.model.id !== modelId) {
+    return c.json({ ok: false, error: "model.id does not match URL parameter" }, 400);
+  }
+  try {
+    const config2 = await withWriteLock(async () => {
+      const cfg = await readModelsJson();
+      if (!cfg.providers[provider]) {
+        throw new ValidationError(`provider "${provider}" not found`, 404);
+      }
+      const idx = cfg.providers[provider].models.findIndex((m) => m.id === modelId);
+      if (idx === -1) {
+        throw new ValidationError(`model "${modelId}" not found in provider "${provider}"`, 404);
+      }
+      cfg.providers[provider].models[idx] = body.model;
+      await writeModelsJson(cfg);
+      return cfg;
+    });
+    const workspaceId = c.req.query("workspaceId");
+    refreshRegistry(workspaceId ?? void 0);
+    const resp = { config: config2 };
+    return c.json(resp);
+  } catch (err) {
+    if (err instanceof ValidationError) {
+      return c.json({ ok: false, error: err.message }, err.status);
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+modelConfigsRoute.delete("/providers/:provider/models/:modelId", async (c) => {
+  const provider = c.req.param("provider");
+  const modelId = c.req.param("modelId");
+  try {
+    const config2 = await withWriteLock(async () => {
+      const cfg = await readModelsJson();
+      if (!cfg.providers[provider]) {
+        throw new ValidationError(`provider "${provider}" not found`, 404);
+      }
+      const idx = cfg.providers[provider].models.findIndex((m) => m.id === modelId);
+      if (idx === -1) {
+        throw new ValidationError(`model "${modelId}" not found in provider "${provider}"`, 404);
+      }
+      cfg.providers[provider].models.splice(idx, 1);
+      await writeModelsJson(cfg);
+      return cfg;
+    });
+    const workspaceId = c.req.query("workspaceId");
+    refreshRegistry(workspaceId ?? void 0);
+    const resp = { config: config2 };
+    return c.json(resp);
+  } catch (err) {
+    if (err instanceof ValidationError) {
+      return c.json({ ok: false, error: err.message }, err.status);
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+
+// src/ws/hub.ts
+import { WebSocketServer } from "ws";
+
+// src/ws/bridge.ts
+function translatePiEvent(ev) {
+  switch (ev.type) {
+    case "agent_start":
+      return { kind: "agent_start" };
+    case "agent_end":
+      return { kind: "agent_end", willRetry: ev.willRetry };
+    case "turn_start":
+      return { kind: "turn_start" };
+    case "turn_end":
+      return { kind: "turn_end" };
+    case "message_start":
+      return { kind: "message_start", role: roleOf(ev.message) };
+    case "message_end":
+      return { kind: "message_end", role: roleOf(ev.message) };
+    case "message_update": {
+      const ame = ev.assistantMessageEvent;
+      if (ame.type === "text_delta") {
+        return {
+          kind: "message_update",
+          delta: { kind: "text", contentIndex: ame.contentIndex, text: ame.delta }
+        };
+      }
+      if (ame.type === "thinking_delta") {
+        return {
+          kind: "message_update",
+          delta: { kind: "thinking", contentIndex: ame.contentIndex, text: ame.delta }
+        };
+      }
+      return { kind: "message_update", delta: { kind: "other" } };
+    }
+    case "tool_execution_start":
+      return {
+        kind: "tool_execution_start",
+        toolCallId: ev.toolCallId,
+        toolName: ev.toolName,
+        args: ev.args
+      };
+    case "tool_execution_update":
+      return {
+        kind: "tool_execution_update",
+        toolCallId: ev.toolCallId,
+        toolName: ev.toolName,
+        partialText: extractText(ev.partialResult)
+      };
+    case "tool_execution_end":
+      return {
+        kind: "tool_execution_end",
+        toolCallId: ev.toolCallId,
+        toolName: ev.toolName,
+        isError: ev.isError,
+        text: extractText(ev.result)
+      };
+    case "queue_update":
+      return {
+        kind: "queue_update",
+        steering: [...ev.steering],
+        followUp: [...ev.followUp]
+      };
+    case "auto_retry_start":
+      return {
+        kind: "auto_retry_start",
+        attempt: ev.attempt,
+        maxAttempts: ev.maxAttempts,
+        delayMs: ev.delayMs,
+        errorMessage: ev.errorMessage
+      };
+    case "auto_retry_end":
+      return {
+        kind: "auto_retry_end",
+        success: ev.success,
+        attempt: ev.attempt,
+        finalError: ev.finalError
+      };
+    case "compaction_start":
+      return { kind: "compaction_start", reason: ev.reason };
+    case "compaction_end":
+      return {
+        kind: "compaction_end",
+        reason: ev.reason,
+        aborted: ev.aborted,
+        willRetry: ev.willRetry,
+        errorMessage: ev.errorMessage
+      };
+    case "session_info_changed":
+      return { kind: "session_info_changed", name: ev.name };
+    case "thinking_level_changed":
+      return { kind: "thinking_level_changed", level: ev.level };
+    default:
+      return void 0;
+  }
+}
+function roleOf(message) {
+  const role = message?.role;
+  if (role === "user" || role === "assistant" || role === "toolResult" || role === "bashExecution") {
+    return role;
+  }
+  return "assistant";
+}
+function extractText(result) {
+  if (!result || typeof result !== "object") return void 0;
+  const content = result.content;
+  if (!Array.isArray(content)) return void 0;
+  const parts = [];
+  for (const c of content) {
+    if (c && typeof c === "object" && c.type === "text") {
+      const text = c.text;
+      if (typeof text === "string") parts.push(text);
+    }
+  }
+  return parts.length === 0 ? void 0 : parts.join("");
+}
+
+// src/ws/hub.ts
+var replacementLocks = /* @__PURE__ */ new Map();
+function withReplacementLock(workspaceId, fn) {
+  const prev = replacementLocks.get(workspaceId) ?? Promise.resolve();
+  const next = prev.then(fn, fn);
+  replacementLocks.set(workspaceId, next);
+  const cleanup = () => {
+    if (replacementLocks.get(workspaceId) === next) {
+      replacementLocks.delete(workspaceId);
+    }
+  };
+  next.then(cleanup, cleanup);
+  return next;
+}
+function attachWsHub(httpServer) {
+  const wss = new WebSocketServer({ server: httpServer, path: "/ws" });
+  wss.on("connection", (ws) => {
+    const state = {};
+    ws.on("message", async (raw) => {
+      let msg;
+      try {
+        msg = JSON.parse(raw.toString());
+      } catch {
+        send(ws, { type: "error", message: "invalid JSON" });
+        return;
+      }
+      try {
+        await handle(ws, state, msg);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        send(ws, { type: "error", message, command: msg.type });
+      }
+    });
+    ws.on("close", () => {
+      detach(state, ws);
+    });
+  });
+  return wss;
+}
+async function handle(ws, state, msg) {
+  switch (msg.type) {
+    case "subscribe": {
+      const hadCurrentSubscription = state.workspaceId === msg.workspaceId && !!state.unsubscribeSession;
+      ensureRebindListener(ws, state, msg.workspaceId);
+      await workspaceManager.getOrCreate(msg.workspaceId);
+      let switched = false;
+      let switchError;
+      if (msg.sessionPath) {
+        await withReplacementLock(msg.workspaceId, async () => {
+          try {
+            switched = await workspaceManager.switchSession(msg.workspaceId, msg.sessionPath);
+          } catch (err) {
+            switchError = err instanceof Error ? err.message : String(err);
+          }
+        });
+      }
+      if (!switched && !hadCurrentSubscription) {
+        bindCurrentSession(ws, state, msg.workspaceId);
+      }
+      if (switchError) {
+        send(ws, { type: "error", message: switchError, command: "subscribe" });
+      }
+      send(ws, { type: "ack", command: "subscribe" });
+      return;
+    }
+    case "prompt": {
+      const wsId = state.workspaceId;
+      if (!wsId) {
+        send(ws, { type: "error", message: "not subscribed", command: "prompt" });
+        return;
+      }
+      if (replacementLocks.has(wsId)) {
+        send(ws, { type: "error", message: "session switching in progress", command: "prompt" });
+        return;
+      }
+      const runtime = workspaceManager.get(wsId);
+      if (!runtime) {
+        send(ws, { type: "error", message: "runtime gone", command: "prompt" });
+        return;
+      }
+      void runtime.session.prompt(msg.message, {
+        streamingBehavior: msg.streamingBehavior
+      }).catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        send(ws, { type: "error", message, command: "prompt" });
+      });
+      return;
+    }
+    case "abort": {
+      const wsId = state.workspaceId;
+      if (!wsId) {
+        send(ws, { type: "error", message: "not subscribed", command: "abort" });
+        return;
+      }
+      if (replacementLocks.has(wsId)) {
+        send(ws, { type: "error", message: "session switching in progress", command: "abort" });
+        return;
+      }
+      const runtime = workspaceManager.get(wsId);
+      if (!runtime) return;
+      await runtime.session.abort();
+      return;
+    }
+    case "new_session": {
+      const wsId = state.workspaceId;
+      if (!wsId) {
+        send(ws, { type: "error", message: "not subscribed", command: "new_session" });
+        return;
+      }
+      await withReplacementLock(msg.workspaceId, async () => {
+        const runtime = workspaceManager.get(wsId);
+        if (!runtime) {
+          send(ws, { type: "error", message: "runtime gone", command: "new_session" });
+          return;
+        }
+        if (runtime.session.isStreaming) {
+          send(ws, { type: "error", message: "cannot create session while streaming", command: "new_session" });
+          return;
+        }
+        const result = await runtime.newSession();
+        if (result.cancelled) {
+          send(ws, { type: "error", message: "new session cancelled", command: "new_session" });
+        }
+      });
+      return;
+    }
+    case "fork": {
+      const wsId = state.workspaceId;
+      if (!wsId) {
+        send(ws, { type: "error", message: "not subscribed", command: "fork" });
+        return;
+      }
+      await withReplacementLock(msg.workspaceId, async () => {
+        const runtime = workspaceManager.get(wsId);
+        if (!runtime) {
+          send(ws, { type: "error", message: "runtime gone", command: "fork" });
+          return;
+        }
+        if (runtime.session.isStreaming) {
+          send(ws, { type: "error", message: "cannot fork while streaming", command: "fork" });
+          return;
+        }
+        const result = await runtime.fork(msg.entryId);
+        if (result.cancelled) {
+          send(ws, { type: "error", message: "fork cancelled", command: "fork" });
+        }
+      });
+      return;
+    }
+    default: {
+      const _ = msg;
+      void _;
+      send(ws, { type: "error", message: "unknown command" });
+    }
+  }
+}
+function ensureRebindListener(ws, state, workspaceId) {
+  if (state.workspaceId === workspaceId && state.unsubscribeRebind) return;
+  detach(state, ws);
+  state.workspaceId = workspaceId;
+  workspaceManager.addSubscriber(workspaceId, ws);
+  state.unsubscribeRebind = workspaceManager.onSessionReplaced(workspaceId, () => {
+    if (state.workspaceId !== workspaceId) return;
+    bindCurrentSession(ws, state, workspaceId);
+  });
+}
+function bindCurrentSession(ws, state, workspaceId) {
+  const runtime = workspaceManager.get(workspaceId);
+  if (!runtime) {
+    send(ws, { type: "error", message: "runtime gone", command: "subscribe" });
+    return;
+  }
+  state.unsubscribeSession?.();
+  const session = runtime.session;
+  const sessionPath = session.sessionFile ?? null;
+  let assistantStartAt;
+  let assistantFirstTokenAt;
+  state.unsubscribeSession = session.subscribe((ev) => {
+    const payload = translatePiEvent(ev);
+    if (!payload) return;
+    if (payload.kind === "message_start" && payload.role === "assistant") {
+      assistantStartAt = performance.now();
+      assistantFirstTokenAt = void 0;
+    } else if (payload.kind === "message_update" && payload.delta.kind === "text" && assistantStartAt !== void 0 && assistantFirstTokenAt === void 0) {
+      assistantFirstTokenAt = performance.now();
+    }
+    send(ws, {
+      type: "event",
+      workspaceId,
+      sessionPath,
+      payload
+    });
+    if (payload.kind === "message_end" && payload.role === "assistant" && assistantStartAt !== void 0) {
+      const now = performance.now();
+      const timing = {
+        kind: "assistant_timing",
+        firstTokenMs: assistantFirstTokenAt !== void 0 ? Math.round(assistantFirstTokenAt - assistantStartAt) : null,
+        totalMs: Math.round(now - assistantStartAt)
+      };
+      send(ws, {
+        type: "event",
+        workspaceId,
+        sessionPath,
+        payload: timing
+      });
+      assistantStartAt = void 0;
+      assistantFirstTokenAt = void 0;
+    }
+    if (payload.kind === "agent_end" || payload.kind === "compaction_end" || payload.kind === "session_info_changed" || payload.kind === "thinking_level_changed") {
+      sendContextUsage(ws, runtime, workspaceId, sessionPath);
+    }
+  });
+  send(ws, {
+    type: "subscribed",
+    workspaceId,
+    sessionPath,
+    sessionId: session.sessionId
+  });
+  sendContextUsage(ws, runtime, workspaceId, sessionPath);
+}
+function sendContextUsage(ws, runtime, workspaceId, sessionPath) {
+  const usage = runtime.session.getContextUsage();
+  if (!usage) return;
+  const payload = {
+    kind: "context_usage",
+    tokens: usage.tokens,
+    contextWindow: usage.contextWindow,
+    percent: usage.percent
+  };
+  send(ws, {
+    type: "event",
+    workspaceId,
+    sessionPath,
+    payload
+  });
+}
+function detach(state, ws) {
+  state.unsubscribeSession?.();
+  state.unsubscribeSession = void 0;
+  state.unsubscribeRebind?.();
+  state.unsubscribeRebind = void 0;
+  if (state.workspaceId && ws) {
+    workspaceManager.removeSubscriber(state.workspaceId, ws);
+  }
+  state.workspaceId = void 0;
+}
+function send(ws, msg) {
+  if (ws.readyState !== ws.OPEN) return;
+  ws.send(JSON.stringify(msg));
+}
+
+// src/index.ts
+var app = new Hono4();
+var distDir = dirname5(fileURLToPath(import.meta.url));
+var webRoot = resolve5(process.env.PI_PILOT_WEB_ROOT ?? join8(distDir, "..", "public"));
+var webIndexPath = join8(webRoot, "index.html");
+var mimeTypes = {
+  ".css": "text/css; charset=utf-8",
+  ".html": "text/html; charset=utf-8",
+  ".ico": "image/x-icon",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain; charset=utf-8",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function isApiOrWsPath(pathname) {
+  return pathname === "/api" || pathname.startsWith("/api/") || pathname === "/ws";
+}
+function safeResolveWebPath(pathname) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(pathname);
+  } catch {
+    return void 0;
+  }
+  const relativePath = decoded === "/" ? "index.html" : decoded.replace(/^\/+/, "");
+  const candidate = resolve5(webRoot, relativePath);
+  if (candidate !== webRoot && !candidate.startsWith(`${webRoot}${sep3}`)) {
+    return void 0;
+  }
+  return candidate;
+}
+async function readWebFile(path) {
+  try {
+    return await readFile4(path);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "EISDIR") return void 0;
+    throw err;
+  }
+}
+async function serveWeb(c) {
+  const pathname = new URL(c.req.url).pathname;
+  if (isApiOrWsPath(pathname)) return c.notFound();
+  const assetPath = safeResolveWebPath(pathname);
+  if (!assetPath) return c.text("invalid asset path", 400);
+  const asset = await readWebFile(assetPath);
+  const body = asset ?? await readFile4(webIndexPath);
+  const filePath = asset ? assetPath : webIndexPath;
+  const headers = {
+    "Content-Type": mimeTypes[extname(filePath)] ?? "application/octet-stream",
+    "Cache-Control": asset && pathname.startsWith("/assets/") ? "public, max-age=31536000, immutable" : "no-cache"
+  };
+  return new Response(body, { headers });
+}
+app.use(
+  "/api/*",
+  cors({
+    origin: config.corsOrigin,
+    allowMethods: ["GET", "POST", "PUT", "DELETE"]
+  })
+);
+app.get("/api/health", (c) => c.json({ ok: true }));
+app.route("/api/workspaces", workspacesRoute);
+app.route("/api/fs", fsRoute);
+app.route("/api/model-configs", modelConfigsRoute);
+if (existsSync(webIndexPath)) {
+  app.get("*", serveWeb);
+} else {
+  app.get(
+    "/",
+    (c) => c.text(
+      "pi-pilot server is running, but the web UI assets were not found. Run `pnpm build` from the repository root, or set PI_PILOT_WEB_ROOT to a built web dist directory.",
+      500
+    )
+  );
+}
+var server = serve(
+  {
+    fetch: app.fetch,
+    hostname: config.host,
+    port: config.port
+  },
+  (info) => {
+    console.log(`[pi-pilot] http://${info.address}:${info.port}`);
+  }
+);
+attachWsHub(server);
+async function shutdown(reason) {
+  console.log(`[pi-pilot] shutting down (${reason})`);
+  try {
+    await workspaceManager.disposeAll();
+  } catch (e) {
+    console.error("[pi-pilot] disposeAll error:", e);
+  }
+  server.close(() => process.exit(0));
+  setTimeout(() => process.exit(1), 3e3).unref();
+}
+process.on("SIGINT", () => void shutdown("SIGINT"));
+process.on("SIGTERM", () => void shutdown("SIGTERM"));
+//# sourceMappingURL=index.js.map