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

package/index-5405kc0x.js

@@ -0,0 +1,2434 @@
+// @bun
+import {
+  SubagentPool2
+} from "./index-jgrnpt6y.js";
+import {
+  stripAnsi
+} from "./index-7md2g9vw.js";
+import {
+  akanCodeModel2,
+  akanCodeModelSupportsImages2,
+  akanCodeModelWarnings2
+} from "./index-wfwknnje.js";
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeAgent.ts
+import {
+  createAgentSession,
+  DEFAULT_COMPACTION_SETTINGS,
+  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.#status(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) {
+    return await AkanEditScope2.#status(cwd);
+  }
+  static async#status(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-bys6ykcp.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-bys6ykcp.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
+          });
+          return { content: [{ type: "text", text: AkanToolPack2.#render(result) }], 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-9mn3kp36.js");
+      return await Prompter.listGuidelines();
+    } catch {
+      return [];
+    }
+  }
+  static #render(result) {
+    if (typeof result === "string")
+      return result;
+    return JSON.stringify(result, null, 2);
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/tools/MailToolPack.ts
+import { Type as Type2 } 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: Type2.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: Type2.Object({
+        to: Type2.String({ description: "The peer's name, or the front of its id, from list_peers." }),
+        message: Type2.String({ description: "What that session should know or do." })
+      }),
+      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 { existsSync as existsSync5, readFileSync } from "fs";
+import { codeAgentClip, codeAgentOutputChars } from "akanjs/common";
+import { Type as Type3 } from "typebox";
+
+// pkgs/@akanjs/devkit/codeAgent/agent/akanCodePaths.ts
+import { existsSync as existsSync4 } from "fs";
+import { homedir as homedir2 } from "os";
+import path4 from "path";
+var builtinSkillsDir = () => {
+  const candidates = [path4.join(import.meta.dir, "skills"), path4.join(import.meta.dir, "..", "skills")];
+  return candidates.find((candidate) => existsSync4(candidate));
+};
+var akanCodePaths2 = {
+  workspaceDir: (workspaceRoot) => path4.join(workspaceRoot, ".akan", "code"),
+  sessionsDir: (workspaceRoot) => path4.join(workspaceRoot, ".akan", "code", "sessions"),
+  extensionsDir: (workspaceRoot) => path4.join(workspaceRoot, ".akan", "code", "extensions"),
+  skillsDir: (workspaceRoot) => path4.join(workspaceRoot, ".akan", "code", "skills"),
+  mailDir: (workspaceRoot) => path4.join(workspaceRoot, ".akan", "code", "mail"),
+  builtinSkillsDir,
+  mcpFile: (workspaceRoot) => path4.join(workspaceRoot, ".akan", "code", "mcp.json"),
+  globalDir: () => path4.join(homedir2(), ".akan", "code"),
+  authFile: () => path4.join(homedir2(), ".akan", "code", "auth.json"),
+  modelsFile: () => path4.join(homedir2(), ".akan", "code", "models.json")
+};
+
+// pkgs/@akanjs/devkit/codeAgent/tools/McpClient.ts
+var protocolVersion = "2025-06-18";
+
+class McpClient2 {
+  ref;
+  #proc;
+  #nextId = 0;
+  #buffer = "";
+  #pending = new Map;
+  #sessionId;
+  constructor(ref) {
+    this.ref = ref;
+  }
+  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 response = await this.#call("tools/list", {});
+    if (response.error)
+      throw new Error(response.error.message);
+    return response.result?.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",
+        ...this.#sessionId ? { "mcp-session-id": this.#sessionId } : {}
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(30000)
+    });
+    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 {
+  #options;
+  #clients = [];
+  constructor(options) {
+    this.#options = options;
+  }
+  static async connect(options) {
+    const refs = McpToolPack2.#refs(options);
+    if (!refs.length)
+      return;
+    const pack = new McpToolPack2(options);
+    for (const ref of refs) {
+      try {
+        const client = await new McpClient2(ref).connect();
+        pack.#clients.push({ client, tools: await client.listTools() });
+      } catch (error) {
+        options.onNotice?.(`MCP server "${ref.name}" is unavailable: ${String(error)}`);
+      }
+    }
+    return pack.#clients.length ? pack : undefined;
+  }
+  get toolNames() {
+    return this.#clients.flatMap(({ client, tools }) => tools.map((tool) => McpToolPack2.#nameOf(client.ref.name, tool.name)));
+  }
+  extension() {
+    return { name: "akan-mcp", factory: (pi) => this.#register(pi) };
+  }
+  close() {
+    for (const { client } of this.#clients)
+      client.close();
+  }
+  #register(pi) {
+    for (const { client, tools } of this.#clients)
+      for (const tool of tools) {
+        const name = McpToolPack2.#nameOf(client.ref.name, tool.name);
+        const description = tool.description ?? tool.name;
+        pi.registerTool({
+          name,
+          label: `${client.ref.name}: ${tool.name}`,
+          description,
+          promptSnippet: `${name}: ${description.split(".")[0] ?? description}`,
+          parameters: Type3.Unsafe(tool.inputSchema),
+          execute: async (_id, params) => {
+            const result = await client.callTool(tool.name, params ?? {});
+            return {
+              content: [{ type: "text", text: codeAgentClip(result.text, codeAgentOutputChars) }],
+              details: undefined,
+              isError: result.isError
+            };
+          }
+        });
+      }
+  }
+  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 [...McpToolPack2.#fromFile(options.workspaceRoot), ...declared];
+  }
+  static #fromFile(workspaceRoot) {
+    const file = akanCodePaths2.mcpFile(workspaceRoot);
+    if (!existsSync5(file))
+      return [];
+    try {
+      const parsed = JSON.parse(readFileSync(file, "utf8"));
+      const entries = Object.entries(parsed.mcpServers ?? parsed.servers ?? {});
+      return entries.filter(([, entry]) => !entry.disabled).map(([name, entry]) => {
+        const transport = entry.url ? "http" : "stdio";
+        return {
+          name,
+          transport,
+          ...entry.command ? { command: entry.command } : {},
+          ...entry.args ? { args: entry.args } : {},
+          ...entry.url ? { url: entry.url } : {},
+          ...entry.env ? { env: entry.env } : {}
+        };
+      });
+    } catch {
+      return [];
+    }
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/tools/SessionToolPack.ts
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { codeAgentClip as codeAgentClip2, codeAgentOutputChars as codeAgentOutputChars2 } from "akanjs/common";
+import { Type as Type4 } from "typebox";
+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: Type4.Object({
+        query: Type4.String({ description: "A phrase to look for, matched case-insensitively." }),
+        limit: Type4.Optional(Type4.Number({ description: "How many sessions to return, default 5." }))
+      }),
+      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: Type4.Object({ sessionId: Type4.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 Type5 } 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: Type5.Object({ url: Type5.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: Type5.Object({
+        query: Type5.String(),
+        count: Type5.Optional(Type5.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 web = new WebToolPack2({ profile: options.profile });
+    const webExtension = web.extension();
+    const sessions = new SessionToolPack2({
+      workspaceRoot: options.workspace.workspaceRoot,
+      cwd: options.cwd,
+      profile: options.profile,
+      currentSessionId: options.currentSessionId
+    });
+    const sessionExtension = sessions.extension();
+    const mail = new MailToolPack2({ profile: options.profile, mailbox: options.mailbox });
+    const mailExtension = mail.extension();
+    if (!options.profile.tools.akan)
+      return {
+        extensions: [mcp?.extension(), webExtension, sessionExtension, mailExtension].filter((entry) => !!entry),
+        toolNames: [...mcp?.toolNames ?? [], ...web.names(), ...sessions.names(), ...mail.names()],
+        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.onNotice ? { onNotice: options.onNotice } : {}
+    });
+    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());
+    if (mcp)
+      extensions.push(mcp.extension());
+    if (webExtension)
+      extensions.push(webExtension);
+    if (sessionExtension)
+      extensions.push(sessionExtension);
+    if (mailExtension)
+      extensions.push(mailExtension);
+    return {
+      extensions,
+      toolNames: [
+        ...await pack.names(),
+        ...subagent ? [SubagentPool2.toolName] : [],
+        ...mcp?.toolNames ?? [],
+        ...web.names(),
+        ...sessions.names(),
+        ...mail.names()
+      ],
+      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 existsSync9, mkdirSync as mkdirSync2 } from "fs";
+import {
+  AuthStorage,
+  ModelRegistry,
+  SessionManager as SessionManager2,
+  SettingsManager
+} from "@earendil-works/pi-coding-agent";
+
+// pkgs/@akanjs/devkit/codeAgent/tools/AkanEnvKeys.ts
+import { existsSync as existsSync6, readFileSync as readFileSync2 } from "fs";
+import path5 from "path";
+
+class AkanEnvKeys2 {
+  static apply(authStorage, workspaceRoot) {
+    const applied = [];
+    for (const [name, value] of AkanEnvKeys2.#entries(workspaceRoot)) {
+      const provider = AkanEnvKeys2.#providerOf(name);
+      if (!provider || !value)
+        continue;
+      authStorage.setRuntimeApiKey(provider, value);
+      applied.push(provider);
+    }
+    return applied;
+  }
+  static #entries(workspaceRoot) {
+    const fromProcess = Object.entries(process.env).filter(([, value]) => typeof value === "string");
+    const file = path5.join(workspaceRoot, ".env");
+    if (!existsSync6(file))
+      return fromProcess;
+    const fromFile = readFileSync2(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/AkanAuthStorageBackend.ts
+import {
+  closeSync,
+  existsSync as existsSync7,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync3,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import path6 from "path";
+
+class AkanAuthStorageBackend2 {
+  #authPath;
+  #lockPath;
+  constructor(authPath) {
+    this.#authPath = authPath;
+    this.#lockPath = `${authPath}.lock`;
+  }
+  withLock(fn) {
+    this.#acquire();
+    try {
+      const { result, next } = fn(this.#read());
+      if (next !== undefined)
+        this.#write(next);
+      return result;
+    } finally {
+      this.#release();
+    }
+  }
+  async withLockAsync(fn) {
+    this.#acquire();
+    try {
+      const { result, next } = await fn(this.#read());
+      if (next !== undefined)
+        this.#write(next);
+      return result;
+    } finally {
+      this.#release();
+    }
+  }
+  #read() {
+    if (!existsSync7(this.#authPath))
+      return;
+    const text = readFileSync3(this.#authPath, "utf8");
+    return text.trim() ? text : undefined;
+  }
+  #write(next) {
+    mkdirSync(path6.dirname(this.#authPath), { recursive: true, mode: 448 });
+    const temp = `${this.#authPath}.${process.pid}.tmp`;
+    writeFileSync(temp, next, { mode: 384 });
+    renameSync(temp, this.#authPath);
+  }
+  #acquire() {
+    mkdirSync(path6.dirname(this.#lockPath), { recursive: true, mode: 448 });
+    const deadline = Date.now() + 5000;
+    for (;; ) {
+      try {
+        closeSync(openSync(this.#lockPath, "wx"));
+        return;
+      } catch {
+        if (this.#lockIsStale() || Date.now() > deadline) {
+          try {
+            unlinkSync(this.#lockPath);
+          } catch {}
+          continue;
+        }
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+      }
+    }
+  }
+  #lockIsStale() {
+    try {
+      return Date.now() - Bun.file(this.#lockPath).lastModified > 30000;
+    } catch {
+      return true;
+    }
+  }
+  #release() {
+    try {
+      unlinkSync(this.#lockPath);
+    } catch {}
+  }
+}
+
+// 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`.",
+    "- 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.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 existsSync8, readdirSync, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import path7 from "path";
+
+class CodeSessionIndex2 {
+  static readLimit = 512 * 1024;
+  static list(dir, limit = 30) {
+    if (!existsSync8(dir))
+      return [];
+    const files = readdirSync(dir).filter((entry) => entry.endsWith(".jsonl")).map((entry) => path7.join(dir, entry)).map((file) => ({ file, updatedAt: CodeSessionIndex2.#mtime(file) })).sort((left, right) => right.updatedAt - left.updatedAt).slice(0, limit);
+    return files.map((entry) => CodeSessionIndex2.#read(entry.file, entry.updatedAt)).filter((entry) => !!entry);
+  }
+  static fileOf(dir, id) {
+    if (!existsSync8(dir))
+      return;
+    const match = readdirSync(dir).find((entry) => entry.endsWith(`${id}.jsonl`) || entry === `${id}.jsonl`);
+    return match ? path7.join(dir, match) : undefined;
+  }
+  static #mtime(file) {
+    try {
+      return statSync2(file).mtimeMs;
+    } catch {
+      return 0;
+    }
+  }
+  static #read(file, updatedAt) {
+    const lines = CodeSessionIndex2.#lines(file);
+    if (!lines.length)
+      return;
+    const entry = { id: "", file, name: undefined, opening: "", updatedAt, turns: 0 };
+    for (const line of lines) {
+      const record = CodeSessionIndex2.#parse(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 #lines(file) {
+    try {
+      if (statSync2(file).size > CodeSessionIndex2.readLimit)
+        return [];
+      return readFileSync4(file, "utf8").split(`
+`).filter((line) => !!line.trim());
+    } catch {
+      return [];
+    }
+  }
+  static #parse(line) {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return;
+    }
+  }
+  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
+    });
+  }
+  static auth(workspaceRoot) {
+    mkdirSync2(akanCodePaths2.globalDir(), { recursive: true, mode: 448 });
+    const authStorage = AuthStorage.fromStorage(new AkanAuthStorageBackend2(akanCodePaths2.authFile()));
+    AkanEnvKeys2.apply(authStorage, workspaceRoot);
+    return authStorage;
+  }
+  static models(authStorage) {
+    return ModelRegistry.create(authStorage, akanCodePaths2.modelsFile());
+  }
+  static sessions(workspaceRoot, cwd, profile, resume) {
+    if (profile.session.store !== "file")
+      return SessionManager2.inMemory(cwd);
+    const dir = akanCodePaths2.sessionsDir(workspaceRoot);
+    mkdirSync2(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 workspace = akanCodePaths2.skillsDir(workspaceRoot);
+    return [akanCodePaths2.builtinSkillsDir(), existsSync9(workspace) ? workspace : undefined].filter((dir) => !!dir);
+  }
+  static resourceOptions(options) {
+    const present = (dir) => existsSync9(dir) ? [dir] : [];
+    return {
+      noExtensions: true,
+      noSkills: true,
+      noPromptTemplates: true,
+      noThemes: true,
+      noContextFiles: !options.profile.context.projectFiles,
+      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;
+  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.#nextId}`;
+  }
+  openQuestion(question) {
+    this.#question?.deferred.resolve("");
+    const deferred = CodeAgentAsks2.#defer();
+    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 = CodeAgentAsks2.#defer();
+    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();
+  }
+  static #defer() {
+    let resolve = () => {};
+    const promise = new Promise((r) => {
+      resolve = r;
+    });
+    return { resolve, promise };
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeAgentEventMapper.ts
+import {
+  codeAgentClip as codeAgentClip4,
+  codeAgentLabelChars,
+  codeAgentOutputChars as codeAgentOutputChars4
+} from "akanjs/common";
+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 }];
+      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 = CodeAgentEventMapper2.#pathOf(args);
+    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 #pathOf(args) {
+    if (!args || typeof args !== "object")
+      return;
+    const value = args.path;
+    return typeof value === "string" && value ? value : undefined;
+  }
+  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 = CodeAgentGate2.#pathOf(args);
+    if (target) {
+      const denied = this.#deniedReason(target);
+      if (denied)
+        return { block: denied };
+    }
+    const command = CodeAgentGate2.#commandOf(args);
+    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 #commandOf(args) {
+    if (!args || typeof args !== "object")
+      return;
+    const value = args.command;
+    return typeof value === "string" && value ? value : undefined;
+  }
+  static #pathOf(args) {
+    if (!args || typeof args !== "object")
+      return;
+    const value = args.path;
+    return typeof value === "string" && value ? value : undefined;
+  }
+  static #summarize(toolName, args) {
+    const record = args ?? {};
+    if (toolName === "bash")
+      return `run: ${String(record.command ?? "").slice(0, 200)}`;
+    const target = CodeAgentGate2.#pathOf(args);
+    return target ? `${toolName} ${target}` : toolName;
+  }
+}
+
+// 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 existsSync10,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync5,
+  rmSync,
+  statSync as statSync3,
+  writeFileSync as writeFileSync2
+} from "fs";
+import path9 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 path9.join(this.#dir, "inbox", `${this.#id}.jsonl`);
+  }
+  open(cwd, onMail) {
+    mkdirSync3(path9.join(this.#dir, "live"), { recursive: true });
+    mkdirSync3(path9.join(this.#dir, "inbox"), { recursive: true });
+    this.#read = CodeMailbox2.#lines(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 {
+      rmSync(path9.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(path9.join(this.#dir, "live", `${this.#id}.json`), JSON.stringify(peer));
+    } catch {}
+  }
+  peers() {
+    const dir = path9.join(this.#dir, "live");
+    if (!existsSync10(dir))
+      return [];
+    const now = Date.now();
+    return readdirSync2(dir).filter((entry) => entry.endsWith(".json")).map((entry) => CodeMailbox2.#peer(path9.join(dir, entry))).filter((peer) => !!peer && peer.id !== this.#id && now - peer.at < CodeMailbox2.staleMs).sort((left, right) => right.at - left.at);
+  }
+  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(path9.join(this.#dir, "inbox"), { recursive: true });
+    appendFileSync(path9.join(this.#dir, "inbox", `${to}.jsonl`), `${JSON.stringify(mail)}
+`);
+  }
+  #drain() {
+    const lines = CodeMailbox2.#lines(this.inbox);
+    if (lines.length <= this.#read)
+      return [];
+    const fresh = lines.slice(this.#read);
+    this.#read = lines.length;
+    return fresh.map((line) => CodeMailbox2.#parse(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 || statSync3(file).mtimeMs } : undefined;
+    } catch {
+      return;
+    }
+  }
+  static #lines(file) {
+    try {
+      return readFileSync5(file, "utf8").split(`
+`).filter((line) => !!line.trim());
+    } catch {
+      return [];
+    }
+  }
+  static #parse(line) {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return;
+    }
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeSessionFork.ts
+import { randomBytes } from "crypto";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import path10 from "path";
+import { 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) => CodeSessionFork2.#parse(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 = path10.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");
+  }
+  static #parse(line) {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return;
+    }
+  }
+}
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeAgent.ts
+class CodeAgent2 {
+  #profile;
+  #gate;
+  #mapper = new CodeAgentEventMapper2;
+  #asks = new CodeAgentAsks2;
+  #listeners = new Set;
+  #session;
+  #disposePlugins;
+  #seq = 0;
+  #disposed = false;
+  #sessionDir;
+  #mailbox;
+  #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 authStorage = AkanCodeServices2.auth(workspaceRoot);
+    const modelRegistry = AkanCodeServices2.models(authStorage);
+    const model = await akanCodeModel2(modelRegistry, options.model);
+    const compaction = DEFAULT_COMPACTION_SETTINGS;
+    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,
+      currentSessionId: () => agent.sessionId,
+      mailbox: () => agent.#mailbox,
+      onNotice: (message) => agent.#emit({ type: "notice", level: "warning", message })
+    });
+    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(),
+      authStorage,
+      modelRegistry,
+      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;
+    if (options.profile.session.store === "file")
+      agent.#sessionDir = akanCodePaths2.sessionsDir(workspaceRoot);
+    await agent.#attach(session, options.mode ?? "print");
+    if (agent.#sessionDir)
+      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) : [];
+  }
+  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();
+  }
+  #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 });
+    }
+  }
+  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) {
+    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;
+    this.#emit({ type: "question_resolved", questionId, answer, rendered });
+    await this.prompt(`The user answered: ${rendered}
+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;
+    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 });
+  }
+  async setModel(ref) {
+    const session = this.#require();
+    const model = await akanCodeModel2(session.modelRegistry, 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);
+      this.#emitContextUsage(event.type);
+    });
+    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"
+      };
+    }));
+  }
+  #emitContextUsage(eventType) {
+    if (eventType !== "agent_end" && eventType !== "compaction_end")
+      return;
+    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");
+    this.#emit({
+      type: "approval",
+      request: {
+        approvalId,
+        toolCallId,
+        name,
+        summary: codeAgentClip5(summary, codeAgentLabelChars2),
+        policy: this.#profile.approval
+      }
+    });
+    if (this.#profile.interaction.approval === "suspend") {
+      this.#mapper.noteOutcome("awaiting");
+      return false;
+    }
+    return await this.#asks.openApproval(approvalId);
+  }
+  #ui() {
+    return new CodeAgentUi2({
+      ask: async (prompt, kind, choices) => {
+        if (!this.#profile.ui.canPrompt)
+          return;
+        const questionId = this.#asks.nextId("q");
+        const question = {
+          questionId,
+          prompt,
+          kind,
+          ...choices ? { options: choices.map((label) => ({ key: label, label })) } : {},
+          freeText: kind === "text"
+        };
+        this.#emit({ type: "question", question });
+        if (this.#profile.interaction.question === "suspend") {
+          this.#mapper.noteOutcome("awaiting");
+          return;
+        }
+        return await this.#asks.openQuestion(question) || undefined;
+      },
+      notify: (level, message) => this.#emit({ type: "notice", level, message })
+    });
+  }
+}
+
+export { AkanEditScope2, DevLogFeedback2, PreviewChrome2, PreviewView2, PreviewFeedback2, TurnFeedback2, AkanCli2, AkanVerifier2, VerifyFeedback2, AkanToolPack2, MailToolPack2, akanCodePaths2, McpClient2, McpToolPack2, SessionToolPack2, WebToolPack2, AkanCodePlugins2, AkanEnvKeys2, AkanAuthStorageBackend2, akanSystemPrompt2, CodeSessionIndex2, AkanCodeServices2, CodeAgentAsks2, CodeAgentEventMapper2, CodeAgentGate2, CodeAgentUi2, CodeMailbox2, CodeSessionFork2, CodeAgent2 };