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

package/abstractDoc.ts

@@ -5,10 +5,8 @@ export type AbstractKind = "domain" | "service" | "scalar" | "other";
 /** One `*.abstract.md` file: the agent-facing summary a module carries next to its source. */
 export class AbstractDoc {
   static readonly suffix = ".abstract.md";
-  /** `akan quality` warns above this and points at `akan compact`. */
+  /** `akan quality` warns above this. */
   static readonly maxLines = 300;
-  /** `akan compact` floor, and the line budget it compacts down to, so a compacted file is never a candidate again. */
-  static readonly compactMinLines = 40;
   // Abstracts only live in facet folders; globbing the sys root instead would walk node_modules.
   static readonly #facetRoots = "{lib,ui,webkit,srvkit,common,plugin}";
 

package/applicationBuildRunner.ts

@@ -246,11 +246,12 @@ export class ApplicationBuildRunner {
   async #writeConsoleShim() {
     await Bun.write(
       path.join(this.#app.dist.cwdPath, "console.js"),
-      `import { cnst, db, dict, option, server, sig, srv } from "./server.js";
-import { assertAkanConsoleAllowed, startAkanConsole } from "./console-runtime.js";
+      `process.env.AKAN_COMMAND_TYPE = "console";
+const { cnst, db, dict, option, server, sig, srv } = await import("./server.js");
+const { assertAkanConsoleAllowed, startAkanConsole } = await import("./console-runtime.js");
 
 const run = async () => {
-  assertAkanConsoleAllowed(server.env);
+  assertAkanConsoleAllowed();
   await server.start({ listen: false, web: false });
   try {
     await startAkanConsole(server, { globals: { cnst, db, dict, option, sig, srv } });

package/artifact/implicitRootLayout.test.ts

@@ -31,11 +31,11 @@ describe("resolveSsrPageEntries", () => {
     await write(path.join(appRoot, "env", "env.client.ts"), "export const env = {};\n");
     await write(
       rootLayoutPath,
-      'export const theme = "dark";\nexport const fonts = [{ name: "pretendard" }];\nexport const metadata = { title: "Root" };\n',
+      'export const theme = "dark";\nexport const fonts = [{ name: "pretendard" }];\nexport const head = null;\n',
     );
     await write(
       groupedLayoutPath,
-      'export function generateMetadata() { return { title: "Home" }; }\nexport default function Layout({ children }) { return children; }\n',
+      "export function generateHead() { return null; }\nexport default function Layout({ children }) { return children; }\n",
     );
 
     const entries = await resolveSsrPageEntries({
@@ -54,15 +54,10 @@ describe("resolveSsrPageEntries", () => {
     expect(generatedSource).toContain('import * as inheritedModule from "../../../page/_layout.tsx";');
     expect(generatedSource).toContain("const inheritedLayout = resolveRouteModule(inheritedModule as never");
     expect(generatedSource).not.toContain("<System.Provider");
-    expect(generatedSource).toContain("export async function generateMetadata(props: PageProps)");
-    expect(generatedSource).toContain("if (userLayout.generateMetadata) return userLayout.generateMetadata(props);");
-    expect(generatedSource).toContain("if (userLayout.metadata !== undefined) return userLayout.metadata;");
-    expect(generatedSource).toContain(
-      "if (inheritedLayout.generateMetadata) return inheritedLayout.generateMetadata(props);",
-    );
-    expect(generatedSource).toContain("return inheritedLayout.metadata;");
-    expect(generatedSource).not.toContain("Object.keys(userLayout.metadata)");
-    expect(generatedSource).not.toContain("Object.keys(inheritedLayout.metadata)");
+    expect(generatedSource).toContain("export async function generateHead(props: PageProps)");
+    expect(generatedSource).toContain("if (userLayout.generateHead) return userLayout.generateHead(props);");
+    expect(generatedSource).toContain("return inheritedLayout.head;");
+    expect(generatedSource).not.toContain("generateMetadata");
     expect(generatedSource).toContain("export const NotFound = userLayout.NotFound ?? inheritedLayout.NotFound;");
     expect(generatedSource).toContain("export const Error = userLayout.Error ?? inheritedLayout.Error;");
     expect(generatedSource).toContain("export const pageConfig = userLayout.pageConfig ?? inheritedLayout.pageConfig;");

package/artifact/implicitRootLayout.ts

@@ -236,13 +236,6 @@ export async function generateHead(props: PageProps) {
   return inheritedLayout.head;
 }
 
-export async function generateMetadata(props: PageProps) {
-  if (userLayout.generateMetadata) return userLayout.generateMetadata(props);
-  if (userLayout.metadata !== undefined) return userLayout.metadata;
-  if (inheritedLayout.generateMetadata) return inheritedLayout.generateMetadata(props);
-  return inheritedLayout.metadata;
-}
-
 export const NotFound = userLayout.NotFound ?? inheritedLayout.NotFound;
 export const Error = userLayout.Error ?? inheritedLayout.Error;
 export const pageConfig = userLayout.pageConfig ?? inheritedLayout.pageConfig;
@@ -258,7 +251,6 @@ ${layoutBinding}  return (
       theme={userLayout.theme ?? inheritedLayout.theme}
       fonts={loadFonts(userFonts)}
       className={defaultFontClassName}
-      gaTrackingId={userLayout.gaTrackingId ?? inheritedLayout.gaTrackingId}
       layoutStyle={userLayout.layoutStyle ?? inheritedLayout.layoutStyle}
       reconnect={userLayout.reconnect ?? inheritedLayout.reconnect ?? false}
       wsConnect={userLayout.wsConnect ?? inheritedLayout.wsConnect ?? true}
@@ -280,13 +272,6 @@ export async function generateHead(props: PageProps) {
   return inheritedLayout.head;
 }
 
-export async function generateMetadata(props: PageProps) {
-  if (userLayout.generateMetadata) return userLayout.generateMetadata(props);
-  if (userLayout.metadata !== undefined) return userLayout.metadata;
-  if (inheritedLayout.generateMetadata) return inheritedLayout.generateMetadata(props);
-  return inheritedLayout.metadata;
-}
-
 export const NotFound = userLayout.NotFound ?? inheritedLayout.NotFound;
 export const Error = userLayout.Error ?? inheritedLayout.Error;
 export const pageConfig = userLayout.pageConfig ?? inheritedLayout.pageConfig;

package/biome.base.json

@@ -154,7 +154,12 @@
       ]
     },
     {
-      "includes": ["{apps,libs}/**/page/**/*.ts", "{apps,libs}/**/page/**/*.tsx"],
+      "includes": [
+        "{apps,libs}/**/page/**/*.ts",
+        "{apps,libs}/**/page/**/*.tsx",
+        "{apps,libs}/**/*.Unit.tsx",
+        "{apps,libs}/**/*.View.tsx"
+      ],
       "plugins": ["./node_modules/@akanjs/devkit/lint/non-scalar-props-restricted.grit"]
     },
     {

package/capacitorApp.test.ts

@@ -24,6 +24,7 @@ import {
   sanitizeIosNativeRunEnv,
   selectLocalDevHost,
   sortIosRunTargets,
+  toIosInfoPlistUsageDescriptions,
   writeRootCapacitorConfig,
 } from "./capacitorApp";
 
@@ -370,3 +371,28 @@ describe("raiseGradleMinSdkVersion", () => {
     expect(raiseGradleMinSdkVersion("minSdkVersion = 28", 26)).toBeNull();
   });
 });
+
+describe("toIosInfoPlistUsageDescriptions", () => {
+  test("writes Apple's real Info.plist keys, not NS + the description name", () => {
+    expect(
+      toIosInfoPlistUsageDescriptions({
+        cameraUsageDescription: "camera",
+        photoAddUsageDescription: "add",
+        photoUsageDescription: "read",
+        locationAlwaysUsageDescription: "always",
+      }),
+    ).toEqual({
+      NSCameraUsageDescription: "camera",
+      NSPhotoLibraryAddUsageDescription: "add",
+      NSPhotoLibraryUsageDescription: "read",
+      NSLocationAlwaysAndWhenInUseUsageDescription: "always",
+      NSLocationAlwaysUsageDescription: "always",
+    });
+  });
+
+  test("keeps the NS prefix convention for a key it does not know", () => {
+    expect(toIosInfoPlistUsageDescriptions({ bluetoothAlwaysUsageDescription: "ble" })).toEqual({
+      NSBluetoothAlwaysUsageDescription: "ble",
+    });
+  });
+});

package/capacitorApp.ts

@@ -489,7 +489,7 @@ export function classifyIosRunFailure(log: string): IosRunFailureClassification
     kind: "unknown",
     title: "iOS native run failed.",
     detail:
-      "Review the xcodebuild/devicectl output above. You can retry with --noAllowProvisioningUpdates to use the conservative path.",
+      "Review the xcodebuild/devicectl output above. You can retry with --no-allow-provisioning-updates to use the conservative path.",
   };
 }
 
@@ -597,6 +597,29 @@ export function raiseGradleMinSdkVersion(content: string, floor: number = ANDROI
   return content.replace(/(minSdkVersion\s*=\s*)\d+/, `$1${floor}`);
 }
 
+//* Apple's Info.plist keys do not follow the description names (photo → NSPhotoLibrary…), so each one is spelled out.
+const iosUsageDescriptionKeys = {
+  cameraUsageDescription: ["NSCameraUsageDescription"],
+  photoAddUsageDescription: ["NSPhotoLibraryAddUsageDescription"],
+  photoUsageDescription: ["NSPhotoLibraryUsageDescription"],
+  contactsUsageDescription: ["NSContactsUsageDescription"],
+  //? iOS 11+ reads the AlwaysAndWhenInUse key; the Always key only serves iOS 10 and below.
+  locationAlwaysUsageDescription: ["NSLocationAlwaysAndWhenInUseUsageDescription", "NSLocationAlwaysUsageDescription"],
+  locationWhenInUseUsageDescription: ["NSLocationWhenInUseUsageDescription"],
+  microphoneUsageDescription: ["NSMicrophoneUsageDescription"],
+  speechRecognitionUsageDescription: ["NSSpeechRecognitionUsageDescription"],
+} as const;
+
+export const toIosInfoPlistUsageDescriptions = (descriptions: { [key: string]: string }) =>
+  Object.fromEntries(
+    Object.entries(descriptions).flatMap(([key, value]) => {
+      const plistKeys: readonly string[] = Object.hasOwn(iosUsageDescriptionKeys, key)
+        ? iosUsageDescriptionKeys[key as keyof typeof iosUsageDescriptionKeys]
+        : [`NS${capitalize(key)}`];
+      return plistKeys.map((plistKey) => [plistKey, value]);
+    }),
+  );
+
 const mergeAllowNavigation = (configured: unknown, localIp: string | undefined) => {
   const values = Array.isArray(configured)
     ? configured.filter((value): value is string => typeof value === "string")
@@ -1469,9 +1492,7 @@ export class CapacitorApp {
     if (next !== content) await editor.setContent(next).save();
   }
   async #setPermissionInIos(permissions: { [key: string]: string }) {
-    const updateNs = Object.fromEntries(
-      Object.entries(permissions).map(([key, value]) => [`NS${capitalize(key)}`, value]),
-    );
+    const updateNs = toIosInfoPlistUsageDescriptions(permissions);
     await Promise.all([
       this.project.ios.updateInfoPlist(this.iosTargetName, "Debug", updateNs),
       this.project.ios.updateInfoPlist(this.iosTargetName, "Release", updateNs),

package/codeAgent/agent/AkanCodeServices.ts

@@ -1,14 +1,8 @@
 import { existsSync, mkdirSync } from "node:fs";
-import {
-  AuthStorage,
-  type InlineExtension,
-  ModelRegistry,
-  SessionManager,
-  SettingsManager,
-} from "@earendil-works/pi-coding-agent";
+import { type InlineExtension, ModelRuntime, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
 import type { CodeAgentProfile } from "akanjs/common";
 import { AkanEnvKeys } from "../tools/AkanEnvKeys";
-import { AkanAuthStorageBackend } from "./AkanAuthStorageBackend";
+import { type AkanContextFile, AkanContextFiles } from "./AkanContextFiles";
 import { akanCodePaths } from "./akanCodePaths";
 import { akanSystemPrompt } from "./akanSystemPrompt";
 import { CodeSessionIndex } from "./CodeSessionIndex";
@@ -24,8 +18,8 @@ export interface AkanCodeServicesOptions {
 /**
  * Assembles the engine's injectable services from akan's own storage.
  *
- * Every one of the five is passed explicitly. Leave any of them out and the engine falls back to `~/.pi/` —
- * measured: with all five injected it writes nothing outside the paths named here.
+ * Every one of the four is passed explicitly. Leave any of them out and the engine falls back to `~/.pi/` —
+ * measured: with all four injected it writes nothing outside the paths named here.
  */
 export class AkanCodeServices {
   static settings() {
@@ -41,15 +35,21 @@ export class AkanCodeServices {
     });
   }
 
-  static auth(workspaceRoot: string) {
+  /**
+   * The model catalogue and the credentials behind it, both under `~/.akan/`.
+   *
+   * `authPath` is the whole of what akan's own credential file used to need a storage backend for: the engine
+   * locks and rewrites that file itself, so a second `akan code` refreshing an OAuth token at the same moment
+   * cannot clobber the first. Nothing lands in `~/.pi/`, and a user who removes akan takes their keys with them.
+   */
+  static async runtime(workspaceRoot: string) {
     mkdirSync(akanCodePaths.globalDir(), { recursive: true, mode: 0o700 });
-    const authStorage = AuthStorage.fromStorage(new AkanAuthStorageBackend(akanCodePaths.authFile()));
-    AkanEnvKeys.apply(authStorage, workspaceRoot);
-    return authStorage;
-  }
-
-  static models(authStorage: AuthStorage) {
-    return ModelRegistry.create(authStorage, akanCodePaths.modelsFile());
+    const runtime = await ModelRuntime.create({
+      authPath: akanCodePaths.authFile(),
+      modelsPath: akanCodePaths.modelsFile(),
+    });
+    await AkanEnvKeys.apply(runtime, workspaceRoot);
+    return runtime;
   }
 
   static sessions(workspaceRoot: string, cwd: string, profile: CodeAgentProfile, resume?: string) {
@@ -66,22 +66,29 @@ export class AkanCodeServices {
   }
 
   /**
-   * The akan skill set, then the workspace's own.
+   * The akan skill set, then the person's own, then the workspace's.
+   *
+   * `~/.akan/code/skills` is read because a skill somebody wrote for themselves is theirs, not one checkout's,
+   * and having to copy it into every repo is the same friction that makes people stop writing them. It is
+   * text the model may read, never code that runs — which is why extensions stay workspace-only below.
    *
-   * A path that does not exist is a reported load error rather than a skip, so both are checked first.
+   * A path that does not exist is a reported load error rather than a skip, so each is checked first.
    */
   static #skillPaths(profile: CodeAgentProfile, workspaceRoot: string) {
     if (!profile.context.skills) return [];
-    const workspace = akanCodePaths.skillsDir(workspaceRoot);
-    return [akanCodePaths.builtinSkillsDir(), existsSync(workspace) ? workspace : undefined].filter(
-      (dir): dir is string => !!dir,
-    );
+    const dirs = [
+      akanCodePaths.builtinSkillsDir(),
+      akanCodePaths.globalSkillsDir(),
+      akanCodePaths.skillsDir(workspaceRoot),
+    ];
+    return dirs.filter((dir): dir is string => !!dir && existsSync(dir));
   }
 
   /**
-   * What the engine's resource loader may discover. Extensions and skills come from the workspace, never from
-   * the home directory: a coding agent that picks up a globally installed extension behaves differently in two
-   * checkouts of the same repo for reasons nothing in the repo explains.
+   * What the engine's resource loader may discover. Extensions come from the workspace and nowhere else: a
+   * globally installed extension is code that runs in every checkout, so an agent would behave differently in
+   * two clones of the same repo for reasons nothing in the repo explains. Skills are text and are read from
+   * the home directory too — see `#skillPaths`.
    */
   static resourceOptions(options: AkanCodeServicesOptions) {
     // A path that does not exist is reported as a load error rather than skipped, and these two are optional.
@@ -95,6 +102,15 @@ export class AkanCodeServices {
       noPromptTemplates: true,
       noThemes: true,
       noContextFiles: !options.profile.context.projectFiles,
+      // The engine takes one context file per directory and looks at no editor's own rules, so a repo whose
+      // conventions live in a `CLAUDE.md` or under `.cursor/rules` hands this agent less than it hands the
+      // editor beside it — see {@link AkanContextFiles}. Gated on the same flag, so a profile that wants no
+      // project context still gets none.
+      agentsFilesOverride: ({ agentsFiles }: { agentsFiles: AkanContextFile[] }) => ({
+        agentsFiles: options.profile.context.projectFiles
+          ? AkanContextFiles.extend(agentsFiles, { workspaceRoot: options.workspaceRoot, cwd: options.cwd })
+          : agentsFiles,
+      }),
       appendSystemPrompt: [akanSystemPrompt(options.profile)],
       additionalExtensionPaths: present(akanCodePaths.extensionsDir(options.workspaceRoot)),
       additionalSkillPaths: AkanCodeServices.#skillPaths(options.profile, options.workspaceRoot),

package/codeAgent/agent/AkanContextFiles.ts

@@ -0,0 +1,117 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+
+export interface AkanContextFile {
+  path: string;
+  content: string;
+}
+
+export interface AkanContextFilesOptions {
+  workspaceRoot: string;
+  cwd: string;
+}
+
+/**
+ * The workspace-authored rules the engine's own discovery leaves behind.
+ *
+ * It walks the ancestors of `cwd` and takes **one** file per directory, first match of
+ * `AGENTS.override.md · AGENTS.md · AGENTS.MD · CLAUDE.md · CLAUDE.MD` — so a repo carrying both an `AGENTS.md`
+ * and a `CLAUDE.md` has the second one silently dropped, and a `.cursor/rules` tree is never looked at. Both
+ * are files a developer wrote expecting an agent to obey them, and an agent that reads one editor's copy and
+ * not another's follows rules that disagree with the repo it is in.
+ *
+ * Added rather than replaced: the base list keeps its order and its precedence, and these land after it.
+ */
+export class AkanContextFiles {
+  /** Cursor's frontmatter block, which is metadata for its own rule picker and not instruction for a model. */
+  static readonly #frontmatter = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+
+  static extend(base: AkanContextFile[], options: AkanContextFilesOptions): AkanContextFile[] {
+    const seen = new Set(base.map((file) => file.path));
+    // Keyed by content as well as by path, because the usual way to carry both names is to make one a symlink
+    // to the other or a one-line pointer at it — and the same guide twice is the same guide twice.
+    const contents = new Set(base.map((file) => file.content.trim()));
+    const added: AkanContextFile[] = [];
+    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];
+  }
+
+  /**
+   * The `CLAUDE.md` beside an `AGENTS.md` the engine already took.
+   *
+   * Not beside an `AGENTS.override.md`: that name means "ignore what this directory would otherwise say", so
+   * reinstating the file it was written to displace is the one case where loading both is wrong.
+   */
+  static #claude(base: AkanContextFile[]) {
+    const files: AkanContextFile[] = [];
+    for (const file of base) {
+      if (!/^AGENTS\.(md|MD)$/.test(path.basename(file.path))) continue;
+      for (const name of ["CLAUDE.md", "CLAUDE.MD"]) {
+        const candidate = path.join(path.dirname(file.path), name);
+        const content = AkanContextFiles.#read(candidate);
+        if (content !== undefined) files.push({ path: candidate, content });
+      }
+    }
+    return files;
+  }
+
+  /**
+   * Cursor's always-on rules, from the workspace root and from the session's own directory.
+   *
+   * Only `alwaysApply: true` is taken. Cursor's other three kinds are conditional — `globs` attaches a rule to
+   * the files it names, a bare `description` offers it for the model to ask for, and neither means the rule is
+   * loaded manually — so putting them in a system prompt applies rules their author scoped away. A file with
+   * no frontmatter at all is the `.cursorrules` shape, which was never conditional.
+   */
+  static #cursor(options: AkanContextFilesOptions) {
+    const files: AkanContextFile[] = [];
+    const roots = [...new Set([options.workspaceRoot, options.cwd])];
+    for (const root of roots) {
+      const legacy = AkanContextFiles.#read(path.join(root, ".cursorrules"));
+      if (legacy !== undefined) files.push({ path: path.join(root, ".cursorrules"), content: legacy });
+      for (const file of AkanContextFiles.#mdcFiles(path.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;
+  }
+
+  /** The rule body when the rule applies unconditionally, and nothing when its author scoped it. */
+  static #applied(raw: string) {
+    const match = AkanContextFiles.#frontmatter.exec(raw);
+    if (!match) return raw;
+    if (!/^\s*alwaysApply\s*:\s*true\s*$/m.test(match[1] ?? "")) return undefined;
+    return raw.slice(match[0].length);
+  }
+
+  /** Sorted, because the order rules reach the model in is otherwise the order a directory happens to list. */
+  static #mdcFiles(dir: string) {
+    if (!existsSync(dir)) return [];
+    try {
+      return readdirSync(dir, { recursive: true, withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".mdc"))
+        .map((entry) => path.join(entry.parentPath ?? dir, entry.name))
+        .sort();
+    } catch {
+      return [];
+    }
+  }
+
+  static #read(file: string) {
+    try {
+      if (!existsSync(file) || !statSync(file).isFile()) return undefined;
+      return readFileSync(file, "utf8").replace(/^/, "");
+    } catch {
+      // A rule file that cannot be read costs its own rules. It must not cost the session its start.
+      return undefined;
+    }
+  }
+}

package/codeAgent/agent/CodeAgent.ts

@@ -13,7 +13,9 @@ import {
   type CodeAgentEvent,
   type CodeAgentEventBody,
   type CodeAgentImage,
+  type CodeAgentMcpStatus,
   type CodeAgentProfile,
+  type CodeAgentProviderInfo,
   type CodeAgentQuestion,
   type CodeAgentSessionInfo,
   type CodeAgentState,
@@ -82,6 +84,8 @@ export class CodeAgent {
   #disposed = false;
   #sessionDir: string | undefined;
   #mailbox: CodeMailbox | undefined;
+  #mcp: CodeAgentMcpStatus[] = [];
+  #workspaceRoot = "";
   /**
    * The frames of the turn in flight, so a host that reconnects mid-turn can be handed what it missed.
    *
@@ -102,9 +106,8 @@ export class CodeAgent {
     const cwd = options.cwd ?? workspaceRoot;
     const agent = new CodeAgent(options.profile);
     const settingsManager = AkanCodeServices.settings();
-    const authStorage = AkanCodeServices.auth(workspaceRoot);
-    const modelRegistry = AkanCodeServices.models(authStorage);
-    const model = await akanCodeModel(modelRegistry, options.model);
+    const modelRuntime = await AkanCodeServices.runtime(workspaceRoot);
+    const model = await akanCodeModel(modelRuntime, options.model);
     const compaction = DEFAULT_COMPACTION_SETTINGS;
     const modelWarnings = akanCodeModelWarnings(model, compaction.reserveTokens + compaction.keepRecentTokens);
 
@@ -118,6 +121,8 @@ export class CodeAgent {
       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({
@@ -136,8 +141,7 @@ export class CodeAgent {
     const { session } = await createAgentSession({
       cwd,
       agentDir: akanCodePaths.globalDir(),
-      authStorage,
-      modelRegistry,
+      modelRuntime,
       settingsManager,
       resourceLoader,
       model,
@@ -147,6 +151,8 @@ export class CodeAgent {
       customTools: options.customTools,
     });
     agent.#disposePlugins = akan.dispose;
+    agent.#mcp = akan.mcp;
+    agent.#workspaceRoot = workspaceRoot;
     if (options.profile.session.store === "file") agent.#sessionDir = akanCodePaths.sessionsDir(workspaceRoot);
     await agent.#attach(session, options.mode ?? "print");
     if (agent.#sessionDir) agent.#openMail(akanCodePaths.mailDir(workspaceRoot), cwd);
@@ -169,6 +175,21 @@ export class CodeAgent {
     return this.#sessionDir ? CodeSessionIndex.list(this.#sessionDir) : [];
   }
 
+  /** The repo, which is not `profile.paths.root` — that one is narrowed to an app by `akan code --app`. */
+  get workspaceRoot() {
+    return this.#workspaceRoot;
+  }
+
+  /**
+   * The MCP servers this session was built against, and what each one published.
+   *
+   * Read from the assembly rather than from the live session: the tool allowlist is fixed when the session is
+   * created, so a server declared afterwards is not one this agent can reach however the file now reads.
+   */
+  mcpServers(): CodeAgentMcpStatus[] {
+    return this.#mcp;
+  }
+
   /** The other `akan code` sessions running in this workspace right now. */
   peers() {
     return this.#mailbox?.peers() ?? [];
@@ -262,6 +283,7 @@ export class CodeAgent {
       const text = CodeAgent.#textOf(message.content);
       if (text) this.#emit({ type: "message", turnId, role: message.role, text });
     }
+    this.#emitContextNow();
   }
 
   static #textOf(content: unknown) {
@@ -381,9 +403,36 @@ export class CodeAgent {
     this.#emit({ type: "session", info: this.info });
   }
 
+  /**
+   * The model catalogue, as the two questions a person actually asks of it.
+   *
+   * Built from the registry rather than `getAvailable()` so it needs no await and can answer about a provider
+   * nobody has a key for: "what else could I run" is most of why the list is opened, and a list of only what
+   * is already reachable cannot answer it.
+   */
+  catalogue(): CodeAgentProviderInfo[] {
+    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: CodeAgentModelRef) {
     const session = this.#require();
-    const model = await akanCodeModel(session.modelRegistry, ref);
+    const model = await akanCodeModel(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 });
@@ -442,6 +491,17 @@ export class CodeAgent {
    */
   #emitContextUsage(eventType: string) {
     if (eventType !== "agent_end" && eventType !== "compaction_end") return;
+    this.#emitContextNow();
+  }
+
+  /**
+   * The same frame, on demand, for the one moment the window is already full and no turn has run.
+   *
+   * A resumed session restores a conversation the model is carrying and the host has never seen, so without
+   * this the status line offers the declared window and no share of it until the next turn ends — a session
+   * reopened at 80% looks identical to one reopened empty.
+   */
+  #emitContextNow() {
     const usage = this.#session?.getContextUsage();
     // `== null`, not `=== null`: the field is typed `number | null`, and a strict null check sails straight
     // past an `undefined` the way the mirror of this bug does — which would emit `used: undefined`.
@@ -518,25 +578,33 @@ export class CodeAgent {
     return await this.#asks.openApproval(approvalId);
   }
 
+  /**
+   * Puts one question on the wire and waits for its answer, rendered as the labels a person chose.
+   *
+   * The single way anything asks: the engine's own UI port and the `ask_user` tool both land here, so the
+   * suspend path, the profile's refusal to prompt at all, and the id the host answers against cannot disagree
+   * between them. An empty answer is a skip, which is a real answer and not a failure.
+   */
+  async ask(spec: Omit<CodeAgentQuestion, "questionId">) {
+    if (!this.#profile.ui.canPrompt) return undefined;
+    const question: CodeAgentQuestion = { questionId: this.#asks.nextId("q"), ...spec };
+    this.#emit({ type: "question", question });
+    if (this.#profile.interaction.question === "suspend") {
+      this.#mapper.noteOutcome("awaiting");
+      return undefined;
+    }
+    return (await this.#asks.openQuestion(question)) || undefined;
+  }
+
   #ui() {
     return new CodeAgentUi({
-      ask: async (prompt, kind, choices) => {
-        if (!this.#profile.ui.canPrompt) return undefined;
-        const questionId = this.#asks.nextId("q");
-        const question: CodeAgentQuestion = {
-          questionId,
+      ask: async (prompt, kind, choices) =>
+        await this.ask({
           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 undefined;
-        }
-        return (await this.#asks.openQuestion(question)) || undefined;
-      },
+        }),
       notify: (level, message) => this.#emit({ type: "notice", level, message }),
     });
   }

package/codeAgent/agent/CodeAgentStreamPrinter.ts

@@ -54,6 +54,10 @@ export class CodeAgentStreamPrinter {
       case "queue":
       case "context":
         return;
+      // The rail is a live status for a screen that redraws. A stream has no row to update, and the pool
+      // already says on the transcript when a child starts and what it spent when it stops.
+      case "subagent":
+        return;
       case "question":
         return this.#line(chalk.yellow(`? ${event.question.prompt}`));
       case "approval":