@akanjs/cli 3.0.0-beta.16 → 3.0.0-beta.18

package/{index-5405kc0x.js → index-jwexzh42.js}

@@ -1,7 +1,10 @@
 // @bun
 import {
-  SubagentPool2
-} from "./index-jgrnpt6y.js";
+  SubagentPool2,
+  akanCodePaths2,
+  McpServerConfig,
+  McpSignIn
+} from "./index-jd01kj5r.js";
 import {
   stripAnsi
 } from "./index-7md2g9vw.js";
@@ -9,7 +12,7 @@ import {
   akanCodeModel2,
   akanCodeModelSupportsImages2,
   akanCodeModelWarnings2
-} from "./index-wfwknnje.js";
+} from "./index-jwrpsrg3.js";
 
 // pkgs/@akanjs/devkit/codeAgent/agent/CodeAgent.ts
 import {
@@ -511,7 +514,7 @@ class AkanToolPack2 {
     return { name: "akan-tools", factory: async (pi) => await this.#register(pi) };
   }
   async names() {
-    const { ContextRunner } = await import("./context.runner-bys6ykcp.js");
+    const { ContextRunner } = await import("./context.runner-z0rrcz7b.js");
     return [
       ...new ContextRunner().listMcpTools(this.#options.mode).map((tool) => tool.name),
       AkanToolPack2.verifyToolName
@@ -519,7 +522,7 @@ class AkanToolPack2 {
   }
   static verifyToolName = "akan_verify";
   async#register(pi) {
-    const { ContextRunner } = await import("./context.runner-bys6ykcp.js");
+    const { ContextRunner } = await import("./context.runner-z0rrcz7b.js");
     const runner = new ContextRunner;
     const guidelineNames = await AkanToolPack2.#guidelineNames();
     for (const tool of runner.listMcpTools(this.#options.mode, { guidelineNames })) {
@@ -561,7 +564,7 @@ class AkanToolPack2 {
   }
   static async#guidelineNames() {
     try {
-      const { Prompter } = await import("./prompter-9mn3kp36.js");
+      const { Prompter } = await import("./prompter-1f8d9pcc.js");
       return await Prompter.listGuidelines();
     } catch {
       return [];
@@ -574,9 +577,78 @@ class AkanToolPack2 {
   }
 }
 
-// pkgs/@akanjs/devkit/codeAgent/tools/MailToolPack.ts
+// pkgs/@akanjs/devkit/codeAgent/tools/AskToolPack.ts
 import { Type as Type2 } from "typebox";
 
+class AskToolPack {
+  static toolName = "ask_user";
+  static maxQuestions = 4;
+  #options;
+  constructor(options) {
+    this.#options = options;
+  }
+  names() {
+    return this.#options.profile.ui.canPrompt ? [AskToolPack.toolName] : [];
+  }
+  extension() {
+    if (!this.#options.profile.ui.canPrompt)
+      return;
+    return { name: "akan-ask", factory: (pi) => this.#register(pi) };
+  }
+  #register(pi) {
+    pi.registerTool({
+      name: AskToolPack.toolName,
+      label: "Ask",
+      description: "Ask the user to decide something you cannot decide from the code or the request. Use it when two readings of the task would lead to materially different work, not for choices with an obvious default \u2014 and never to ask permission for work you were already asked to do. Offer concrete options whenever you can name them; mark one recommended when you have a view.",
+      promptSnippet: "ask_user: put a decision the user owns back to them, with options",
+      parameters: Type2.Object({
+        questions: Type2.Array(Type2.Object({
+          question: Type2.String({ description: "The whole question, as one sentence ending in a question mark." }),
+          header: Type2.Optional(Type2.String({ description: "Two or three words naming what is being chosen, e.g. 'Auth method'." })),
+          options: Type2.Optional(Type2.Array(Type2.Object({
+            label: Type2.String({ description: "The choice, in one to five words." }),
+            detail: Type2.Optional(Type2.String({ description: "What picking it means, or the trade-off it carries." })),
+            recommended: Type2.Optional(Type2.Boolean({ description: "Mark at most one. It is offered first and labelled as such." }))
+          }), { description: "Two to four distinct choices. Leave it out to ask for an answer in prose." })),
+          multiSelect: Type2.Optional(Type2.Boolean({ description: "Several options may be chosen together, rather than exactly one." })),
+          freeText: Type2.Optional(Type2.Boolean({
+            description: "Offer a further choice that lets the user type an answer of their own. Default true."
+          }))
+        }), { description: `One to ${AskToolPack.maxQuestions} questions, asked in order.` })
+      }),
+      execute: async (_id, params) => {
+        const questions = (params.questions ?? []).slice(0, AskToolPack.maxQuestions);
+        if (!questions.length)
+          return { content: [{ type: "text", text: "No question was asked." }], details: undefined, isError: true };
+        const answers = [];
+        for (const entry of questions) {
+          const options = (entry.options ?? []).map((option, at) => ({
+            key: `${at}`,
+            label: option.label,
+            ...option.detail ? { detail: option.detail } : {},
+            ...option.recommended ? { recommended: true } : {}
+          }));
+          const answer = await this.#options.ask({
+            prompt: entry.header ? `${entry.header} \u2014 ${entry.question}` : entry.question,
+            kind: options.length ? "select" : "text",
+            ...options.length ? { options } : {},
+            ...entry.multiSelect ? { multiSelect: true } : {},
+            freeText: entry.freeText ?? true
+          });
+          answers.push(`${entry.question}
+\u2192 ${answer ?? "(skipped \u2014 decide this yourself and say what you chose)"}`);
+        }
+        return { content: [{ type: "text", text: answers.join(`
+
+`) }], details: undefined };
+      }
+    });
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/tools/MailToolPack.ts
+import { Type as Type3 } from "typebox";
+
 class MailToolPack2 {
   static toolNames = ["list_peers", "send_peer_message"];
   #options;
@@ -597,7 +669,7 @@ class MailToolPack2 {
       label: "List peer sessions",
       description: "List the other akan code sessions running in this workspace right now, with their name and working directory. Call it before send_peer_message so you name a session that is actually there.",
       promptSnippet: "list_peers: the other akan code sessions running here",
-      parameters: Type2.Object({}),
+      parameters: Type3.Object({}),
       execute: async () => ({
         content: [{ type: "text", text: MailToolPack2.#render(this.#options.mailbox()?.peers() ?? []) }],
         details: undefined
@@ -608,9 +680,9 @@ class MailToolPack2 {
       label: "Message a peer session",
       description: "Hand a message to another akan code session in this workspace. It arrives there as a prompt, so it costs that session a turn \u2014 use it to hand over a piece of work or to warn it about a change you made, not to chat. Say what you want done and what you already did.",
       promptSnippet: "send_peer_message: hand work to another akan code session",
-      parameters: Type2.Object({
-        to: Type2.String({ description: "The peer's name, or the front of its id, from list_peers." }),
-        message: Type2.String({ description: "What that session should know or do." })
+      parameters: Type3.Object({
+        to: Type3.String({ description: "The peer's name, or the front of its id, from list_peers." }),
+        message: Type3.String({ description: "What that session should know or do." })
       }),
       execute: async (_id, params) => {
         const mailbox = this.#options.mailbox();
@@ -639,43 +711,36 @@ class MailToolPack2 {
 }
 
 // pkgs/@akanjs/devkit/codeAgent/tools/McpToolPack.ts
-import { existsSync as existsSync5, readFileSync } from "fs";
-import { codeAgentClip, codeAgentOutputChars } from "akanjs/common";
-import { Type as Type3 } from "typebox";
-
-// pkgs/@akanjs/devkit/codeAgent/agent/akanCodePaths.ts
-import { existsSync as existsSync4 } from "fs";
-import { homedir as homedir2 } from "os";
-import path4 from "path";
-var builtinSkillsDir = () => {
-  const candidates = [path4.join(import.meta.dir, "skills"), path4.join(import.meta.dir, "..", "skills")];
-  return candidates.find((candidate) => existsSync4(candidate));
-};
-var akanCodePaths2 = {
-  workspaceDir: (workspaceRoot) => path4.join(workspaceRoot, ".akan", "code"),
-  sessionsDir: (workspaceRoot) => path4.join(workspaceRoot, ".akan", "code", "sessions"),
-  extensionsDir: (workspaceRoot) => path4.join(workspaceRoot, ".akan", "code", "extensions"),
-  skillsDir: (workspaceRoot) => path4.join(workspaceRoot, ".akan", "code", "skills"),
-  mailDir: (workspaceRoot) => path4.join(workspaceRoot, ".akan", "code", "mail"),
-  builtinSkillsDir,
-  mcpFile: (workspaceRoot) => path4.join(workspaceRoot, ".akan", "code", "mcp.json"),
-  globalDir: () => path4.join(homedir2(), ".akan", "code"),
-  authFile: () => path4.join(homedir2(), ".akan", "code", "auth.json"),
-  modelsFile: () => path4.join(homedir2(), ".akan", "code", "models.json")
-};
+import {
+  codeAgentClip,
+  codeAgentOutputChars
+} from "akanjs/common";
+import { Type as Type4 } from "typebox";
 
 // pkgs/@akanjs/devkit/codeAgent/tools/McpClient.ts
 var protocolVersion = "2025-06-18";
 
+class McpUnauthorized2 extends Error {
+  challenge;
+  constructor(name, challenge) {
+    super(`MCP server "${name}" requires authentication`);
+    this.name = "McpUnauthorized";
+    this.challenge = challenge;
+  }
+}
+
 class McpClient2 {
+  static maxToolPages = 50;
   ref;
   #proc;
   #nextId = 0;
   #buffer = "";
   #pending = new Map;
   #sessionId;
-  constructor(ref) {
+  #token;
+  constructor(ref, token) {
     this.ref = ref;
+    this.#token = token;
   }
   async connect() {
     if (this.ref.transport === "stdio")
@@ -691,10 +756,19 @@ class McpClient2 {
     return this;
   }
   async listTools() {
-    const response = await this.#call("tools/list", {});
-    if (response.error)
-      throw new Error(response.error.message);
-    return response.result?.tools ?? [];
+    const tools = [];
+    let cursor;
+    for (let page = 0;page < McpClient2.maxToolPages; page += 1) {
+      const response = await this.#call("tools/list", cursor ? { cursor } : {});
+      if (response.error)
+        throw new Error(response.error.message);
+      tools.push(...response.result?.tools ?? []);
+      const next = response.result?.nextCursor;
+      if (!next || next === cursor)
+        return tools;
+      cursor = next;
+    }
+    return tools;
   }
   async callTool(name, args) {
     const response = await this.#call("tools/call", { name, arguments: args });
@@ -778,11 +852,16 @@ class McpClient2 {
       headers: {
         "content-type": "application/json",
         accept: "application/json, text/event-stream",
+        "mcp-protocol-version": protocolVersion,
+        ...this.ref.headers,
+        ...this.#token ? { authorization: `Bearer ${this.#token}` } : {},
         ...this.#sessionId ? { "mcp-session-id": this.#sessionId } : {}
       },
       body: JSON.stringify(body),
       signal: AbortSignal.timeout(30000)
     });
+    if (response.status === 401)
+      throw new McpUnauthorized2(this.ref.name, response.headers.get("www-authenticate") ?? "");
     this.#sessionId = response.headers.get("mcp-session-id") ?? this.#sessionId;
     const text = await response.text();
     if (!text.trim())
@@ -804,29 +883,44 @@ class McpClient2 {
 
 // pkgs/@akanjs/devkit/codeAgent/tools/McpToolPack.ts
 class McpToolPack2 {
-  #options;
   #clients = [];
-  constructor(options) {
-    this.#options = options;
-  }
+  #status = [];
+  constructor() {}
   static async connect(options) {
     const refs = McpToolPack2.#refs(options);
     if (!refs.length)
       return;
-    const pack = new McpToolPack2(options);
+    const pack = new McpToolPack2;
     for (const ref of refs) {
+      const base = { name: ref.name, transport: ref.transport, target: McpServerConfig.targetOf(ref) };
+      const token = ref.transport === "http" ? await McpSignIn.token(ref, options.onNotice) : undefined;
       try {
-        const client = await new McpClient2(ref).connect();
-        pack.#clients.push({ client, tools: await client.listTools() });
+        const client = await new McpClient2(ref, token).connect();
+        const tools = await client.listTools();
+        pack.#clients.push({ client, tools });
+        pack.#status.push({
+          ...base,
+          tools: tools.map((tool) => McpToolPack2.#nameOf(ref.name, tool.name)),
+          auth: token ? "authorized" : "none"
+        });
       } catch (error) {
+        if (error instanceof McpUnauthorized2) {
+          options.onNotice?.(`MCP server "${ref.name}" needs signing in \u2014 /mcp login ${ref.name}`);
+          pack.#status.push({ ...base, tools: [], auth: "required" });
+          continue;
+        }
         options.onNotice?.(`MCP server "${ref.name}" is unavailable: ${String(error)}`);
+        pack.#status.push({ ...base, tools: [], error: String(error) });
       }
     }
-    return pack.#clients.length ? pack : undefined;
+    return pack;
   }
   get toolNames() {
     return this.#clients.flatMap(({ client, tools }) => tools.map((tool) => McpToolPack2.#nameOf(client.ref.name, tool.name)));
   }
+  get status() {
+    return this.#status;
+  }
   extension() {
     return { name: "akan-mcp", factory: (pi) => this.#register(pi) };
   }
@@ -844,7 +938,7 @@ class McpToolPack2 {
           label: `${client.ref.name}: ${tool.name}`,
           description,
           promptSnippet: `${name}: ${description.split(".")[0] ?? description}`,
-          parameters: Type3.Unsafe(tool.inputSchema),
+          parameters: Type4.Unsafe(tool.inputSchema),
           execute: async (_id, params) => {
             const result = await client.callTool(tool.name, params ?? {});
             return {
@@ -863,36 +957,14 @@ class McpToolPack2 {
     if (options.profile.tools.mcp === "off")
       return [];
     const declared = Array.isArray(options.profile.tools.mcp) ? options.profile.tools.mcp : [];
-    return [...McpToolPack2.#fromFile(options.workspaceRoot), ...declared];
-  }
-  static #fromFile(workspaceRoot) {
-    const file = akanCodePaths2.mcpFile(workspaceRoot);
-    if (!existsSync5(file))
-      return [];
-    try {
-      const parsed = JSON.parse(readFileSync(file, "utf8"));
-      const entries = Object.entries(parsed.mcpServers ?? parsed.servers ?? {});
-      return entries.filter(([, entry]) => !entry.disabled).map(([name, entry]) => {
-        const transport = entry.url ? "http" : "stdio";
-        return {
-          name,
-          transport,
-          ...entry.command ? { command: entry.command } : {},
-          ...entry.args ? { args: entry.args } : {},
-          ...entry.url ? { url: entry.url } : {},
-          ...entry.env ? { env: entry.env } : {}
-        };
-      });
-    } catch {
-      return [];
-    }
+    return [...McpServerConfig.read(options.workspaceRoot), ...declared];
   }
 }
 
 // pkgs/@akanjs/devkit/codeAgent/tools/SessionToolPack.ts
 import { SessionManager } from "@earendil-works/pi-coding-agent";
 import { codeAgentClip as codeAgentClip2, codeAgentOutputChars as codeAgentOutputChars2 } from "akanjs/common";
-import { Type as Type4 } from "typebox";
+import { Type as Type5 } from "typebox";
 var snippetChars = 240;
 
 class SessionToolPack2 {
@@ -915,9 +987,9 @@ class SessionToolPack2 {
       label: "Search sessions",
       description: "Search earlier coding-agent conversations in this workspace for a phrase, and get back the matching sessions with a snippet. Use it when the user refers to something decided before, or when you suspect this problem has been solved here already.",
       promptSnippet: "session_search: find earlier conversations in this workspace by phrase",
-      parameters: Type4.Object({
-        query: Type4.String({ description: "A phrase to look for, matched case-insensitively." }),
-        limit: Type4.Optional(Type4.Number({ description: "How many sessions to return, default 5." }))
+      parameters: Type5.Object({
+        query: Type5.String({ description: "A phrase to look for, matched case-insensitively." }),
+        limit: Type5.Optional(Type5.Number({ description: "How many sessions to return, default 5." }))
       }),
       execute: async (_id, params) => {
         const matches = await this.#search(params.query, params.limit ?? 5);
@@ -929,7 +1001,7 @@ class SessionToolPack2 {
       label: "Read session",
       description: "Read one earlier conversation, found with session_search, as plain text.",
       promptSnippet: "session_read: read one earlier conversation by id",
-      parameters: Type4.Object({ sessionId: Type4.String() }),
+      parameters: Type5.Object({ sessionId: Type5.String() }),
       execute: async (_id, params) => {
         const text = await this.#read(params.sessionId);
         return { content: [{ type: "text", text }], details: undefined, isError: text.startsWith("No session") };
@@ -962,7 +1034,7 @@ class SessionToolPack2 {
 
 // pkgs/@akanjs/devkit/codeAgent/tools/WebToolPack.ts
 import { codeAgentClip as codeAgentClip3, codeAgentOutputChars as codeAgentOutputChars3 } from "akanjs/common";
-import { Type as Type5 } from "typebox";
+import { Type as Type6 } from "typebox";
 
 class WebToolPack2 {
   #options;
@@ -1027,7 +1099,7 @@ class WebToolPack2 {
       label: "Fetch",
       description: "Fetch a URL and return its readable text. HTML is stripped to text; the result is truncated.",
       promptSnippet: "web_fetch: fetch a URL and return its readable text",
-      parameters: Type5.Object({ url: Type5.String({ description: "Absolute http(s) URL." }) }),
+      parameters: Type6.Object({ url: Type6.String({ description: "Absolute http(s) URL." }) }),
       execute: async (_id, params) => {
         const refusal = WebToolPack2.#refuseHost(params.url, allowHosts);
         if (refusal)
@@ -1052,9 +1124,9 @@ ${codeAgentClip3(text, codeAgentOutputChars3)}` }
       label: "Search",
       description: `Search the web (${provider.name}) and return the top results as title, url and snippet.`,
       promptSnippet: "web_search: search the web and return titles, urls and snippets",
-      parameters: Type5.Object({
-        query: Type5.String(),
-        count: Type5.Optional(Type5.Number({ description: "How many results, default 5." }))
+      parameters: Type6.Object({
+        query: Type6.String(),
+        count: Type6.Optional(Type6.Number({ description: "How many results, default 5." }))
       }),
       execute: async (_id, params) => {
         const key = process.env[provider.envKey] ?? "";
@@ -1098,6 +1170,7 @@ class AkanCodePlugins2 {
       ...options.onNotice ? { onNotice: options.onNotice } : {}
     });
     const dispose = () => mcp?.close();
+    const mcpStatus = mcp?.status ?? [];
     const web = new WebToolPack2({ profile: options.profile });
     const webExtension = web.extension();
     const sessions = new SessionToolPack2({
@@ -1109,10 +1182,20 @@ class AkanCodePlugins2 {
     const sessionExtension = sessions.extension();
     const mail = new MailToolPack2({ profile: options.profile, mailbox: options.mailbox });
     const mailExtension = mail.extension();
+    const onAsk = options.onAsk;
+    const ask = onAsk ? new AskToolPack({ profile: options.profile, ask: onAsk }) : undefined;
+    const askExtension = ask?.extension();
     if (!options.profile.tools.akan)
       return {
-        extensions: [mcp?.extension(), webExtension, sessionExtension, mailExtension].filter((entry) => !!entry),
-        toolNames: [...mcp?.toolNames ?? [], ...web.names(), ...sessions.names(), ...mail.names()],
+        extensions: [mcp?.extension(), webExtension, sessionExtension, mailExtension, askExtension].filter((entry) => !!entry),
+        toolNames: [
+          ...mcp?.toolNames ?? [],
+          ...web.names(),
+          ...sessions.names(),
+          ...mail.names(),
+          ...ask?.names() ?? []
+        ],
+        mcp: mcpStatus,
         dispose
       };
     const readOnly = !options.profile.tools.builtin.includes("write");
@@ -1127,7 +1210,8 @@ class AkanCodePlugins2 {
       cwd: options.cwd,
       parent: options.profile,
       depth: options.depth,
-      ...options.onNotice ? { onNotice: options.onNotice } : {}
+      ...options.onNotice ? { onNotice: options.onNotice } : {},
+      ...options.onAgents ? { onAgents: options.onAgents } : {}
     });
     if (subagent)
       extensions.push(subagent);
@@ -1145,6 +1229,8 @@ class AkanCodePlugins2 {
       extensions.push(sessionExtension);
     if (mailExtension)
       extensions.push(mailExtension);
+    if (askExtension)
+      extensions.push(askExtension);
     return {
       extensions,
       toolNames: [
@@ -1153,8 +1239,10 @@ class AkanCodePlugins2 {
         ...mcp?.toolNames ?? [],
         ...web.names(),
         ...sessions.names(),
-        ...mail.names()
+        ...mail.names(),
+        ...ask?.names() ?? []
       ],
+      mcp: mcpStatus,
       dispose
     };
   }
@@ -1184,36 +1272,31 @@ class AkanCodePlugins2 {
 }
 
 // pkgs/@akanjs/devkit/codeAgent/agent/AkanCodeServices.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync2 } from "fs";
-import {
-  AuthStorage,
-  ModelRegistry,
-  SessionManager as SessionManager2,
-  SettingsManager
-} from "@earendil-works/pi-coding-agent";
+import { existsSync as existsSync7, mkdirSync } from "fs";
+import { ModelRuntime, SessionManager as SessionManager2, SettingsManager } from "@earendil-works/pi-coding-agent";
 
 // pkgs/@akanjs/devkit/codeAgent/tools/AkanEnvKeys.ts
-import { existsSync as existsSync6, readFileSync as readFileSync2 } from "fs";
-import path5 from "path";
+import { existsSync as existsSync4, readFileSync } from "fs";
+import path4 from "path";
 
 class AkanEnvKeys2 {
-  static apply(authStorage, workspaceRoot) {
+  static async apply(runtime, workspaceRoot) {
     const applied = [];
     for (const [name, value] of AkanEnvKeys2.#entries(workspaceRoot)) {
       const provider = AkanEnvKeys2.#providerOf(name);
       if (!provider || !value)
         continue;
-      authStorage.setRuntimeApiKey(provider, value);
+      await runtime.setRuntimeApiKey(provider, value);
       applied.push(provider);
     }
     return applied;
   }
   static #entries(workspaceRoot) {
     const fromProcess = Object.entries(process.env).filter(([, value]) => typeof value === "string");
-    const file = path5.join(workspaceRoot, ".env");
-    if (!existsSync6(file))
+    const file = path4.join(workspaceRoot, ".env");
+    if (!existsSync4(file))
       return fromProcess;
-    const fromFile = readFileSync2(file, "utf8").split(`
+    const fromFile = readFileSync(file, "utf8").split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && line.includes("=")).map((line) => {
       const index = line.indexOf("=");
       return [
@@ -1229,89 +1312,82 @@ class AkanEnvKeys2 {
   }
 }
 
-// pkgs/@akanjs/devkit/codeAgent/agent/AkanAuthStorageBackend.ts
-import {
-  closeSync,
-  existsSync as existsSync7,
-  mkdirSync,
-  openSync,
-  readFileSync as readFileSync3,
-  renameSync,
-  unlinkSync,
-  writeFileSync
-} from "fs";
-import path6 from "path";
+// pkgs/@akanjs/devkit/codeAgent/agent/AkanContextFiles.ts
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+import path5 from "path";
 
-class AkanAuthStorageBackend2 {
-  #authPath;
-  #lockPath;
-  constructor(authPath) {
-    this.#authPath = authPath;
-    this.#lockPath = `${authPath}.lock`;
-  }
-  withLock(fn) {
-    this.#acquire();
-    try {
-      const { result, next } = fn(this.#read());
-      if (next !== undefined)
-        this.#write(next);
-      return result;
-    } finally {
-      this.#release();
+class AkanContextFiles {
+  static #frontmatter = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+  static extend(base, options) {
+    const seen = new Set(base.map((file) => file.path));
+    const contents = new Set(base.map((file) => file.content.trim()));
+    const added = [];
+    for (const file of [...AkanContextFiles.#claude(base), ...AkanContextFiles.#cursor(options)]) {
+      if (seen.has(file.path) || contents.has(file.content.trim()) || !file.content.trim())
+        continue;
+      seen.add(file.path);
+      contents.add(file.content.trim());
+      added.push(file);
     }
+    return [...base, ...added];
   }
-  async withLockAsync(fn) {
-    this.#acquire();
-    try {
-      const { result, next } = await fn(this.#read());
-      if (next !== undefined)
-        this.#write(next);
-      return result;
-    } finally {
-      this.#release();
+  static #claude(base) {
+    const files = [];
+    for (const file of base) {
+      if (!/^AGENTS\.(md|MD)$/.test(path5.basename(file.path)))
+        continue;
+      for (const name of ["CLAUDE.md", "CLAUDE.MD"]) {
+        const candidate = path5.join(path5.dirname(file.path), name);
+        const content = AkanContextFiles.#read(candidate);
+        if (content !== undefined)
+          files.push({ path: candidate, content });
+      }
     }
-  }
-  #read() {
-    if (!existsSync7(this.#authPath))
-      return;
-    const text = readFileSync3(this.#authPath, "utf8");
-    return text.trim() ? text : undefined;
-  }
-  #write(next) {
-    mkdirSync(path6.dirname(this.#authPath), { recursive: true, mode: 448 });
-    const temp = `${this.#authPath}.${process.pid}.tmp`;
-    writeFileSync(temp, next, { mode: 384 });
-    renameSync(temp, this.#authPath);
-  }
-  #acquire() {
-    mkdirSync(path6.dirname(this.#lockPath), { recursive: true, mode: 448 });
-    const deadline = Date.now() + 5000;
-    for (;; ) {
-      try {
-        closeSync(openSync(this.#lockPath, "wx"));
-        return;
-      } catch {
-        if (this.#lockIsStale() || Date.now() > deadline) {
-          try {
-            unlinkSync(this.#lockPath);
-          } catch {}
+    return files;
+  }
+  static #cursor(options) {
+    const files = [];
+    const roots = [...new Set([options.workspaceRoot, options.cwd])];
+    for (const root of roots) {
+      const legacy = AkanContextFiles.#read(path5.join(root, ".cursorrules"));
+      if (legacy !== undefined)
+        files.push({ path: path5.join(root, ".cursorrules"), content: legacy });
+      for (const file of AkanContextFiles.#mdcFiles(path5.join(root, ".cursor", "rules"))) {
+        const raw = AkanContextFiles.#read(file);
+        if (raw === undefined)
           continue;
-        }
-        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+        const body = AkanContextFiles.#applied(raw);
+        if (body !== undefined)
+          files.push({ path: file, content: body });
       }
     }
+    return files;
   }
-  #lockIsStale() {
+  static #applied(raw) {
+    const match = AkanContextFiles.#frontmatter.exec(raw);
+    if (!match)
+      return raw;
+    if (!/^\s*alwaysApply\s*:\s*true\s*$/m.test(match[1] ?? ""))
+      return;
+    return raw.slice(match[0].length);
+  }
+  static #mdcFiles(dir) {
+    if (!existsSync5(dir))
+      return [];
     try {
-      return Date.now() - Bun.file(this.#lockPath).lastModified > 30000;
+      return readdirSync(dir, { recursive: true, withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".mdc")).map((entry) => path5.join(entry.parentPath ?? dir, entry.name)).sort();
     } catch {
-      return true;
+      return [];
     }
   }
-  #release() {
+  static #read(file) {
     try {
-      unlinkSync(this.#lockPath);
-    } catch {}
+      if (!existsSync5(file) || !statSync2(file).isFile())
+        return;
+      return readFileSync2(file, "utf8").replace(/^\uFEFF/, "");
+    } catch {
+      return;
+    }
   }
 }
 
@@ -1323,6 +1399,7 @@ var akanSystemPrompt2 = (profile) => {
     "- Prefer an akan workflow to a direct source edit. `list_workflows` / `explain_workflow` / `plan_workflow`, then `apply_workflow({ planPath })`. Editing source by hand is the fallback, not the default.",
     "- Read context with `inspect_akan_context` before reading source bodies; it answers most structural questions without spending the file.",
     "- Fetch the guideline for an area before a deep pass on it: `get_guideline`.",
+    "- A question about `akan code` itself \u2014 its slash commands, MCP servers, sessions, models, keys, or where its files live \u2014 is answered by the `akan-code` skill. Read it rather than describing the tool from memory.",
     "- Never hand-edit a generated file (`lib/cnst.ts`, `db.ts`, `st.ts`, any `*/index.ts` barrel). Fix the owning source and run `repair_generated` or `akan sync`."
   ];
   if (profile.tools.builtin.includes("write"))
@@ -1331,6 +1408,8 @@ var akanSystemPrompt2 = (profile) => {
     lines.push("- This session is read-only: there is no write, edit or bash tool. Report what should change instead of changing it.");
   if (profile.tools.subagent)
     lines.push('- Hand a self-contained search or read to `task` \u2014 `type: "explore"` reads and reports, `type: "code"` makes the change. Only its answer comes back, so give it everything it needs and ask for exactly what you want returned. Do it yourself when the reading is short or when you need the files in front of you.');
+  if (profile.ui.canPrompt)
+    lines.push("- Ask with `ask_user` when two readings of the request would lead to materially different work, and offer the options you can name. Do not ask for a choice that has an obvious default, and do not ask permission for work you were already asked to do \u2014 make the call, say the assumption, and carry on.");
   if (profile.approval !== "never")
     lines.push(`- Some tool calls need the user's approval (policy: ${profile.approval}). A refusal is an answer; do not retry it a different way.`);
   lines.push("- Secrets are refused at the tool boundary. If you need a value from `.env`, ask the user for it rather than looking for another way to read the file.", "", "## How to answer", "", "- Answer in as few words as carry the answer. A short question gets one sentence with no heading.", "- Do not open with what you are about to do, and do not close with a summary of what you did. The tool calls are already on the user's screen.", "- Skip headings, bold labels and bullet lists unless the answer is genuinely a list. Prose is shorter.", "- State a file as `path:line`. Do not paste a file back that the user can open.", "- Say what you could not do, and why, in one line. Do not offer alternatives nobody asked for.");
@@ -1339,26 +1418,26 @@ var akanSystemPrompt2 = (profile) => {
 };
 
 // pkgs/@akanjs/devkit/codeAgent/agent/CodeSessionIndex.ts
-import { existsSync as existsSync8, readdirSync, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import path7 from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
+import path6 from "path";
 
 class CodeSessionIndex2 {
   static readLimit = 512 * 1024;
   static list(dir, limit = 30) {
-    if (!existsSync8(dir))
+    if (!existsSync6(dir))
       return [];
-    const files = readdirSync(dir).filter((entry) => entry.endsWith(".jsonl")).map((entry) => path7.join(dir, entry)).map((file) => ({ file, updatedAt: CodeSessionIndex2.#mtime(file) })).sort((left, right) => right.updatedAt - left.updatedAt).slice(0, limit);
+    const files = readdirSync2(dir).filter((entry) => entry.endsWith(".jsonl")).map((entry) => path6.join(dir, entry)).map((file) => ({ file, updatedAt: CodeSessionIndex2.#mtime(file) })).sort((left, right) => right.updatedAt - left.updatedAt).slice(0, limit);
     return files.map((entry) => CodeSessionIndex2.#read(entry.file, entry.updatedAt)).filter((entry) => !!entry);
   }
   static fileOf(dir, id) {
-    if (!existsSync8(dir))
+    if (!existsSync6(dir))
       return;
-    const match = readdirSync(dir).find((entry) => entry.endsWith(`${id}.jsonl`) || entry === `${id}.jsonl`);
-    return match ? path7.join(dir, match) : undefined;
+    const match = readdirSync2(dir).find((entry) => entry.endsWith(`${id}.jsonl`) || entry === `${id}.jsonl`);
+    return match ? path6.join(dir, match) : undefined;
   }
   static #mtime(file) {
     try {
-      return statSync2(file).mtimeMs;
+      return statSync3(file).mtimeMs;
     } catch {
       return 0;
     }
@@ -1389,9 +1468,9 @@ class CodeSessionIndex2 {
   }
   static #lines(file) {
     try {
-      if (statSync2(file).size > CodeSessionIndex2.readLimit)
+      if (statSync3(file).size > CodeSessionIndex2.readLimit)
         return [];
-      return readFileSync4(file, "utf8").split(`
+      return readFileSync3(file, "utf8").split(`
 `).filter((line) => !!line.trim());
     } catch {
       return [];
@@ -1419,20 +1498,20 @@ class AkanCodeServices2 {
       quietStartup: true
     });
   }
-  static auth(workspaceRoot) {
-    mkdirSync2(akanCodePaths2.globalDir(), { recursive: true, mode: 448 });
-    const authStorage = AuthStorage.fromStorage(new AkanAuthStorageBackend2(akanCodePaths2.authFile()));
-    AkanEnvKeys2.apply(authStorage, workspaceRoot);
-    return authStorage;
-  }
-  static models(authStorage) {
-    return ModelRegistry.create(authStorage, akanCodePaths2.modelsFile());
+  static async runtime(workspaceRoot) {
+    mkdirSync(akanCodePaths2.globalDir(), { recursive: true, mode: 448 });
+    const runtime = await ModelRuntime.create({
+      authPath: akanCodePaths2.authFile(),
+      modelsPath: akanCodePaths2.modelsFile()
+    });
+    await AkanEnvKeys2.apply(runtime, workspaceRoot);
+    return runtime;
   }
   static sessions(workspaceRoot, cwd, profile, resume) {
     if (profile.session.store !== "file")
       return SessionManager2.inMemory(cwd);
     const dir = akanCodePaths2.sessionsDir(workspaceRoot);
-    mkdirSync2(dir, { recursive: true });
+    mkdirSync(dir, { recursive: true });
     const manager = SessionManager2.create(cwd, dir);
     if (!resume)
       return manager;
@@ -1445,17 +1524,24 @@ class AkanCodeServices2 {
   static #skillPaths(profile, workspaceRoot) {
     if (!profile.context.skills)
       return [];
-    const workspace = akanCodePaths2.skillsDir(workspaceRoot);
-    return [akanCodePaths2.builtinSkillsDir(), existsSync9(workspace) ? workspace : undefined].filter((dir) => !!dir);
+    const dirs = [
+      akanCodePaths2.builtinSkillsDir(),
+      akanCodePaths2.globalSkillsDir(),
+      akanCodePaths2.skillsDir(workspaceRoot)
+    ];
+    return dirs.filter((dir) => !!dir && existsSync7(dir));
   }
   static resourceOptions(options) {
-    const present = (dir) => existsSync9(dir) ? [dir] : [];
+    const present = (dir) => existsSync7(dir) ? [dir] : [];
     return {
       noExtensions: true,
       noSkills: true,
       noPromptTemplates: true,
       noThemes: true,
       noContextFiles: !options.profile.context.projectFiles,
+      agentsFilesOverride: ({ agentsFiles }) => ({
+        agentsFiles: options.profile.context.projectFiles ? AkanContextFiles.extend(agentsFiles, { workspaceRoot: options.workspaceRoot, cwd: options.cwd }) : agentsFiles
+      }),
       appendSystemPrompt: [akanSystemPrompt2(options.profile)],
       additionalExtensionPaths: present(akanCodePaths2.extensionsDir(options.workspaceRoot)),
       additionalSkillPaths: AkanCodeServices2.#skillPaths(options.profile, options.workspaceRoot),
@@ -1733,7 +1819,7 @@ class CodeAgentEventMapper2 {
 }
 
 // pkgs/@akanjs/devkit/codeAgent/agent/CodeAgentGate.ts
-import path8 from "path";
+import path7 from "path";
 var writeTools = new Set(["write", "edit"]);
 var commandTools = new Set(["bash"]);
 
@@ -1772,9 +1858,9 @@ class CodeAgentGate2 {
     return `The command names "${hit}", which the profile's deny list covers. Ask the user for the value instead of reading the file.`;
   }
   #deniedReason(target) {
-    const absolute = path8.isAbsolute(target) ? target : path8.resolve(this.#profile.paths.root, target);
-    const relative = path8.relative(this.#profile.paths.root, absolute);
-    if (relative.startsWith("..") || path8.isAbsolute(relative))
+    const absolute = path7.isAbsolute(target) ? target : path7.resolve(this.#profile.paths.root, target);
+    const relative = path7.relative(this.#profile.paths.root, absolute);
+    if (relative.startsWith("..") || path7.isAbsolute(relative))
       return `Path is outside the agent root (${this.#profile.paths.root}).`;
     if (this.#deny.some((glob) => glob.match(absolute) || glob.match(relative)))
       return "Path is on the profile's deny list (secrets and environment files are never readable).";
@@ -1864,15 +1950,15 @@ class CodeAgentUi2 {
 // pkgs/@akanjs/devkit/codeAgent/agent/CodeMailbox.ts
 import {
   appendFileSync,
-  existsSync as existsSync10,
-  mkdirSync as mkdirSync3,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync5,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync4,
   rmSync,
-  statSync as statSync3,
-  writeFileSync as writeFileSync2
+  statSync as statSync4,
+  writeFileSync
 } from "fs";
-import path9 from "path";
+import path8 from "path";
 
 class CodeMailbox2 {
   static staleMs = 20000;
@@ -1892,11 +1978,11 @@ class CodeMailbox2 {
     this.#name = name;
   }
   get inbox() {
-    return path9.join(this.#dir, "inbox", `${this.#id}.jsonl`);
+    return path8.join(this.#dir, "inbox", `${this.#id}.jsonl`);
   }
   open(cwd, onMail) {
-    mkdirSync3(path9.join(this.#dir, "live"), { recursive: true });
-    mkdirSync3(path9.join(this.#dir, "inbox"), { recursive: true });
+    mkdirSync2(path8.join(this.#dir, "live"), { recursive: true });
+    mkdirSync2(path8.join(this.#dir, "inbox"), { recursive: true });
     this.#read = CodeMailbox2.#lines(this.inbox).length;
     this.beat(cwd);
     this.#beat = setInterval(() => this.beat(cwd), CodeMailbox2.beatMs);
@@ -1913,7 +1999,7 @@ class CodeMailbox2 {
     this.#beat = null;
     this.#poll = null;
     try {
-      rmSync(path9.join(this.#dir, "live", `${this.#id}.json`), { force: true });
+      rmSync(path8.join(this.#dir, "live", `${this.#id}.json`), { force: true });
     } catch {}
   }
   rename(name, cwd) {
@@ -1923,15 +2009,15 @@ class CodeMailbox2 {
   beat(cwd) {
     const peer = { id: this.#id, name: this.#name, cwd, pid: process.pid, at: Date.now() };
     try {
-      writeFileSync2(path9.join(this.#dir, "live", `${this.#id}.json`), JSON.stringify(peer));
+      writeFileSync(path8.join(this.#dir, "live", `${this.#id}.json`), JSON.stringify(peer));
     } catch {}
   }
   peers() {
-    const dir = path9.join(this.#dir, "live");
-    if (!existsSync10(dir))
+    const dir = path8.join(this.#dir, "live");
+    if (!existsSync8(dir))
       return [];
     const now = Date.now();
-    return readdirSync2(dir).filter((entry) => entry.endsWith(".json")).map((entry) => CodeMailbox2.#peer(path9.join(dir, entry))).filter((peer) => !!peer && peer.id !== this.#id && now - peer.at < CodeMailbox2.staleMs).sort((left, right) => right.at - left.at);
+    return readdirSync3(dir).filter((entry) => entry.endsWith(".json")).map((entry) => CodeMailbox2.#peer(path8.join(dir, entry))).filter((peer) => !!peer && peer.id !== this.#id && now - peer.at < CodeMailbox2.staleMs).sort((left, right) => right.at - left.at);
   }
   find(target) {
     const needle = target.trim().toLowerCase();
@@ -1949,8 +2035,8 @@ class CodeMailbox2 {
       throw new Error(`Too many messages: ${CodeMailbox2.sendsPerMinute} a minute is the ceiling.`);
     this.#sent.push(now);
     const mail = { at: now, from: this.#id, fromName: this.#name, text };
-    mkdirSync3(path9.join(this.#dir, "inbox"), { recursive: true });
-    appendFileSync(path9.join(this.#dir, "inbox", `${to}.jsonl`), `${JSON.stringify(mail)}
+    mkdirSync2(path8.join(this.#dir, "inbox"), { recursive: true });
+    appendFileSync(path8.join(this.#dir, "inbox", `${to}.jsonl`), `${JSON.stringify(mail)}
 `);
   }
   #drain() {
@@ -1963,15 +2049,15 @@ class CodeMailbox2 {
   }
   static #peer(file) {
     try {
-      const peer = JSON.parse(readFileSync5(file, "utf8"));
-      return typeof peer.id === "string" ? { ...peer, at: peer.at || statSync3(file).mtimeMs } : undefined;
+      const peer = JSON.parse(readFileSync4(file, "utf8"));
+      return typeof peer.id === "string" ? { ...peer, at: peer.at || statSync4(file).mtimeMs } : undefined;
     } catch {
       return;
     }
   }
   static #lines(file) {
     try {
-      return readFileSync5(file, "utf8").split(`
+      return readFileSync4(file, "utf8").split(`
 `).filter((line) => !!line.trim());
     } catch {
       return [];
@@ -1988,15 +2074,15 @@ class CodeMailbox2 {
 
 // pkgs/@akanjs/devkit/codeAgent/agent/CodeSessionFork.ts
 import { randomBytes } from "crypto";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
-import path10 from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import path9 from "path";
 import { codeAgentSessionName } from "akanjs/common";
 class CodeSessionFork2 {
   static fork(dir, id, name) {
     const source = CodeSessionIndex2.fileOf(dir, id);
     if (!source)
       throw new Error(`No stored session ${id} in ${dir}`);
-    const lines = readFileSync6(source, "utf8").split(`
+    const lines = readFileSync5(source, "utf8").split(`
 `).filter((line) => !!line.trim());
     if (!lines.length)
       throw new Error(`Session ${id} has nothing in it to fork`);
@@ -2009,8 +2095,8 @@ class CodeSessionFork2 {
     first.id = forked;
     first.timestamp = at.toISOString();
     records.push(CodeSessionFork2.#named(records, name ?? CodeSessionFork2.#nameOf(records), at));
-    const file = path10.join(dir, `${at.toISOString().replace(/[:.]/g, "-")}_${forked}.jsonl`);
-    writeFileSync3(file, `${records.map((record) => JSON.stringify(record)).join(`
+    const file = path9.join(dir, `${at.toISOString().replace(/[:.]/g, "-")}_${forked}.jsonl`);
+    writeFileSync2(file, `${records.map((record) => JSON.stringify(record)).join(`
 `)}
 `);
     return { id: forked, file };
@@ -2052,6 +2138,8 @@ class CodeAgent2 {
   #disposed = false;
   #sessionDir;
   #mailbox;
+  #mcp = [];
+  #workspaceRoot = "";
   #replay = [];
   #replayFrom = 0;
   #lastContextTokens;
@@ -2064,9 +2152,8 @@ class CodeAgent2 {
     const cwd = options.cwd ?? workspaceRoot;
     const agent = new CodeAgent2(options.profile);
     const settingsManager = AkanCodeServices2.settings();
-    const authStorage = AkanCodeServices2.auth(workspaceRoot);
-    const modelRegistry = AkanCodeServices2.models(authStorage);
-    const model = await akanCodeModel2(modelRegistry, options.model);
+    const modelRuntime = await AkanCodeServices2.runtime(workspaceRoot);
+    const model = await akanCodeModel2(modelRuntime, options.model);
     const compaction = DEFAULT_COMPACTION_SETTINGS;
     const modelWarnings = akanCodeModelWarnings2(model, compaction.reserveTokens + compaction.keepRecentTokens);
     const akan = await AkanCodePlugins2.build({
@@ -2078,7 +2165,9 @@ class CodeAgent2 {
       depth: options.depth ?? 0,
       currentSessionId: () => agent.sessionId,
       mailbox: () => agent.#mailbox,
-      onNotice: (message) => agent.#emit({ type: "notice", level: "warning", message })
+      onNotice: (message) => agent.#emit({ type: "notice", level: "warning", message }),
+      onAgents: (agents) => agent.#emit({ type: "subagent", agents }),
+      onAsk: (question) => agent.ask(question)
     });
     const resourceLoader = new DefaultResourceLoader({
       cwd,
@@ -2095,8 +2184,7 @@ class CodeAgent2 {
     const { session } = await createAgentSession({
       cwd,
       agentDir: akanCodePaths2.globalDir(),
-      authStorage,
-      modelRegistry,
+      modelRuntime,
       settingsManager,
       resourceLoader,
       model,
@@ -2106,6 +2194,8 @@ class CodeAgent2 {
       customTools: options.customTools
     });
     agent.#disposePlugins = akan.dispose;
+    agent.#mcp = akan.mcp;
+    agent.#workspaceRoot = workspaceRoot;
     if (options.profile.session.store === "file")
       agent.#sessionDir = akanCodePaths2.sessionsDir(workspaceRoot);
     await agent.#attach(session, options.mode ?? "print");
@@ -2125,6 +2215,12 @@ class CodeAgent2 {
   sessions() {
     return this.#sessionDir ? CodeSessionIndex2.list(this.#sessionDir) : [];
   }
+  get workspaceRoot() {
+    return this.#workspaceRoot;
+  }
+  mcpServers() {
+    return this.#mcp;
+  }
   peers() {
     return this.#mailbox?.peers() ?? [];
   }
@@ -2190,6 +2286,7 @@ ${mail.text}`).catch((error) => this.#emit({ type: "notice", level: "error", mes
       if (text)
         this.#emit({ type: "message", turnId, role: message.role, text });
     }
+    this.#emitContextNow();
   }
   static #textOf(content) {
     if (typeof content === "string")
@@ -2279,9 +2376,26 @@ Continue the task.`);
     session.setThinkingLevel(effort);
     this.#emit({ type: "session", info: this.info });
   }
+  catalogue() {
+    const runtime = this.#session?.modelRuntime;
+    if (!runtime)
+      return [];
+    const current = this.#session?.model;
+    return runtime.getProviders().map((provider) => ({
+      id: provider.id,
+      name: provider.name ?? provider.id,
+      authorized: runtime.hasConfiguredAuth(provider.id),
+      models: (runtime.getModels(provider.id) ?? []).map((model) => ({
+        id: model.id,
+        name: model.name,
+        ...model.contextWindow ? { contextWindow: model.contextWindow } : {},
+        current: model.provider === current?.provider && model.id === current?.id
+      }))
+    })).sort((a, b) => a.id.localeCompare(b.id));
+  }
   async setModel(ref) {
     const session = this.#require();
-    const model = await akanCodeModel2(session.modelRegistry, ref);
+    const model = await akanCodeModel2(session.modelRuntime, ref);
     if (!model)
       throw new Error(`Unknown model: ${ref.provider}/${ref.id}`);
     await session.setModel(model);
@@ -2331,6 +2445,9 @@ Continue the task.`);
   #emitContextUsage(eventType) {
     if (eventType !== "agent_end" && eventType !== "compaction_end")
       return;
+    this.#emitContextNow();
+  }
+  #emitContextNow() {
     const usage = this.#session?.getContextUsage();
     if (usage?.tokens == null)
       return;
@@ -2406,29 +2523,28 @@ Continue the task.`);
     }
     return await this.#asks.openApproval(approvalId);
   }
+  async ask(spec) {
+    if (!this.#profile.ui.canPrompt)
+      return;
+    const question = { questionId: this.#asks.nextId("q"), ...spec };
+    this.#emit({ type: "question", question });
+    if (this.#profile.interaction.question === "suspend") {
+      this.#mapper.noteOutcome("awaiting");
+      return;
+    }
+    return await this.#asks.openQuestion(question) || undefined;
+  }
   #ui() {
     return new CodeAgentUi2({
-      ask: async (prompt, kind, choices) => {
-        if (!this.#profile.ui.canPrompt)
-          return;
-        const questionId = this.#asks.nextId("q");
-        const question = {
-          questionId,
-          prompt,
-          kind,
-          ...choices ? { options: choices.map((label) => ({ key: label, label })) } : {},
-          freeText: kind === "text"
-        };
-        this.#emit({ type: "question", question });
-        if (this.#profile.interaction.question === "suspend") {
-          this.#mapper.noteOutcome("awaiting");
-          return;
-        }
-        return await this.#asks.openQuestion(question) || undefined;
-      },
+      ask: async (prompt, kind, choices) => await this.ask({
+        prompt,
+        kind,
+        ...choices ? { options: choices.map((label) => ({ key: label, label })) } : {},
+        freeText: kind === "text"
+      }),
       notify: (level, message) => this.#emit({ type: "notice", level, message })
     });
   }
 }
 
-export { AkanEditScope2, DevLogFeedback2, PreviewChrome2, PreviewView2, PreviewFeedback2, TurnFeedback2, AkanCli2, AkanVerifier2, VerifyFeedback2, AkanToolPack2, MailToolPack2, akanCodePaths2, McpClient2, McpToolPack2, SessionToolPack2, WebToolPack2, AkanCodePlugins2, AkanEnvKeys2, AkanAuthStorageBackend2, akanSystemPrompt2, CodeSessionIndex2, AkanCodeServices2, CodeAgentAsks2, CodeAgentEventMapper2, CodeAgentGate2, CodeAgentUi2, CodeMailbox2, CodeSessionFork2, CodeAgent2 };
+export { AkanEditScope2, DevLogFeedback2, PreviewChrome2, PreviewView2, PreviewFeedback2, TurnFeedback2, AkanCli2, AkanVerifier2, VerifyFeedback2, AkanToolPack2, MailToolPack2, McpUnauthorized2, McpClient2, McpToolPack2, SessionToolPack2, WebToolPack2, AkanCodePlugins2, AkanEnvKeys2, akanSystemPrompt2, CodeSessionIndex2, AkanCodeServices2, CodeAgentAsks2, CodeAgentEventMapper2, CodeAgentGate2, CodeAgentUi2, CodeMailbox2, CodeSessionFork2, CodeAgent2 };