@akanjs/cli 3.0.0-beta.9 → 3.0.1

package/index-y5ga5w9t.js

@@ -0,0 +1,2729 @@
+// @bun
+import {
+  SubagentPool2,
+  akanCodePaths2,
+  McpServerConfig,
+  McpSignIn
+} from "./index-c14nsvnv.js";
+import {
+  stripAnsi
+} from "./index-7md2g9vw.js";
+import {
+  akanCodeDefaultModel2,
+  akanCodeModel2,
+  akanCodeModelSupportsImages2,
+  akanCodeModelWarnings2
+} from "./index-c6eggbee.js";
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeAgent.ts
+import {
+  createAgentSession,
+  DefaultResourceLoader
+} from "@earendil-works/pi-coding-agent";
+import {
+  codeAgentClip as codeAgentClip5,
+  codeAgentLabelChars as codeAgentLabelChars2,
+  codeAgentRenderAnswer,
+  codeAgentSessionName as codeAgentSessionName2
+} from "akanjs/common";
+
+// pkgs/@akanjs/devkit/codeAgent/feedback/DevLogFeedback.ts
+import { existsSync, statSync } from "fs";
+import path from "path";
+
+// pkgs/@akanjs/devkit/codeAgent/tools/AkanEditScope.ts
+var empty = { paths: [], apps: [], libs: [], needsSync: false, touchesTsx: false };
+
+class AkanEditScope2 {
+  static async since(cwd, baseline) {
+    const current = await AkanEditScope2.baseline(cwd);
+    const changed = [...current].filter((line) => !baseline.has(line));
+    if (!changed.length)
+      return empty;
+    const entries = changed.map((line) => ({ code: line.slice(0, 2), file: line.slice(3).split(" -> ").at(-1) ?? "" }));
+    const paths = entries.map((entry) => entry.file).filter(Boolean);
+    return {
+      paths,
+      apps: AkanEditScope2.#targets(paths, "apps"),
+      libs: AkanEditScope2.#targets(paths, "libs"),
+      needsSync: entries.some((entry) => /[ARD?]/.test(entry.code) && /^(apps|libs)\//.test(entry.file)),
+      touchesTsx: paths.some((file) => file.endsWith(".tsx"))
+    };
+  }
+  static async baseline(cwd) {
+    const proc = Bun.spawn(["git", "status", "--porcelain=v1", "--untracked-files=all"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "ignore"
+    });
+    const text = await new Response(proc.stdout).text();
+    await proc.exited;
+    return new Set(text.split(`
+`).filter((line) => line.trim().length > 3));
+  }
+  static #targets(paths, root) {
+    const names = paths.filter((file) => file.startsWith(`${root}/`)).map((file) => file.split("/")[1] ?? "").filter(Boolean);
+    return [...new Set(names)];
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/feedback/DevLogFeedback.ts
+var errorPattern = /\bERROR\b|\bFATAL\b|\[stderr\]|error:|Error:|\u2716|Unhandled|Cannot find|is not a function/;
+var noisePattern = /DEBUG|\bWARN\b|MCP catalogue|rate limit/;
+
+class DevLogFeedback2 {
+  key = "dev-server";
+  #options;
+  #marks = new Map;
+  #baseline = new Set;
+  constructor(options) {
+    this.#options = { graceMs: 1500, maxLines: 30, ...options };
+  }
+  async begin() {
+    for (const app of this.#options.apps)
+      this.#marks.set(app, DevLogFeedback2.#sizeOf(this.#pathOf(app)));
+    this.#baseline = await AkanEditScope2.baseline(this.#options.cwd);
+  }
+  async observe() {
+    const running = this.#options.apps.filter((app) => existsSync(this.#pathOf(app)));
+    if (!running.length)
+      return;
+    if (!(await AkanEditScope2.since(this.#options.cwd, this.#baseline)).paths.length)
+      return;
+    await Bun.sleep(this.#options.graceMs);
+    const reports = [];
+    for (const app of running) {
+      const lines = await this.#linesSince(app);
+      if (lines.length)
+        reports.push(`**${app}** dev server:
+\`\`\`
+${lines.join(`
+`)}
+\`\`\``);
+    }
+    if (!reports.length)
+      return;
+    return [
+      "The dev server logged errors after your edits:",
+      ...reports,
+      `Full log: ${running.map((app) => path.relative(this.#options.workspaceRoot, this.#pathOf(app))).join(", ")}`
+    ].join(`
+
+`);
+  }
+  async#linesSince(app) {
+    const file = this.#pathOf(app);
+    const from = this.#marks.get(app) ?? 0;
+    const size = DevLogFeedback2.#sizeOf(file);
+    if (size <= from)
+      return [];
+    const text = await Bun.file(file).slice(from, size).text();
+    this.#marks.set(app, size);
+    return text.split(`
+`).filter((line) => errorPattern.test(line) && !noisePattern.test(line)).slice(-this.#options.maxLines);
+  }
+  #pathOf(app) {
+    return path.join(this.#options.workspaceRoot, "local", "apps", app, "runtime", "dev.log");
+  }
+  static async previewUrl(workspaceRoot, app) {
+    const file = path.join(workspaceRoot, "local", "apps", app, "runtime", "dev.log");
+    if (!existsSync(file))
+      return;
+    const matches = [...(await Bun.file(file).text()).matchAll(/ready \(pid=\d+\) \u2014 (https?:\/\/\S+)/g)];
+    return matches.at(-1)?.[1];
+  }
+  static #sizeOf(file) {
+    return existsSync(file) ? statSync(file).size : 0;
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/feedback/PreviewChrome.ts
+import { existsSync as existsSync2 } from "fs";
+import { homedir } from "os";
+import path2 from "path";
+
+class PreviewChrome2 {
+  static pathEnvKey = "BUN_CHROME_PATH";
+  static backendEnvKey = "AKAN_CODE_WEBVIEW_BACKEND";
+  static executables = [
+    "chromium",
+    "chromium-browser",
+    "google-chrome-stable",
+    "google-chrome",
+    "brave-browser",
+    "microsoft-edge",
+    "chrome"
+  ];
+  static appBundles = [
+    "Google Chrome.app/Contents/MacOS/Google Chrome",
+    "Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+    "Chromium.app/Contents/MacOS/Chromium",
+    "Brave Browser.app/Contents/MacOS/Brave Browser",
+    "Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
+  ];
+  static get backend() {
+    const declared = process.env[PreviewChrome2.backendEnvKey];
+    if (declared === "webkit" || declared === "chrome")
+      return declared;
+    return process.platform === "darwin" ? "webkit" : "chrome";
+  }
+  static executable() {
+    const declared = process.env[PreviewChrome2.pathEnvKey];
+    if (declared)
+      return declared;
+    for (const name of PreviewChrome2.executables) {
+      const found = Bun.which(name);
+      if (found)
+        return found;
+    }
+    if (process.platform !== "darwin")
+      return;
+    for (const root of ["/Applications", path2.join(homedir(), "Applications")])
+      for (const bundle of PreviewChrome2.appBundles) {
+        const candidate = path2.join(root, bundle);
+        if (existsSync2(candidate))
+          return candidate;
+      }
+    return;
+  }
+  static get available() {
+    return PreviewChrome2.backend === "webkit" ? process.platform === "darwin" : !!PreviewChrome2.executable();
+  }
+  static backendOption() {
+    if (PreviewChrome2.backend === "webkit")
+      return "webkit";
+    const argv = ["--disable-dev-shm-usage"];
+    if (process.getuid?.() === 0)
+      argv.push("--no-sandbox");
+    return { type: "chrome", argv };
+  }
+  static dockerRuns = [
+    "apt-get update && apt-get install -y --no-install-recommends chromium fonts-liberation fonts-noto-color-emoji fonts-noto-cjk && rm -rf /var/lib/apt/lists/*"
+  ];
+  static unavailableReason() {
+    if (PreviewChrome2.available)
+      return;
+    if (PreviewChrome2.backend === "webkit")
+      return `The webkit WebView backend exists only on macOS. Set ${PreviewChrome2.backendEnvKey}=chrome and install a browser.`;
+    return [
+      "The page preview needs a browser and this machine has none on PATH.",
+      `Install one (${PreviewChrome2.dockerRuns[0]}) or point ${PreviewChrome2.pathEnvKey} at an existing Chrome.`
+    ].join(" ");
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/feedback/PreviewView.ts
+class PreviewView2 {
+  static get available() {
+    return typeof Bun.WebView === "function" && PreviewChrome2.available;
+  }
+  static unavailableReason() {
+    if (typeof Bun.WebView !== "function")
+      return "This Bun build has no WebView, so the page preview is off.";
+    return PreviewChrome2.unavailableReason();
+  }
+  static async probe(url, { screenshot = false, width = 1280, height = 800 } = {}) {
+    const logs = [];
+    const view = PreviewView2.#open({ width, height, onConsole: (line) => logs.push(line) });
+    try {
+      await view.navigate(url);
+      const result = {
+        url,
+        title: view.title,
+        consoleErrors: logs.filter((line) => line.startsWith("error") || line.startsWith("warn")),
+        pageErrors: PreviewView2.#strings(await view.evaluate(pageErrorsExpression)),
+        domFindings: PreviewView2.#strings(await view.evaluate(domFindingsExpression))
+      };
+      if (screenshot)
+        result.screenshot = await view.screenshot({ encoding: "base64" });
+      return result;
+    } finally {
+      await view.close();
+    }
+  }
+  static #open({ width, height, onConsole }) {
+    const Ctor = Bun.WebView;
+    return new Ctor({
+      width,
+      height,
+      dataStore: "ephemeral",
+      backend: PreviewChrome2.backendOption(),
+      console: (type, ...args) => onConsole(`${type} ${args.map(String).join(" ")}`)
+    });
+  }
+  static #strings(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+  }
+}
+var pageErrorsExpression = `(() => {
+  const found = [];
+  const root = document.getElementById("__next") || document.body;
+  const rendered = root ? Array.from(root.children).filter((el) => !["SCRIPT", "STYLE", "TEMPLATE", "LINK", "NOSCRIPT"].includes(el.tagName)) : [];
+  if (!rendered.length && !(root && root.innerText && root.innerText.trim())) found.push("The page body rendered empty.");
+  const overlay = document.querySelector("[data-nextjs-dialog], .error-overlay, #akan-error");
+  if (overlay) found.push("An error overlay is on the page: " + overlay.textContent.slice(0, 400));
+  return found;
+})()`;
+var domFindingsExpression = `(() => {
+  const found = [];
+  const all = Array.from(document.querySelectorAll("body *"));
+  const overflowing = all.filter((el) => el.scrollWidth > document.documentElement.clientWidth + 8);
+  if (overflowing.length) found.push(overflowing.length + " element(s) overflow the viewport horizontally, first: " + (overflowing[0].tagName + "." + overflowing[0].className).slice(0, 120));
+  const invisibleText = all.filter((el) => {
+    if (!el.textContent || !el.textContent.trim()) return false;
+    const style = getComputedStyle(el);
+    return style.color === style.backgroundColor && style.backgroundColor !== "rgba(0, 0, 0, 0)";
+  });
+  if (invisibleText.length) found.push(invisibleText.length + " element(s) render text in the same colour as their background.");
+  const unresolved = all.filter((el) => /(^|\\s)(bg|text|border)-(base-100|base-content|primary-content|error)(\\s|$)/.test(el.className || ""));
+  if (unresolved.length) found.push(unresolved.length + " element(s) use a dropped daisyUI colour slot that renders no CSS.");
+  return found;
+})()`;
+
+// pkgs/@akanjs/devkit/codeAgent/feedback/PreviewFeedback.ts
+class PreviewFeedback2 {
+  key = "preview";
+  #options;
+  #baseline = new Set;
+  constructor(options) {
+    this.#options = options;
+  }
+  async begin() {
+    this.#baseline = await AkanEditScope2.baseline(this.#options.cwd);
+  }
+  async observe() {
+    if (!this.#options.previewUrl || !PreviewView2.available)
+      return;
+    const scope = await AkanEditScope2.since(this.#options.cwd, this.#baseline);
+    if (!scope.touchesTsx)
+      return;
+    const findings = [];
+    const images = [];
+    for (const route of this.#options.routes ?? ["/en/"]) {
+      const url = new URL(route, this.#options.previewUrl).toString();
+      const probe = await PreviewView2.probe(url, { screenshot: !!this.#options.canSeeImages });
+      const problems = [...probe.pageErrors, ...probe.consoleErrors, ...probe.domFindings];
+      if (!problems.length)
+        continue;
+      findings.push(`**${url}**
+${problems.map((line) => `- ${line}`).join(`
+`)}`);
+      if (probe.screenshot)
+        images.push({ data: probe.screenshot, mimeType: "image/png" });
+    }
+    if (!findings.length)
+      return;
+    return { text: ["The rendered page has problems after your UI edits:", ...findings].join(`
+
+`), images };
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/feedback/TurnFeedback.ts
+class TurnFeedback2 {
+  #sources;
+  #options;
+  #spent = new Map;
+  constructor(sources, options) {
+    this.#sources = sources;
+    this.#options = options;
+  }
+  extension() {
+    return {
+      name: "akan-turn-feedback",
+      factory: (pi) => {
+        pi.on("agent_start", async () => {
+          await Promise.all(this.#sources.map((source) => TurnFeedback2.#quietly(() => source.begin())));
+        });
+        pi.on("agent_end", async () => {
+          const message = await this.collect();
+          if (message)
+            pi.sendUserMessage(message, { deliverAs: "followUp" });
+        });
+      }
+    };
+  }
+  async collect() {
+    const texts = [];
+    const images = [];
+    const reopened = [];
+    for (const source of this.#sources) {
+      const finding = await TurnFeedback2.#quietly(() => source.observe());
+      if (!finding) {
+        this.#spent.delete(source.key);
+        continue;
+      }
+      const spent = this.#spent.get(source.key) ?? 0;
+      if (spent >= this.#options.budget) {
+        this.#options.onNotice?.(`${source.key}: still failing after ${spent} attempts \u2014 handing back to you.`);
+        continue;
+      }
+      this.#spent.set(source.key, spent + 1);
+      reopened.push(source.key);
+      if (typeof finding === "string")
+        texts.push(finding);
+      else {
+        texts.push(finding.text);
+        images.push(...finding.images ?? []);
+      }
+    }
+    if (!texts.length)
+      return;
+    this.#options.onNotice?.(`${reopened.join(" \xB7 ")} reopened the turn \u2014 esc stops it`);
+    const text = [
+      "The previous turn left problems you cannot see from the transcript. Fix them, then stop.",
+      ...texts
+    ].join(`
+
+`);
+    return images.length ? [{ type: "text", text }, ...images.map((image) => ({ type: "image", ...image }))] : text;
+  }
+  static async#quietly(fn) {
+    try {
+      return await fn();
+    } catch {
+      return;
+    }
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/tools/AkanCli.ts
+import { existsSync as existsSync3 } from "fs";
+import path3 from "path";
+class AkanCli2 {
+  #cwd;
+  #entry;
+  constructor(cwd) {
+    this.#cwd = cwd;
+    this.#entry = AkanCli2.#resolveEntry();
+  }
+  async run(args, { timeoutMs = 300000 } = {}) {
+    const proc = Bun.spawn([process.execPath, this.#entry, ...args], {
+      cwd: this.#cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" }
+    });
+    const timer = setTimeout(() => proc.kill(), timeoutMs);
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited
+    ]);
+    clearTimeout(timer);
+    const output = stripAnsi(`${stdout}${stderr}`).trim();
+    return { command: `akan ${args.join(" ")}`, ok: exitCode === 0, exitCode, output };
+  }
+  static #resolveEntry() {
+    const candidates = [
+      path3.join(import.meta.dir, "index.js"),
+      path3.join(import.meta.dir, "..", "..", "..", "cli", "index.ts")
+    ];
+    return candidates.find((candidate) => existsSync3(candidate)) ?? Bun.main;
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/tools/AkanVerifier.ts
+class AkanVerifier2 {
+  #cli;
+  constructor(cwd) {
+    this.#cli = new AkanCli2(cwd);
+  }
+  async verify(scope) {
+    const steps = [];
+    const targets = [...scope.apps, ...scope.libs];
+    if (scope.needsSync)
+      for (const target of targets)
+        steps.push(await this.#cli.run(["sync", target]));
+    for (const target of targets)
+      steps.push(await this.#cli.run(["lint", target]));
+    for (const app of scope.apps)
+      steps.push(await this.#cli.run(["typecheck", app]));
+    if (scope.touchesTsx)
+      steps.push(await this.#cli.run(["quality", "ssr"]));
+    return { ok: steps.every((step) => step.ok), steps, scope };
+  }
+  static summarize(report, { tailLines = 40 } = {}) {
+    if (!report.steps.length)
+      return "No akan target was touched, so there was nothing to verify.";
+    if (report.ok)
+      return `Verification passed: ${report.steps.map((step) => step.command).join(", ")}.`;
+    const failed = report.steps.filter((step) => !step.ok);
+    const passed = report.steps.filter((step) => step.ok).map((step) => step.command);
+    const blocks = failed.map((step) => `### ${step.command} (exit ${step.exitCode})
+${tail(step.output, tailLines)}`);
+    return [
+      `Verification failed: ${failed.map((step) => step.command).join(", ")}.`,
+      passed.length ? `Passed: ${passed.join(", ")}.` : "",
+      ...blocks
+    ].filter(Boolean).join(`
+
+`);
+  }
+}
+var tail = (text, lines) => {
+  const all = text.split(`
+`);
+  return all.length <= lines ? text : `\u2026
+${all.slice(-lines).join(`
+`)}`;
+};
+
+// pkgs/@akanjs/devkit/codeAgent/feedback/VerifyFeedback.ts
+class VerifyFeedback2 {
+  key = "verify";
+  #options;
+  #verifier;
+  #baseline = new Set;
+  constructor(options) {
+    this.#options = options;
+    this.#verifier = new AkanVerifier2(options.cwd);
+  }
+  async begin() {
+    this.#baseline = await AkanEditScope2.baseline(this.#options.cwd);
+  }
+  async observe() {
+    const scope = await AkanEditScope2.since(this.#options.cwd, this.#baseline);
+    if (!scope.apps.length && !scope.libs.length)
+      return;
+    if (this.#options.readOnly)
+      return VerifyFeedback2.#readOnlyNotice(scope.needsSync, [...scope.apps, ...scope.libs]);
+    const report = await this.#verifier.verify(scope);
+    if (report.ok)
+      return;
+    return AkanVerifier2.summarize(report);
+  }
+  static #readOnlyNotice(needsSync, targets) {
+    if (!needsSync)
+      return;
+    return `Files were added or removed under ${targets.join(", ")}, so the generated barrels are stale. This profile does not write, so run \`akan sync ${targets.join(" ")}\` yourself before trusting a typecheck.`;
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/tools/AkanToolPack.ts
+import { Type } from "typebox";
+class AkanToolPack2 {
+  #options;
+  constructor(options) {
+    this.#options = options;
+  }
+  extension() {
+    return { name: "akan-tools", factory: async (pi) => await this.#register(pi) };
+  }
+  async names() {
+    const { ContextRunner } = await import("./context.runner-erfe68j5.js");
+    return [
+      ...new ContextRunner().listMcpTools(this.#options.mode).map((tool) => tool.name),
+      AkanToolPack2.verifyToolName
+    ];
+  }
+  static verifyToolName = "akan_verify";
+  async#register(pi) {
+    const { ContextRunner } = await import("./context.runner-erfe68j5.js");
+    const runner = new ContextRunner;
+    const guidelineNames = await AkanToolPack2.#guidelineNames();
+    for (const tool of runner.listMcpTools(this.#options.mode, { guidelineNames })) {
+      const description = tool.description ?? tool.name;
+      pi.registerTool({
+        name: tool.name,
+        label: tool.name,
+        description,
+        promptSnippet: `${tool.name}: ${description.split(".")[0] ?? description}`,
+        parameters: Type.Unsafe(tool.inputSchema),
+        execute: async (_id, params) => {
+          const result = await runner.callMcpTool(this.#options.workspace, tool.name, params ?? {}, {
+            mode: this.#options.mode
+          });
+          const text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+          return { content: [{ type: "text", text }], details: undefined };
+        }
+      });
+    }
+    this.#registerVerify(pi);
+  }
+  #registerVerify(pi) {
+    const verifier = new AkanVerifier2(this.#options.cwd);
+    pi.registerTool({
+      name: AkanToolPack2.verifyToolName,
+      label: "akan verify",
+      description: "Run the akan validation chain (sync, lint, typecheck, and quality ssr for .tsx changes) over everything the working tree has changed, and report what failed. Call this after editing before you finish.",
+      promptSnippet: "akan_verify: run sync/lint/typecheck/quality over the working tree's changes",
+      parameters: Type.Object({}),
+      execute: async () => {
+        const scope = await AkanEditScope2.since(this.#options.cwd, new Set);
+        const report = await verifier.verify(scope);
+        return {
+          content: [{ type: "text", text: AkanVerifier2.summarize(report) }],
+          details: undefined,
+          isError: !report.ok
+        };
+      }
+    });
+  }
+  static async#guidelineNames() {
+    try {
+      const { Prompter } = await import("./prompter-76k56b37.js");
+      return await Prompter.listGuidelines();
+    } catch {
+      return [];
+    }
+  }
+}
+
+// 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;
+  constructor(options) {
+    this.#options = options;
+  }
+  names() {
+    return this.#options.profile.session.store === "file" ? MailToolPack2.toolNames : [];
+  }
+  extension() {
+    if (!this.names().length)
+      return;
+    return { name: "akan-mail", factory: (pi) => this.#register(pi) };
+  }
+  #register(pi) {
+    pi.registerTool({
+      name: "list_peers",
+      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: Type3.Object({}),
+      execute: async () => ({
+        content: [{ type: "text", text: MailToolPack2.#render(this.#options.mailbox()?.peers() ?? []) }],
+        details: undefined
+      })
+    });
+    pi.registerTool({
+      name: "send_peer_message",
+      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: 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();
+        const peer = mailbox?.find(params.to);
+        if (!mailbox || !peer)
+          return {
+            content: [{ type: "text", text: `No live session matches "${params.to}". Call list_peers.` }],
+            details: undefined,
+            isError: true
+          };
+        try {
+          mailbox.send(peer.id, params.message);
+          return { content: [{ type: "text", text: `Sent to ${peer.name}.` }], details: undefined };
+        } catch (error) {
+          return { content: [{ type: "text", text: String(error) }], details: undefined, isError: true };
+        }
+      }
+    });
+  }
+  static #render(peers) {
+    if (!peers.length)
+      return "No other akan code session is running in this workspace.";
+    return peers.map((peer) => `${peer.name} (${peer.id.slice(0, 8)}) \u2014 ${peer.cwd}`).join(`
+`);
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/tools/McpToolPack.ts
+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;
+  #token;
+  constructor(ref, token) {
+    this.ref = ref;
+    this.#token = token;
+  }
+  async connect() {
+    if (this.ref.transport === "stdio")
+      this.#spawn();
+    const initialize = await this.#call("initialize", {
+      protocolVersion,
+      capabilities: {},
+      clientInfo: { name: "akan-code", version: "1" }
+    });
+    if (initialize.error)
+      throw new Error(initialize.error.message);
+    await this.#notify("notifications/initialized");
+    return this;
+  }
+  async listTools() {
+    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 });
+    if (response.error)
+      return { text: response.error.message, isError: true };
+    return { text: McpClient2.#renderContent(response.result?.content), isError: !!response.result?.isError };
+  }
+  close() {
+    this.#proc?.kill();
+    this.#proc = undefined;
+    for (const resolve of this.#pending.values())
+      resolve({ error: { code: -1, message: "MCP server closed" } });
+    this.#pending.clear();
+  }
+  #spawn() {
+    if (!this.ref.command)
+      throw new Error(`MCP server "${this.ref.name}" declares no command`);
+    this.#proc = Bun.spawn([this.ref.command, ...this.ref.args ?? []], {
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "ignore",
+      env: { ...process.env, ...this.ref.env }
+    });
+    this.#readStdout();
+  }
+  async#readStdout() {
+    const decoder = new TextDecoder;
+    for await (const chunk of this.#proc?.stdout ?? []) {
+      this.#buffer += decoder.decode(chunk, { stream: true });
+      let index = this.#buffer.indexOf(`
+`);
+      while (index >= 0) {
+        const line = this.#buffer.slice(0, index).trim();
+        this.#buffer = this.#buffer.slice(index + 1);
+        if (line)
+          this.#receive(line);
+        index = this.#buffer.indexOf(`
+`);
+      }
+    }
+  }
+  #receive(line) {
+    try {
+      const message = JSON.parse(line);
+      if (typeof message.id !== "number")
+        return;
+      this.#pending.get(message.id)?.(message);
+      this.#pending.delete(message.id);
+    } catch {}
+  }
+  async#call(method, params) {
+    this.#nextId += 1;
+    const id = this.#nextId;
+    const request = { jsonrpc: "2.0", id, method, params };
+    if (this.ref.transport === "http")
+      return await this.#post(request);
+    this.#proc?.stdin.write(`${JSON.stringify(request)}
+`);
+    return await new Promise((resolve) => {
+      this.#pending.set(id, resolve);
+      setTimeout(() => {
+        if (!this.#pending.delete(id))
+          return;
+        resolve({ error: { code: -2, message: `MCP server "${this.ref.name}" timed out on ${method}` } });
+      }, 30000);
+    });
+  }
+  async#notify(method) {
+    const request = { jsonrpc: "2.0", method };
+    if (this.ref.transport === "http")
+      await this.#post(request);
+    else
+      this.#proc?.stdin.write(`${JSON.stringify(request)}
+`);
+  }
+  async#post(body) {
+    if (!this.ref.url)
+      throw new Error(`MCP server "${this.ref.name}" declares no url`);
+    const response = await fetch(this.ref.url, {
+      method: "POST",
+      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())
+      return {};
+    const payload = text.startsWith("event:") || text.startsWith("data:") ? McpClient2.#firstSseData(text) : text;
+    return payload ? JSON.parse(payload) : {};
+  }
+  static #firstSseData(text) {
+    return text.split(`
+`).find((line) => line.startsWith("data:"))?.slice(5).trim();
+  }
+  static #renderContent(content) {
+    if (!Array.isArray(content))
+      return typeof content === "string" ? content : JSON.stringify(content ?? null);
+    return content.map((part) => part.type === "text" ? part.text ?? "" : JSON.stringify(part)).join(`
+`);
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/tools/McpToolPack.ts
+class McpToolPack2 {
+  #clients = [];
+  #status = [];
+  #onNotice;
+  constructor(onNotice) {
+    this.#onNotice = onNotice;
+  }
+  static async connect(options) {
+    const refs = McpToolPack2.#refs(options);
+    if (!refs.length)
+      return;
+    const pack = new McpToolPack2(options.onNotice);
+    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 opened = await McpToolPack2.#openRefreshing(ref, token, options.onNotice);
+        const status = {
+          ...base,
+          tools: opened.tools.map((tool) => McpToolPack2.#nameOf(ref.name, tool.name)),
+          auth: opened.token ? "authorized" : "none"
+        };
+        pack.#clients.push({ ...opened, status, renewing: undefined, refused: undefined });
+        pack.#status.push(status);
+      } 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;
+  }
+  static async#openRefreshing(ref, token, onNotice) {
+    try {
+      return await McpToolPack2.#open(ref, token);
+    } catch (error) {
+      if (!(error instanceof McpUnauthorized2) || !token)
+        throw error;
+      const retry = await McpSignIn.retryToken(ref, token, onNotice);
+      if (!retry)
+        throw error;
+      return await McpToolPack2.#open(ref, retry);
+    }
+  }
+  static async#open(ref, token) {
+    const client = await new McpClient2(ref, token).connect();
+    return { client, tools: await client.listTools(), token };
+  }
+  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) };
+  }
+  close() {
+    for (const { client } of this.#clients)
+      client.close();
+  }
+  #register(pi) {
+    for (const server of this.#clients)
+      for (const tool of server.tools) {
+        const name = McpToolPack2.#nameOf(server.client.ref.name, tool.name);
+        const description = tool.description ?? tool.name;
+        pi.registerTool({
+          name,
+          label: `${server.client.ref.name}: ${tool.name}`,
+          description,
+          promptSnippet: `${name}: ${description.split(".")[0] ?? description}`,
+          parameters: Type4.Unsafe(tool.inputSchema),
+          execute: async (_id, params) => {
+            const result = await this.#call(server, tool.name, params ?? {});
+            return {
+              content: [{ type: "text", text: codeAgentClip(result.text, codeAgentOutputChars) }],
+              details: undefined,
+              isError: result.isError
+            };
+          }
+        });
+      }
+  }
+  async#call(server, tool, args) {
+    const client = server.client;
+    try {
+      return await client.callTool(tool, args);
+    } catch (error) {
+      if (!(error instanceof McpUnauthorized2))
+        throw error;
+    }
+    const renewed = await this.#renewed(server, client);
+    try {
+      if (renewed)
+        return await renewed.callTool(tool, args);
+    } catch (error) {
+      if (!(error instanceof McpUnauthorized2))
+        throw error;
+      McpToolPack2.#refuse(server, renewed);
+    }
+    throw new Error(`MCP server "${client.ref.name}" needs signing in \u2014 /mcp login ${client.ref.name}`);
+  }
+  static #refuse(server, client) {
+    server.refused = client;
+    server.status.auth = "required";
+  }
+  async#renewed(server, refused) {
+    if (server.client === refused && server.refused !== refused)
+      server.renewing ??= this.#renew(server, refused).finally(() => {
+        server.renewing = undefined;
+      });
+    if (server.renewing)
+      return await server.renewing;
+    return server.client === server.refused ? undefined : server.client;
+  }
+  async#renew(server, refused) {
+    const token = server.token ? await McpSignIn.retryToken(refused.ref, server.token, this.#onNotice) : undefined;
+    const client = token ? await McpToolPack2.#reopen(refused.ref, token) : undefined;
+    if (!client) {
+      McpToolPack2.#refuse(server, refused);
+      return;
+    }
+    refused.close();
+    server.client = client;
+    server.token = token;
+    return client;
+  }
+  static async#reopen(ref, token) {
+    try {
+      return await new McpClient2(ref, token).connect();
+    } catch (error) {
+      if (error instanceof McpUnauthorized2)
+        return;
+      throw error;
+    }
+  }
+  static #nameOf(server, tool) {
+    return `mcp__${server.replace(/[^a-zA-Z0-9_]/g, "_")}__${tool}`;
+  }
+  static #refs(options) {
+    if (options.profile.tools.mcp === "off")
+      return [];
+    const declared = Array.isArray(options.profile.tools.mcp) ? options.profile.tools.mcp : [];
+    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 Type5 } from "typebox";
+var snippetChars = 240;
+
+class SessionToolPack2 {
+  #options;
+  constructor(options) {
+    this.#options = options;
+  }
+  static toolNames = ["session_search", "session_read"];
+  names() {
+    return this.#options.profile.session.crossSession ? SessionToolPack2.toolNames : [];
+  }
+  extension() {
+    if (!this.names().length)
+      return;
+    return { name: "akan-sessions", factory: (pi) => this.#register(pi) };
+  }
+  #register(pi) {
+    pi.registerTool({
+      name: "session_search",
+      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: 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);
+        return { content: [{ type: "text", text: matches }], details: undefined };
+      }
+    });
+    pi.registerTool({
+      name: "session_read",
+      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: 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") };
+      }
+    });
+  }
+  async#search(query, limit) {
+    const needle = query.toLowerCase();
+    const sessions = (await this.#list()).filter((session) => session.id !== this.#options.currentSessionId() && session.allMessagesText.toLowerCase().includes(needle));
+    if (!sessions.length)
+      return `No earlier session mentions "${query}".`;
+    return sessions.slice(0, limit).map((session) => {
+      const at = session.allMessagesText.toLowerCase().indexOf(needle);
+      const snippet = session.allMessagesText.slice(Math.max(0, at - 80), at + snippetChars).replace(/\s+/g, " ");
+      return `- ${session.id} (${session.modified.toISOString().slice(0, 10)}${session.name ? `, "${session.name}"` : ""})
+  \u2026${snippet}\u2026`;
+    }).join(`
+`);
+  }
+  async#read(sessionId) {
+    const session = (await this.#list()).find((entry) => entry.id === sessionId);
+    if (!session)
+      return `No session with id ${sessionId} in this workspace.`;
+    return codeAgentClip2(session.allMessagesText, codeAgentOutputChars2 * 2);
+  }
+  async#list() {
+    return await SessionManager.list(this.#options.cwd, akanCodePaths2.sessionsDir(this.#options.workspaceRoot));
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/tools/WebToolPack.ts
+import { codeAgentClip as codeAgentClip3, codeAgentOutputChars as codeAgentOutputChars3 } from "akanjs/common";
+import { Type as Type6 } from "typebox";
+
+class WebToolPack2 {
+  #options;
+  constructor(options) {
+    this.#options = options;
+  }
+  static providers = [
+    {
+      name: "brave",
+      envKey: "BRAVE_API_KEY",
+      search: async (key, query, count) => {
+        const url = `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${count}`;
+        const response = await fetch(url, { headers: { "x-subscription-token": key, accept: "application/json" } });
+        const body = await response.json();
+        return (body.web?.results ?? []).map((r) => `- ${r.title}
+  ${r.url}
+  ${r.description}`).join(`
+`);
+      }
+    },
+    {
+      name: "tavily",
+      envKey: "TAVILY_API_KEY",
+      search: async (key, query, count) => {
+        const response = await fetch("https://api.tavily.com/search", {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ api_key: key, query, max_results: count })
+        });
+        const body = await response.json();
+        return (body.results ?? []).map((r) => `- ${r.title}
+  ${r.url}
+  ${r.content}`).join(`
+`);
+      }
+    }
+  ];
+  names() {
+    const names = [];
+    if (this.#options.profile.tools.web.fetch)
+      names.push("web_fetch");
+    if (this.#options.profile.tools.web.search && WebToolPack2.#provider())
+      names.push("web_search");
+    return names;
+  }
+  extension() {
+    if (!this.names().length)
+      return;
+    return { name: "akan-web", factory: (pi) => this.#register(pi) };
+  }
+  #register(pi) {
+    if (this.#options.profile.tools.web.fetch)
+      this.#registerFetch(pi);
+    const provider = WebToolPack2.#provider();
+    if (this.#options.profile.tools.web.search && provider)
+      this.#registerSearch(pi, provider);
+  }
+  #registerFetch(pi) {
+    const allowHosts = this.#options.profile.network.allowHosts;
+    pi.registerTool({
+      name: "web_fetch",
+      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: Type6.Object({ url: Type6.String({ description: "Absolute http(s) URL." }) }),
+      execute: async (_id, params) => {
+        const refusal = WebToolPack2.#refuseHost(params.url, allowHosts);
+        if (refusal)
+          return { content: [{ type: "text", text: refusal }], details: undefined, isError: true };
+        const response = await fetch(params.url, { signal: AbortSignal.timeout(20000), redirect: "follow" });
+        const text = WebToolPack2.#readable(await response.text());
+        return {
+          content: [
+            { type: "text", text: `${response.status} ${params.url}
+
+${codeAgentClip3(text, codeAgentOutputChars3)}` }
+          ],
+          details: undefined,
+          isError: !response.ok
+        };
+      }
+    });
+  }
+  #registerSearch(pi, provider) {
+    pi.registerTool({
+      name: "web_search",
+      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: 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] ?? "";
+        const results = await provider.search(key, params.query, params.count ?? 5);
+        return {
+          content: [{ type: "text", text: codeAgentClip3(results || "(no results)", codeAgentOutputChars3) }],
+          details: undefined
+        };
+      }
+    });
+  }
+  static #provider() {
+    return WebToolPack2.providers.find((provider) => !!process.env[provider.envKey]);
+  }
+  static #refuseHost(url, allowHosts) {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      return `"${url}" is not an absolute URL.`;
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+      return "Only http and https URLs can be fetched.";
+    if (allowHosts?.length && !allowHosts.includes(parsed.hostname))
+      return `This profile only allows ${allowHosts.join(", ")}.`;
+    return;
+  }
+  static #readable(html) {
+    return html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/[ \t]+/g, " ").replace(/\n{3,}/g, `
+
+`).trim();
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/tools/AkanCodePlugins.ts
+class AkanCodePlugins2 {
+  static async build(options) {
+    const mcp = await McpToolPack2.connect({
+      workspaceRoot: options.workspace.workspaceRoot,
+      profile: options.profile,
+      ...options.onNotice ? { onNotice: options.onNotice } : {}
+    });
+    const dispose = () => mcp?.close();
+    const mcpStatus = mcp?.status ?? [];
+    const web = new WebToolPack2({ profile: options.profile });
+    const sessions = new SessionToolPack2({
+      workspaceRoot: options.workspace.workspaceRoot,
+      cwd: options.cwd,
+      profile: options.profile,
+      currentSessionId: options.currentSessionId
+    });
+    const mail = new MailToolPack2({ profile: options.profile, mailbox: options.mailbox });
+    const onAsk = options.onAsk;
+    const ask = onAsk ? new AskToolPack({ profile: options.profile, ask: onAsk }) : undefined;
+    const shared = {
+      extensions: [mcp?.extension(), web.extension(), sessions.extension(), mail.extension(), ask?.extension()].filter((entry) => !!entry),
+      toolNames: [
+        ...mcp?.toolNames ?? [],
+        ...web.names(),
+        ...sessions.names(),
+        ...mail.names(),
+        ...ask?.names() ?? []
+      ]
+    };
+    if (!options.profile.tools.akan)
+      return { ...shared, mcp: mcpStatus, dispose };
+    const readOnly = !options.profile.tools.builtin.includes("write");
+    const pack = new AkanToolPack2({
+      workspace: options.workspace,
+      cwd: options.cwd,
+      mode: readOnly ? "readonly" : "apply"
+    });
+    const extensions = [pack.extension()];
+    const subagent = SubagentPool2.extensionFor({
+      workspace: options.workspace,
+      cwd: options.cwd,
+      parent: options.profile,
+      depth: options.depth,
+      ...options.subagentSpend ? { spend: options.subagentSpend } : {},
+      ...options.onNotice ? { onNotice: options.onNotice } : {},
+      ...options.onAgents ? { onAgents: options.onAgents } : {}
+    });
+    if (subagent)
+      extensions.push(subagent);
+    const sources = await AkanCodePlugins2.#sources(options, readOnly);
+    if (sources.length)
+      extensions.push(new TurnFeedback2(sources, {
+        budget: options.profile.limits.feedback,
+        ...options.onNotice ? { onNotice: options.onNotice } : {}
+      }).extension());
+    return {
+      extensions: [...extensions, ...shared.extensions],
+      toolNames: [...await pack.names(), ...subagent ? [SubagentPool2.toolName] : [], ...shared.toolNames],
+      mcp: mcpStatus,
+      dispose
+    };
+  }
+  static async#sources(options, readOnly) {
+    const sources = [
+      new VerifyFeedback2({ cwd: options.cwd, readOnly }),
+      new DevLogFeedback2({ workspaceRoot: options.workspace.workspaceRoot, cwd: options.cwd, apps: options.apps })
+    ];
+    const previewUrl = await AkanCodePlugins2.#previewUrl(options);
+    if (!previewUrl)
+      return sources;
+    const reason = PreviewView2.unavailableReason();
+    if (reason)
+      options.onNotice?.(reason);
+    else
+      sources.push(new PreviewFeedback2({ cwd: options.cwd, previewUrl, canSeeImages: options.canSeeImages }));
+    return sources;
+  }
+  static async#previewUrl(options) {
+    for (const app of options.apps) {
+      const url = await DevLogFeedback2.previewUrl(options.workspace.workspaceRoot, app);
+      if (url)
+        return url;
+    }
+    return;
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/agent/AkanCodeServices.ts
+import { existsSync as existsSync7, mkdirSync, mkdtempSync } from "fs";
+import { tmpdir } from "os";
+import path7 from "path";
+import { ModelRuntime, SessionManager as SessionManager2, SettingsManager } from "@earendil-works/pi-coding-agent";
+
+// pkgs/@akanjs/devkit/codeAgent/tools/AkanEnvKeys.ts
+import { existsSync as existsSync4, readFileSync } from "fs";
+import path4 from "path";
+
+class AkanEnvKeys2 {
+  static async apply(runtime, workspaceRoot) {
+    const applied = [];
+    for (const [name, value] of AkanEnvKeys2.#entries(workspaceRoot)) {
+      const provider = AkanEnvKeys2.#providerOf(name);
+      if (!provider || !value)
+        continue;
+      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 = path4.join(workspaceRoot, ".env");
+    if (!existsSync4(file))
+      return fromProcess;
+    const fromFile = readFileSync(file, "utf8").split(`
+`).map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && line.includes("=")).map((line) => {
+      const index = line.indexOf("=");
+      return [
+        line.slice(0, index).trim(),
+        line.slice(index + 1).trim().replace(/^["']|["']$/g, "")
+      ];
+    });
+    return [...fromFile, ...fromProcess];
+  }
+  static #providerOf(name) {
+    const match = /^([A-Z0-9_]+)_API_KEY$/.exec(name);
+    return match?.[1]?.toLowerCase().replace(/_/g, "-");
+  }
+}
+
+// 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 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];
+  }
+  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 });
+      }
+    }
+    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;
+        const body = AkanContextFiles.#applied(raw);
+        if (body !== undefined)
+          files.push({ path: file, content: body });
+      }
+    }
+    return files;
+  }
+  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 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 [];
+    }
+  }
+  static #read(file) {
+    try {
+      if (!existsSync5(file) || !statSync2(file).isFile())
+        return;
+      return readFileSync2(file, "utf8").replace(/^\uFEFF/, "");
+    } catch {
+      return;
+    }
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/agent/akanSystemPrompt.ts
+var akanSystemPrompt2 = (profile) => {
+  const lines = [
+    "You are the akan coding agent, running inside an Akan.js workspace.",
+    "",
+    "- 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"))
+    lines.push("- After editing, call `akan_verify`. It runs sync, lint, typecheck and the SSR check over what the working tree changed. A turn that edits and does not verify is not finished.");
+  else
+    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.");
+  return lines.join(`
+`);
+};
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeSessionIndex.ts
+import { existsSync as existsSync6, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
+import path6 from "path";
+
+// pkgs/@akanjs/devkit/codeAgent/agent/jsonLines.ts
+import { closeSync, openSync, readFileSync as readFileSync3, readSync, statSync as statSync3 } from "fs";
+var readHead = (file, maxBytes) => {
+  const fd = openSync(file, "r");
+  try {
+    const head = Buffer.alloc(maxBytes);
+    return head.subarray(0, readSync(fd, head, 0, maxBytes, 0)).toString("utf8");
+  } finally {
+    closeSync(fd);
+  }
+};
+var readJsonLines = (file, maxBytes) => {
+  try {
+    const text = maxBytes !== undefined && statSync3(file).size > maxBytes ? readHead(file, maxBytes) : readFileSync3(file, "utf8");
+    return text.split(`
+`).filter((line) => !!line.trim());
+  } catch {
+    return [];
+  }
+};
+var parseJsonLine = (line) => {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return;
+  }
+};
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeSessionIndex.ts
+class CodeSessionIndex2 {
+  static readLimit = 512 * 1024;
+  static list(dir, limit = 30) {
+    if (!existsSync6(dir))
+      return [];
+    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 (!existsSync6(dir))
+      return;
+    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 statSync4(file).mtimeMs;
+    } catch {
+      return 0;
+    }
+  }
+  static #read(file, updatedAt) {
+    const lines = readJsonLines(file, CodeSessionIndex2.readLimit);
+    if (!lines.length)
+      return;
+    const entry = { id: "", file, name: undefined, opening: "", updatedAt, turns: 0 };
+    for (const line of lines) {
+      const record = parseJsonLine(line);
+      if (!record)
+        continue;
+      if (record.type === "session" && typeof record.id === "string")
+        entry.id = record.id;
+      if (record.type === "session_info" && typeof record.name === "string")
+        entry.name = record.name;
+      if (record.type !== "message")
+        continue;
+      const message = record.message;
+      if (message?.role !== "user")
+        continue;
+      entry.turns += 1;
+      if (!entry.opening)
+        entry.opening = CodeSessionIndex2.#text(message.content);
+    }
+    return entry.id ? entry : undefined;
+  }
+  static #text(content) {
+    const text = typeof content === "string" ? content : Array.isArray(content) ? content.map((part) => typeof part === "object" && part && ("text" in part) ? String(part.text) : "").join(" ") : "";
+    return text.replace(/\s+/g, " ").trim();
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/agent/AkanCodeServices.ts
+class AkanCodeServices2 {
+  static settings() {
+    return SettingsManager.inMemory({
+      enableInstallTelemetry: false,
+      enableAnalytics: false,
+      quietStartup: true,
+      compaction: { reserveTokens: 32768 }
+    });
+  }
+  static async runtime(workspaceRoot, proxy = null) {
+    mkdirSync(akanCodePaths2.globalDir(), { recursive: true, mode: 448 });
+    const runtime = await ModelRuntime.create({
+      authPath: proxy ? path7.join(mkdtempSync(path7.join(tmpdir(), "akan-code-proxy-")), "auth.json") : akanCodePaths2.authFile(),
+      modelsPath: akanCodePaths2.modelsFile()
+    });
+    if (proxy)
+      await proxy.apply(runtime);
+    else
+      await AkanEnvKeys2.apply(runtime, workspaceRoot);
+    return runtime;
+  }
+  static sessions(workspaceRoot, cwd, profile, resume) {
+    if (profile.session.store === "memory")
+      return SessionManager2.inMemory(cwd);
+    const dir = akanCodePaths2.sessionsDir(workspaceRoot);
+    mkdirSync(dir, { recursive: true });
+    const manager = SessionManager2.create(cwd, dir);
+    if (!resume)
+      return manager;
+    const file = CodeSessionIndex2.fileOf(dir, resume);
+    if (!file)
+      throw new Error(`No stored session ${resume} in ${dir}`);
+    manager.setSessionFile(file);
+    return manager;
+  }
+  static #skillPaths(profile, workspaceRoot) {
+    if (!profile.context.skills)
+      return [];
+    const dirs = [
+      akanCodePaths2.builtinSkillsDir(),
+      akanCodePaths2.globalSkillsDir(),
+      akanCodePaths2.skillsDir(workspaceRoot)
+    ];
+    return dirs.filter((dir) => !!dir && existsSync7(dir));
+  }
+  static resourceOptions(options) {
+    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),
+      extensionFactories: options.extensions
+    };
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeAgentAsks.ts
+class CodeAgentAsks2 {
+  #question;
+  #approvals = new Map;
+  #nextId = 0;
+  #epoch = Date.now().toString(36);
+  get pendingQuestionId() {
+    return this.#question?.question.questionId;
+  }
+  questionOf(questionId) {
+    return this.#question?.question.questionId === questionId ? this.#question.question : undefined;
+  }
+  get hasPendingApproval() {
+    return this.#approvals.size > 0;
+  }
+  nextId(prefix) {
+    this.#nextId += 1;
+    return `${prefix}${this.#epoch}.${this.#nextId}`;
+  }
+  openQuestion(question) {
+    this.#question?.deferred.resolve("");
+    const deferred = Promise.withResolvers();
+    this.#question = { question, deferred };
+    return deferred.promise;
+  }
+  answer(id, text) {
+    if (this.#question?.question.questionId !== id)
+      return false;
+    const { deferred } = this.#question;
+    this.#question = undefined;
+    deferred.resolve(text);
+    return true;
+  }
+  openApproval(id) {
+    const deferred = Promise.withResolvers();
+    this.#approvals.set(id, deferred);
+    return deferred.promise;
+  }
+  resolveApproval(id, approved) {
+    const deferred = this.#approvals.get(id);
+    if (!deferred)
+      return false;
+    this.#approvals.delete(id);
+    deferred.resolve(approved);
+    return true;
+  }
+  clear() {
+    this.#question?.deferred.resolve("");
+    this.#question = undefined;
+    for (const deferred of this.#approvals.values())
+      deferred.resolve(false);
+    this.#approvals.clear();
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeAgentEventMapper.ts
+import {
+  codeAgentClip as codeAgentClip4,
+  codeAgentLabelChars,
+  codeAgentOutputChars as codeAgentOutputChars4
+} from "akanjs/common";
+
+// pkgs/@akanjs/devkit/codeAgent/agent/stringArg.ts
+var stringArg = (args, key) => {
+  if (!args || typeof args !== "object")
+    return;
+  const value = args[key];
+  return typeof value === "string" && value ? value : undefined;
+};
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeAgentEventMapper.ts
+var toolOps = {
+  read: "read",
+  write: "write",
+  edit: "write",
+  ls: "list",
+  find: "search",
+  grep: "search",
+  bash: "execute"
+};
+
+class CodeAgentEventMapper2 {
+  #turn = 0;
+  #turnId = "";
+  #outcome;
+  #openTools = new Map;
+  #blocked = new Map;
+  get turnId() {
+    return this.#turnId;
+  }
+  map(event) {
+    switch (event.type) {
+      case "agent_start":
+        this.#turn += 1;
+        this.#turnId = `t${this.#turn}`;
+        this.#outcome = undefined;
+        return [{ type: "turn_start", turnId: this.#turnId }];
+      case "agent_end":
+        return [
+          ...this.flushBlocked(),
+          { type: "turn_end", turnId: this.#turnId, stopReason: this.#stopReason(event) }
+        ];
+      case "agent_settled":
+        return [{ type: "idle" }];
+      case "message_update":
+        return this.#mapDelta(event);
+      case "message_end":
+        return this.#mapMessage(event);
+      case "tool_execution_start": {
+        const tool = this.#summary(event.toolCallId, event.toolName, event.args);
+        this.#openTools.set(event.toolCallId, tool);
+        return [{ type: "tool_start", turnId: this.#turnId, tool }];
+      }
+      case "tool_execution_update":
+        return [
+          {
+            type: "tool_progress",
+            turnId: this.#turnId,
+            toolCallId: event.toolCallId,
+            text: codeAgentClip4(CodeAgentEventMapper2.#renderToolText(event.partialResult), codeAgentLabelChars)
+          }
+        ];
+      case "tool_execution_end":
+        return [this.#mapToolEnd(event)];
+      case "queue_update":
+        return [{ type: "queue", steering: [...event.steering], followUp: [...event.followUp] }];
+      case "compaction_start":
+        return [{ type: "compaction", phase: "start", reason: event.reason }];
+      case "compaction_end":
+        return [
+          {
+            type: "compaction",
+            phase: "end",
+            reason: event.reason,
+            ...event.errorMessage ? { error: event.errorMessage } : {},
+            ...event.aborted ? { aborted: true } : {}
+          }
+        ];
+      case "auto_retry_start":
+        return [
+          {
+            type: "retry",
+            attempt: event.attempt,
+            maxAttempts: event.maxAttempts,
+            delayMs: event.delayMs,
+            message: event.errorMessage
+          }
+        ];
+      default:
+        return [];
+    }
+  }
+  markBlocked(toolCallId, toolName, args, reason) {
+    this.#blocked.set(toolCallId, reason);
+    if (this.#openTools.has(toolCallId))
+      return [];
+    const tool = this.#summary(toolCallId, toolName, args);
+    this.#openTools.set(toolCallId, tool);
+    return [{ type: "tool_start", turnId: this.#turnId, tool }];
+  }
+  flushBlocked() {
+    const frames = [];
+    for (const [toolCallId, reason] of this.#blocked) {
+      const tool = this.#openTools.get(toolCallId);
+      if (!tool)
+        continue;
+      this.#openTools.delete(toolCallId);
+      frames.push({
+        type: "tool_end",
+        turnId: this.#turnId,
+        tool,
+        outcome: "blocked",
+        output: reason,
+        truncated: false
+      });
+    }
+    this.#blocked.clear();
+    return frames;
+  }
+  #mapToolEnd(event) {
+    const tool = this.#openTools.get(event.toolCallId) ?? this.#summary(event.toolCallId, event.toolName, undefined);
+    this.#openTools.delete(event.toolCallId);
+    const reason = this.#blocked.get(event.toolCallId);
+    this.#blocked.delete(event.toolCallId);
+    const full = reason ?? CodeAgentEventMapper2.#renderToolText(event.result);
+    return {
+      type: "tool_end",
+      turnId: this.#turnId,
+      tool,
+      outcome: reason ? "blocked" : event.isError ? "error" : "ok",
+      output: codeAgentClip4(full, codeAgentOutputChars4),
+      truncated: full.length > codeAgentOutputChars4
+    };
+  }
+  noteOutcome(reason) {
+    this.#outcome = reason;
+  }
+  #stopReason(event) {
+    const noted = this.#outcome;
+    this.#outcome = undefined;
+    if (noted)
+      return noted;
+    if (event.willRetry)
+      return "error";
+    const last = event.messages.at(-1);
+    if (last?.stopReason === "aborted")
+      return "aborted";
+    if (last?.stopReason === "error")
+      return "error";
+    if (last?.stopReason === "length")
+      return "truncated";
+    return "done";
+  }
+  #summary(toolCallId, name, args) {
+    const path = stringArg(args, "path");
+    return {
+      toolCallId,
+      name,
+      op: toolOps[name] ?? "other",
+      ...path ? { path } : {},
+      title: codeAgentClip4(`${name}${CodeAgentEventMapper2.#renderArgs(args)}`, codeAgentLabelChars)
+    };
+  }
+  #mapDelta(event) {
+    const inner = event.assistantMessageEvent;
+    if (inner.type === "text_delta")
+      return [{ type: "text_delta", turnId: this.#turnId, text: inner.delta }];
+    if (inner.type === "thinking_delta")
+      return [{ type: "thinking_delta", turnId: this.#turnId, text: inner.delta }];
+    return [];
+  }
+  #mapMessage(event) {
+    const message = event.message;
+    if (message.role !== "assistant" && message.role !== "user")
+      return [];
+    const text = CodeAgentEventMapper2.#renderContent(message.content);
+    if (!text)
+      return [];
+    return [{ type: "message", turnId: this.#turnId, role: message.role, text }];
+  }
+  static #renderArgs(args) {
+    if (!args || typeof args !== "object")
+      return "";
+    const entries = Object.entries(args).filter(([, value]) => value !== undefined);
+    if (!entries.length)
+      return "";
+    const rendered = entries.map(([key, value]) => `${key}=${CodeAgentEventMapper2.#renderArgValue(value)}`).join(" ");
+    return `(${codeAgentClip4(rendered, 120)})`;
+  }
+  static #renderArgValue(value) {
+    if (Array.isArray(value))
+      return `${value.length} item${value.length === 1 ? "" : "s"}`;
+    if (value && typeof value === "object") {
+      const keys = Object.keys(value).length;
+      return `{${keys} key${keys === 1 ? "" : "s"}}`;
+    }
+    return codeAgentClip4(String(value), 60);
+  }
+  static #renderContent(content) {
+    if (typeof content === "string")
+      return content;
+    if (!Array.isArray(content))
+      return "";
+    return content.filter((part) => !!part && typeof part === "object" && part.type === "text").map((part) => part.text).join("");
+  }
+  static #renderToolText(value) {
+    if (typeof value === "string")
+      return value;
+    if (value && typeof value === "object" && "content" in value)
+      return CodeAgentEventMapper2.#renderContent(value.content);
+    return value === undefined ? "" : JSON.stringify(value);
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeAgentGate.ts
+import path8 from "path";
+var writeTools = new Set(["write", "edit"]);
+var commandTools = new Set(["bash"]);
+
+class CodeAgentGate2 {
+  #profile;
+  #deny;
+  #allow;
+  #deniedFragments;
+  constructor(profile) {
+    this.#profile = profile;
+    this.#deny = (profile.paths.deny ?? []).map((pattern) => new Bun.Glob(pattern));
+    this.#allow = (profile.paths.allow ?? []).map((pattern) => new Bun.Glob(pattern));
+    this.#deniedFragments = [...new Set((profile.paths.deny ?? []).map(CodeAgentGate2.#fragmentOf).filter(Boolean))];
+  }
+  verdict(toolName, args) {
+    const target = stringArg(args, "path");
+    if (target) {
+      const denied = this.#deniedReason(target);
+      if (denied)
+        return { block: denied };
+    }
+    const command = stringArg(args, "command");
+    if (command) {
+      const denied = this.#deniedCommandReason(command);
+      if (denied)
+        return { block: denied };
+    }
+    if (!this.#needsApproval(toolName))
+      return {};
+    return { approval: CodeAgentGate2.#summarize(toolName, args) };
+  }
+  #deniedCommandReason(command) {
+    const hit = this.#deniedFragments.find((fragment) => command.includes(fragment));
+    if (!hit)
+      return;
+    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))
+      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).";
+    if (this.#allow.length && !this.#allow.some((glob) => glob.match(absolute) || glob.match(relative)))
+      return "Path is outside the profile's allow list.";
+    return;
+  }
+  #needsApproval(toolName) {
+    switch (this.#profile.approval) {
+      case "never":
+        return false;
+      case "writes":
+        return writeTools.has(toolName);
+      case "commands":
+        return commandTools.has(toolName);
+      case "all":
+        return true;
+      default:
+        return false;
+    }
+  }
+  static #fragmentOf(pattern) {
+    const trimmed = pattern.replace(/^\*\*\//, "").replace(/\/\*\*$/, "/").replace(/^\*+/, "");
+    return trimmed.includes("*") ? "" : trimmed;
+  }
+  static #summarize(toolName, args) {
+    const record = args ?? {};
+    if (toolName === "bash")
+      return `run: ${String(record.command ?? "").slice(0, 200)}`;
+    const target = stringArg(args, "path");
+    return target ? `${toolName} ${target}` : toolName;
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeAgentProxy.ts
+import { readFile } from "fs/promises";
+class CodeAgentProxy {
+  static placeholderKey = "akan-code-proxy";
+  baseUrl;
+  providers;
+  #tokenFile;
+  #token;
+  constructor({ baseUrl, providers, tokenFile, token }) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.providers = providers;
+    this.#tokenFile = tokenFile;
+    this.#token = token;
+    if (!tokenFile && !token)
+      throw new Error("AKAN_CODE_PROXY_URL needs AKAN_CODE_PROXY_TOKEN_FILE or AKAN_CODE_PROXY_TOKEN");
+  }
+  static fromEnv(profile) {
+    const baseUrl = process.env.AKAN_CODE_PROXY_URL?.trim() || profile?.network.proxyBaseUrl;
+    if (!baseUrl)
+      return null;
+    const providers = (process.env.AKAN_CODE_PROXY_PROVIDERS ?? akanCodeDefaultModel2.provider).split(",").map((provider) => provider.trim()).filter(Boolean);
+    return new CodeAgentProxy({
+      baseUrl,
+      providers,
+      tokenFile: process.env.AKAN_CODE_PROXY_TOKEN_FILE?.trim() || undefined,
+      token: process.env.AKAN_CODE_PROXY_TOKEN?.trim() || undefined
+    });
+  }
+  baseUrlFor(provider) {
+    return this.baseUrl.replaceAll("{provider}", provider);
+  }
+  async token() {
+    if (!this.#tokenFile)
+      return this.#token ?? "";
+    const token = (await readFile(this.#tokenFile, "utf8")).trim();
+    if (!token)
+      throw new Error(`${this.#tokenFile} is empty`);
+    return token;
+  }
+  async apply(runtime) {
+    const target = runtime;
+    const original = target.prepareRequest?.bind(runtime);
+    if (!original)
+      throw new Error("The model runtime no longer exposes prepareRequest; update CodeAgentProxy");
+    for (const provider of this.providers)
+      await runtime.setRuntimeApiKey(provider, CodeAgentProxy.placeholderKey);
+    target.prepareRequest = async (model, options = {}) => {
+      const apiKey = await this.token();
+      const prepared = await original(model, { ...options, apiKey });
+      return {
+        ...prepared,
+        model: { ...prepared.model, baseUrl: this.baseUrlFor(prepared.model.provider) },
+        options: { ...prepared.options, apiKey }
+      };
+    };
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeAgentSuspended.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync4, rmSync, writeFileSync } from "fs";
+import path9 from "path";
+
+class CodeAgentSuspended {
+  #file;
+  #state;
+  constructor(file) {
+    this.#file = file;
+    this.#state = CodeAgentSuspended.#read(file);
+  }
+  static fileOf(sessionDir, sessionId) {
+    return sessionDir ? path9.join(sessionDir, `${sessionId}.suspended.json`) : null;
+  }
+  get question() {
+    return this.#state.question;
+  }
+  get approvals() {
+    return this.#state.approvals;
+  }
+  setQuestion(question) {
+    this.#state = { ...this.#state, question };
+    this.#save();
+  }
+  addApproval(request) {
+    this.#state = { ...this.#state, approvals: [...this.#state.approvals, request] };
+    this.#save();
+  }
+  takeQuestion(questionId) {
+    const question = this.#state.question;
+    if (question?.questionId !== questionId)
+      return;
+    this.#state = { approvals: this.#state.approvals };
+    this.#save();
+    return question;
+  }
+  takeApproval(approvalId) {
+    const request = this.#state.approvals.find((approval) => approval.approvalId === approvalId);
+    if (!request)
+      return;
+    this.#state = { ...this.#state, approvals: this.#state.approvals.filter((approval) => approval !== request) };
+    this.#save();
+    return request;
+  }
+  clear() {
+    if (!this.#state.question && !this.#state.approvals.length)
+      return;
+    this.#state = { approvals: [] };
+    this.#save();
+  }
+  #save() {
+    if (!this.#file)
+      return;
+    if (!this.#state.question && !this.#state.approvals.length) {
+      rmSync(this.#file, { force: true });
+      return;
+    }
+    mkdirSync2(path9.dirname(this.#file), { recursive: true });
+    writeFileSync(this.#file, `${JSON.stringify(this.#state)}
+`);
+  }
+  static #read(file) {
+    if (!file || !existsSync8(file))
+      return { approvals: [] };
+    try {
+      const parsed = JSON.parse(readFileSync4(file, "utf8"));
+      return { ...parsed.question ? { question: parsed.question } : {}, approvals: parsed.approvals ?? [] };
+    } catch {
+      return { approvals: [] };
+    }
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeAgentUi.ts
+class CodeAgentUi2 {
+  #handlers;
+  constructor(handlers) {
+    this.#handlers = handlers;
+  }
+  context() {
+    const noop = () => {};
+    const ui = {
+      select: async (title, options) => await this.#handlers.ask(title, "select", options),
+      confirm: async (title, message) => {
+        const answer = await this.#handlers.ask(message ? `${title}: ${message}` : title, "confirm");
+        return answer === "yes" || answer === "true";
+      },
+      input: async (title) => await this.#handlers.ask(title, "text"),
+      notify: (message, type = "info") => this.#handlers.notify(type, message),
+      editor: async (title, prefill) => await this.#handlers.ask(title, "text") ?? prefill,
+      onTerminalInput: () => noop,
+      setStatus: noop,
+      setWorkingMessage: noop,
+      setWorkingVisible: noop,
+      setWorkingIndicator: noop,
+      setHiddenThinkingLabel: noop,
+      setWidget: noop,
+      setFooter: noop,
+      setHeader: noop,
+      setTitle: noop,
+      custom: async () => {
+        return;
+      },
+      pasteToEditor: noop,
+      setEditorText: noop,
+      getEditorText: () => "",
+      addAutocompleteProvider: noop,
+      setCustomEditorComponent: noop
+    };
+    return ui;
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeMailbox.ts
+import {
+  appendFileSync,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync5,
+  rmSync as rmSync2,
+  statSync as statSync5,
+  writeFileSync as writeFileSync2
+} from "fs";
+import path10 from "path";
+class CodeMailbox2 {
+  static staleMs = 20000;
+  static beatMs = 5000;
+  static pollMs = 1500;
+  static sendsPerMinute = 20;
+  #dir;
+  #id;
+  #name;
+  #read = 0;
+  #sent = [];
+  #beat = null;
+  #poll = null;
+  constructor(dir, id, name) {
+    this.#dir = dir;
+    this.#id = id;
+    this.#name = name;
+  }
+  get inbox() {
+    return path10.join(this.#dir, "inbox", `${this.#id}.jsonl`);
+  }
+  open(cwd, onMail) {
+    mkdirSync3(path10.join(this.#dir, "live"), { recursive: true });
+    mkdirSync3(path10.join(this.#dir, "inbox"), { recursive: true });
+    this.#read = readJsonLines(this.inbox).length;
+    this.beat(cwd);
+    this.#beat = setInterval(() => this.beat(cwd), CodeMailbox2.beatMs);
+    this.#poll = setInterval(() => {
+      for (const mail of this.#drain())
+        onMail(mail);
+    }, CodeMailbox2.pollMs);
+  }
+  close() {
+    if (this.#beat)
+      clearInterval(this.#beat);
+    if (this.#poll)
+      clearInterval(this.#poll);
+    this.#beat = null;
+    this.#poll = null;
+    try {
+      rmSync2(path10.join(this.#dir, "live", `${this.#id}.json`), { force: true });
+    } catch {}
+  }
+  rename(name, cwd) {
+    this.#name = name;
+    this.beat(cwd);
+  }
+  beat(cwd) {
+    const peer = { id: this.#id, name: this.#name, cwd, pid: process.pid, at: Date.now() };
+    try {
+      writeFileSync2(path10.join(this.#dir, "live", `${this.#id}.json`), JSON.stringify(peer));
+    } catch {}
+  }
+  peers() {
+    const dir = path10.join(this.#dir, "live");
+    if (!existsSync9(dir))
+      return [];
+    const now = Date.now();
+    return readdirSync3(dir).filter((entry) => entry.endsWith(".json")).map((entry) => CodeMailbox2.#peer(path10.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();
+    const peers = this.peers();
+    const byName = peers.filter((peer) => peer.name.toLowerCase() === needle);
+    if (byName.length === 1)
+      return byName[0];
+    const byPrefix = peers.filter((peer) => peer.id.startsWith(needle) || peer.name.toLowerCase().startsWith(needle));
+    return byPrefix.length === 1 ? byPrefix[0] : undefined;
+  }
+  send(to, text) {
+    const now = Date.now();
+    this.#sent = this.#sent.filter((at) => now - at < 60000);
+    if (this.#sent.length >= CodeMailbox2.sendsPerMinute)
+      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(path10.join(this.#dir, "inbox"), { recursive: true });
+    appendFileSync(path10.join(this.#dir, "inbox", `${to}.jsonl`), `${JSON.stringify(mail)}
+`);
+  }
+  #drain() {
+    const lines = readJsonLines(this.inbox);
+    if (lines.length <= this.#read)
+      return [];
+    const fresh = lines.slice(this.#read);
+    this.#read = lines.length;
+    return fresh.map((line) => parseJsonLine(line)).filter((mail) => !!mail?.text && typeof mail.from === "string");
+  }
+  static #peer(file) {
+    try {
+      const peer = JSON.parse(readFileSync5(file, "utf8"));
+      return typeof peer.id === "string" ? { ...peer, at: peer.at || statSync5(file).mtimeMs } : undefined;
+    } catch {
+      return;
+    }
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeSessionFork.ts
+import { randomBytes } from "crypto";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import path11 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(`
+`).filter((line) => !!line.trim());
+    if (!lines.length)
+      throw new Error(`Session ${id} has nothing in it to fork`);
+    const at = new Date;
+    const forked = Bun.randomUUIDv7();
+    const records = lines.map((line) => parseJsonLine(line)).filter((record) => !!record);
+    const first = records.find((record) => record.type === "session");
+    if (!first)
+      throw new Error(`Session ${id} carries no session record`);
+    first.id = forked;
+    first.timestamp = at.toISOString();
+    records.push(CodeSessionFork2.#named(records, name ?? CodeSessionFork2.#nameOf(records), at));
+    const file = path11.join(dir, `${at.toISOString().replace(/[:.]/g, "-")}_${forked}.jsonl`);
+    writeFileSync3(file, `${records.map((record) => JSON.stringify(record)).join(`
+`)}
+`);
+    return { id: forked, file };
+  }
+  static #named(records, name, at) {
+    const parent = records.at(-1)?.id;
+    return {
+      type: "session_info",
+      id: randomBytes(4).toString("hex"),
+      parentId: typeof parent === "string" ? parent : null,
+      timestamp: at.toISOString(),
+      name
+    };
+  }
+  static #nameOf(records) {
+    const named = records.filter((record) => record.type === "session_info").at(-1);
+    const current = typeof named?.name === "string" ? named.name : "";
+    return codeAgentSessionName(current ? `${current} fork` : "fork");
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeAgent.ts
+class CodeAgent2 {
+  #profile;
+  #gate;
+  #mapper = new CodeAgentEventMapper2;
+  #asks = new CodeAgentAsks2;
+  #suspended = new CodeAgentSuspended(null);
+  #listeners = new Set;
+  #session;
+  #disposePlugins;
+  #seq = 0;
+  #disposed = false;
+  #sessionDir;
+  #mailbox;
+  #mcp = [];
+  #workspaceRoot = "";
+  #replay = [];
+  #replayFrom = 0;
+  #lastContextTokens;
+  constructor(profile) {
+    this.#profile = profile;
+    this.#gate = new CodeAgentGate2(profile);
+  }
+  static async create(options) {
+    const workspaceRoot = options.workspace.workspaceRoot;
+    const cwd = options.cwd ?? workspaceRoot;
+    const agent = new CodeAgent2(options.profile);
+    const settingsManager = AkanCodeServices2.settings();
+    const modelRuntime = await AkanCodeServices2.runtime(workspaceRoot, CodeAgentProxy.fromEnv(options.profile));
+    const model = await akanCodeModel2(modelRuntime, options.model);
+    const compaction = settingsManager.getCompactionSettings(model);
+    const modelWarnings = akanCodeModelWarnings2(model, compaction.reserveTokens + compaction.keepRecentTokens);
+    const akan = await AkanCodePlugins2.build({
+      workspace: options.workspace,
+      cwd,
+      profile: options.profile,
+      apps: options.apps ?? [],
+      canSeeImages: akanCodeModelSupportsImages2(model),
+      depth: options.depth ?? 0,
+      ...options.subagentSpend ? { subagentSpend: options.subagentSpend } : {},
+      currentSessionId: () => agent.sessionId,
+      mailbox: () => agent.#mailbox,
+      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,
+      agentDir: akanCodePaths2.globalDir(),
+      settingsManager,
+      ...AkanCodeServices2.resourceOptions({
+        workspaceRoot,
+        cwd,
+        profile: options.profile,
+        extensions: [agent.#gateExtension(), ...akan.extensions, ...options.extensions ?? []]
+      })
+    });
+    await resourceLoader.reload();
+    const { session } = await createAgentSession({
+      cwd,
+      agentDir: akanCodePaths2.globalDir(),
+      modelRuntime,
+      settingsManager,
+      resourceLoader,
+      model,
+      sessionManager: AkanCodeServices2.sessions(workspaceRoot, cwd, options.profile, options.resume),
+      noTools: "builtin",
+      tools: [...options.profile.tools.builtin, ...akan.toolNames],
+      customTools: options.customTools
+    });
+    agent.#disposePlugins = akan.dispose;
+    agent.#mcp = akan.mcp;
+    agent.#workspaceRoot = workspaceRoot;
+    if (options.profile.session.store !== "memory")
+      agent.#sessionDir = akanCodePaths2.sessionsDir(workspaceRoot);
+    await agent.#attach(session, options.mode ?? "print");
+    agent.#suspended = new CodeAgentSuspended(CodeAgentSuspended.fileOf(agent.#sessionDir, agent.sessionId));
+    if (agent.#sessionDir && options.profile.session.store === "file")
+      agent.#openMail(akanCodePaths2.mailDir(workspaceRoot), cwd);
+    for (const message of modelWarnings)
+      agent.#emit({ type: "notice", level: "warning", message });
+    return agent;
+  }
+  get profile() {
+    return this.#profile;
+  }
+  get canSeeImages() {
+    const model = this.#session?.model;
+    return model ? akanCodeModelSupportsImages2(model) : false;
+  }
+  sessions() {
+    return this.#sessionDir ? CodeSessionIndex2.list(this.#sessionDir) : [];
+  }
+  get workspaceRoot() {
+    return this.#workspaceRoot;
+  }
+  mcpServers() {
+    return this.#mcp;
+  }
+  peers() {
+    return this.#mailbox?.peers() ?? [];
+  }
+  send(target, text) {
+    const mailbox = this.#mailbox;
+    if (!mailbox)
+      throw new Error("This profile keeps no shared mailbox, so it has no peers.");
+    const peer = mailbox.find(target);
+    if (!peer)
+      throw new Error(`No live session matches "${target}". Ask for the list first.`);
+    mailbox.send(peer.id, text);
+    return peer;
+  }
+  #openMail(dir, cwd) {
+    const session = this.#session;
+    if (!session)
+      return;
+    this.#mailbox = new CodeMailbox2(dir, session.sessionId, session.sessionName ?? session.sessionId.slice(0, 8));
+    this.#mailbox.open(cwd, (mail) => {
+      const from = `${mail.fromName} (${mail.from.slice(0, 8)})`;
+      this.#emit({ type: "notice", level: "info", message: `message from ${from}` });
+      this.#prompt(`Message from another session \u2014 ${from}:
+${mail.text}`).catch((error) => this.#emit({ type: "notice", level: "error", message: String(error) }));
+    });
+  }
+  get sessionId() {
+    return this.#session?.sessionId ?? "";
+  }
+  get isStreaming() {
+    return this.#session?.isStreaming ?? false;
+  }
+  get tokensUsed() {
+    return this.#session?.getSessionStats().tokens.total ?? 0;
+  }
+  get info() {
+    const session = this.#require();
+    const model = session.model;
+    return {
+      sessionId: session.sessionId,
+      cwd: this.#profile.paths.root,
+      profile: this.#profile.name,
+      model: model ? { provider: model.provider, id: model.id, name: model.name } : undefined,
+      tools: session.getActiveToolNames(),
+      contextTokens: model?.contextWindow,
+      effort: session.supportsThinking() ? session.thinkingLevel : undefined,
+      name: session.sessionName,
+      interaction: this.#profile.interaction
+    };
+  }
+  announce() {
+    this.#emit({ type: "session", info: this.info });
+    this.#restore();
+    const { question, approvals } = this.#suspended;
+    if (question)
+      this.#emit({ type: "question", question });
+    for (const request of approvals)
+      this.#emit({ type: "approval", request });
+  }
+  #restore() {
+    const session = this.#session;
+    if (!session)
+      return;
+    const turnId = `restored:${session.sessionId}`;
+    for (const message of session.messages) {
+      if (message.role !== "user" && message.role !== "assistant")
+        continue;
+      const text = CodeAgent2.#textOf(message.content);
+      if (text)
+        this.#emit({ type: "message", turnId, role: message.role, text });
+    }
+    this.#emitContextNow();
+  }
+  static #textOf(content) {
+    if (typeof content === "string")
+      return content.trim();
+    if (!Array.isArray(content))
+      return "";
+    return content.map((part) => typeof part === "object" && part && ("text" in part) ? String(part.text) : "").join("").trim();
+  }
+  on(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  static replayLimit = 2000;
+  async state({ sinceSeq } = {}) {
+    const base = { info: this.info, streaming: this.isStreaming, replayFrom: this.#replayFrom };
+    if (sinceSeq === undefined)
+      return base;
+    return { ...base, frames: this.#replay.filter((event) => event.seq > sinceSeq) };
+  }
+  async prompt(message, images) {
+    this.#suspended.clear();
+    await this.#prompt(message, images);
+  }
+  async#prompt(message, images) {
+    const session = this.#require();
+    if (!session.sessionName && message.trim())
+      this.setName(codeAgentSessionName2(message));
+    const attachments = await CodeAgent2.#attachments(images);
+    const options = attachments.length ? { images: attachments } : {};
+    if (session.isStreaming)
+      return await session.prompt(message, { ...options, streamingBehavior: "followUp" });
+    await session.prompt(message, { ...options, source: "extension" });
+  }
+  async abort() {
+    this.#mapper.noteOutcome("aborted");
+    this.#asks.clear();
+    await this.#require().abort();
+  }
+  async answer(questionId, answer) {
+    const question = this.#asks.questionOf(questionId);
+    const rendered = question ? codeAgentRenderAnswer(question, answer) : answer.text ?? "";
+    if (this.#asks.answer(questionId, rendered)) {
+      this.#emit({ type: "question_resolved", questionId, answer, rendered });
+      return true;
+    }
+    if (this.#profile.interaction.question !== "suspend")
+      return false;
+    const suspended = this.#suspended.takeQuestion(questionId);
+    if (!suspended)
+      return false;
+    const suspendedRendered = codeAgentRenderAnswer(suspended, answer);
+    this.#emit({ type: "question_resolved", questionId, answer, rendered: suspendedRendered });
+    await this.#prompt(`The user answered: ${suspendedRendered}
+Continue the task.`);
+    return true;
+  }
+  async approve(approvalId, approved) {
+    if (this.#asks.resolveApproval(approvalId, approved)) {
+      this.#emit({ type: "approval_resolved", approvalId, approved });
+      return true;
+    }
+    if (this.#profile.interaction.approval !== "suspend")
+      return false;
+    if (!this.#suspended.takeApproval(approvalId))
+      return false;
+    this.#emit({ type: "approval_resolved", approvalId, approved });
+    if (approved)
+      await this.#prompt("The user approved the pending action. Retry it and continue.");
+    return true;
+  }
+  async compact(instructions) {
+    await this.#require().compact(instructions);
+  }
+  setName(name) {
+    const clean = name.trim();
+    if (!clean)
+      return;
+    this.#require().setSessionName(clean);
+    this.#mailbox?.rename(clean, this.#profile.paths.root);
+    this.#emit({ type: "session", info: this.info });
+  }
+  fork(name) {
+    if (!this.#sessionDir)
+      throw new Error("This profile keeps no sessions on disk, so there is nothing to fork");
+    return CodeSessionFork2.fork(this.#sessionDir, this.sessionId, name);
+  }
+  efforts() {
+    const session = this.#session;
+    if (!session?.supportsThinking())
+      return [];
+    return session.getAvailableThinkingLevels();
+  }
+  setEffort(effort) {
+    const session = this.#require();
+    if (!session.supportsThinking())
+      throw new Error(`${session.model?.id ?? "this model"} does no reasoning`);
+    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.modelRuntime, ref);
+    if (!model)
+      throw new Error(`Unknown model: ${ref.provider}/${ref.id}`);
+    await session.setModel(model);
+    this.#emit({ type: "session", info: this.info });
+  }
+  async waitForIdle() {
+    await this.#require().waitForIdle();
+  }
+  dispose() {
+    this.#mailbox?.close();
+    if (this.#disposed)
+      return;
+    this.#disposed = true;
+    this.#asks.clear();
+    this.#listeners.clear();
+    this.#disposePlugins?.();
+    this.#session?.dispose();
+  }
+  async#attach(session, mode) {
+    this.#session = session;
+    session.subscribe((event) => {
+      for (const body of this.#mapper.map(event))
+        this.#emit(body);
+      if (event.type === "agent_end" || event.type === "compaction_end")
+        this.#emitContextNow();
+    });
+    await session.bindExtensions({
+      mode,
+      uiContext: this.#ui().context(),
+      abortHandler: () => void session.abort(),
+      onError: (error) => this.#emit({ type: "error", message: String(error), fatal: false })
+    });
+  }
+  static async#attachments(images) {
+    if (!images?.length)
+      return [];
+    return await Promise.all(images.map(async (image) => {
+      if ("data" in image)
+        return { type: "image", data: image.data, mimeType: image.mime };
+      const file = Bun.file(image.path);
+      return {
+        type: "image",
+        data: Buffer.from(await file.arrayBuffer()).toString("base64"),
+        mimeType: file.type || "image/png"
+      };
+    }));
+  }
+  #emitContextNow() {
+    const usage = this.#session?.getContextUsage();
+    if (usage?.tokens == null)
+      return;
+    if (usage.tokens === this.#lastContextTokens)
+      return;
+    this.#lastContextTokens = usage.tokens;
+    this.#emit({ type: "context", used: usage.tokens, max: usage.contextWindow || undefined });
+  }
+  #require() {
+    if (!this.#session)
+      throw new Error("CodeAgent is not started");
+    return this.#session;
+  }
+  #emit(body) {
+    this.#seq += 1;
+    const event = { ...body, seq: this.#seq };
+    this.#remember(event);
+    for (const listener of this.#listeners)
+      listener(event);
+  }
+  #remember(event) {
+    if (event.type === "idle") {
+      this.#replay.length = 0;
+      this.#replayFrom = event.seq;
+      return;
+    }
+    this.#replay.push(event);
+    while (this.#replay.length > CodeAgent2.replayLimit) {
+      const dropped = this.#replay.shift();
+      this.#replayFrom = dropped?.seq ?? this.#replayFrom;
+    }
+  }
+  #gateExtension() {
+    return {
+      name: "akan-profile-gate",
+      factory: (pi) => {
+        pi.on("tool_call", async (event) => {
+          const verdict = this.#gate.verdict(event.toolName, event.input);
+          if (verdict.block)
+            return this.#refuse(event.toolCallId, event.toolName, event.input, verdict.block);
+          if (!verdict.approval)
+            return;
+          const approved = await this.#requestApproval(event.toolCallId, event.toolName, event.input, verdict.approval);
+          if (approved)
+            return;
+          return this.#refuse(event.toolCallId, event.toolName, event.input, "The user declined this action.");
+        });
+      }
+    };
+  }
+  #refuse(toolCallId, toolName, args, reason) {
+    for (const body of this.#mapper.markBlocked(toolCallId, toolName, args, reason))
+      this.#emit(body);
+    return { block: true, reason };
+  }
+  async#requestApproval(toolCallId, name, args, summary) {
+    if (!this.#profile.ui.canPrompt)
+      return true;
+    const approvalId = this.#asks.nextId("a");
+    const request = {
+      approvalId,
+      toolCallId,
+      name,
+      summary: codeAgentClip5(summary, codeAgentLabelChars2),
+      policy: this.#profile.approval
+    };
+    this.#emit({ type: "approval", request });
+    if (this.#profile.interaction.approval === "suspend") {
+      this.#suspended.addApproval(request);
+      this.#mapper.noteOutcome("awaiting");
+      return false;
+    }
+    return await this.#asks.openApproval(approvalId);
+  }
+  async ask(spec) {
+    const question = { questionId: this.#asks.nextId("q"), ...spec };
+    if (!this.#profile.ui.canPrompt) {
+      this.#emit({ type: "question_skipped", question, reason: "no-host" });
+      return;
+    }
+    this.#emit({ type: "question", question });
+    if (this.#profile.interaction.question === "suspend") {
+      this.#suspended.setQuestion(question);
+      this.#mapper.noteOutcome("awaiting");
+      return;
+    }
+    return await this.#asks.openQuestion(question) || undefined;
+  }
+  #ui() {
+    return new CodeAgentUi2({
+      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, McpUnauthorized2, McpClient2, McpToolPack2, SessionToolPack2, WebToolPack2, AkanCodePlugins2, AkanEnvKeys2, akanSystemPrompt2, CodeSessionIndex2, AkanCodeServices2, CodeAgentAsks2, CodeAgentEventMapper2, CodeAgentGate2, CodeAgentUi2, CodeMailbox2, CodeSessionFork2, CodeAgent2 };