pipe-kan 0.18.0 → 0.19.0

package/dist/pipe-kan.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/server.ts
-import { readFileSync as readFileSync3, writeSync } from "node:fs";
+import { readFileSync as readFileSync4, writeSync } from "node:fs";
 import { createServer } from "node:http";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // src/board.ts
 function formatDueDate(value) {
@@ -904,25 +904,148 @@ 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, readFileSync } from "node:fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { 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: {
       command: "cursor-agent",
-      args: ["acp"]
+      args: ["acp"],
+      model: "claude-sonnet-4"
     },
     devin: {
       command: "devin",
-      args: ["acp"]
+      args: ["acp"],
+      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 {
@@ -932,16 +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,
-    agents: { ...DEFAULT_CONFIG.agents, ...raw.agents }
+    defaultSkill: raw.defaultSkill ?? DEFAULT_CONFIG.defaultSkill,
+    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";
@@ -10571,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;
@@ -10597,30 +10815,51 @@ class AcpSession {
   textBuffer = "";
   detectToolCall = null;
   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;
   }
+  setToolExecutor(shouldAutoApprove, execute) {
+    this.shouldAutoApproveTool = shouldAutoApprove;
+    this.executeTool = execute;
+  }
   pendingToolCalls() {
     return this.toolCalls;
   }
-  resolveToolCall(requestId, resultText) {
+  resolveToolCall(requestId, resultText, rawResult) {
     const call = this.toolCalls.get(requestId);
     if (!call)
       return;
     this.toolCalls.delete(requestId);
+    this.push({ type: "tool_result", requestId, name: call.name, result: rawResult ?? resultText });
     this.prompt(`Tool result for ${call.name}(${JSON.stringify(call.args)}):
-${resultText}`);
+${resultText}`).catch(() => {
+      return;
+    });
   }
   approve(requestId, decision) {
     const entry = this.pendingPermissionResolvers.get(requestId);
@@ -10631,21 +10870,78 @@ ${resultText}`);
     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() {
@@ -10653,47 +10949,83 @@ ${resultText}`);
   }
   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)
@@ -10718,7 +11050,11 @@ ${resultText}`);
       const tool = this.detectToolCall?.(this.textBuffer);
       if (tool) {
         this.toolCalls.set(tool.requestId, tool);
-        this.push({ type: "tool_call", ...tool });
+        if (this.shouldAutoApproveTool?.(tool.name)) {
+          this.executeTool?.(tool).then(({ text, result }) => this.resolveToolCall(tool.requestId, text, result));
+        } else {
+          this.push({ type: "tool_call", ...tool });
+        }
         return;
       }
       this.push({ type: "agent_message_chunk", text: update.content.text });
@@ -10726,9 +11062,12 @@ ${resultText}`);
       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) {
@@ -10738,7 +11077,7 @@ ${resultText}`);
     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 }));
