pipe-kan 0.18.1 → 0.19.0

package/dist/pipe-kan.js

@@ -904,13 +904,116 @@ function handleAppApi(req, res, app) {
   return false;
 }
 
+// src/agent-context.ts
+function boardViewContext(view) {
+  return [
+    { type: "text", text: formatBoardView({ ...view, scope: view.scope ?? "view" }) },
+    {
+      type: "resource",
+      resource: {
+        uri: "pipe-kan://board",
+        mimeType: "application/json",
+        text: JSON.stringify(view)
+      }
+    }
+  ];
+}
+function pipedBoardContext(board) {
+  return boardViewContext({
+    scope: "pipe",
+    kind: "stories",
+    selectedEpic: null,
+    search: "",
+    filter: {},
+    sort: "payload",
+    hide: [],
+    columns: board.columns,
+    epics: board.epics
+  });
+}
+function hasAttachedBoard(context = []) {
+  return context.some((block) => block.type === "resource" && block.resource.uri === "pipe-kan://board");
+}
+function withPipedBoardContext(board, clientContext = []) {
+  if (hasAttachedBoard(clientContext))
+    return clientContext;
+  return [...pipedBoardContext(board), ...clientContext];
+}
+function formatBoardView(view) {
+  const opener = view.kind === "epics" ? "All epics" : "All stories";
+  const scope = view.selectedEpic ? `${opener}, children of ${view.selectedEpic}` : opener;
+  const lines = [
+    view.scope === "pipe" ? "The user is working with piped Jira issues (the full payload). Answer from these Jira issues. This is not GitHub and not the local source repo." : "The user attached the current Jira Kanban board (visible cards only). Answer from these Jira issues. This is not GitHub and not the local source repo.",
+    `Board: ${scope}`
+  ];
+  if (view.search.trim())
+    lines.push(`Search: ${view.search.trim()}`);
+  if (Object.values(view.filter).some((values) => values.length)) {
+    lines.push(`Filter: ${JSON.stringify(view.filter)}`);
+  }
+  lines.push(`Sort: ${view.sort}`);
+  if (view.hide.length)
+    lines.push(`Hidden columns: ${view.hide.join(", ")}`);
+  lines.push("", "Columns:");
+  if (!view.columns.length) {
+    lines.push("(empty)");
+  } else {
+    for (const column of view.columns) {
+      lines.push(`## ${column.title}`);
+      if (!column.cards.length) {
+        lines.push("(no cards)");
+        continue;
+      }
+      for (const card of column.cards) {
+        lines.push(`- ${formatCard(card)}`);
+      }
+    }
+  }
+  if (view.epics.length) {
+    lines.push("", "Epics:");
+    for (const epic of view.epics) {
+      const status = epic.status ? ` (${epic.status})` : "";
+      lines.push(`- ${epic.key} ${epic.summary}${status}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function formatCard(card) {
+  const bits = [card.key, card.summary];
+  if (card.epic)
+    bits.push(`[epic ${card.epic}]`);
+  const extras = [card.priority, card.assignee, card.dueDate, card.labels?.join(", ")].filter((value) => Boolean(value));
+  if (extras.length)
+    bits.push(`(${extras.join(", ")})`);
+  return bits.join(" ");
+}
+
 // src/server/agent/config.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync } from "node:fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join as join2 } from "node:path";
+import { delimiter as delimiter2, dirname, join as join2 } from "node:path";
 var DEFAULT_CONFIG_PATH = join2(homedir(), ".config", "pipe-kan", "agent.json");
+var FALLBACK_MODELS = {
+  cursor: [
+    { id: "composer-2", name: "Composer 2" },
+    { id: "composer-2-fast", name: "Composer 2 Fast" },
+    { id: "claude-sonnet-4", name: "Claude Sonnet 4" },
+    { id: "gpt-4.1", name: "GPT-4.1" }
+  ],
+  devin: [
+    { id: "swe-1-6-slow", name: "SWE-1.6 (slow)", description: "Free slower tier" },
+    { id: "swe-1-6-fast", name: "SWE-1.6 Fast" },
+    { id: "swe-1-7", name: "SWE-1.7" },
+    { id: "swe", name: "SWE (latest)" },
+    { id: "adaptive", name: "Adaptive" },
+    { id: "sonnet", name: "Sonnet" },
+    { id: "opus", name: "Opus" },
+    { id: "gpt", name: "GPT" }
+  ]
+};
 var DEFAULT_CONFIG = {
-  defaultAgent: "cursor",
+  defaultAgent: "devin",
   defaultSkill: null,
   agents: {
     cursor: {
@@ -921,11 +1024,28 @@ var DEFAULT_CONFIG = {
     devin: {
       command: "devin",
       args: ["acp"],
-      model: "devin"
+      model: "swe-1-6-slow"
     }
   }
 };
-function loadAgentConfig(path = DEFAULT_CONFIG_PATH) {
+function agentConfigPath() {
+  return process.env.PIPE_KAN_AGENT_CONFIG ?? DEFAULT_CONFIG_PATH;
+}
+function commandOnPath(command, env = process.env) {
+  if (!command)
+    return false;
+  if (command.includes("/") || command.includes("\\"))
+    return existsSync2(command);
+  const pathVar = env.PATH ?? "";
+  for (const dir of pathVar.split(delimiter2)) {
+    if (!dir)
+      continue;
+    if (existsSync2(join2(dir, command)))
+      return true;
+  }
+  return false;
+}
+function loadAgentConfig(path = agentConfigPath()) {
   if (!existsSync2(path))
     return structuredClone(DEFAULT_CONFIG);
   try {
@@ -935,17 +1055,43 @@ function loadAgentConfig(path = DEFAULT_CONFIG_PATH) {
     return structuredClone(DEFAULT_CONFIG);
   }
 }
+function saveAgentConfig(patch, path = agentConfigPath()) {
+  const current = loadAgentConfig(path);
+  const next = {
+    defaultAgent: patch.defaultAgent ?? current.defaultAgent,
+    defaultSkill: patch.defaultSkill !== undefined ? patch.defaultSkill : current.defaultSkill,
+    agents: { ...current.agents }
+  };
+  if (patch.agents) {
+    for (const [id, config] of Object.entries(patch.agents)) {
+      next.agents[id] = { ...next.agents[id], ...config };
+    }
+  }
+  ensureAgentConfigDir(path);
+  writeFileSync(path, `${JSON.stringify(next, null, 2)}
+`);
+  return next;
+}
 function mergeConfig(raw) {
+  const agents = { ...DEFAULT_CONFIG.agents };
+  for (const [id, config] of Object.entries({ ...DEFAULT_CONFIG.agents, ...raw.agents })) {
+    agents[id] = { ...DEFAULT_CONFIG.agents[id], ...config };
+  }
   return {
     defaultAgent: raw.defaultAgent ?? DEFAULT_CONFIG.defaultAgent,
     defaultSkill: raw.defaultSkill ?? DEFAULT_CONFIG.defaultSkill,
-    agents: { ...DEFAULT_CONFIG.agents, ...raw.agents }
+    agents
   };
 }
+function ensureAgentConfigDir(path = agentConfigPath()) {
+  const dir = dirname(path);
+  if (!existsSync2(dir))
+    mkdirSync(dir, { recursive: true });
+}
 
 // src/server/agent/session.ts
 import { spawn as spawn2 } from "node:child_process";
-import { mkdtempSync } from "node:fs";
+import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join3 } from "node:path";
 import { Readable } from "node:stream";
@@ -10575,25 +10721,93 @@ var legacyClientNotificationMethods = new Set([
   CLIENT_METHODS.elicitation_complete
 ]);
 
-// src/server/agent/session.ts
-function createAcpBackend(id, label) {
-  return {
-    id,
-    label,
-    spawn(config) {
-      const session = new AcpSession(config);
-      return session.connect().then(() => session);
+// src/server/agent/models.ts
+function modelsFromConfigOptions(options) {
+  if (!options?.length)
+    return [];
+  const model = options.find((option) => option.category === "model" || option.id === "model");
+  if (!model || model.type !== "select")
+    return [];
+  return flattenSelectOptions(model.options);
+}
+function selectedModelFromConfigOptions(options) {
+  const model = options?.find((option) => option.category === "model" || option.id === "model");
+  if (!model || model.type !== "select")
+    return null;
+  return model.currentValue ?? null;
+}
+var MODEL_ALIASES = {
+  "swe-1-6": ["swe-1-6-slow"],
+  "swe-1.6": ["swe-1-6-slow"],
+  "swe-1.6-slow": ["swe-1-6-slow"],
+  "swe-1-6-slow": ["swe-1-6"]
+};
+function resolveRequestedModel(requested, live) {
+  if (!requested)
+    return null;
+  if (!live.length)
+    return requested;
+  if (live.some((model) => model.id === requested))
+    return requested;
+  for (const alias of MODEL_ALIASES[requested] ?? []) {
+    const hit = live.find((model) => model.id === alias);
+    if (hit)
+      return hit.id;
+  }
+  const lower = requested.toLowerCase();
+  return live.find((model) => model.name.toLowerCase() === lower)?.id ?? null;
+}
+function errorText(err) {
+  if (err instanceof Error) {
+    const extra = err.data;
+    return extra ? `${err.message} ${JSON.stringify(extra)}` : err.message;
+  }
+  return String(err);
+}
+function parseAvailableModelsFromError(err) {
+  const text = errorText(err);
+  const match = text.match(/Available models:\s*([^\n"}]+)/i);
+  if (!match)
+    return [];
+  return match[1].split(",").map((id) => id.trim()).filter(Boolean);
+}
+function flattenSelectOptions(options) {
+  if (!Array.isArray(options))
+    return [];
+  const models = [];
+  for (const item of options) {
+    if (!item || typeof item !== "object")
+      continue;
+    if ("group" in item && Array.isArray(item.options)) {
+      models.push(...flattenSelectOptions(item.options));
+      continue;
     }
-  };
+    if ("value" in item && "name" in item) {
+      const option = item;
+      models.push({
+        id: option.value,
+        name: option.name,
+        ...option.description ? { description: option.description } : {}
+      });
+    }
+  }
+  return models;
 }
 
+// src/server/agent/session.ts
+var CONNECT_TIMEOUT_MS = 15000;
+function createAcpSession(config) {
+  return new AcpSession(config);
+}
 class AcpSession {
   config;
   id;
   proc = null;
   activeSession = null;
+  agentCtx = null;
+  configOptions = [];
   eventsQueue = [];
-  eventResolvers = [];
+  listeners = new Set;
   pendingPermissionResolvers = new Map;
   closed = false;
   lifetime = null;
@@ -10603,16 +10817,28 @@ class AcpSession {
   toolCalls = new Map;
   shouldAutoApproveTool = null;
   executeTool = null;
+  stderr = "";
+  selectedModelId = null;
+  workspace = mkdtempSync(join3(tmpdir(), "pipe-kan-agent-"));
   constructor(config) {
     this.config = config;
     this.id = crypto.randomUUID();
+    this.selectedModelId = config.model ?? null;
+    this.ready.promise.catch(() => {
+      return;
+    });
   }
   async prompt(text, context) {
     if (!this.activeSession)
       throw new Error("ACP session not connected");
-    const blocks = (context ?? []).map(toContentBlock);
-    blocks.push({ type: "text", text });
-    await this.activeSession.prompt(blocks);
+    const resources = (context ?? []).filter((block) => block.type === "resource").map(toContentBlock);
+    const contextText = (context ?? []).filter((block) => block.type === "text").map((block) => block.text).filter(Boolean).join(`
+
+`);
+    const prompt = contextText ? `${contextText}
+
+${text}` : text;
+    await this.activeSession.prompt([...resources, { type: "text", text: prompt }]);
   }
   setToolParser(parser) {
     this.detectToolCall = parser;
@@ -10644,21 +10870,78 @@ ${resultText}`).catch(() => {
     entry.resolve(outcome);
     this.pendingPermissionResolvers.delete(requestId);
   }
+  models() {
+    const live = modelsFromConfigOptions(this.configOptions);
+    return live.length ? live : [];
+  }
+  selectedModel() {
+    return selectedModelFromConfigOptions(this.configOptions) ?? this.selectedModelId;
+  }
+  async setModel(id) {
+    const live = this.models();
+    let resolved = resolveRequestedModel(id, live);
+    if (!resolved && live.length)
+      return;
+    resolved = resolved ?? id;
+    this.selectedModelId = resolved;
+    this.config.model = resolved;
+    const option = this.configOptions.find((item) => item.category === "model" || item.id === "model");
+    if (!option || option.type !== "select" || !this.agentCtx || !this.activeSession)
+      return;
+    try {
+      const result = await this.agentCtx.request(methods.agent.session.setConfigOption, {
+        sessionId: this.activeSession.sessionId,
+        configId: option.id,
+        value: resolved
+      });
+      if (result.configOptions)
+        this.configOptions = result.configOptions;
+      this.selectedModelId = this.selectedModel();
+      this.push({ type: "config", models: this.models(), selectedModel: this.selectedModel() });
+    } catch (err) {
+      const available = parseAvailableModelsFromError(err).map((modelId) => ({ id: modelId, name: modelId }));
+      const retry = resolveRequestedModel(id, available) ?? resolveRequestedModel(resolved, available);
+      if (retry && retry !== resolved) {
+        await this.setModel(retry);
+        return;
+      }
+      this.selectedModelId = selectedModelFromConfigOptions(this.configOptions);
+      throw new Error(errorText(err));
+    }
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    if (this.eventsQueue.length) {
+      const queued = this.eventsQueue.splice(0);
+      for (const event of queued)
+        listener(event);
+    }
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
   cancel() {
     this.proc?.kill("SIGTERM");
   }
   async* [Symbol.asyncIterator]() {
-    while (!this.closed || this.eventsQueue.length) {
-      if (this.eventsQueue.length) {
-        yield this.eventsQueue.shift();
-      } else {
-        const { promise, resolve } = Promise.withResolvers();
-        this.eventResolvers.push(resolve);
-        const result = await promise;
-        if (result.done)
-          return;
-        yield result.value;
+    const queue = [];
+    let wake = null;
+    const unsub = this.subscribe((event) => {
+      queue.push(event);
+      wake?.();
+    });
+    try {
+      while (!this.closed || queue.length) {
+        if (!queue.length) {
+          await new Promise((resolve) => {
+            wake = resolve;
+          });
+        }
+        while (queue.length)
+          yield queue.shift();
       }
+    } finally {
+      unsub();
     }
   }
   events() {
@@ -10666,47 +10949,83 @@ ${resultText}`).catch(() => {
   }
   async close() {
     this.closed = true;
+    this.ready.reject(new Error("ACP session closed"));
     this.activeSession?.dispose();
     this.lifetime?.resolve();
     this.proc?.kill("SIGTERM");
     this.flushQueue();
     this.proc = null;
+    rmSync(this.workspace, { recursive: true, force: true });
   }
   async connect() {
-    const cwd = mkdtempSync(join3(tmpdir(), "pipe-kan-acp-"));
+    if (this.closed)
+      throw new Error("ACP session closed");
+    const cwd = this.workspace;
     const cmd = this.config.command;
     const args = this.config.args ?? [];
     this.proc = spawn2(cmd, args, {
-      cwd,
+      cwd: process.cwd(),
       env: { ...process.env, ...this.config.env ?? {} },
       stdio: ["pipe", "pipe", "pipe"]
     });
+    if (this.closed) {
+      this.proc.kill("SIGTERM");
+      this.proc = null;
+      throw new Error("ACP session closed");
+    }
     if (!this.proc.stdout || !this.proc.stdin) {
       throw new Error(`Failed to spawn ACP agent: ${cmd}`);
     }
+    this.proc.stderr?.on("data", (chunk) => {
+      this.stderr += chunk.toString("utf8");
+    });
     const stdout = Readable.toWeb(this.proc.stdout);
     const stream = ndJsonStream2(new WritableStream({
       write: (chunk) => this.writeStdin(chunk)
     }), stdout);
-    this.proc.on("error", (err) => this.push({ type: "error", message: err.message }));
-    this.proc.on("exit", () => {
+    this.proc.on("error", (err) => {
+      this.push({ type: "error", message: err.message });
+      this.ready.reject(err);
+    });
+    this.proc.on("exit", (code) => {
       this.push({ type: "disconnected" });
       this.closed = true;
       this.flushQueue();
+      if (code) {
+        this.ready.reject(new Error(`ACP agent exited (${code})${this.stderr.trim() ? `: ${this.stderr.trim()}` : ""}`));
+      }
     });
     const app = client({ name: "pipe-kan" });
     app.onRequest(methods.client.session.requestPermission, (ctx) => this.handlePermission(ctx.params));
     app.onRequest(methods.client.fs.readTextFile, () => Promise.reject(new Error("read_file not implemented")));
     this.lifetime = Promise.withResolvers();
     const connected = app.connectWith(stream, async (ctx) => {
+      this.agentCtx = ctx;
       this.activeSession = await ctx.buildSession(cwd).start();
+      this.configOptions = this.activeSession.newSessionResponse.configOptions ?? [];
+      try {
+        if (this.config.model)
+          await this.setModel(this.config.model);
+      } catch (err) {
+        this.push({ type: "error", message: `Could not set model ${this.config.model}: ${errorText(err)}` });
+      }
       this.ready.resolve();
       this.push({ type: "connected" });
+      this.push({ type: "config", models: this.models(), selectedModel: this.selectedModel() });
       this.readLoop();
       await this.lifetime.promise;
     });
     connected.catch(() => {});
-    await this.ready.promise;
+    const timeout = setTimeout(() => {
+      this.ready.reject(new Error(`Timed out starting ${cmd}${this.stderr.trim() ? `:
+${lastLines(this.stderr)}` : ""}`));
+      this.close();
+    }, CONNECT_TIMEOUT_MS);
+    try {
+      await this.ready.promise;
+    } finally {
+      clearTimeout(timeout);
+    }
   }
   async readLoop() {
     if (!this.activeSession)
@@ -10743,9 +11062,12 @@ ${resultText}`).catch(() => {
       this.push({
         type: "tool_call",
         requestId: update.toolCallId ?? crypto.randomUUID(),
-        name: update.name ?? "unknown",
+        name: update.title ?? "unknown",
         args: {}
       });
+    } else if (update.sessionUpdate === "config_option_update") {
+      this.configOptions = update.configOptions ?? this.configOptions;
+      this.push({ type: "config", models: this.models(), selectedModel: this.selectedModel() });
     }
   }
   handlePermission(params) {
@@ -10755,7 +11077,7 @@ ${resultText}`).catch(() => {
     this.push({
       type: "request_permission",
       requestId,
-      kind: params.toolCall.name ?? "unknown",
+      kind: params.toolCall.title ?? "unknown",
       description: params.toolCall.content ? JSON.stringify(params.toolCall.content) : ""
     });
     return promise.then((outcome) => ({ outcome }));
@@ -10771,19 +11093,23 @@ ${resultText}`).catch(() => {
     }
   }
   push(event) {
-    const resolver = this.eventResolvers.shift();
-    if (resolver) {
-      resolver({ value: event, done: false });
-    } else {
+    if (this.listeners.size === 0) {
       this.eventsQueue.push(event);
+      return;
     }
+    for (const listener of this.listeners)
+      listener(event);
   }
   flushQueue() {
-    while (this.eventResolvers.length) {
-      this.eventResolvers.shift()({ value: undefined, done: true });
-    }
+    this.eventsQueue.length = 0;
+    for (const listener of this.listeners)
+      listener({ type: "disconnected" });
   }
 }
+function lastLines(text, n = 12) {
+  return text.trim().split(/\n/).slice(-n).join(`
+`);
+}
 function toContentBlock(ctx) {
   if (ctx.type === "resource") {
     return {
@@ -11007,7 +11333,9 @@ var EXECUTORS = {
     return { ok: true, value: { __ui_action: "set_filter", filter } };
   }
 };
-var SYSTEM_TEXT = `You can call tools by emitting a single JSON code block matching this schema:
+var SYSTEM_TEXT = `Your working context is the attached Jira issues from the pipe. Answer from that payload. Do not search GitHub, git history, or local source files unless the user explicitly asks about the pipe-kan app itself.
+
+You can call tools by emitting a single JSON code block matching this schema:
 
 {"tool": "<name>", "args": {...}}
 
@@ -11062,6 +11390,8 @@ function createToolRegistry() {
 
 // src/server/agent/api.ts
 var sessions = new Map;
+var connecting = null;
+var startEpoch = 0;
 var skills2 = createSkillRegistry();
 var tools = createToolRegistry();
 function json2(res, status, body) {
@@ -11080,21 +11410,45 @@ function readBody2(req) {
 function pathOf2(req) {
   return new URL(req.url ?? "/", "http://127.0.0.1");
 }
+function publicConfig(cfg) {
+  return {
+    defaultAgent: cfg.defaultAgent,
+    defaultSkill: cfg.defaultSkill ?? null,
+    agents: Object.entries(cfg.agents).map(([id, c]) => ({
+      id,
+      command: [c.command, ...c.args ?? []].join(" "),
+      model: c.model ?? null,
+      options: c.options,
+      available: commandOnPath(c.command),
+      models: FALLBACK_MODELS[id] ?? []
+    }))
+  };
+}
+function attachTools(session, app) {
+  session.setToolParser((text) => {
+    const call = tools.parse(text);
+    return call ? { requestId: call.requestId, name: call.name, args: call.args } : undefined;
+  });
+  session.setToolExecutor((name) => !tools.isMutating(name), async (call) => {
+    const result = await tools.execute(call.name, call.args, app);
+    return {
+      text: result.ok ? `Result: ${JSON.stringify(result.value)}` : `Error: ${result.error}`,
+      result: result.ok ? result.value : undefined
+    };
+  });
+}
 function handleAgentApi(req, res, app) {
   const url = pathOf2(req);
   const method = (req.method ?? "GET").toUpperCase();
   if (url.pathname === "/api/agent/config" && method === "GET") {
-    const cfg = loadAgentConfig();
-    json2(res, 200, {
-      defaultAgent: cfg.defaultAgent,
-      defaultSkill: cfg.defaultSkill,
-      agents: Object.entries(cfg.agents).map(([id, c]) => ({
-        id,
-        command: [c.command, ...c.args ?? []].join(" "),
-        model: c.model,
-        options: c.options
-      }))
-    });
+    json2(res, 200, publicConfig(loadAgentConfig()));
+    return true;
+  }
+  if (url.pathname === "/api/agent/config" && method === "POST") {
+    readBody2(req).then((text) => {
+      const body = text ? JSON.parse(text) : {};
+      json2(res, 200, publicConfig(saveAgentConfig(body)));
+    }).catch((err) => json2(res, 500, { error: String(err) }));
     return true;
   }
   if (url.pathname === "/api/agent/skills" && method === "GET") {
@@ -11102,27 +11456,67 @@ function handleAgentApi(req, res, app) {
     return true;
   }
   if (url.pathname === "/api/agent/session" && method === "POST") {
-    const cfg = loadAgentConfig();
-    const backendConfig = cfg.agents[cfg.defaultAgent];
-    if (!backendConfig) {
-      json2(res, 500, { error: `No agent config for ${cfg.defaultAgent}` });
-      return true;
-    }
-    const backend = createAcpBackend(cfg.defaultAgent, cfg.defaultAgent);
-    backend.spawn(backendConfig).then((session) => {
-      session.setToolParser((text) => {
-        const call = tools.parse(text);
-        return call ? { requestId: call.requestId, name: call.name, args: call.args } : undefined;
-      });
-      session.setToolExecutor((name) => !tools.isMutating(name), async (call) => {
-        const result = await tools.execute(call.name, call.args, app);
-        return {
-          text: result.ok ? `Result: ${JSON.stringify(result.value)}` : `Error: ${result.error}`,
-          result: result.ok ? result.value : undefined
-        };
+    readBody2(req).then(async (text) => {
+      const body = text ? JSON.parse(text) : {};
+      const cfg = loadAgentConfig();
+      const agentId = body.agentId || cfg.defaultAgent;
+      const backendConfig = cfg.agents[agentId];
+      if (!backendConfig) {
+        json2(res, 500, { error: `No agent config for ${agentId}` });
+        return;
+      }
+      if (!commandOnPath(backendConfig.command)) {
+        json2(res, 500, { error: `${backendConfig.command} is not on PATH` });
+        return;
+      }
+      const session = createAcpSession({
+        ...backendConfig,
+        model: body.model || backendConfig.model
       });
-      sessions.set(session.id, session);
-      json2(res, 200, { sessionId: session.id });
+      const epoch = ++startEpoch;
+      const previous = connecting;
+      const old = [...sessions.values()];
+      connecting = session;
+      sessions.clear();
+      await Promise.all([previous, ...old].filter((item) => item != null).map((item) => item.close().catch(() => {
+        return;
+      })));
+      try {
+        await session.connect();
+        if (epoch !== startEpoch) {
+          await session.close().catch(() => {
+            return;
+          });
+          json2(res, 500, { error: "Session replaced" });
+          return;
+        }
+        connecting = null;
+        attachTools(session, app);
+        sessions.set(session.id, session);
+        json2(res, 200, {
+          sessionId: session.id,
+          agentId,
+          models: session.models().length ? session.models() : FALLBACK_MODELS[agentId] ?? [],
+          selectedModel: session.selectedModel()
+        });
+      } catch (err) {
+        if (connecting === session)
+          connecting = null;
+        throw err;
+      }
+    }).catch((err) => json2(res, 500, { error: String(err) }));
+    return true;
+  }
+  if (url.pathname === "/api/agent/model" && method === "POST") {
+    readBody2(req).then(async (text) => {
+      const body = JSON.parse(text);
+      const session = sessions.get(body.sessionId ?? "");
+      if (!session) {
+        json2(res, 404, { error: "Session not found" });
+        return;
+      }
+      await session.setModel(String(body.model ?? ""));
+      json2(res, 200, { ok: true, models: session.models(), selectedModel: session.selectedModel() });
     }).catch((err) => json2(res, 500, { error: String(err) }));
     return true;
   }
@@ -11134,7 +11528,7 @@ function handleAgentApi(req, res, app) {
         json2(res, 404, { error: "Session not found" });
         return;
       }
-      const context = [tools.systemBlock(), ...body.context ?? []];
+      const context = [tools.systemBlock(), ...withPipedBoardContext(app.board(), body.context ?? [])];
       if (body.skillId) {
         const skill = skills2.load(body.skillId);
         if (skill)
@@ -11206,21 +11600,13 @@ function handleAgentApi(req, res, app) {
 
 `);
     };
-    (async () => {
-      for await (const event of session.events()) {
-        writeEvent(event);
-        if (event.type === "disconnected") {
-          break;
-        }
-      }
-      if (!res.writableEnded)
-        res.end();
-    })().catch((err) => {
-      writeEvent({ type: "error", message: String(err) });
-      if (!res.writableEnded)
+    const unsubscribe = session.subscribe((event) => {
+      writeEvent(event);
+      if (event.type === "disconnected" && !res.writableEnded)
         res.end();
     });
     req.on("close", () => {
+      unsubscribe();
       if (!res.writableEnded)
         res.end();
     });
@@ -11335,12 +11721,12 @@ function handleRequest(req, res, ctx) {
 }
 
 // src/jira-config.ts
-import { mkdirSync as mkdirSync2, writeFileSync } from "node:fs";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { join as join6 } from "node:path";
 function writeJiraConfig(dir, server) {
   mkdirSync2(dir, { recursive: true });
   const path = join6(dir, "jira.config.yml");
-  writeFileSync(path, [
+  writeFileSync2(path, [
     "installation: Cloud",
     `server: ${server}`,
     `login: ${ME.emailAddress}`,