@supanadit/morse-web 0.2.0

package/dist/server.mjs

@@ -0,0 +1,3910 @@
+// Generated by packages/morse-web/build.mjs — do not edit.
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// ../server/src/main.ts
+import "reflect-metadata";
+import { Logger as Logger2 } from "@nestjs/common";
+import { NestFactory } from "@nestjs/core";
+import { WsAdapter } from "@nestjs/platform-ws";
+
+// ../protocol/dist/wire.js
+var CLIENT_MESSAGE_TYPES = [
+  "client/ready",
+  "chat/prompt",
+  "chat/edit",
+  "chat/fork",
+  "chat/abort",
+  "session/new",
+  "session/load",
+  "session/activate",
+  "session/close",
+  "session/delete",
+  "session/compact",
+  "history/load",
+  "session/list",
+  "project/list",
+  "project/open",
+  "model/set",
+  "thinking/set",
+  "interaction/respond",
+  "host/command"
+];
+function encodeWireMessage(message) {
+  return JSON.stringify(message);
+}
+function isClientToHostMessage(value) {
+  return hasKnownType(value, CLIENT_MESSAGE_TYPES);
+}
+function parseClientMessage(raw) {
+  const value = decode(raw);
+  return isClientToHostMessage(value) ? value : void 0;
+}
+function decode(raw) {
+  if (typeof raw === "string") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  if (raw instanceof Uint8Array) {
+    return decode(new TextDecoder().decode(raw));
+  }
+  if (raw instanceof ArrayBuffer) {
+    return decode(new TextDecoder().decode(new Uint8Array(raw)));
+  }
+  return raw;
+}
+function hasKnownType(value, allowed) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const type = value.type;
+  return typeof type === "string" && allowed.includes(type);
+}
+
+// ../protocol/dist/version.js
+var PROTOCOL_VERSION = 15;
+var DEFAULT_WS_PATH = "/ws";
+
+// ../protocol/dist/frontend-manifest.js
+function isFrontendManifest(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.name === "string" && typeof candidate.version === "string" && typeof candidate.protocolVersion === "number" && typeof candidate.entry === "string";
+}
+function parseFrontendManifest(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return isFrontendManifest(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// ../server/src/app.module.ts
+import { Module } from "@nestjs/common";
+
+// ../core/dist/domain.js
+var THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+
+// ../core/dist/errors.js
+var MorseError = class extends Error {
+  code;
+  constructor(message, code, options) {
+    super(message, options);
+    this.code = code;
+    this.name = new.target.name;
+  }
+};
+var AgentUnavailableError = class extends MorseError {
+  constructor(message, options) {
+    super(message, "agent-unavailable", options);
+  }
+};
+var AgentProtocolError = class extends MorseError {
+  constructor(message, options) {
+    super(message, "agent-protocol", options);
+  }
+};
+var UnsupportedByHostError = class extends MorseError {
+  constructor(message) {
+    super(message, "unsupported-by-host");
+  }
+};
+
+// ../core/dist/session/service.js
+var DEFAULT_HOT_LIMIT = 4;
+var SessionRegistry = class {
+  deps;
+  hot = /* @__PURE__ */ new Map();
+  /** Least recently used first. */
+  recency = [];
+  listeners = /* @__PURE__ */ new Set();
+  hotLimit;
+  activeKey;
+  syntheticKeys = 0;
+  /** Cached snapshot of a never-recording spawn (see `draftDefaults`). */
+  draftCache;
+  draftProbe;
+  constructor(deps) {
+    this.deps = deps;
+    this.hotLimit = Math.max(1, deps.hotLimit ?? DEFAULT_HOT_LIMIT);
+  }
+  get defaultWorkspace() {
+    return this.deps.defaultWorkspace;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  activeKeyOf() {
+    return this.activeKey;
+  }
+  active() {
+    return this.activeKey === void 0 ? void 0 : this.hot.get(this.activeKey)?.gateway;
+  }
+  requireActive() {
+    const gateway = this.active();
+    if (!gateway) {
+      throw new AgentUnavailableError("No active Morse session. Open a session first.");
+    }
+    return gateway;
+  }
+  stateOf(key) {
+    return this.hot.get(key)?.state;
+  }
+  hotKeys() {
+    return [...this.recency];
+  }
+  /**
+   * What the backend offers before any session exists: the model catalog,
+   * thinking levels and commands of an untouched spawn. Probed once per
+   * registry — never per client — from a gateway that never records itself
+   * (pi `--no-session`), so the empty state can ship a real model picker
+   * without creating a session.
+   */
+  async draftDefaults() {
+    if (this.draftCache) {
+      return this.draftCache;
+    }
+    this.draftProbe ??= this.probeDraft();
+    return this.draftProbe;
+  }
+  /** Opens a new (or resumes an existing) session and makes it active. */
+  async open(options = {}) {
+    const workspace = options.workspace ?? this.deps.defaultWorkspace;
+    const gateway = await this.deps.factory.create({
+      workspace,
+      sessionId: options.sessionId
+    });
+    const state = await gateway.state();
+    const key = state.sessionId ?? this.nextSyntheticKey(workspace);
+    const alreadyHot = this.hot.get(key);
+    if (alreadyHot) {
+      await gateway.dispose().catch((error) => {
+        this.deps.logger.warn("Failed to dispose a duplicate agent gateway", error);
+      });
+      this.touch(key);
+      this.activeKey = key;
+      return { key, state: alreadyHot.state, reused: true };
+    }
+    this.hot.set(key, {
+      key,
+      gateway,
+      workspace,
+      detach: gateway.subscribe((event) => {
+        this.emit({ sessionKey: key, event: this.absorb(key, event) });
+      }),
+      state
+    });
+    this.touch(key);
+    this.activeKey = key;
+    await this.evictBeyondLimit();
+    return { key, state, reused: false };
+  }
+  /** Switches to a hot session, or opens it when it is not running anymore. */
+  async activate(key, workspace) {
+    const existing = this.hot.get(key);
+    if (existing) {
+      this.touch(key);
+      this.activeKey = key;
+      return { key, state: existing.state, reused: true };
+    }
+    return this.open({ workspace, sessionId: key });
+  }
+  /**
+   * Forks the active session before a past user message. pi's fork writes a
+   * *new* session file while reusing the same subprocess, so the hot entry is
+   * re-keyed to the new session id instead of respawning the agent. The
+   * controller truncates its transcript to match, then sends the edited prompt.
+   */
+  async forkActive(entryId) {
+    const previousKey = this.activeKey;
+    const hot = previousKey === void 0 ? void 0 : this.hot.get(previousKey);
+    if (previousKey === void 0 || !hot) {
+      throw new AgentUnavailableError("No active Morse session. Open a session first.");
+    }
+    const result = await hot.gateway.fork(entryId);
+    const state = await hot.gateway.state();
+    if (result.cancelled) {
+      return { key: previousKey, previousKey, state, text: result.text, cancelled: true };
+    }
+    const key = state.sessionId ?? this.nextSyntheticKey(hot.workspace);
+    if (key === previousKey) {
+      return { key, previousKey, state, text: result.text, cancelled: false };
+    }
+    hot.detach();
+    this.hot.delete(previousKey);
+    this.hot.set(key, {
+      key,
+      gateway: hot.gateway,
+      workspace: hot.workspace,
+      state,
+      detach: hot.gateway.subscribe((event) => {
+        this.emit({ sessionKey: key, event: this.absorb(key, event) });
+      })
+    });
+    const index = this.recency.indexOf(previousKey);
+    if (index >= 0) {
+      this.recency[index] = key;
+    } else {
+      this.recency.push(key);
+    }
+    this.activeKey = key;
+    return { key, previousKey, state, text: result.text, cancelled: false };
+  }
+  async close(key) {
+    const session = this.hot.get(key);
+    this.forget(key);
+    if (!session) {
+      return;
+    }
+    session.detach();
+    await session.gateway.dispose().catch((error) => {
+      this.deps.logger.warn("Failed to dispose an agent gateway", error);
+    });
+  }
+  /**
+   * Deletes a session for good: its hot process first (it may hold the file
+   * open), then the stored conversation through the catalog. Storage rules stay
+   * in the adapter; this use case owns only the order and the refusal when the
+   * host cannot delete at all.
+   */
+  async remove(key) {
+    await this.close(key);
+    const remove = this.deps.catalog.remove;
+    if (!remove) {
+      throw new UnsupportedByHostError("This host cannot delete sessions.");
+    }
+    await remove.call(this.deps.catalog, key);
+  }
+  listSessions() {
+    return this.deps.catalog.list();
+  }
+  /** Projects are the directories pi has session buckets for. */
+  async listProjects(sessions) {
+    const all = sessions ?? await this.listSessions();
+    const projects = /* @__PURE__ */ new Map();
+    for (const session of all) {
+      if (session.cwd.length === 0) {
+        continue;
+      }
+      const existing = projects.get(session.cwd);
+      if (existing) {
+        existing.sessionCount += 1;
+        existing.lastUsedAt = Math.max(existing.lastUsedAt, session.updatedAt);
+        continue;
+      }
+      projects.set(session.cwd, {
+        path: session.cwd,
+        name: baseName(session.cwd),
+        sessionCount: 1,
+        lastUsedAt: session.updatedAt
+      });
+    }
+    const defaultPath = this.deps.defaultWorkspace.cwd;
+    if (!projects.has(defaultPath)) {
+      projects.set(defaultPath, {
+        path: defaultPath,
+        name: this.deps.defaultWorkspace.name,
+        sessionCount: 0,
+        lastUsedAt: 0
+      });
+    }
+    return [...projects.values()].sort((left, right) => right.lastUsedAt - left.lastUsedAt);
+  }
+  async dispose() {
+    const sessions = [...this.hot.values()];
+    this.hot.clear();
+    this.recency.length = 0;
+    this.listeners.clear();
+    this.activeKey = void 0;
+    this.draftCache = void 0;
+    this.draftProbe = void 0;
+    await Promise.all(sessions.map((session) => {
+      session.detach();
+      return session.gateway.dispose().catch((error) => {
+        this.deps.logger.warn("Failed to dispose an agent gateway", error);
+      });
+    }));
+  }
+  absorb(key, event) {
+    const session = this.hot.get(key);
+    if (session && (event.type === "agent/ready" || event.type === "agent/state")) {
+      session.state = event.state;
+    }
+    return event;
+  }
+  emit(event) {
+    for (const listener of [...this.listeners]) {
+      try {
+        listener(event);
+      } catch (error) {
+        this.deps.logger.error("Agent event listener failed", error);
+      }
+    }
+  }
+  touch(key) {
+    const index = this.recency.indexOf(key);
+    if (index >= 0) {
+      this.recency.splice(index, 1);
+    }
+    this.recency.push(key);
+  }
+  forget(key) {
+    const index = this.recency.indexOf(key);
+    if (index >= 0) {
+      this.recency.splice(index, 1);
+    }
+    this.hot.delete(key);
+    if (this.activeKey === key) {
+      this.activeKey = void 0;
+    }
+  }
+  /**
+   * Keeps at most `hotLimit` processes alive, retiring the coldest one that is
+   * not working. A running session is never killed: when every candidate is
+   * mid-run the registry goes over the limit instead, because dropping a
+   * parallel conversation is worse than a few extra processes.
+   */
+  async evictBeyondLimit() {
+    while (this.recency.length > this.hotLimit) {
+      const coldest = this.recency.find((key) => key !== this.activeKey && !this.isWorking(key));
+      if (coldest === void 0) {
+        return;
+      }
+      this.deps.logger.info(`Retiring idle session ${coldest} (hot limit ${this.hotLimit})`);
+      await this.close(coldest);
+    }
+  }
+  /** A session the agent is answering in is off limits for the LRU. */
+  isWorking(key) {
+    return this.hot.get(key)?.state.streaming === true;
+  }
+  nextSyntheticKey(workspace) {
+    this.syntheticKeys += 1;
+    return `${workspace.cwd}#ephemeral-${this.syntheticKeys}`;
+  }
+  /** Asks the factory for a never-recording gateway and snapshots its state. */
+  async probeDraft() {
+    const factory = this.deps.factory.probeDefaults;
+    if (!factory) {
+      return void 0;
+    }
+    try {
+      const gateway = await factory.call(this.deps.factory, { workspace: this.deps.defaultWorkspace });
+      const state = await gateway.state();
+      await gateway.dispose();
+      return state;
+    } catch (error) {
+      this.deps.logger.warn("Could not probe the draft model catalog", error);
+      return void 0;
+    }
+  }
+};
+function baseName(path) {
+  const parts = path.split(/[\\/]/).filter((part) => part.length > 0);
+  return parts.at(-1) ?? path;
+}
+
+// ../core/dist/chat/service.js
+var ChatService = class {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async prompt(text, mode = "new", images, pins) {
+    const trimmed = text.trim();
+    const hasAttachments = images !== void 0 && images.length > 0 || pins !== void 0 && pins.length > 0;
+    if (trimmed.length === 0 && !hasAttachments) {
+      this.notice("warn", "Nothing to send \u2014 the prompt is empty.");
+      return { accepted: false, reason: "empty-prompt" };
+    }
+    let agent;
+    try {
+      agent = this.deps.agent.requireActive();
+    } catch (error) {
+      this.deps.logger.error("Prompt rejected: no active agent session", error);
+      return { accepted: false, reason: "no-session" };
+    }
+    let effectiveMode = mode;
+    const state = await agent.state();
+    if (state.streaming && effectiveMode === "new") {
+      effectiveMode = "followUp";
+      this.notice("info", "The agent is still working \u2014 queued as a follow-up.");
+    }
+    const disposition = await agent.prompt(trimmed, effectiveMode, images, pins);
+    return { accepted: true, disposition };
+  }
+  async abort() {
+    await this.deps.agent.requireActive().abort();
+  }
+  async setModel(model) {
+    await this.deps.agent.requireActive().setModel(model);
+  }
+  async setThinkingLevel(level) {
+    await this.deps.agent.requireActive().setThinkingLevel(level);
+  }
+  /** Shrinks the conversation context (`/compact` in the TUI). */
+  async compact(customInstructions) {
+    await this.deps.agent.requireActive().compact(customInstructions);
+  }
+  async state() {
+    return this.deps.agent.requireActive().state();
+  }
+  notice(level, text) {
+    this.deps.onNotice?.(level, text);
+  }
+};
+
+// ../adapter-pi-rpc/dist/internal/rpc-types.js
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : void 0;
+}
+
+// ../adapter-pi-rpc/dist/event-mapping.js
+function mapSessionEvent(record, now) {
+  switch (record.type) {
+    case "agent_start":
+      return { events: [{ type: "agent/run-start", at: now() }], state: { streaming: true } };
+    case "message_update":
+      return mapMessageUpdate(record, now);
+    case "message_end":
+      return mapMessageEnd(record, now);
+    case "tool_execution_start":
+      return mapToolStart(record, now);
+    case "tool_execution_update":
+      return mapToolUpdate(record, now);
+    case "tool_execution_end":
+      return mapToolEnd(record, now);
+    case "compaction_start":
+      return { events: [notice("info", "Compacting the conversation context\u2026", now)] };
+    case "compaction_end":
+      return mapCompactionEnd(record, now);
+    case "auto_retry_start": {
+      const attempt = numberField(record, "attempt");
+      const max = numberField(record, "maxAttempts");
+      const reason = stringField(record, "errorMessage");
+      const label = attempt && max ? ` (attempt ${attempt}/${max})` : "";
+      return { events: [notice("warn", `Retrying${label}: ${reason ?? "provider error"}`, now)] };
+    }
+    case "auto_retry_end":
+      return record["success"] === true ? { events: [] } : {
+        events: [
+          notice("error", stringField(record, "finalError") ?? "Retries exhausted.", now)
+        ]
+      };
+    case "extension_error":
+      return {
+        events: [
+          notice("error", `pi extension failed: ${stringField(record, "error") ?? "unknown error"}`, now)
+        ]
+      };
+    default:
+      return { events: [] };
+  }
+}
+function toEntryHistory(entries) {
+  const history = [];
+  const toolEntries = /* @__PURE__ */ new Map();
+  for (const raw of entries) {
+    const entry = asRecord(raw);
+    if (!entry) {
+      continue;
+    }
+    switch (asString(entry["type"])) {
+      case "message": {
+        const message = asRecord(entry["message"]);
+        if (message) {
+          collectMessage(message, history, toolEntries);
+        }
+        break;
+      }
+      case "compaction": {
+        const at = entryTimestamp(entry["timestamp"]);
+        history.push({
+          role: "compaction",
+          summary: asString(entry["summary"]) ?? "",
+          tokensBefore: asNumber(entry["tokensBefore"]),
+          ...at !== void 0 ? { at } : {}
+        });
+        break;
+      }
+      case "branch_summary": {
+        const summary = asString(entry["summary"]);
+        if (!summary) {
+          break;
+        }
+        const at = entryTimestamp(entry["timestamp"]);
+        history.push({
+          role: "user",
+          text: `*The conversation briefly explored another branch and returned with this summary:*
+
+${summary}`,
+          ...at !== void 0 ? { at } : {}
+        });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return history;
+}
+function activePathEntries(data) {
+  const records = (data?.entries ?? []).map(asRecord).filter(isDefined);
+  const leafId = asString(data?.leafId);
+  if (!leafId) {
+    return records;
+  }
+  const byId = new Map(records.map((record) => [asString(record["id"]), record]).filter((pair) => pair[0] !== void 0));
+  if (!byId.has(leafId)) {
+    return records;
+  }
+  const keep = /* @__PURE__ */ new Set([leafId]);
+  let cursor = leafId;
+  while (cursor !== null) {
+    const parent = byId.get(cursor);
+    const parentId = parent ? asString(parent["parentId"]) ?? null : null;
+    if (parentId === null || keep.has(parentId)) {
+      break;
+    }
+    keep.add(parentId);
+    cursor = parentId;
+  }
+  return records.filter((record) => keep.has(asString(record["id"]) ?? ""));
+}
+function collectMessage(message, entries, toolEntries) {
+  const role = asString(message["role"]);
+  if (role === "toolResult") {
+    const toolCallId = asString(message["toolCallId"]);
+    const entry = toolCallId ? toolEntries.get(toolCallId) : void 0;
+    if (entry) {
+      const output = contentToText(message["content"]);
+      if (output.length > 0) {
+        entry.output = output;
+      }
+      entry.status = message["isError"] === true ? "error" : "ok";
+    }
+    return;
+  }
+  if (role !== "user" && role !== "assistant") {
+    return;
+  }
+  let text = contentToText(message["content"]);
+  const thinking = contentToThinking(message["content"]);
+  let pins;
+  const images = role === "user" ? contentToImages(message["content"]) : [];
+  if (role === "user") {
+    const split = splitTrailingMentions(text);
+    text = split.text;
+    pins = split.pins.length > 0 ? split.pins : void 0;
+  }
+  if (text.length > 0 || thinking.length > 0 || pins !== void 0 && pins.length > 0 || images.length > 0) {
+    entries.push({
+      role,
+      text,
+      thinking: thinking.length > 0 ? thinking : void 0,
+      ...images.length > 0 ? { images } : {},
+      ...pins !== void 0 ? { pins } : {},
+      model: asString(message["model"]),
+      at: asNumber(message["timestamp"])
+    });
+  }
+  if (role === "assistant") {
+    for (const call of toolCallsOf(message["content"])) {
+      const entry = {
+        role: "tool",
+        toolCallId: call.id,
+        name: call.name,
+        title: describeToolCall(call.name, call.arguments),
+        input: safeStringify(call.arguments),
+        status: "ok",
+        at: asNumber(message["timestamp"])
+      };
+      toolEntries.set(call.id, entry);
+      entries.push(entry);
+    }
+  }
+}
+function toolCallsOf(content) {
+  const blocks = asArray(content);
+  if (!blocks) {
+    return [];
+  }
+  const calls = [];
+  for (const block of blocks) {
+    const record = asRecord(block);
+    if (!record || asString(record["type"]) !== "toolCall") {
+      continue;
+    }
+    const name = asString(record["name"]);
+    if (!name) {
+      continue;
+    }
+    calls.push({
+      id: asString(record["id"]) ?? `call-${calls.length}`,
+      name,
+      arguments: asRecord(record["arguments"])
+    });
+  }
+  return calls;
+}
+function mapMessageUpdate(record, now) {
+  const assistant = asRecord(record["assistantMessageEvent"]);
+  if (!assistant) {
+    return { events: [] };
+  }
+  if (assistant.type === "text_delta" && assistant.delta) {
+    return {
+      events: [{ type: "agent/delta", at: now(), channel: "text", delta: assistant.delta }]
+    };
+  }
+  if (assistant.type === "thinking_delta" && assistant.delta) {
+    return {
+      events: [{ type: "agent/delta", at: now(), channel: "thinking", delta: assistant.delta }]
+    };
+  }
+  return { events: [] };
+}
+function mapMessageEnd(record, now) {
+  const message = asRecord(record["message"]);
+  if (!message || message.role !== "assistant") {
+    return { events: [] };
+  }
+  const events = [];
+  const state = {};
+  const usage = toUsage(message.usage);
+  if (usage) {
+    state.lastUsage = usage;
+  }
+  const text = contentToText(message.content);
+  const thinking = contentToThinking(message.content);
+  if (text.length > 0 || thinking.length > 0) {
+    events.push({ type: "agent/message", at: now(), text, thinking });
+  }
+  if (message.stopReason === "aborted") {
+    state.streaming = false;
+    events.push({ type: "agent/run-end", at: now(), reason: "aborted" });
+  } else if (message.stopReason === "error") {
+    events.push(notice("error", "The model request failed.", now));
+  }
+  return { events, state };
+}
+function mapToolStart(record, now) {
+  const toolCallId = stringField(record, "toolCallId") ?? `tool-${now()}`;
+  const toolName = stringField(record, "toolName") ?? "tool";
+  const args = asRecord(record["args"]);
+  return {
+    events: [
+      {
+        type: "agent/tool-start",
+        at: now(),
+        toolCallId,
+        name: toolName,
+        title: describeToolCall(toolName, args),
+        input: safeStringify(record["args"])
+      }
+    ]
+  };
+}
+function mapToolUpdate(record, now) {
+  const toolCallId = stringField(record, "toolCallId");
+  if (!toolCallId) {
+    return { events: [] };
+  }
+  return {
+    events: [
+      {
+        type: "agent/tool-update",
+        at: now(),
+        toolCallId,
+        output: resultToText(record["partialResult"]),
+        status: "running"
+      }
+    ]
+  };
+}
+function mapToolEnd(record, now) {
+  const toolCallId = stringField(record, "toolCallId");
+  if (!toolCallId) {
+    return { events: [] };
+  }
+  return {
+    events: [
+      {
+        type: "agent/tool-end",
+        at: now(),
+        toolCallId,
+        status: record["isError"] === true ? "error" : "ok",
+        output: resultToText(record["result"])
+      }
+    ]
+  };
+}
+function mapCompactionEnd(record, now) {
+  if (record["aborted"] === true) {
+    return { events: [notice("warn", "Compaction was aborted.", now)] };
+  }
+  const error = stringField(record, "errorMessage");
+  if (error) {
+    return { events: [notice("error", `Compaction failed: ${error}`, now)] };
+  }
+  const result = asRecord(record["result"]);
+  return {
+    events: [
+      {
+        type: "agent/compaction",
+        at: now(),
+        summary: asString(result?.["summary"]) ?? "",
+        tokensBefore: asNumber(result?.["tokensBefore"])
+      }
+    ]
+  };
+}
+function notice(level, text, now) {
+  return { type: "agent/notice", at: now(), level, text };
+}
+function stringField(record, key) {
+  return asString(record[key]);
+}
+function numberField(record, key) {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function toUsage(usage) {
+  if (!usage) {
+    return void 0;
+  }
+  const input = usage.input ?? 0;
+  const output = usage.output ?? 0;
+  const cacheRead = usage.cacheRead ?? 0;
+  const cacheWrite = usage.cacheWrite ?? 0;
+  const reasoning = usage.reasoning ?? 0;
+  return {
+    inputTokens: input,
+    outputTokens: output,
+    totalTokens: usage.totalTokens ?? usage.total ?? input + output,
+    ...cacheRead > 0 ? { cacheReadTokens: cacheRead } : {},
+    ...cacheWrite > 0 ? { cacheWriteTokens: cacheWrite } : {},
+    ...reasoning > 0 ? { reasoningTokens: reasoning } : {}
+  };
+}
+function toSessionStats(stats) {
+  if (!stats) {
+    return {};
+  }
+  const patch = {};
+  const usage = toUsage(stats.tokens);
+  if (usage) {
+    patch.usage = usage;
+  }
+  if (typeof stats.cost === "number" && Number.isFinite(stats.cost)) {
+    patch.costUsd = stats.cost;
+  }
+  const context = stats.contextUsage;
+  if (context && typeof context.contextWindow === "number") {
+    patch.contextUsage = {
+      tokens: typeof context.tokens === "number" ? context.tokens : null,
+      contextWindow: context.contextWindow,
+      percent: typeof context.percent === "number" ? context.percent : null
+    };
+  }
+  if (typeof stats.totalMessages === "number") {
+    patch.counts = {
+      userMessages: stats.userMessages ?? 0,
+      assistantMessages: stats.assistantMessages ?? 0,
+      toolCalls: stats.toolCalls ?? 0,
+      toolResults: stats.toolResults ?? 0,
+      totalMessages: stats.totalMessages
+    };
+  }
+  return patch;
+}
+function contentToText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  const blocks = asArray(content);
+  if (!blocks) {
+    return "";
+  }
+  const parts = [];
+  for (const block of blocks) {
+    const record = asRecord(block);
+    if (!record || record["type"] !== "text") {
+      continue;
+    }
+    parts.push(asString(record["text"]) ?? "");
+  }
+  return parts.join("");
+}
+function contentToThinking(content) {
+  const blocks = asArray(content);
+  if (!blocks) {
+    return "";
+  }
+  const parts = [];
+  for (const block of blocks) {
+    const record = asRecord(block);
+    if (!record) {
+      continue;
+    }
+    const type = asString(record["type"]);
+    if (type !== "thinking" && type !== "reasoning") {
+      continue;
+    }
+    parts.push(asString(record["thinking"]) ?? asString(record["text"]) ?? "");
+  }
+  return parts.join("");
+}
+function contentToImages(content) {
+  const blocks = asArray(content);
+  if (!blocks) {
+    return [];
+  }
+  const images = [];
+  for (const block of blocks) {
+    const record = asRecord(block);
+    if (!record || asString(record["type"]) !== "image") {
+      continue;
+    }
+    const data = asString(record["data"]);
+    if (!data) {
+      continue;
+    }
+    images.push({ data, mimeType: asString(record["mimeType"]) ?? "image/png" });
+  }
+  return images;
+}
+var PIN_MENTION = /^@([^\s]+?)(?::(\d+)-(\d+))?$/;
+function splitTrailingMentions(text) {
+  const lines = text.split("\n");
+  let cursor = lines.length;
+  const pins = [];
+  while (cursor > 0) {
+    const match = PIN_MENTION.exec(lines[cursor - 1] ?? "");
+    const record = match ? {
+      path: match[1] ?? "",
+      ...match[2] !== void 0 ? { startLine: Number(match[2]) } : {},
+      ...match[3] !== void 0 ? { endLine: Number(match[3]) } : {}
+    } : void 0;
+    if (!record || record.path.length === 0) {
+      break;
+    }
+    pins.unshift(record);
+    cursor -= 1;
+  }
+  if (cursor === lines.length) {
+    return { text, pins: [] };
+  }
+  let prose = lines.slice(0, cursor).join("\n");
+  while (prose.endsWith("\n")) {
+    prose = prose.slice(0, -1);
+  }
+  return { text: prose, pins };
+}
+function resultToText(result) {
+  if (result === void 0 || result === null) {
+    return void 0;
+  }
+  if (typeof result === "string") {
+    return result;
+  }
+  const record = asRecord(result);
+  if (!record) {
+    return safeStringify(result);
+  }
+  const text = contentToText(record["content"]);
+  return text.length > 0 ? text : safeStringify(record);
+}
+function describeToolCall(toolName, args) {
+  if (!args) {
+    return toolName;
+  }
+  const command = asString(args["command"]) ?? asString(args["cmd"]);
+  if (toolName === "bash" && command) {
+    return `bash: ${truncate(command, 100)}`;
+  }
+  const path = asString(args["path"]) ?? asString(args["file_path"]) ?? asString(args["filePath"]) ?? asString(args["file"]) ?? asString(args["target"]);
+  if (path) {
+    return `${toolName}: ${truncate(path, 100)}`;
+  }
+  const pattern = asString(args["pattern"]) ?? asString(args["query"]);
+  if (pattern) {
+    return `${toolName}: ${truncate(pattern, 100)}`;
+  }
+  return toolName;
+}
+function safeStringify(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  try {
+    return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+function truncate(value, max) {
+  const single = value.replace(/\s+/g, " ").trim();
+  return single.length > max ? `${single.slice(0, max)}\u2026` : single;
+}
+function entryTimestamp(value) {
+  const ms = asNumber(value);
+  if (ms !== void 0) {
+    return ms;
+  }
+  const iso = asString(value);
+  if (iso) {
+    const parsed = Date.parse(iso);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function isDefined(value) {
+  return value !== void 0;
+}
+
+// ../adapter-pi-rpc/dist/internal/rpc-client.js
+import { spawn } from "node:child_process";
+
+// ../adapter-pi-rpc/dist/internal/jsonl-framer.js
+import { StringDecoder } from "node:string_decoder";
+var JsonlFramer = class {
+  decoder = new StringDecoder("utf8");
+  buffer = "";
+  push(chunk) {
+    this.buffer += typeof chunk === "string" ? chunk : this.decoder.write(chunk);
+    const records = [];
+    let newline = this.buffer.indexOf("\n");
+    while (newline !== -1) {
+      const line = stripCarriageReturn(this.buffer.slice(0, newline));
+      this.buffer = this.buffer.slice(newline + 1);
+      if (line.trim().length > 0) {
+        records.push(line);
+      }
+      newline = this.buffer.indexOf("\n");
+    }
+    return records;
+  }
+  /** Returns a trailing record that never got its LF, if any. */
+  flush() {
+    const rest = stripCarriageReturn(this.buffer + this.decoder.end());
+    this.buffer = "";
+    return rest.trim().length > 0 ? rest : void 0;
+  }
+};
+function stripCarriageReturn(line) {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+
+// ../adapter-pi-rpc/dist/internal/rpc-client.js
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var SHUTDOWN_GRACE_MS = 2e3;
+var PiRpcClient = class {
+  options;
+  child;
+  framer = new JsonlFramer();
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  failed;
+  constructor(options) {
+    this.options = options;
+  }
+  get running() {
+    return this.child !== void 0;
+  }
+  start() {
+    if (this.child) {
+      return;
+    }
+    this.failed = void 0;
+    const child = spawn(this.options.command, this.options.args, {
+      cwd: this.options.cwd,
+      env: this.options.env ?? process.env,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true
+    });
+    this.child = child;
+    child.stdout.on("data", (chunk) => this.onStdout(chunk));
+    child.stderr.on("data", (chunk) => {
+      this.options.onStderr?.(chunk.toString("utf8"));
+    });
+    child.on("error", (error) => {
+      this.failAll(new AgentUnavailableError(`Failed to start the pi agent (${this.options.command}): ${error.message}`, { cause: error }));
+    });
+    child.on("exit", (code, signal) => {
+      this.child = void 0;
+      this.failAll(new AgentUnavailableError(`The pi agent exited (code=${code === null ? "null" : code}, signal=${signal ?? "null"}).`));
+      this.options.onExit?.({ code, signal });
+    });
+  }
+  async request(command, timeoutMs = this.options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS) {
+    if (!this.child) {
+      throw this.failed ?? new AgentUnavailableError("The pi agent is not running.");
+    }
+    const id = `morse-${this.nextId++}`;
+    return new Promise((resolve4, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new AgentProtocolError(`pi did not answer "${command.type}" within ${timeoutMs} ms.`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        command: command.type,
+        resolve: (data) => resolve4(data),
+        reject,
+        timer
+      });
+      this.write({ id, ...command }, (error) => {
+        this.settle(id, error);
+      });
+    });
+  }
+  /** Answers an `extension_ui_request`; never expects a matching response. */
+  respond(response) {
+    this.write(response);
+  }
+  async dispose() {
+    const child = this.child;
+    if (!child) {
+      return;
+    }
+    let exited = false;
+    await new Promise((resolve4) => {
+      const finish = () => {
+        exited = true;
+        resolve4();
+      };
+      child.once("exit", finish);
+      child.stdin.end();
+      setTimeout(resolve4, SHUTDOWN_GRACE_MS).unref?.();
+    });
+    if (!exited) {
+      child.kill();
+    }
+    this.child = void 0;
+  }
+  onStdout(chunk) {
+    for (const line of this.framer.push(chunk)) {
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        this.options.onStderr?.(`[morse] unreadable pi record: ${line}
+`);
+        continue;
+      }
+      this.handleRecord(parsed);
+    }
+  }
+  handleRecord(parsed) {
+    const record = parsed;
+    if (record !== null && typeof record === "object" && record["type"] === "response") {
+      this.handleResponse(record);
+    }
+    this.options.onRecord(record);
+  }
+  handleResponse(record) {
+    const id = typeof record["id"] === "string" ? record["id"] : void 0;
+    if (!id) {
+      return;
+    }
+    const pending = this.pending.get(id);
+    if (!pending) {
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pending.delete(id);
+    if (record["success"] === true) {
+      pending.resolve(record["data"]);
+      return;
+    }
+    const error = typeof record["error"] === "string" ? record["error"] : "unknown error";
+    pending.reject(new AgentProtocolError(`pi rejected "${pending.command}": ${error}`));
+  }
+  write(payload, onError) {
+    const child = this.child;
+    if (!child) {
+      onError?.(new AgentUnavailableError("The pi agent is not running."));
+      return;
+    }
+    const frame = `${JSON.stringify(payload)}
+`;
+    child.stdin.write(frame, "utf8", (error) => {
+      if (error) {
+        onError?.(error);
+      }
+    });
+  }
+  settle(id, error) {
+    const pending = this.pending.get(id);
+    if (!pending) {
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pending.delete(id);
+    pending.reject(error);
+  }
+  failAll(error) {
+    this.failed = error;
+    for (const [id, pending] of [...this.pending]) {
+      clearTimeout(pending.timer);
+      this.pending.delete(id);
+      pending.reject(error);
+    }
+  }
+};
+
+// ../adapter-pi-rpc/dist/pi-rpc-agent.js
+var COMPACT_REQUEST_TIMEOUT_MS = 6e5;
+var PiRpcAgent = class {
+  options;
+  client;
+  listeners = /* @__PURE__ */ new Set();
+  now;
+  sessionState;
+  ready = false;
+  disposed = false;
+  /** Full mapped history, fetched once and paged locally (see `history`). */
+  historyCache;
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? (() => Date.now());
+    this.sessionState = {
+      workspace: options.workspace,
+      thinkingLevel: "off",
+      availableModels: [],
+      availableThinkingLevels: [],
+      availableCommands: [],
+      streaming: false
+    };
+    this.client = new PiRpcClient({
+      command: options.spawn.command,
+      args: options.spawn.args,
+      cwd: options.workspace.cwd,
+      env: options.env,
+      requestTimeoutMs: options.requestTimeoutMs,
+      onRecord: (record) => {
+        this.onRecord(record);
+      },
+      onStderr: (text) => {
+        const trimmed = text.trim();
+        if (trimmed.length > 0) {
+          this.options.logger.debug(`pi: ${trimmed}`);
+        }
+      },
+      onExit: (info) => {
+        this.ready = false;
+        if (!this.disposed) {
+          this.emit({
+            type: "agent/fatal",
+            at: this.now(),
+            message: `The pi agent stopped (code=${info.code === null ? "null" : info.code}).`
+          });
+        }
+      }
+    });
+  }
+  /** Spawns the subprocess and reads its initial state. Throws when pi is missing. */
+  async initialize() {
+    this.client.start();
+    await this.refreshState();
+    return this.snapshotState();
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async state() {
+    if (!this.ready) {
+      await this.refreshState();
+    }
+    return this.snapshotState();
+  }
+  /**
+   * Resumed sessions keep their messages on disk; `get_messages` is how a client
+   * shows what was said before this connection existed.
+   *
+   * pi's `get_messages` has no cursor, so the full mapping is fetched once and
+   * cached; pages are then sliced locally from the end. The cache is dropped on
+   * the next prompt, so a re-seed never serves stale history.
+   */
+  async history(options = {}) {
+    const entries = await this.historyEntries();
+    const total = entries.length;
+    const limit = options.limit !== void 0 && options.limit > 0 ? options.limit : total;
+    const requested = options.before === void 0 ? total : Number(options.before);
+    const end = Number.isFinite(requested) ? Math.max(0, Math.min(total, Math.trunc(requested))) : total;
+    const start = Math.max(0, end - limit);
+    return {
+      entries: entries.slice(start, end),
+      hasOlder: start > 0,
+      ...start > 0 ? { before: String(start) } : {}
+    };
+  }
+  async historyEntries() {
+    if (this.historyCache !== void 0) {
+      return this.historyCache;
+    }
+    const data = await this.client.request({
+      type: "get_entries"
+    });
+    this.historyCache = toEntryHistory(activePathEntries(data));
+    return this.historyCache;
+  }
+  async prompt(text, mode, images, pins) {
+    const attachment = images && images.length > 0 ? toPiImages(images) : void 0;
+    const imageArgs = attachment ? { images: attachment } : {};
+    const message = appendPinMentions(text, pins);
+    this.historyCache = void 0;
+    const command = mode === "steer" ? { type: "steer", message, ...imageArgs } : mode === "followUp" ? { type: "follow_up", message, ...imageArgs } : { type: "prompt", message, ...imageArgs };
+    const data = await this.client.request(command);
+    const disposition = data?.disposition;
+    if (disposition === "queued" || disposition === "handled") {
+      return disposition;
+    }
+    return "started";
+  }
+  async abort() {
+    await this.client.request({ type: "abort" });
+  }
+  /** Past user messages pi can fork from (its `get_fork_messages`). */
+  async forkMessages() {
+    const data = await this.client.request({
+      type: "get_fork_messages"
+    });
+    const messages = Array.isArray(data?.messages) ? data.messages : [];
+    const result = [];
+    for (const raw of messages) {
+      const record = asRecord(raw);
+      const entryId = record ? asString(record["entryId"]) : void 0;
+      if (!record || !entryId) {
+        continue;
+      }
+      result.push({ entryId, text: asString(record["text"]) ?? "" });
+    }
+    return result;
+  }
+  /**
+   * Forks the conversation before a user entry. pi writes a new session file and
+   * rebinds in place, so the process stays alive but `sessionFile` changes —
+   * the cached state is refreshed before returning.
+   */
+  async fork(entryId) {
+    const data = await this.client.request({
+      type: "fork",
+      entryId
+    });
+    this.historyCache = void 0;
+    if (data?.cancelled === true) {
+      return { text: data.text ?? "", cancelled: true };
+    }
+    await this.refreshState();
+    return { text: data?.text ?? "", cancelled: false };
+  }
+  async setModel(model) {
+    const data = await this.client.request({
+      type: "set_model",
+      provider: model.provider,
+      modelId: model.id
+    });
+    this.patchState({ model: data ? toModelRef(data) : model });
+  }
+  async setThinkingLevel(level) {
+    await this.client.request({ type: "set_thinking_level", level });
+    this.patchState({ thinkingLevel: level });
+  }
+  async compact(customInstructions) {
+    await this.client.request(customInstructions === void 0 ? { type: "compact" } : { type: "compact", customInstructions }, COMPACT_REQUEST_TIMEOUT_MS);
+    await this.refreshStats();
+  }
+  respondToInteraction(response) {
+    this.client.respond({
+      type: "extension_ui_response",
+      id: response.requestId,
+      value: response.value,
+      confirmed: response.confirmed,
+      cancelled: response.cancelled
+    });
+    return Promise.resolve();
+  }
+  async dispose() {
+    this.disposed = true;
+    this.listeners.clear();
+    await this.client.dispose();
+  }
+  async refreshState() {
+    const state = await this.client.request({ type: "get_state" });
+    const models = await this.client.request({ type: "get_available_models" }).catch(() => void 0);
+    const levels = await this.client.request({ type: "get_available_thinking_levels" }).catch(() => void 0);
+    const commands = await this.client.request({ type: "get_commands" }).catch(() => void 0);
+    const availableModels = (models?.models ?? []).map(toModelRef);
+    const availableThinkingLevels = dedupeThinkingLevels((levels?.levels ?? []).map(toThinkingLevel).filter(isDefined2));
+    const thinkingLevel = toThinkingLevel(state.thinkingLevel);
+    this.sessionState = {
+      ...this.sessionState,
+      sessionId: state.sessionFile ?? state.sessionId,
+      sessionTitle: state.sessionName,
+      model: state.model ? toModelRef(state.model) : this.sessionState.model,
+      thinkingLevel: thinkingLevel ?? this.sessionState.thinkingLevel,
+      availableModels,
+      availableThinkingLevels: availableThinkingLevels.length > 0 ? availableThinkingLevels : [...THINKING_LEVELS],
+      availableCommands: toCommands(commands?.commands),
+      streaming: state.isStreaming === true
+    };
+    this.ready = true;
+    await this.refreshStats();
+    this.emit({ type: "agent/ready", at: this.now(), state: this.snapshotState() });
+  }
+  /**
+   * Pulls the cumulative token/cost/context totals pi keeps for the session, so
+   * the footer can show the same numbers the TUI does. Best-effort: an older pi
+   * without `get_session_stats` simply leaves the previous values in place.
+   */
+  async refreshStats() {
+    const stats = await this.client.request({ type: "get_session_stats" }).catch(() => void 0);
+    const patch = toSessionStats(stats);
+    if (Object.keys(patch).length === 0) {
+      return;
+    }
+    this.sessionState = { ...this.sessionState, ...patch };
+    this.emit({ type: "agent/state", at: this.now(), state: this.snapshotState() });
+  }
+  onRecord(record) {
+    if (record["type"] === "extension_ui_request") {
+      this.onUiRequest(record);
+      return;
+    }
+    switch (record["type"]) {
+      case "agent_settled":
+        this.patchState({ streaming: false });
+        this.emit({ type: "agent/run-end", at: this.now(), reason: "settled" });
+        void this.refreshStats();
+        return;
+      case "thinking_level_changed": {
+        const level = toThinkingLevel(asString(record["level"]));
+        if (level) {
+          this.patchState({ thinkingLevel: level });
+        }
+        return;
+      }
+      case "session_info_changed":
+        this.patchState({ sessionTitle: asString(record["name"]) });
+        return;
+      case "queue_update":
+        return;
+      default:
+        break;
+    }
+    const mapped = mapSessionEvent(record, this.now);
+    if (mapped.state) {
+      this.patchState(mapped.state);
+    }
+    for (const event of mapped.events) {
+      this.emit(event);
+    }
+    if (record["type"] === "compaction_end") {
+      void this.refreshStats();
+    }
+  }
+  onUiRequest(request) {
+    const method = request.method;
+    if (method === "notify") {
+      this.emit({
+        type: "agent/notice",
+        at: this.now(),
+        level: toNoticeLevel(request.notifyType),
+        text: request.message ?? ""
+      });
+      return;
+    }
+    if (method !== "select" && method !== "confirm" && method !== "input" && method !== "editor") {
+      this.options.logger.debug(`pi requested unsupported UI method "${method}"; ignoring.`);
+      return;
+    }
+    this.emit({
+      type: "agent/interaction",
+      at: this.now(),
+      request: toInteractionRequest(method, request)
+    });
+  }
+  patchState(patch) {
+    this.sessionState = { ...this.sessionState, ...patch };
+    this.emit({ type: "agent/state", at: this.now(), state: this.snapshotState() });
+  }
+  snapshotState() {
+    return {
+      ...this.sessionState,
+      workspace: { ...this.sessionState.workspace },
+      availableModels: [...this.sessionState.availableModels],
+      availableThinkingLevels: [...this.sessionState.availableThinkingLevels],
+      availableCommands: [...this.sessionState.availableCommands]
+    };
+  }
+  emit(event) {
+    for (const listener of [...this.listeners]) {
+      try {
+        listener(event);
+      } catch (error) {
+        this.options.logger.error("Agent event listener failed", error);
+      }
+    }
+  }
+};
+function toInteractionRequest(kind, request) {
+  const title = request.title ?? kind;
+  switch (kind) {
+    case "select":
+      return {
+        requestId: request.id,
+        kind: "select",
+        title,
+        options: (request.options ?? []).map((value) => ({ value, label: value }))
+      };
+    case "confirm":
+      return { requestId: request.id, kind: "confirm", title, message: request.message ?? "" };
+    case "input":
+      return {
+        requestId: request.id,
+        kind: "input",
+        title,
+        placeholder: request.placeholder
+      };
+    case "editor":
+      return { requestId: request.id, kind: "editor", title, value: request.prefill };
+  }
+}
+function toModelRef(model) {
+  return {
+    provider: model.provider,
+    id: model.id,
+    name: model.name ?? model.id,
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens
+  };
+}
+function toThinkingLevel(value) {
+  if (!value) {
+    return void 0;
+  }
+  return THINKING_LEVELS.find((level) => level === value);
+}
+function dedupeThinkingLevels(levels) {
+  return [...new Set(levels)];
+}
+function toCommandSource(value) {
+  return value === "prompt" || value === "skill" ? value : "extension";
+}
+function toCommands(items) {
+  return (items ?? []).filter((item) => {
+    return typeof item.name === "string" && item.name.trim().length > 0;
+  }).map((item) => ({
+    name: item.name,
+    description: item.description,
+    source: toCommandSource(item.source)
+  }));
+}
+function toNoticeLevel(value) {
+  if (value === "error") {
+    return "error";
+  }
+  if (value === "warning" || value === "warn") {
+    return "warn";
+  }
+  return "info";
+}
+function isDefined2(value) {
+  return value !== void 0;
+}
+function toPiImages(images) {
+  return images.map((image) => ({ type: "image", data: image.data, mimeType: image.mimeType }));
+}
+function appendPinMentions(text, pins) {
+  if (!pins || pins.length === 0) {
+    return text;
+  }
+  const mentions = pins.map((pin) => {
+    if (pin.startLine === void 0) {
+      return `@${pin.path}`;
+    }
+    const end = pin.endLine ?? pin.startLine;
+    return `@${pin.path}:${pin.startLine}-${end}`;
+  }).join("\n");
+  const prose = text.trim();
+  return prose.length > 0 ? `${prose}
+
+${mentions}` : mentions;
+}
+
+// ../adapter-pi-rpc/dist/internal/resolve-pi.js
+import { accessSync, constants } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, isAbsolute, join } from "node:path";
+function buildRpcArgs(options) {
+  const args = ["--mode", "rpc"];
+  if (options.noSession) {
+    args.push("--no-session");
+  }
+  if (options.sessionDir) {
+    args.push("--session-dir", options.sessionDir);
+  }
+  if (options.sessionPath) {
+    args.push("--session", options.sessionPath);
+  }
+  args.push(...options.extraArgs ?? []);
+  return args;
+}
+function resolvePi(options = {}) {
+  const env = options.env ?? process.env;
+  const args = buildRpcArgs(options);
+  const configured = options.piPath ?? env.MORSE_PI_PATH;
+  if (configured) {
+    return { command: configured, args, source: "configured" };
+  }
+  const entry = options.nodeEntryPath ?? env.MORSE_PI_ENTRY;
+  if (entry && isExecutableEntry(entry)) {
+    return { command: process.execPath, args: [entry, ...args], source: "node-entry" };
+  }
+  const onPath = findOnPath("pi", env);
+  if (onPath) {
+    return { command: onPath, args, source: "path" };
+  }
+  throw new AgentUnavailableError([
+    "The pi coding agent was not found.",
+    "Install it (`npm install -g @earendil-works/pi-coding-agent`) or point Morse at it:",
+    '- VS Code: setting "morse.pi.path"',
+    "- NestJS host: env MORSE_PI_PATH (or MORSE_PI_ENTRY for a bundled rpc-entry.js)"
+  ].join("\n"));
+}
+function findOnPath(binary, env = process.env) {
+  const pathValue = env.PATH ?? env.Path ?? "";
+  if (pathValue.length === 0) {
+    return void 0;
+  }
+  const extensions = process.platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter((value) => value.length > 0) : [""];
+  for (const directory of pathValue.split(delimiter)) {
+    if (directory.length === 0) {
+      continue;
+    }
+    for (const extension of extensions) {
+      const candidate = join(directory, `${binary}${extension}`);
+      if (isExecutableEntry(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return void 0;
+}
+function resolveSessionDir(configured, env = process.env) {
+  const fromEnv = env.PI_CODING_AGENT_SESSION_DIR;
+  const value = configured ?? (fromEnv && fromEnv.length > 0 ? fromEnv : void 0);
+  const base = value ?? join(homedir(), ".pi", "agent", "sessions");
+  return isAbsolute(base) ? base : join(process.cwd(), base);
+}
+function isExecutableEntry(path) {
+  try {
+    accessSync(path, constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../adapter-pi-rpc/dist/pi-rpc-agent-factory.js
+var PiRpcAgentFactory = class {
+  options;
+  logger;
+  constructor(options, logger) {
+    this.options = options;
+    this.logger = logger;
+  }
+  async create(input) {
+    const resolveOptions = {
+      piPath: this.options.piPath,
+      nodeEntryPath: this.options.nodeEntryPath,
+      sessionDir: this.options.sessionDir,
+      noSession: this.options.noSession,
+      // The catalog hands back session file paths as ids, which is what
+      // `pi --session <path>` expects.
+      sessionPath: input.sessionId,
+      extraArgs: this.options.extraArgs,
+      env: this.options.env
+    };
+    return this.spawnAgent(resolveOptions, input.workspace, input.sessionId);
+  }
+  /**
+   * A gateway that never records: pi is forced onto `--no-session` and no
+   * session path is passed, so this spawn cannot touch the session list on
+   * disk. Its only job is to answer state once — model catalog, thinking
+   * levels, commands — for the draft (empty panel) state.
+   */
+  async probeDefaults(input) {
+    const resolveOptions = {
+      piPath: this.options.piPath,
+      nodeEntryPath: this.options.nodeEntryPath,
+      sessionDir: this.options.sessionDir,
+      noSession: true,
+      extraArgs: this.options.extraArgs,
+      env: this.options.env
+    };
+    return this.spawnAgent(resolveOptions, input.workspace);
+  }
+  async spawnAgent(resolveOptions, workspace, sessionPath) {
+    const spawn2 = resolvePi(resolveOptions);
+    this.logger.info(`Starting pi agent (${spawn2.source}): ${spawn2.command} ${spawn2.args.join(" ")}`);
+    const agent = new PiRpcAgent({
+      spawn: spawn2,
+      workspace,
+      logger: this.logger,
+      sessionPath,
+      env: this.options.env,
+      requestTimeoutMs: this.options.requestTimeoutMs
+    });
+    await agent.initialize();
+    return agent;
+  }
+};
+
+// ../adapter-pi-rpc/dist/pi-rpc-session-catalog.js
+import { readdir, readFile, stat, unlink } from "node:fs/promises";
+import { basename, join as join2, resolve, sep } from "node:path";
+var PiRpcSessionCatalog = class {
+  directory;
+  maxSessions;
+  removeFile;
+  constructor(options = {}) {
+    this.directory = resolveSessionDir(options.sessionDir, options.env);
+    this.maxSessions = options.maxSessions ?? 50;
+    this.removeFile = options.removeFile ?? unlink;
+  }
+  get sessionDirectory() {
+    return this.directory;
+  }
+  async list() {
+    const files = await this.collectSessionFiles();
+    const summaries = [];
+    for (const file of files.slice(0, this.maxSessions)) {
+      const summary = await readSessionSummary(file.path, file.updatedAt);
+      if (summary) {
+        summaries.push(summary);
+      }
+    }
+    return summaries;
+  }
+  /**
+   * Deletes one stored session. The id is a session file path, so the guard is
+   * the point: only a `.jsonl` inside this catalog's session directory is ever
+   * removed. A stale client or a hostile payload cannot turn a session id into
+   * a delete of an arbitrary file.
+   */
+  async remove(id) {
+    const path = resolve(id);
+    const directory = resolve(this.directory);
+    if (!path.startsWith(`${directory}${sep}`) || !path.endsWith(".jsonl")) {
+      throw new Error(`Refusing to delete a session outside ${directory}`);
+    }
+    await this.removeFile(path);
+  }
+  async collectSessionFiles() {
+    const buckets = await safeReadDir(this.directory);
+    const files = [];
+    for (const bucket of buckets) {
+      if (!bucket.isDirectory()) {
+        continue;
+      }
+      const bucketPath = join2(this.directory, bucket.name);
+      for (const entry of await safeReadDir(bucketPath)) {
+        if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+          continue;
+        }
+        const path = join2(bucketPath, entry.name);
+        const info = await stat(path).catch(() => void 0);
+        files.push({ path, updatedAt: info?.mtimeMs ?? 0 });
+      }
+    }
+    files.sort((left, right) => right.updatedAt - left.updatedAt);
+    return files;
+  }
+};
+async function readSessionSummary(path, updatedAt) {
+  const raw = await readFile(path, "utf8").catch(() => void 0);
+  if (raw === void 0) {
+    return void 0;
+  }
+  let id = basename(path, ".jsonl");
+  let cwd = "";
+  let name;
+  let firstUserText;
+  let messageCount = 0;
+  for (const line of raw.split("\n")) {
+    if (!line.startsWith("{")) {
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const type = entry["type"];
+    if (type === "session" && cwd.length === 0) {
+      id = asString(entry["id"]) ?? id;
+      cwd = asString(entry["cwd"]) ?? "";
+      continue;
+    }
+    if (type === "message") {
+      messageCount += 1;
+      if (!firstUserText) {
+        const message = asRecord(entry["message"]);
+        if (message?.["role"] === "user") {
+          firstUserText = textOf(message["content"]);
+        }
+      }
+      continue;
+    }
+    if ((type === "session_info" || type === "session_name") && !name) {
+      name = asString(entry["name"]);
+    }
+  }
+  return {
+    id: path,
+    title: name ?? titleFromText(firstUserText) ?? "Untitled session",
+    cwd,
+    updatedAt,
+    messageCount
+  };
+}
+function textOf(content) {
+  const direct = asString(content);
+  if (direct !== void 0) {
+    return direct.length > 0 ? direct : void 0;
+  }
+  const blocks = Array.isArray(content) ? content : void 0;
+  if (!blocks) {
+    return void 0;
+  }
+  for (const block of blocks) {
+    const record = asRecord(block);
+    if (record?.["type"] !== "text") {
+      continue;
+    }
+    const text = asString(record["text"]);
+    if (text !== void 0 && text.trim().length > 0) {
+      return text;
+    }
+  }
+  return void 0;
+}
+function titleFromText(text) {
+  if (!text) {
+    return void 0;
+  }
+  const single = text.replace(/\s+/g, " ").trim();
+  if (single.length === 0) {
+    return void 0;
+  }
+  return single.length > 72 ? `${single.slice(0, 72)}\u2026` : single;
+}
+async function safeReadDir(path) {
+  try {
+    return await readdir(path, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+// ../adapter-pi-rpc/dist/create-pi-rpc-adapter.js
+function createPiRpcAdapter(config, logger) {
+  const factory = new PiRpcAgentFactory(config, logger);
+  const catalog = new PiRpcSessionCatalog({
+    sessionDir: config.sessionDir,
+    maxSessions: config.maxSessions,
+    env: config.env,
+    removeFile: config.removeSessionFile
+  });
+  return {
+    factory,
+    catalog,
+    describe: () => resolvePi({
+      piPath: config.piPath,
+      nodeEntryPath: config.nodeEntryPath,
+      sessionDir: config.sessionDir,
+      noSession: config.noSession,
+      extraArgs: config.extraArgs,
+      env: config.env
+    })
+  };
+}
+
+// ../host-runtime/dist/transcript-projector.js
+var TranscriptProjector = class {
+  options;
+  items = [];
+  toolIndexes = /* @__PURE__ */ new Map();
+  assistantIndex = -1;
+  counter = 0;
+  now;
+  idPrefix;
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? (() => Date.now());
+    this.idPrefix = options.idPrefix ?? "morse";
+  }
+  snapshot() {
+    return this.items.map((item) => ({ ...item }));
+  }
+  reset() {
+    this.items.length = 0;
+    this.toolIndexes.clear();
+    this.assistantIndex = -1;
+    this.options.emit({ type: "transcript/replace", payload: { items: [] } });
+  }
+  userPrompt(text, images, pins) {
+    const item = {
+      kind: "user",
+      id: this.nextId("user"),
+      at: this.now(),
+      text,
+      ...images && images.length > 0 ? { images } : {},
+      ...pins && pins.length > 0 ? { pins } : {}
+    };
+    this.assistantIndex = -1;
+    this.appendItem(item);
+  }
+  /** Appends an item that already happened (a seeded history entry). */
+  append(item) {
+    this.items.push(item);
+    this.options.emit({ type: "transcript/append", payload: { ...item } });
+  }
+  /**
+   * Replaces the whole transcript in one message. Used when a fork re-parents
+   * the session: the branch after the edited message no longer exists, so the
+   * client must drop those rows instead of appending to them.
+   */
+  replace(items) {
+    this.items.length = 0;
+    this.items.push(...items);
+    this.toolIndexes.clear();
+    this.assistantIndex = -1;
+    this.options.emit({ type: "transcript/replace", payload: { items: this.snapshot() } });
+  }
+  /**
+   * Inserts an older history page in front of everything already shown. The
+   * recorded indexes point into `items`, so they shift by the page size.
+   */
+  prepend(items) {
+    if (items.length === 0) {
+      return;
+    }
+    this.items.unshift(...items);
+    if (this.assistantIndex !== -1) {
+      this.assistantIndex += items.length;
+    }
+    for (const [toolCallId, index] of this.toolIndexes) {
+      this.toolIndexes.set(toolCallId, index + items.length);
+    }
+    this.options.emit({ type: "transcript/prepend", payload: { items } });
+  }
+  notice(level, text) {
+    this.appendItem({ kind: "notice", id: this.nextId("notice"), at: this.now(), level, text });
+  }
+  /** The live compaction boundary: a marker row for where the context reset. */
+  appendMarker(event) {
+    const { summary, tokensBefore } = event;
+    this.appendItem({
+      kind: "compaction",
+      id: this.nextId("compaction"),
+      at: this.now(),
+      ...summary.length > 0 ? { summary } : {},
+      ...tokensBefore !== void 0 ? { tokensBefore } : {}
+    });
+  }
+  error(message, detail) {
+    this.appendItem({
+      kind: "notice",
+      id: this.nextId("error"),
+      at: this.now(),
+      level: "error",
+      text: detail ? `${message}
+${detail}` : message
+    });
+  }
+  apply(event) {
+    switch (event.type) {
+      case "agent/run-start":
+        this.assistantIndex = -1;
+        break;
+      case "agent/delta":
+        this.applyDelta(event.channel, event.delta);
+        break;
+      case "agent/message":
+        this.applyMessage(event.text, event.thinking);
+        break;
+      case "agent/tool-start":
+        this.applyToolStart(event.toolCallId, event.name, event.title, event.input);
+        break;
+      case "agent/tool-update":
+        this.applyToolUpdate(event.toolCallId, event.output, event.status);
+        break;
+      case "agent/tool-end":
+        this.applyToolEnd(event.toolCallId, event.status, event.output, event.durationMs);
+        break;
+      case "agent/run-end":
+        this.finishAssistant(event.reason === "error" ? void 0 : event.reason);
+        break;
+      case "agent/notice":
+        this.notice(event.level, event.text);
+        break;
+      case "agent/compaction":
+        this.appendMarker(event);
+        break;
+      case "agent/fatal":
+        this.error(event.message, event.detail);
+        break;
+      default:
+        break;
+    }
+  }
+  applyDelta(channel, delta) {
+    const item = this.ensureAssistant();
+    this.options.emit({
+      type: "transcript/delta",
+      payload: channel === "text" ? { id: item.id, text: delta } : { id: item.id, thinking: delta }
+    });
+    item[channel] += delta;
+    item.streaming = true;
+  }
+  applyMessage(text, thinking) {
+    const item = this.ensureAssistant();
+    item.text = text;
+    item.thinking = thinking;
+    item.streaming = false;
+    this.assistantIndex = -1;
+    this.options.emit({ type: "transcript/update", payload: { ...item } });
+  }
+  finishAssistant(reason) {
+    if (this.assistantIndex === -1) {
+      return;
+    }
+    const item = this.items[this.assistantIndex];
+    if (item && item.kind === "assistant") {
+      item.streaming = false;
+      if (reason === "aborted" && item.text.length === 0) {
+        item.text = "_Run aborted._";
+      }
+      this.options.emit({ type: "transcript/update", payload: { ...item } });
+    }
+    this.assistantIndex = -1;
+  }
+  applyToolStart(toolCallId, name, title, input) {
+    const item = {
+      kind: "tool",
+      id: this.nextId("tool"),
+      at: this.now(),
+      name,
+      title,
+      status: "running",
+      input
+    };
+    this.toolIndexes.set(toolCallId, this.items.length);
+    this.appendItem(item);
+  }
+  applyToolUpdate(toolCallId, output, status) {
+    const item = this.toolItem(toolCallId);
+    if (!item) {
+      return;
+    }
+    if (output !== void 0) {
+      item.output = output;
+    }
+    if (status !== void 0) {
+      item.status = status;
+    }
+    this.updateItem(item);
+  }
+  applyToolEnd(toolCallId, status, output, durationMs) {
+    const item = this.toolItem(toolCallId);
+    if (!item) {
+      return;
+    }
+    item.status = status;
+    if (output !== void 0) {
+      item.output = output;
+    }
+    if (durationMs !== void 0) {
+      item.durationMs = durationMs;
+    }
+    this.updateItem(item);
+    this.toolIndexes.delete(toolCallId);
+  }
+  ensureAssistant() {
+    const existing = this.assistantIndex >= 0 ? this.items[this.assistantIndex] : void 0;
+    if (existing && existing.kind === "assistant") {
+      return existing;
+    }
+    const item = {
+      kind: "assistant",
+      id: this.nextId("assistant"),
+      at: this.now(),
+      text: "",
+      thinking: "",
+      streaming: true
+    };
+    this.assistantIndex = this.items.length;
+    this.appendItem(item);
+    return item;
+  }
+  toolItem(toolCallId) {
+    const index = this.toolIndexes.get(toolCallId);
+    if (index === void 0) {
+      return void 0;
+    }
+    const item = this.items[index];
+    return item && item.kind === "tool" ? item : void 0;
+  }
+  appendItem(item) {
+    this.items.push(item);
+    this.options.emit({ type: "transcript/append", payload: { ...item } });
+  }
+  updateItem(item) {
+    this.options.emit({ type: "transcript/update", payload: { ...item } });
+  }
+  nextId(kind) {
+    this.counter += 1;
+    return `${this.idPrefix}-${kind}-${this.counter}`;
+  }
+};
+
+// ../host-runtime/dist/transcript-store.js
+var SessionTranscriptStore = class {
+  projectors = /* @__PURE__ */ new Map();
+  cursors = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  items(sessionKey) {
+    return this.projectors.get(sessionKey)?.snapshot() ?? [];
+  }
+  /**
+   * Paging state lives with the transcript, not the connection: a refresh
+   * reattaches to the same warm session and must keep offering older pages.
+   */
+  historyCursor(sessionKey) {
+    return this.cursors.get(sessionKey) ?? { hasOlder: false };
+  }
+  setHistoryCursor(sessionKey, cursor) {
+    this.cursors.set(sessionKey, cursor);
+  }
+  apply(sessionKey, event) {
+    this.projectorFor(sessionKey).apply(event);
+  }
+  /** Replays a resumed session's history into an empty transcript. */
+  seed(sessionKey, items) {
+    const projector = this.projectorFor(sessionKey);
+    for (const item of items) {
+      projector.append(item);
+    }
+  }
+  /** Inserts an older history page in front of a session's transcript. */
+  prepend(sessionKey, items) {
+    this.projectorFor(sessionKey).prepend(items);
+  }
+  /**
+   * Moves a transcript to a new session key after the agent forked the session
+   * before a past message. The caller passes the rows that survive the fork;
+   * the branch after the edited message is dropped with a single replace, so no
+   * stale rows linger under the new session.
+   */
+  move(fromKey, toKey, items) {
+    if (fromKey === toKey) {
+      this.projectorFor(toKey).replace(items);
+      return;
+    }
+    this.projectors.delete(fromKey);
+    this.cursors.delete(fromKey);
+    this.cursors.set(toKey, { hasOlder: false });
+    this.projectorFor(toKey).replace(items);
+  }
+  userPrompt(sessionKey, text, images, pins) {
+    this.projectorFor(sessionKey).userPrompt(text, images, pins);
+  }
+  notice(sessionKey, level, text) {
+    this.projectorFor(sessionKey).notice(level, text);
+  }
+  error(sessionKey, message, detail) {
+    this.projectorFor(sessionKey).error(message, detail);
+  }
+  /** Drops a transcript (used when a session is closed or restarted). */
+  reset(sessionKey) {
+    this.cursors.delete(sessionKey);
+    const projector = this.projectors.get(sessionKey);
+    if (!projector) {
+      return;
+    }
+    projector.reset();
+  }
+  clear(sessionKey) {
+    this.cursors.delete(sessionKey);
+    this.projectors.delete(sessionKey);
+  }
+  dispose() {
+    this.projectors.clear();
+    this.cursors.clear();
+    this.listeners.clear();
+  }
+  projectorFor(sessionKey) {
+    let projector = this.projectors.get(sessionKey);
+    if (!projector) {
+      projector = new TranscriptProjector({
+        emit: (message) => {
+          this.emit({
+            sessionKey,
+            message,
+            items: projector?.snapshot() ?? []
+          });
+        }
+      });
+      this.projectors.set(sessionKey, projector);
+    }
+    return projector;
+  }
+  emit(update) {
+    for (const listener of [...this.listeners]) {
+      listener(update);
+    }
+  }
+};
+
+// ../host-runtime/dist/view-state.js
+function emptySessionViewState(workspace, meta) {
+  return {
+    workspace: { cwd: workspace.cwd, name: workspace.name },
+    thinkingLevel: "off",
+    availableModels: [],
+    availableThinkingLevels: [],
+    availableCommands: [],
+    streaming: false,
+    busy: meta.busy,
+    agentReady: meta.agentReady,
+    agentStarting: meta.agentStarting,
+    agentError: meta.agentError,
+    hasOlderHistory: meta.hasOlderHistory,
+    loadingOlderHistory: meta.loadingOlderHistory
+  };
+}
+function draftSessionViewState(workspace, meta, catalog, pendingModel, pendingThinking) {
+  const empty = emptySessionViewState(workspace, meta);
+  if (!catalog) {
+    return empty;
+  }
+  return {
+    ...empty,
+    model: toModelOption(pendingModel ?? catalog.model),
+    thinkingLevel: pendingThinking ?? catalog.thinkingLevel ?? "off",
+    availableModels: catalog.availableModels.map(toModelOption).filter(isModelOption),
+    availableThinkingLevels: catalog.availableThinkingLevels.map(toThinkingLevel2),
+    availableCommands: catalog.availableCommands.map(toCommandOption)
+  };
+}
+function toSessionViewState(state, meta) {
+  return {
+    sessionId: state.sessionId,
+    sessionTitle: state.sessionTitle,
+    workspace: { cwd: state.workspace.cwd, name: state.workspace.name },
+    model: toModelOption(state.model),
+    thinkingLevel: state.thinkingLevel,
+    availableModels: state.availableModels.map(toModelOption).filter(isModelOption),
+    availableThinkingLevels: state.availableThinkingLevels.map(toThinkingLevel2),
+    availableCommands: state.availableCommands.map(toCommandOption),
+    streaming: state.streaming,
+    busy: meta.busy,
+    usage: toUsage2(state.usage),
+    lastUsage: toUsage2(state.lastUsage),
+    costUsd: state.costUsd,
+    contextUsage: state.contextUsage ? { ...state.contextUsage } : void 0,
+    counts: state.counts ? { ...state.counts } : void 0,
+    agentReady: meta.agentReady,
+    agentStarting: meta.agentStarting,
+    agentError: meta.agentError,
+    hasOlderHistory: meta.hasOlderHistory,
+    loadingOlderHistory: meta.loadingOlderHistory
+  };
+}
+function toModelOption(model) {
+  if (!model) {
+    return void 0;
+  }
+  return {
+    provider: model.provider,
+    id: model.id,
+    name: model.name,
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens
+  };
+}
+function isModelOption(value) {
+  return value !== void 0;
+}
+function toCommandOption(command) {
+  return {
+    name: command.name,
+    description: command.description,
+    source: command.source
+  };
+}
+function toThinkingLevel2(level) {
+  return level;
+}
+function toUsage2(usage) {
+  return usage ? { ...usage } : void 0;
+}
+function toInteractionRequest2(request) {
+  switch (request.kind) {
+    case "select":
+      return {
+        requestId: request.requestId,
+        kind: "select",
+        title: request.title,
+        message: request.message,
+        options: request.options.map((option) => ({ ...option }))
+      };
+    case "confirm":
+      return {
+        requestId: request.requestId,
+        kind: "confirm",
+        title: request.title,
+        message: request.message,
+        danger: request.danger
+      };
+    case "input":
+      return {
+        requestId: request.requestId,
+        kind: "input",
+        title: request.title,
+        placeholder: request.placeholder,
+        value: request.value
+      };
+    case "editor":
+      return {
+        requestId: request.requestId,
+        kind: "editor",
+        title: request.title,
+        value: request.value,
+        language: request.language
+      };
+  }
+}
+function noticeMessage(level, text, at) {
+  return { type: "notice", payload: { level, text, at } };
+}
+
+// ../host-runtime/dist/session-controller.js
+var HISTORY_PAGE_SIZE = 50;
+var HostSessionController = class {
+  options;
+  summaries = /* @__PURE__ */ new Map();
+  detachRegistry;
+  detachTranscripts;
+  activeKey;
+  /** True while the panel shows the intentional no-session draft state. */
+  isDraft = false;
+  /** Project a draft opens its first session in (browser "New session here"). */
+  draftWorkspace;
+  /** Catalog of a never-recording probe — fills the draft pickers. */
+  draftCatalog;
+  /** Picks made in the draft, applied to the session the first prompt opens. */
+  draftModel;
+  draftThinking;
+  agentReady = false;
+  agentStarting = false;
+  agentError;
+  busy = false;
+  disposed = false;
+  hasOpenedOnce = false;
+  hostReadyEmitted = false;
+  pendingInteractions = /* @__PURE__ */ new Set();
+  /** Cursor of the oldest history page loaded for the active session. */
+  historyBefore;
+  hasOlderHistory = false;
+  loadingOlderHistory = false;
+  /** Discriminates history item ids across pages (see `historyItems`). */
+  historyPageSeq = 0;
+  constructor(options) {
+    this.options = options;
+  }
+  async start() {
+    this.detachRegistry = this.options.services.registry.subscribe((tagged) => {
+      void this.onTaggedEvent(tagged.sessionKey, tagged.event);
+    });
+    this.detachTranscripts = this.options.transcripts.subscribe((update) => {
+      if (update.sessionKey === this.activeKey) {
+        this.options.emit(update.message);
+      }
+    });
+    if (this.options.autoOpen !== false) {
+      this.agentStarting = true;
+    }
+    this.emitReady();
+    if (this.options.autoOpen !== false) {
+      await this.openDefaultSession();
+    } else {
+      const existingKey = this.options.services.registry.activeKeyOf();
+      if (existingKey === void 0) {
+        this.isDraft = true;
+        void this.warmDraft();
+      } else {
+        await this.runSessionChange(() => this.options.services.registry.activate(existingKey));
+      }
+    }
+    void this.publishLists();
+  }
+  /**
+   * Points this controller at a new client. Hosts that reattach a still-warm
+   * session to a reconnecting client use this so the same agent process keeps
+   * serving without being respawned.
+   */
+  setEmitter(emit) {
+    this.options.emit = emit;
+  }
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.detachRegistry?.();
+    this.detachRegistry = void 0;
+    this.detachTranscripts?.();
+    this.detachTranscripts = void 0;
+    if (this.options.ownsRegistry === true) {
+      await this.options.services.registry.dispose();
+    }
+  }
+  async handleClientMessage(message) {
+    if (this.disposed) {
+      return;
+    }
+    switch (message.type) {
+      case "client/ready":
+        if (message.payload.protocolVersion !== PROTOCOL_VERSION) {
+          this.emitWireError("Frontend and host speak different protocol versions.", `frontend=${message.payload.protocolVersion} host=${PROTOCOL_VERSION}`);
+          return;
+        }
+        if (message.payload.frontend) {
+          this.options.logger.info(`Frontend ${message.payload.frontend.name}@${message.payload.frontend.version} connected`);
+        }
+        if (!this.hostReadyEmitted) {
+          return;
+        }
+        this.emitReady();
+        void this.publishLists();
+        return;
+      case "chat/prompt":
+        await this.prompt(message.payload.text, message.payload.mode, message.payload.images, message.payload.pins);
+        return;
+      case "chat/edit":
+        await this.editPrompt(message.payload.itemId, message.payload.text);
+        return;
+      case "chat/fork":
+        await this.forkPrompt(message.payload.itemId);
+        return;
+      case "chat/abort":
+        await this.guard(() => this.options.services.chat.abort());
+        return;
+      case "session/new":
+        await this.enterDraft(message.payload.cwd ? workspaceOf(message.payload.cwd) : void 0);
+        return;
+      case "session/activate":
+      case "session/load":
+        await this.activateSession(message.payload.sessionId, message.payload.cwd);
+        return;
+      case "session/close":
+        await this.closeSession(message.payload.sessionId);
+        return;
+      case "session/delete":
+        await this.deleteSession(message.payload.sessionId);
+        return;
+      case "session/compact":
+        this.setBusy(true);
+        try {
+          await this.guard(() => this.options.services.chat.compact(message.payload.instructions));
+        } finally {
+          this.setBusy(false);
+        }
+        return;
+      case "history/load":
+        await this.loadOlderHistory();
+        return;
+      case "session/list":
+        await this.publishSessions();
+        return;
+      case "project/list":
+        await this.publishProjects();
+        return;
+      case "project/open":
+        await this.enterDraft(workspaceOf(message.payload.path));
+        return;
+      case "model/set":
+        await this.setModel(message.payload.provider, message.payload.id);
+        return;
+      case "thinking/set":
+        await this.setThinkingLevel(message.payload.level);
+        return;
+      case "interaction/respond":
+        await this.respondToInteraction(message.payload);
+        return;
+      case "host/command":
+        await this.runHostCommand(message.payload.command, message.payload.args, message.payload.requestId);
+        return;
+      default:
+        return;
+    }
+  }
+  async openDefaultSession() {
+    const existingKey = this.options.services.registry.activeKeyOf();
+    if (existingKey) {
+      await this.runSessionChange(() => this.options.services.registry.activate(existingKey));
+      return;
+    }
+    await this.runSessionChange(() => this.options.services.registry.open());
+  }
+  /**
+   * The empty panel is an intentional draft: no agent process, no session
+   * file, no navigator entry — "New session" becomes real only once the first
+   * prompt runs. A pending project and pending picks (model, thinking) wait
+   * here until that first prompt opens the session they belong to.
+   */
+  async enterDraft(workspace) {
+    if (workspace && !this.canOpen(workspace.cwd)) {
+      this.fail(`Morse is not allowed to run an agent in ${workspace.cwd}.`, "Add it to MORSE_PROJECTS first.");
+      return;
+    }
+    this.activeKey = void 0;
+    this.isDraft = true;
+    this.draftWorkspace = workspace;
+    this.resetViewState();
+    this.options.emit({ type: "transcript/replace", payload: { items: [] } });
+    this.emitState();
+    await this.warmDraft();
+  }
+  /** Clears everything the previous session had left on the view state. */
+  resetViewState() {
+    this.historyBefore = void 0;
+    this.hasOlderHistory = false;
+    this.loadingOlderHistory = false;
+    this.agentReady = false;
+    this.agentStarting = false;
+    this.agentError = void 0;
+  }
+  /** Fills the draft pickers from the registry's session-less probe. */
+  async warmDraft() {
+    this.draftCatalog = await this.options.services.registry.draftDefaults();
+    if (this.activeKey === void 0 && !this.disposed) {
+      this.emitState();
+    }
+  }
+  async activateSession(sessionId, cwd) {
+    const known = this.summaries.get(sessionId);
+    const path = cwd ?? known?.cwd;
+    if (path && !this.canOpen(path)) {
+      this.fail(`Morse is not allowed to run an agent in ${path}.`, "Add it to MORSE_PROJECTS first.");
+      return;
+    }
+    this.isDraft = false;
+    this.draftWorkspace = void 0;
+    this.draftModel = void 0;
+    this.draftThinking = void 0;
+    await this.runSessionChange(() => this.options.services.registry.activate(sessionId, path ? workspaceOf(path) : void 0));
+  }
+  async closeSession(sessionId) {
+    await this.guard(() => this.options.services.registry.close(sessionId));
+    this.options.transcripts.clear(sessionId);
+    await this.fallBackAfterSessionGone(sessionId);
+  }
+  /**
+   * Deletes a session for good: the registry disposes its process and the
+   * catalog drops the stored conversation. Which directories an agent may
+   * touch is the host's rule (`ProjectPolicy`), so one use case is safe behind
+   * a server allow-list and inside a VS Code window — the wiring differs, the
+   * decision does not.
+   */
+  async deleteSession(sessionId) {
+    const path = this.summaries.get(sessionId)?.cwd;
+    if (path !== void 0 && path.length > 0 && !this.canOpen(path)) {
+      this.fail(`Morse is not allowed to delete sessions in ${path}.`, "Add it to MORSE_PROJECTS first.");
+      return;
+    }
+    const result = await this.guard(() => this.options.services.registry.remove(sessionId));
+    if (!result.ok) {
+      return;
+    }
+    this.options.transcripts.clear(sessionId);
+    await this.fallBackAfterSessionGone(sessionId);
+    this.options.emit(noticeMessage("info", "Session deleted.", Date.now()));
+  }
+  /** The panel must stay usable once the session it showed is gone. */
+  async fallBackAfterSessionGone(sessionId) {
+    if (this.activeKey !== sessionId) {
+      this.publishActivity();
+      await this.publishSessions();
+      return;
+    }
+    this.activeKey = void 0;
+    this.historyBefore = void 0;
+    this.hasOlderHistory = false;
+    this.loadingOlderHistory = false;
+    this.agentReady = false;
+    this.agentError = void 0;
+    const next = this.options.services.registry.hotKeys().at(-1);
+    if (next) {
+      await this.runSessionChange(() => this.options.services.registry.activate(next));
+    } else {
+      await this.enterDraft();
+    }
+    await this.publishSessions();
+  }
+  /** Opens/activates a session while reporting progress and failures. */
+  async runSessionChange(change) {
+    const announce = this.hasOpenedOnce;
+    if (announce) {
+      this.setBusy(true);
+    }
+    this.agentStarting = true;
+    if (announce) {
+      this.emitState();
+    }
+    try {
+      const opened = await change();
+      this.adopt(opened);
+    } catch (error) {
+      this.agentReady = false;
+      this.agentError = describeError(error);
+      this.options.logger.warn("Could not start the Morse agent", error);
+      this.fail(`Could not start the Morse agent: ${this.agentError}`, this.options.agentHint);
+    } finally {
+      this.agentStarting = false;
+      this.hasOpenedOnce = true;
+      if (announce) {
+        this.setBusy(false);
+      } else {
+        this.emitState();
+      }
+    }
+  }
+  adopt(opened) {
+    this.activeKey = opened.key;
+    this.isDraft = false;
+    this.draftWorkspace = void 0;
+    if (!opened.reused) {
+      this.options.transcripts.reset(opened.key);
+    }
+    this.historyBefore = void 0;
+    this.hasOlderHistory = false;
+    this.loadingOlderHistory = false;
+    this.agentReady = true;
+    this.agentError = void 0;
+    this.emitTranscript(opened.key);
+    this.emitState();
+    void this.publishSessions();
+    void this.seedHistory(opened.key);
+  }
+  /**
+   * A resumed session has its messages on disk but streams nothing on attach, so
+   * the transcript would look empty. Fill it from the *newest* page of history:
+   * a session with thousands of messages must open without rendering them all,
+   * and older pages are fetched on demand (see `loadOlderHistory`).
+   */
+  async seedHistory(key) {
+    if (this.options.transcripts.items(key).length > 0) {
+      const cursor = this.options.transcripts.historyCursor(key);
+      this.historyBefore = cursor.before;
+      this.hasOlderHistory = cursor.hasOlder;
+      this.emitState();
+      return;
+    }
+    if (this.activeKey !== key) {
+      return;
+    }
+    const gateway = this.options.services.registry.active();
+    if (!gateway) {
+      return;
+    }
+    this.loadingOlderHistory = true;
+    this.emitState();
+    const result = await this.guard(() => gateway.history({ limit: HISTORY_PAGE_SIZE }));
+    this.loadingOlderHistory = false;
+    if (!result.ok || this.options.transcripts.items(key).length > 0 || this.activeKey !== key) {
+      this.emitState();
+      return;
+    }
+    this.historyBefore = result.value.before;
+    this.hasOlderHistory = result.value.hasOlder;
+    this.options.transcripts.setHistoryCursor(key, {
+      before: result.value.before,
+      hasOlder: result.value.hasOlder
+    });
+    this.options.transcripts.seed(key, historyItems(key, result.value.entries, this.historyPageSeq++));
+    this.emitState();
+  }
+  /** Prepends the previous page of history when the reader reaches the top. */
+  async loadOlderHistory() {
+    if (!this.hasOlderHistory || this.loadingOlderHistory) {
+      return;
+    }
+    const key = this.activeKey;
+    const gateway = this.options.services.registry.active();
+    if (key === void 0 || !gateway) {
+      return;
+    }
+    this.loadingOlderHistory = true;
+    this.emitState();
+    const result = await this.guard(() => gateway.history({ limit: HISTORY_PAGE_SIZE, before: this.historyBefore }));
+    this.loadingOlderHistory = false;
+    if (!result.ok || this.activeKey !== key) {
+      this.emitState();
+      return;
+    }
+    this.historyBefore = result.value.before;
+    this.hasOlderHistory = result.value.hasOlder;
+    this.options.transcripts.setHistoryCursor(key, {
+      before: result.value.before,
+      hasOlder: result.value.hasOlder
+    });
+    this.options.transcripts.prepend(key, historyItems(key, result.value.entries, this.historyPageSeq++));
+    this.emitState();
+  }
+  canOpen(path) {
+    const scope = this.options.scope ?? { kind: "global" };
+    if (scope.kind === "workspace" && !insideRoots(path, scope.roots)) {
+      return false;
+    }
+    return this.options.policy?.canOpen(path) ?? true;
+  }
+  withinScope(path) {
+    const scope = this.options.scope ?? { kind: "global" };
+    return scope.kind === "global" || insideRoots(path, scope.roots);
+  }
+  async prompt(text, mode, images, pins) {
+    if (!this.agentReady) {
+      if (this.isDraft) {
+        await this.runSessionChange(() => this.options.services.registry.open({ workspace: this.draftWorkspace }));
+        this.draftWorkspace = void 0;
+      } else {
+        await this.openDefaultSession();
+      }
+      if (!this.agentReady) {
+        return;
+      }
+    }
+    this.isDraft = false;
+    const pendingModel = this.draftModel;
+    const pendingThinking = this.draftThinking;
+    this.draftModel = void 0;
+    this.draftThinking = void 0;
+    if (pendingModel) {
+      await this.guard(() => this.options.services.chat.setModel({
+        provider: pendingModel.provider,
+        id: pendingModel.id,
+        name: pendingModel.name
+      }));
+    }
+    if (pendingThinking) {
+      await this.guard(() => this.options.services.chat.setThinkingLevel(pendingThinking));
+    }
+    const result = await this.guard(() => this.options.services.chat.prompt(text, mode ?? "new", images, pins));
+    if (!result.ok || !result.value.accepted) {
+      return;
+    }
+    const key = this.activeKey;
+    if (key) {
+      this.options.transcripts.userPrompt(key, text, images, pins);
+      void this.publishSessions();
+    }
+  }
+  /**
+   * Edits a past user message: fork the conversation before it (which discards
+   * that turn and everything after), truncate the transcript to match, then send
+   * the edited text as a fresh prompt. Attachments on the original message ride
+   * along, so an image or pin is not silently dropped by the edit.
+   */
+  async editPrompt(itemId, text) {
+    const target = await this.forkBefore(itemId, "edit");
+    if (!target) {
+      return;
+    }
+    await this.prompt(text, "new", target.images, target.pins);
+  }
+  /**
+   * Branches the conversation before a past user message without sending
+   * anything. pi's fork writes a new session file while the old branch stays
+   * resumable; the transcript re-homes onto the new, shorter branch and the
+   * forked prompt goes back to the composer, so the user continues from the
+   * fork point instead of retyping it.
+   */
+  async forkPrompt(itemId) {
+    const target = await this.forkBefore(itemId, "fork");
+    if (!target) {
+      return;
+    }
+    this.options.emit({
+      type: "composer/seed",
+      payload: {
+        text: target.text,
+        ...target.images ? { images: target.images } : {},
+        ...target.pins ? { pins: target.pins } : {}
+      }
+    });
+    void this.publishSessions();
+  }
+  /**
+   * Forks the active session before a past user message and re-homes the
+   * transcript onto the new branch. Shared by edit (which then sends) and fork
+   * (which seeds the composer). Returns the forked message, or `undefined` when
+   * the fork was refused — a notice has already been emitted in that case.
+   */
+  async forkBefore(itemId, action) {
+    const gerund = action === "edit" ? "editing" : "forking";
+    const past = action === "edit" ? "edited" : "forked";
+    if (this.isDraft) {
+      this.options.emit(noticeMessage("warn", `Nothing to ${action} yet \u2014 this session has no messages.`, Date.now()));
+      return void 0;
+    }
+    if (!this.agentReady) {
+      await this.openDefaultSession();
+      if (!this.agentReady) {
+        return void 0;
+      }
+    }
+    const key = this.activeKey;
+    const gateway = this.options.services.registry.active();
+    if (key === void 0 || !gateway) {
+      this.options.emit(noticeMessage("warn", `No session to ${action}.`, Date.now()));
+      return void 0;
+    }
+    const items = this.options.transcripts.items(key);
+    const target = items.find((item) => item.id === itemId);
+    if (!target || target.kind !== "user") {
+      this.options.emit(noticeMessage("warn", `That message is no longer available to ${action}.`, Date.now()));
+      return void 0;
+    }
+    if (this.options.services.registry.stateOf(key)?.streaming === true) {
+      this.options.emit(noticeMessage("warn", `Wait for the agent to finish before ${gerund} a message.`, Date.now()));
+      return void 0;
+    }
+    const messages = await this.guard(() => gateway.forkMessages());
+    if (!messages.ok) {
+      return void 0;
+    }
+    const entryId = entryIdForEdit(items, itemId, messages.value);
+    if (entryId === void 0) {
+      this.options.emit(noticeMessage("warn", `This message cannot be ${past} \u2014 the agent has no fork point for it.`, Date.now()));
+      return void 0;
+    }
+    const forked = await this.guard(() => this.options.services.registry.forkActive(entryId));
+    if (!forked.ok) {
+      return void 0;
+    }
+    if (forked.value.cancelled) {
+      this.options.emit(noticeMessage("warn", "The fork was cancelled.", Date.now()));
+      return void 0;
+    }
+    const index = items.findIndex((item) => item.id === itemId);
+    const kept = items.slice(0, index);
+    this.activeKey = forked.value.key;
+    this.options.transcripts.move(key, forked.value.key, kept);
+    this.historyBefore = void 0;
+    this.hasOlderHistory = false;
+    this.loadingOlderHistory = false;
+    this.emitState();
+    return target;
+  }
+  async setModel(provider, id) {
+    if (this.activeKey === void 0) {
+      const match = this.draftCatalog?.availableModels.find((model) => model.provider === provider && model.id === id);
+      this.draftModel = match ?? { provider, id, name: id };
+      this.emitState();
+      return;
+    }
+    const result = await this.guard(() => this.options.services.chat.setModel({ provider, id, name: id }));
+    if (result.ok) {
+      this.emitState();
+    }
+  }
+  async setThinkingLevel(level) {
+    if (this.activeKey === void 0) {
+      this.draftThinking = level;
+      this.emitState();
+      return;
+    }
+    const result = await this.guard(() => this.options.services.chat.setThinkingLevel(level));
+    if (result.ok) {
+      this.emitState();
+    }
+  }
+  async respondToInteraction(response) {
+    this.pendingInteractions.delete(response.requestId);
+    this.options.emit({ type: "interaction/dismiss", payload: { requestId: response.requestId } });
+    const gateway = this.options.services.registry.active();
+    if (!gateway) {
+      return;
+    }
+    await this.guard(() => gateway.respondToInteraction(response));
+  }
+  async runHostCommand(command, args, requestId) {
+    const handler = this.options.onHostCommand;
+    if (!handler) {
+      this.options.emit(noticeMessage("warn", `This host does not support "${command}".`, Date.now()));
+      this.answerHostCommand(requestId, false, void 0, `This host does not support "${command}".`);
+      return;
+    }
+    const result = await this.guard(() => Promise.resolve(handler(command, args, { cwd: this.currentState().workspace.cwd })));
+    if (!requestId) {
+      return;
+    }
+    if (result.ok) {
+      this.answerHostCommand(requestId, true, result.value);
+      return;
+    }
+    this.answerHostCommand(requestId, false, void 0, `"${command}" failed`);
+  }
+  /** Replies to a host command the frontend asked a value for. */
+  answerHostCommand(requestId, ok, data, error) {
+    if (!requestId) {
+      return;
+    }
+    this.options.emit({ type: "host/command/result", payload: { requestId, ok, data, error } });
+  }
+  async onTaggedEvent(sessionKey, event) {
+    if (sessionKey !== this.activeKey) {
+      if (event.type !== "agent/ready" && event.type !== "agent/state") {
+        this.options.transcripts.apply(sessionKey, event);
+        if (event.type === "agent/run-end") {
+          void this.publishSessions();
+        }
+      } else {
+        this.publishActivity();
+      }
+      return;
+    }
+    switch (event.type) {
+      case "agent/ready":
+        this.agentReady = true;
+        this.agentError = void 0;
+        this.emitState();
+        return;
+      case "agent/state":
+        this.emitState();
+        return;
+      case "agent/run-end":
+        this.options.transcripts.apply(sessionKey, event);
+        void this.publishSessions();
+        return;
+      case "agent/interaction":
+        await this.handleInteraction(event.request);
+        return;
+      case "agent/fatal":
+        this.agentReady = false;
+        this.agentError = event.message;
+        this.options.transcripts.error(sessionKey, event.message, event.detail);
+        this.emitState();
+        return;
+      default:
+        this.options.transcripts.apply(sessionKey, event);
+    }
+  }
+  async handleInteraction(request) {
+    const dialogs = this.options.dialogs;
+    if (!dialogs) {
+      this.pendingInteractions.add(request.requestId);
+      this.options.emit({ type: "interaction/request", payload: toInteractionRequest2(request) });
+      return;
+    }
+    const response = await this.askNatively(dialogs, request);
+    const gateway = this.options.services.registry.active();
+    if (!gateway) {
+      return;
+    }
+    await this.guard(() => gateway.respondToInteraction(response));
+  }
+  async askNatively(dialogs, request) {
+    switch (request.kind) {
+      case "select": {
+        const value = await dialogs.select(request);
+        return value === void 0 ? { requestId: request.requestId, cancelled: true } : { requestId: request.requestId, value };
+      }
+      case "confirm":
+        return { requestId: request.requestId, confirmed: await dialogs.confirm(request) };
+      case "input": {
+        const value = await dialogs.input(request);
+        return value === void 0 ? { requestId: request.requestId, cancelled: true } : { requestId: request.requestId, value };
+      }
+      case "editor": {
+        const value = await dialogs.editor(request);
+        return value === void 0 ? { requestId: request.requestId, cancelled: true } : { requestId: request.requestId, value };
+      }
+    }
+  }
+  async publishLists() {
+    await this.publishSessions();
+  }
+  /**
+   * Projects are derived from sessions, so the caller can hand in the list it
+   * just built instead of making the registry read the catalog again. That also
+   * lets a brand-new project show up before pi has persisted its first session.
+   */
+  async publishProjects(sessions) {
+    const result = await this.guard(() => this.options.services.registry.listProjects(sessions));
+    if (result.ok) {
+      const projects = result.value.filter((project) => this.withinScope(project.path));
+      this.options.emit({ type: "project/list", payload: { projects } });
+    }
+  }
+  async publishSessions() {
+    const result = await this.guard(() => this.options.services.registry.listSessions());
+    if (result.ok) {
+      const sessions = result.value.filter((session) => this.withinScope(session.cwd));
+      const known = new Set(sessions.map((session) => session.id));
+      for (const key of this.options.services.registry.hotKeys()) {
+        if (known.has(key)) {
+          continue;
+        }
+        const state = this.options.services.registry.stateOf(key);
+        const cwd = state?.workspace.cwd ?? this.options.services.registry.defaultWorkspace.cwd;
+        if (!this.withinScope(cwd)) {
+          continue;
+        }
+        sessions.push({
+          id: key,
+          title: state?.sessionTitle ?? this.derivedTitle(key) ?? "New session",
+          cwd,
+          updatedAt: Date.now(),
+          messageCount: 0
+        });
+      }
+      this.summaries = new Map(sessions.map((session) => [session.id, session]));
+      this.options.emit({ type: "session/list", payload: { sessions } });
+      await this.publishProjects(sessions);
+    }
+  }
+  /**
+   * Title for a session pi has not persisted yet. pi names a session only when
+   * something calls `set_session_name`, and until the file exists the catalog
+   * cannot derive a title from the file either — so derive it from the first
+   * user message here, the same way the catalog does. A session must not stay
+   * "New session" once the user has said something.
+   */
+  derivedTitle(key) {
+    for (const item of this.options.transcripts.items(key)) {
+      if (item.kind !== "user" || item.text.trim().length === 0) {
+        continue;
+      }
+      const single = item.text.replace(/\s+/g, " ").trim();
+      return single.length > 72 ? `${single.slice(0, 72)}\u2026` : single;
+    }
+    return void 0;
+  }
+  emitReady() {
+    this.hostReadyEmitted = true;
+    this.options.emit({
+      type: "transcript/replace",
+      payload: { items: this.activeKey ? this.options.transcripts.items(this.activeKey) : [] }
+    });
+    this.options.emit({
+      type: "host/ready",
+      payload: {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: this.options.capabilities,
+        state: this.currentState(),
+        frontend: this.options.frontend
+      }
+    });
+    this.publishActivity();
+  }
+  emitTranscript(key) {
+    this.options.emit({
+      type: "transcript/replace",
+      payload: { items: this.options.transcripts.items(key) }
+    });
+  }
+  emitState() {
+    this.options.emit({ type: "session/state", payload: this.currentState() });
+    this.publishActivity();
+  }
+  /**
+   * Reports every live session (hot process), not only the selected one. The
+   * navigator marks the ones the agent is actively working in, so two parallel
+   * conversations both read as running instead of one silently taking over.
+   */
+  publishActivity() {
+    const sessions = this.options.services.registry.hotKeys().map((key) => {
+      const state = this.options.services.registry.stateOf(key);
+      const isActive = key === this.activeKey;
+      return {
+        sessionKey: key,
+        streaming: state?.streaming ?? false,
+        busy: isActive ? this.busy : false,
+        agentReady: isActive ? this.agentReady : state !== void 0,
+        agentStarting: isActive ? this.agentStarting : false,
+        ...isActive && this.agentError !== void 0 ? { agentError: this.agentError } : {}
+      };
+    });
+    this.options.emit({ type: "session/activity", payload: { sessions } });
+  }
+  currentState() {
+    const meta = {
+      agentReady: this.agentReady,
+      agentStarting: this.agentStarting,
+      agentError: this.agentError,
+      busy: this.busy,
+      hasOlderHistory: this.hasOlderHistory,
+      loadingOlderHistory: this.loadingOlderHistory
+    };
+    const state = this.activeKey === void 0 ? void 0 : this.options.services.registry.stateOf(this.activeKey);
+    if (state) {
+      return toSessionViewState(state, meta);
+    }
+    return draftSessionViewState(this.draftWorkspace ?? this.options.services.registry.defaultWorkspace, meta, this.draftCatalog, this.draftModel, this.draftThinking);
+  }
+  setBusy(busy) {
+    if (this.busy === busy) {
+      return;
+    }
+    this.busy = busy;
+    this.emitState();
+  }
+  fail(message, detail) {
+    const key = this.activeKey;
+    if (key !== void 0) {
+      this.options.transcripts.error(key, message, detail);
+      return;
+    }
+    this.options.emit(noticeMessage("error", detail ? `${message}
+${detail}` : message, Date.now()));
+  }
+  /** Transient error for the client (banner), never a transcript item. */
+  emitWireError(message, detail) {
+    this.options.emit({ type: "error", payload: { message, detail, at: Date.now() } });
+    this.options.emit(noticeMessage("error", detail ? `${message}
+${detail}` : message, Date.now()));
+  }
+  async guard(action) {
+    try {
+      return { ok: true, value: await action() };
+    } catch (error) {
+      const message = describeError(error);
+      this.options.logger.error(`Morse command failed: ${message}`, error);
+      this.fail(message);
+      return { ok: false };
+    }
+  }
+};
+function workspaceOf(path) {
+  const parts = path.split(/[\\/]/).filter((part) => part.length > 0);
+  return { cwd: path, name: parts.at(-1) ?? path };
+}
+function insideRoots(path, roots) {
+  return roots.some((root) => path === root || path.startsWith(`${root}/`) || path.startsWith(`${root}\\`));
+}
+function historyItems(key, entries, page) {
+  return entries.map((entry, index) => {
+    const id = `${key}#history-${page}-${index}`;
+    const at = entry.at ?? 0;
+    if (entry.role === "user") {
+      return {
+        kind: "user",
+        id,
+        at,
+        text: entry.text,
+        ...entry.images ? { images: entry.images } : {},
+        ...entry.pins ? { pins: entry.pins } : {}
+      };
+    }
+    if (entry.role === "tool") {
+      return {
+        kind: "tool",
+        id,
+        at,
+        name: entry.name,
+        title: entry.title,
+        status: entry.status,
+        input: entry.input,
+        output: entry.output
+      };
+    }
+    if (entry.role === "compaction") {
+      return {
+        kind: "compaction",
+        id,
+        at,
+        summary: entry.summary,
+        ...entry.tokensBefore !== void 0 ? { tokensBefore: entry.tokensBefore } : {}
+      };
+    }
+    return {
+      kind: "assistant",
+      id,
+      at,
+      text: entry.text,
+      thinking: entry.thinking ?? "",
+      streaming: false,
+      model: entry.model
+    };
+  });
+}
+function entryIdForEdit(items, itemId, forkMessages) {
+  const forkable = items.filter((item) => item.kind === "user" && (item.text.trim().length > 0 || (item.pins?.length ?? 0) > 0));
+  const index = forkable.findIndex((item) => item.id === itemId);
+  if (index === -1) {
+    return void 0;
+  }
+  const position = forkMessages.length - 1 - (forkable.length - 1 - index);
+  return position >= 0 ? forkMessages[position]?.entryId : void 0;
+}
+function describeError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return typeof error === "string" ? error : JSON.stringify(error);
+}
+
+// ../server/src/internal/http/health.controller.ts
+import { Controller, Get } from "@nestjs/common";
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+import { Inject } from "@nestjs/common";
+
+// ../server/src/app/tokens.ts
+var MORSE_CONFIG = "MORSE_CONFIG";
+var MORSE_LOGGER = "MORSE_LOGGER";
+var MORSE_PI_ADAPTER = "MORSE_PI_ADAPTER";
+var MORSE_SESSION_REGISTRY = "MORSE_SESSION_REGISTRY";
+var MORSE_TRANSCRIPT_STORE = "MORSE_TRANSCRIPT_STORE";
+var MORSE_PROJECT_POLICY = "MORSE_PROJECT_POLICY";
+
+// ../server/src/internal/http/health.controller.ts
+var HealthController = class {
+  constructor(config) {
+    this.config = config;
+  }
+  health() {
+    return {
+      status: "ok",
+      protocolVersion: PROTOCOL_VERSION,
+      workspace: this.config.workspace.cwd,
+      frontend: this.config.uiDir
+    };
+  }
+  async manifest() {
+    const raw = await readFile2(join3(this.config.uiDir, "webview.manifest.json"), "utf8").catch(
+      () => void 0
+    );
+    return parseFrontendManifest(raw) ?? { name: "unknown", protocolVersion: PROTOCOL_VERSION };
+  }
+};
+__decorateClass([
+  Get("health")
+], HealthController.prototype, "health", 1);
+__decorateClass([
+  Get("manifest")
+], HealthController.prototype, "manifest", 1);
+HealthController = __decorateClass([
+  Controller("api"),
+  __decorateParam(0, Inject(MORSE_CONFIG))
+], HealthController);
+
+// ../server/src/internal/logging/nest-logger.ts
+import { Logger } from "@nestjs/common";
+var NestMorseLogger = class {
+  constructor() {
+    this.logger = new Logger("morse");
+  }
+  debug(message, detail) {
+    this.logger.debug(withDetail(message, detail));
+  }
+  info(message, detail) {
+    this.logger.log(withDetail(message, detail));
+  }
+  warn(message, detail) {
+    this.logger.warn(withDetail(message, detail));
+  }
+  error(message, detail) {
+    this.logger.error(withDetail(message, detail));
+  }
+};
+function withDetail(message, detail) {
+  if (detail === void 0) {
+    return message;
+  }
+  if (detail instanceof Error) {
+    return `${message}: ${detail.message}`;
+  }
+  try {
+    return `${message} ${JSON.stringify(detail)}`;
+  } catch {
+    return `${message} ${String(detail)}`;
+  }
+}
+
+// ../server/src/internal/projects/project-policy.ts
+import { isAbsolute as isAbsolute2, resolve as resolve2, sep as sep2 } from "node:path";
+var ServerProjectPolicy = class {
+  constructor(roots) {
+    this.roots = roots.filter((root) => root.trim().length > 0).map((root) => resolve2(root));
+  }
+  get allowList() {
+    return [...this.roots];
+  }
+  canOpen(path) {
+    if (!isAbsolute2(path)) {
+      return false;
+    }
+    if (this.roots.length === 0) {
+      return true;
+    }
+    const target = resolve2(path);
+    return this.roots.some(
+      (root) => target === root || target.startsWith(`${root}${sep2}`)
+    );
+  }
+};
+
+// ../server/src/internal/registry.ts
+import { Inject as Inject2, Injectable } from "@nestjs/common";
+function createSessionRegistry(adapter, config, logger) {
+  return new SessionRegistry({
+    factory: adapter.factory,
+    catalog: adapter.catalog,
+    defaultWorkspace: config.workspace,
+    hotLimit: config.hotSessions,
+    logger
+  });
+}
+var MorseRegistryLifecycle = class {
+  constructor(registry, transcripts) {
+    this.registry = registry;
+    this.transcripts = transcripts;
+  }
+  async onModuleDestroy() {
+    await this.registry.dispose();
+    this.transcripts.dispose();
+  }
+};
+MorseRegistryLifecycle = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject2(MORSE_SESSION_REGISTRY)),
+  __decorateParam(1, Inject2(MORSE_TRANSCRIPT_STORE))
+], MorseRegistryLifecycle);
+
+// ../server/src/internal/ws/morse.gateway.ts
+import {
+  WebSocketGateway
+} from "@nestjs/websockets";
+import { Inject as Inject4 } from "@nestjs/common";
+
+// ../server/src/internal/ws/session-factory.service.ts
+import { Inject as Inject3, Injectable as Injectable2 } from "@nestjs/common";
+
+// ../server/src/internal/uploads/upload-store.ts
+import { existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename as basename2, isAbsolute as isAbsolute3, join as join4, relative, sep as sep3 } from "node:path";
+var MAX_UPLOAD_BYTES = 10 * 1024 * 1024;
+var DEFAULT_UPLOAD_DIR = ".morse/uploads";
+var UploadError = class extends Error {
+};
+async function saveUpload(cwd, request, uploadDir = DEFAULT_UPLOAD_DIR) {
+  const name = safeFileName(request.name);
+  const data = request.data;
+  if (typeof data !== "string" || data.length === 0) {
+    throw new UploadError("That upload carried no data.");
+  }
+  const bytes = Buffer.from(data, "base64");
+  if (bytes.length === 0) {
+    throw new UploadError("That upload carried no data.");
+  }
+  if (bytes.length > MAX_UPLOAD_BYTES) {
+    throw new UploadError(
+      `That file is ${formatMb(bytes.length)} MB; the limit is ${formatMb(MAX_UPLOAD_BYTES)} MB.`
+    );
+  }
+  const directory = isAbsolute3(uploadDir) ? uploadDir : join4(cwd, uploadDir);
+  await mkdir(directory, { recursive: true });
+  const target = uniquePath(directory, name);
+  await writeFile(target, bytes);
+  return { path: mentionPath(cwd, target), name: basename2(target), bytes: bytes.length };
+}
+function safeFileName(raw) {
+  const value = typeof raw === "string" ? raw : "";
+  const base = basename2(value.replace(/\\/g, "/")).trim();
+  const cleaned = base.replace(/[\u0000-\u001f<>:"|?*]/g, "_").replace(/^\.+/, "").trim();
+  if (cleaned.length === 0) {
+    throw new UploadError("That upload had no usable file name.");
+  }
+  return cleaned.slice(0, 120);
+}
+function uniquePath(directory, name) {
+  const dot = name.lastIndexOf(".");
+  const stem = dot > 0 ? name.slice(0, dot) : name;
+  const extension = dot > 0 ? name.slice(dot) : "";
+  let candidate = join4(directory, name);
+  let suffix = 1;
+  while (existsSync(candidate)) {
+    candidate = join4(directory, `${stem}-${suffix}${extension}`);
+    suffix += 1;
+  }
+  return candidate;
+}
+function mentionPath(cwd, target) {
+  const rel = relative(cwd, target);
+  const posix = rel.split(sep3).join("/");
+  return posix.length === 0 || posix.startsWith("..") || isAbsolute3(rel) ? target : posix;
+}
+function formatMb(bytes) {
+  return (bytes / (1024 * 1024)).toFixed(1).replace(/\.0$/, "");
+}
+
+// ../server/src/internal/workspace/directory-browser.ts
+import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { basename as basename3, dirname, isAbsolute as isAbsolute4, join as join5, resolve as resolve3 } from "node:path";
+var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "out",
+  "build",
+  "coverage",
+  "target",
+  "vendor",
+  "venv",
+  "__pycache__",
+  ".angular",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  ".cache"
+]);
+async function browseDirectory(path, options) {
+  const requested = path?.trim();
+  const start = resolve3(requested && requested.length > 0 ? requested : options.defaultPath);
+  if (requested && !isAbsolute4(requested)) {
+    throw new Error(`A folder path must be absolute: ${requested}`);
+  }
+  const entries = await readdir2(start, { withFileTypes: true });
+  const directories = entries.filter((entry) => entry.isDirectory()).filter((entry) => !shouldSkip(entry.name)).map((entry) => ({ name: entry.name, path: join5(start, entry.name) })).sort((left, right) => left.name.localeCompare(right.name));
+  const parent = dirname(start);
+  return {
+    path: start,
+    parent: parent === start ? void 0 : parent,
+    directories,
+    isGitRepo: await isGitRepo(start),
+    roots: shortcutRoots(options)
+  };
+}
+function shouldSkip(name) {
+  return name.startsWith(".") || SKIPPED_DIRECTORIES.has(name);
+}
+async function isGitRepo(path) {
+  try {
+    await stat2(join5(path, ".git"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function shortcutRoots(options) {
+  const seen = /* @__PURE__ */ new Set();
+  const roots = [];
+  for (const candidate of [...options.roots ?? [], homedir2(), options.defaultPath]) {
+    if (!candidate || !isAbsolute4(candidate)) {
+      continue;
+    }
+    const path = resolve3(candidate);
+    if (seen.has(path)) {
+      continue;
+    }
+    seen.add(path);
+    roots.push({ name: basename3(path) || path, path });
+  }
+  return roots;
+}
+
+// ../server/src/internal/workspace/workspace-index.ts
+import { execFile } from "node:child_process";
+import { readdir as readdir3 } from "node:fs/promises";
+import { join as join6, relative as relative2 } from "node:path";
+var SKIPPED_DIRECTORIES2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "out",
+  "build",
+  "coverage",
+  "target",
+  "vendor",
+  "venv",
+  "__pycache__",
+  ".angular",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  ".cache"
+]);
+var MAX_INDEXED_FILES = 5e3;
+var INDEX_TTL_MS = 6e4;
+var indexes = /* @__PURE__ */ new Map();
+var inFlight = /* @__PURE__ */ new Map();
+async function workspaceFiles(cwd, logger) {
+  const { files, source } = await cachedIndex(cwd);
+  logger.info(`File picker: ${files.length} entries via ${source} in ${cwd}`);
+  return files;
+}
+async function cachedIndex(cwd) {
+  const now = Date.now();
+  const cached = indexes.get(cwd);
+  if (cached && now - cached.at < INDEX_TTL_MS) {
+    return cached;
+  }
+  const pending = inFlight.get(cwd);
+  if (pending) {
+    return pending;
+  }
+  const task = indexWorkspace(cwd).then((index) => {
+    const entry = { ...index, at: Date.now() };
+    indexes.set(cwd, entry);
+    return entry;
+  }).finally(() => {
+    inFlight.delete(cwd);
+  });
+  inFlight.set(cwd, task);
+  return task;
+}
+async function indexWorkspace(cwd) {
+  const fromGit = await gitFileList(cwd);
+  if (fromGit) {
+    return { files: indexEntries(fromGit), source: "git" };
+  }
+  const fromWalk = [];
+  await walk(cwd, cwd, fromWalk);
+  return { files: indexEntries(fromWalk), source: "walk" };
+}
+function indexEntries(paths) {
+  const entries = new Set(dedupe(paths).slice(0, MAX_INDEXED_FILES));
+  for (const path of [...entries]) {
+    const segments = path.split("/");
+    for (let depth = 1; depth < segments.length; depth += 1) {
+      entries.add(`${segments.slice(0, depth).join("/")}/`);
+    }
+  }
+  return [...entries].sort();
+}
+function dedupe(paths) {
+  return [...new Set(paths)];
+}
+async function gitFileList(cwd) {
+  try {
+    const [prefix, listed] = await Promise.all([
+      runGit(["rev-parse", "--show-prefix"], cwd),
+      runGit(["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--full-name"], cwd)
+    ]);
+    if (listed === void 0) {
+      return void 0;
+    }
+    const root = prefix?.trim() ?? "";
+    return listed.split("\0").filter((path) => path.length > 0).filter((path) => root.length === 0 || path.startsWith(root)).map((path) => path.slice(root.length)).filter((path) => path.length > 0 && !isInSkippedDirectory(path));
+  } catch {
+    return void 0;
+  }
+}
+function runGit(args, cwd) {
+  return new Promise((resolve4) => {
+    execFile(
+      "git",
+      args,
+      { cwd, timeout: 5e3, maxBuffer: 8 * 1024 * 1024, windowsHide: true },
+      (error, stdout) => resolve4(error ? void 0 : stdout)
+    );
+  });
+}
+function isInSkippedDirectory(path) {
+  const folders = path.split("/").slice(0, -1);
+  return folders.some((folder) => SKIPPED_DIRECTORIES2.has(folder) || folder.startsWith("."));
+}
+async function walk(root, directory, files) {
+  if (files.length >= MAX_INDEXED_FILES) {
+    return;
+  }
+  let entries;
+  try {
+    entries = await readdir3(directory, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (files.length >= MAX_INDEXED_FILES) {
+      return;
+    }
+    const full = join6(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (SKIPPED_DIRECTORIES2.has(entry.name) || entry.name.startsWith(".")) {
+        continue;
+      }
+      await walk(root, full, files);
+      continue;
+    }
+    if (entry.isFile() || entry.isSymbolicLink()) {
+      files.push(toPosix(relative2(root, full)));
+    }
+  }
+}
+function toPosix(path) {
+  return path.split("\\").join("/");
+}
+
+// ../server/src/internal/ws/session-factory.service.ts
+var MorseSessionFactory = class {
+  constructor(registry, transcripts, policy, logger, config) {
+    this.registry = registry;
+    this.transcripts = transcripts;
+    this.policy = policy;
+    this.logger = logger;
+    this.config = config;
+  }
+  capabilities() {
+    return {
+      hostKind: "server",
+      // The browser host is global: every project pi knows about.
+      scope: "global",
+      // A browser has no local editor to read, so there is nothing to pin.
+      editorContext: false,
+      // No QuickPick/InputBox here, so the frontend renders interactions.
+      nativeDialogs: false,
+      insertIntoEditor: false,
+      revealFile: false,
+      // The server can walk the active session's directory, so the composer's
+      // `@` picker works here too — the same list VS Code offers for a workspace.
+      filePicker: true,
+      // A browser cannot hand a dragged file's path to pi, so the host takes the
+      // bytes and writes them next to the session; the frontend then `@mentions`
+      // the path it gets back.
+      fileUpload: true,
+      // The browser host has no workspace folder, so "New session" has to ask
+      // which directory the agent should run in. The frontend opens its folder
+      // modal; VS Code has a folder already and leaves this off.
+      directoryPicker: true,
+      // pi's fork re-parents the conversation, so a past prompt can be edited.
+      editMessage: true,
+      // The same fork can branch a new session and hand the prompt back instead.
+      forkMessage: true
+    };
+  }
+  createFor(emit) {
+    const services = {
+      registry: this.registry,
+      chat: new ChatService({ agent: this.registry, logger: this.logger })
+    };
+    return new HostSessionController({
+      services,
+      capabilities: this.capabilities(),
+      emit,
+      logger: this.logger,
+      transcripts: this.transcripts,
+      policy: this.policy,
+      scope: { kind: "global" },
+      // The registry outlives this connection on purpose.
+      ownsRegistry: false,
+      // A page load must not create a session; the first prompt opens one.
+      autoOpen: false,
+      onHostCommand: (command, args, context) => this.runHostCommand(command, args, context),
+      agentHint: "Install the pi CLI and make sure it is on PATH, or start the server with MORSE_PI_PATH set."
+    });
+  }
+  /**
+   * The host commands this host answers: browsing the filesystem for a project
+   * folder, listing the active session's files for the composer's `@mention`
+   * picker, and writing a browser upload down next to the session.
+   *
+   * `listDirectories` is read-only and may look anywhere the server can read;
+   * the commands that touch a session are scoped to its cwd (which
+   * `ProjectPolicy` already approved when the session was opened), never to a
+   * path the client names.
+   */
+  async runHostCommand(command, args, context) {
+    switch (command) {
+      case "listDirectories": {
+        const requested = typeof args?.path === "string" ? args.path : void 0;
+        const listing = await browseDirectory(requested, {
+          roots: this.policy.allowList,
+          defaultPath: this.registry.defaultWorkspace.cwd
+        });
+        return { ...listing, canOpen: this.policy.canOpen(listing.path) };
+      }
+      case "listFiles": {
+        const cwd = this.requireWritableCwd(context);
+        const files = await workspaceFiles(cwd, this.logger);
+        return { files };
+      }
+      case "uploadFile": {
+        const cwd = this.requireWritableCwd(context);
+        const saved = await saveUpload(cwd, args ?? {}, this.config.uploadDir);
+        this.logger.info(`Upload stored: ${saved.path} (${saved.bytes} bytes)`);
+        return saved;
+      }
+      default:
+        throw new UnsupportedByHostError(`This host does not support "${command}".`);
+    }
+  }
+  /**
+   * The directory the command should touch, after `ProjectPolicy` approved it.
+   * The controller hands in what the client is viewing; the registry's active
+   * session is only a fallback for a host command issued without one.
+   */
+  requireWritableCwd(context) {
+    const cwd = context?.cwd ?? this.activeCwd();
+    if (!cwd) {
+      throw new UnsupportedByHostError("No active Morse session yet.");
+    }
+    if (!this.policy.canOpen(cwd)) {
+      throw new UnsupportedByHostError(`Morse is not allowed to work in ${cwd}.`);
+    }
+    return cwd;
+  }
+  /** The cwd of the session this connection is showing. */
+  activeCwd() {
+    const key = this.registry.activeKeyOf();
+    const workspace = key === void 0 ? void 0 : this.registry.stateOf(key)?.workspace;
+    return workspace?.cwd ?? this.registry.defaultWorkspace.cwd;
+  }
+};
+MorseSessionFactory = __decorateClass([
+  Injectable2(),
+  __decorateParam(0, Inject3(MORSE_SESSION_REGISTRY)),
+  __decorateParam(1, Inject3(MORSE_TRANSCRIPT_STORE)),
+  __decorateParam(2, Inject3(MORSE_PROJECT_POLICY)),
+  __decorateParam(3, Inject3(MORSE_LOGGER)),
+  __decorateParam(4, Inject3(MORSE_CONFIG))
+], MorseSessionFactory);
+
+// ../server/src/internal/ws/morse.gateway.ts
+var MorseGateway = class {
+  constructor(sessions, logger) {
+    this.sessions = sessions;
+    this.logger = logger;
+    this.clients = /* @__PURE__ */ new Map();
+  }
+  handleConnection(client) {
+    const emit = (message) => {
+      if (client.readyState === 1) {
+        client.send(encodeWireMessage(message));
+      }
+    };
+    const controller = this.sessions.createFor(emit);
+    this.clients.set(client, controller);
+    client.on("message", (data) => {
+      void this.onMessage(controller, data);
+    });
+    client.on("error", (error) => {
+      this.logger.warn("WebSocket error", error);
+    });
+    void controller.start().catch((error) => {
+      this.logger.error("Failed to start a Morse session for a new client", error);
+    });
+  }
+  handleDisconnect(client) {
+    const controller = this.clients.get(client);
+    this.clients.delete(client);
+    void controller?.dispose().catch((error) => {
+      this.logger.warn("Failed to dispose a Morse session controller", error);
+    });
+  }
+  async onMessage(controller, data) {
+    const message = parseClientMessage(decode(data));
+    if (!message) {
+      this.logger.warn("Ignoring an unrecognised client message");
+      return;
+    }
+    await controller.handleClientMessage(message);
+  }
+};
+MorseGateway = __decorateClass([
+  WebSocketGateway({ path: DEFAULT_WS_PATH }),
+  __decorateParam(0, Inject4(MorseSessionFactory)),
+  __decorateParam(1, Inject4(MORSE_LOGGER))
+], MorseGateway);
+
+// ../server/src/app/config.ts
+import { basename as basename4, dirname as dirname2, isAbsolute as isAbsolute5, join as join7 } from "node:path";
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+function loadConfig(env = process.env) {
+  const workspacePath = resolveWorkspacePath(env);
+  const configuredUiDir = env.MORSE_UI_DIR;
+  const moduleDir = dirname2(fileURLToPath(import.meta.url));
+  const bundledUiDir = join7(moduleDir, "ui");
+  const monorepoUiDir = join7(moduleDir, "..", "..", "..", "ui-angular", "dist");
+  const defaultUiDir = existsSync2(join7(bundledUiDir, "index.html")) ? bundledUiDir : monorepoUiDir;
+  const defaultHost = "127.0.0.1";
+  return {
+    host: env.MORSE_HOST ?? defaultHost,
+    port: parsePositiveInt(env.MORSE_PORT, 4399),
+    uiDir: configuredUiDir ? isAbsolute5(configuredUiDir) ? configuredUiDir : join7(process.cwd(), configuredUiDir) : defaultUiDir,
+    workspace: { cwd: workspacePath, name: basename4(workspacePath) || workspacePath },
+    piPath: env.MORSE_PI_PATH,
+    nodeEntryPath: env.MORSE_PI_ENTRY,
+    sessionDir: env.MORSE_SESSION_DIR,
+    noSession: env.MORSE_NO_SESSION === "1",
+    requestTimeoutMs: parsePositiveInt(env.MORSE_REQUEST_TIMEOUT_MS, 3e4),
+    hotSessions: parsePositiveInt(env.MORSE_HOT_SESSIONS, 4),
+    projects: parseList(env.MORSE_PROJECTS),
+    uploadDir: env.MORSE_UPLOAD_DIR?.trim() || DEFAULT_UPLOAD_DIR
+  };
+}
+function parsePositiveInt(value, fallback) {
+  if (!value) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+function parseList(value) {
+  if (!value) {
+    return [];
+  }
+  return value.split(/[:,]/).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function resolveWorkspacePath(env) {
+  const explicit = env.MORSE_WORKSPACE;
+  if (explicit && explicit.trim().length > 0) {
+    return explicit;
+  }
+  const start = process.cwd();
+  let directory = start;
+  for (; ; ) {
+    const manifest = join7(directory, "package.json");
+    if (existsSync2(manifest) && declaresWorkspaces(manifest)) {
+      return directory;
+    }
+    const parent = dirname2(directory);
+    if (parent === directory) {
+      return start;
+    }
+    directory = parent;
+  }
+}
+function declaresWorkspaces(manifestPath) {
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    return manifest.workspaces !== void 0;
+  } catch {
+    return false;
+  }
+}
+
+// ../server/src/app.module.ts
+var AppModule = class {
+};
+AppModule = __decorateClass([
+  Module({
+    controllers: [HealthController],
+    providers: [
+      {
+        provide: MORSE_CONFIG,
+        useFactory: () => loadConfig()
+      },
+      {
+        provide: MORSE_LOGGER,
+        useFactory: () => new NestMorseLogger()
+      },
+      {
+        provide: MORSE_PI_ADAPTER,
+        useFactory: (config, logger) => createPiRpcAdapter(
+          {
+            piPath: config.piPath,
+            nodeEntryPath: config.nodeEntryPath,
+            sessionDir: config.sessionDir,
+            noSession: config.noSession,
+            requestTimeoutMs: config.requestTimeoutMs
+          },
+          logger
+        ),
+        inject: [MORSE_CONFIG, MORSE_LOGGER]
+      },
+      {
+        provide: MORSE_SESSION_REGISTRY,
+        useFactory: (adapter, config, logger) => createSessionRegistry(adapter, config, logger),
+        inject: [MORSE_PI_ADAPTER, MORSE_CONFIG, MORSE_LOGGER]
+      },
+      {
+        provide: MORSE_TRANSCRIPT_STORE,
+        useFactory: () => new SessionTranscriptStore()
+      },
+      {
+        provide: MORSE_PROJECT_POLICY,
+        useFactory: (config) => new ServerProjectPolicy(config.projects),
+        inject: [MORSE_CONFIG]
+      },
+      MorseRegistryLifecycle,
+      MorseSessionFactory,
+      MorseGateway
+    ]
+  })
+], AppModule);
+
+// ../server/src/main.ts
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  const config = app.get(MORSE_CONFIG);
+  app.useWebSocketAdapter(new WsAdapter(app));
+  app.useStaticAssets(config.uiDir);
+  app.enableCors({ origin: true });
+  app.enableShutdownHooks();
+  await app.listen(config.port, config.host);
+  const logger = new Logger2("morse");
+  logger.log(`Morse server listening on http://${config.host}:${config.port}`);
+  logger.log(`WebSocket endpoint: ws://${config.host}:${config.port}${DEFAULT_WS_PATH}`);
+  logger.log(`Frontend served from ${config.uiDir}`);
+  logger.log(`Workspace: ${config.workspace.cwd} (override with MORSE_WORKSPACE)`);
+}
+void bootstrap();
+//# sourceMappingURL=server.mjs.map