@@ -10754,19 +11093,23 @@ ${resultText}`);
     }
   }
   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 {
@@ -10862,6 +11205,8 @@ function parseFrontMatter(text) {
 }
 
 // src/server/agent/tools.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { join as join5 } from "node:path";
 var TOOLS = [
   {
     name: "board_state",
@@ -10875,6 +11220,18 @@ var TOOLS = [
     parameters: { key: { type: "string", description: "Issue key, e.g. DEMO-123" } },
     mutates: false
   },
+  {
+    name: "run_skill",
+    description: "Load a skill by id and return its instructions as context.",
+    parameters: { skillId: { type: "string", description: "Skill id, e.g. triage" } },
+    mutates: false
+  },
+  {
+    name: "read_repo_file",
+    description: "Read a file under the repo root as plain text.",
+    parameters: { path: { type: "string", description: "Relative repo path" } },
+    mutates: false
+  },
   {
     name: "move_card",
     description: "Move a card to a new status. Requires user approval because it changes Jira via jira-cli.",
@@ -10903,6 +11260,7 @@ var TOOLS = [
     mutates: true
   }
 ];
+var skills = createSkillRegistry();
 var EXECUTORS = {
   board_state(_, app) {
     const board = app.board();
@@ -10921,6 +11279,32 @@ var EXECUTORS = {
       return { ok: false, error: result.error };
     return { ok: true, value: { url: result.url, fields: result.fields } };
   },
+  run_skill(args) {
+    const skillId = String(args.skillId ?? "");
+    if (!skillId)
+      return { ok: false, error: "Missing skillId" };
+    const skill = skills.load(skillId);
+    if (!skill)
+      return { ok: false, error: `Skill not found: ${skillId}` };
+    const block = skillContextBlock(skill);
+    if (block.type !== "resource")
+      return { ok: false, error: "Skill produced unexpected block" };
+    return { ok: true, value: block.resource };
+  },
+  read_repo_file(args) {
+    const relPath = String(args.path ?? "");
+    if (!relPath)
+      return { ok: false, error: "Missing path" };
+    if (relPath.includes(".."))
+      return { ok: false, error: "Path traversal not allowed" };
+    const repoRoot = process.cwd();
+    try {
+      const text = readFileSync3(join5(repoRoot, relPath), "utf8");
+      return { ok: true, value: { path: relPath, text } };
+    } catch (err) {
+      return { ok: false, error: String(err) };
+    }
+  },
   async move_card(args, app) {
     const key = String(args.key ?? "");
     const status = String(args.status ?? "");
@@ -10940,16 +11324,18 @@ var EXECUTORS = {
     const name = String(args.name ?? "");
     if (!name)
       return { ok: false, error: "Missing preset name" };
-    return { ok: true, value: `Preset '${name}' would be applied by the UI when tool execution is wired there.` };
+    return { ok: true, value: { __ui_action: "apply_preset", preset: name } };
   },
   set_filter(args) {
     const filter = args.filter;
     if (!filter || typeof filter !== "object")
       return { ok: false, error: "Missing filter object" };
-    return { ok: true, value: `Filter set to ${JSON.stringify(filter)}. UI should apply this filter.` };
+    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": {...}}
 
@@ -10986,6 +11372,9 @@ function createToolRegistry() {
         return;
       }
     },
+    isMutating(name) {
+      return TOOLS.find((t) => t.name === name)?.mutates ?? true;
+    },
     async execute(name, args, app) {
       const executor = EXECUTORS[name];
       if (!executor)
@@ -11001,7 +11390,9 @@ function createToolRegistry() {
 
 // src/server/agent/api.ts
 var sessions = new Map;
-var skills = createSkillRegistry();
+var connecting = null;
+var startEpoch = 0;
+var skills2 = createSkillRegistry();
 var tools = createToolRegistry();
 function json2(res, status, body) {
   res.statusCode = status;
@@ -11019,39 +11410,113 @@ 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,
-      agents: Object.entries(cfg.agents).map(([id, c]) => ({
-        id,
-        command: [c.command, ...c.args ?? []].join(" ")
-      }))
-    });
+    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") {
-    json2(res, 200, skills.list().map((s) => ({ id: s.id, name: s.name, description: s.description })));
+    json2(res, 200, skills2.list().map((s) => ({ id: s.id, name: s.name, description: s.description })));
     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;
+    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;
   }
@@ -11063,9 +11528,9 @@ 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 = skills.load(body.skillId);
+        const skill = skills2.load(body.skillId);
         if (skill)
           context.push(skillContextBlock(skill));
       }
@@ -11105,7 +11570,7 @@ function handleAgentApi(req, res, app) {
         } else {
           const result = await tools.execute(toolCall.name, toolCall.args, app);
           const resultText = result.ok ? `Result: ${JSON.stringify(result.value)}` : `Error: ${result.error}`;
-          session.resolveToolCall(requestId, resultText);
+          session.resolveToolCall(requestId, resultText, result.ok ? result.value : undefined);
         }
         json2(res, 200, { ok: true });
         return;
@@ -11135,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();
     });
@@ -11264,12 +11721,12 @@ function handleRequest(req, res, ctx) {
 }
 
 // src/jira-config.ts
-import { mkdirSync, writeFileSync } from "node:fs";
-import { join as join5 } from "node:path";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join6 } from "node:path";
 function writeJiraConfig(dir, server) {
-  mkdirSync(dir, { recursive: true });
-  const path = join5(dir, "jira.config.yml");
-  writeFileSync(path, [
+  mkdirSync2(dir, { recursive: true });
+  const path = join6(dir, "jira.config.yml");
+  writeFileSync2(path, [
     "installation: Cloud",
     `server: ${server}`,
     `login: ${ME.emailAddress}`,
@@ -11324,7 +11781,7 @@ function stdinStat() {
 
 // src/ui.ts
 import { createReadStream, existsSync as existsSync4, statSync } from "node:fs";
-import { dirname, extname, join as join6, resolve as resolve2, sep } from "node:path";
+import { dirname as dirname2, extname, join as join7, resolve as resolve2, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 var types = {
   ".css": "text/css; charset=utf-8",
@@ -11338,10 +11795,10 @@ var types = {
   ".woff2": "font/woff2"
 };
 function packageRoot(from = import.meta.url) {
-  return resolve2(dirname(fileURLToPath(from)), "..");
+  return resolve2(dirname2(fileURLToPath(from)), "..");
 }
 function uiDir(root) {
-  return join6(root, "dist", "ui");
+  return join7(root, "dist", "ui");
 }
 function inside(root, file) {
   const base = resolve2(root);
@@ -11350,7 +11807,7 @@ function inside(root, file) {
 }
 function sendUi(root, req, res) {
   const ui = uiDir(root);
-  const index = join6(ui, "index.html");
+  const index = join7(ui, "index.html");
   if (!existsSync4(index))
     return false;
   const path = new URL(req.url ?? "/", "http://127.0.0.1").pathname;
@@ -11371,7 +11828,7 @@ function announce(line) {
 }
 async function runServer(opts) {
   const piped = await readPipe();
-  const raw = piped ?? JSON.parse(readFileSync3(join7(opts.root, "fixtures/issues.json"), "utf8"));
+  const raw = piped ?? JSON.parse(readFileSync4(join8(opts.root, "fixtures/issues.json"), "utf8"));
   const { app, store, kind } = await createBoardApp({
     raw,
     piped: Boolean(piped)
@@ -11391,7 +11848,7 @@ async function runServer(opts) {
   const { host, port } = resolveListen();
   await bindListen(server, host, port);
   const origin = `http://127.0.0.1:${port}`;
-  const fakeConfig = writeJiraConfig(join7(tmpdir2(), "pipe-kan"), origin);
+  const fakeConfig = writeJiraConfig(join8(tmpdir2(), "pipe-kan"), origin);
   announce(`pipe-kan http://${host}:${port}`);
   announce(`cli ${kind === "jira" ? resolveJiraBin() : "store"}`);
   announce(`Fake Jira ${origin}/rest/api/2/search`);