@akanjs/cli 3.0.0-beta.2 → 3.0.0-beta.21

package/README.md

@@ -74,6 +74,9 @@ artifact is built last and is not overwritten by the root `akan` bootstrap scrip
 - Use `@akanjs/cli` as the user-facing executable package.
 - `@akanjs/devkit` is bundled into the CLI for published CLI usage; it is not required as a separate
   runtime dependency for ordinary CLI users.
+- The `akan code` agent follows that same split: its engine, tools and skills are a devkit facet
+  (`@akanjs/devkit/codeAgent`), and `@akanjs/cli/code` is the terminal host plus the SDK entry that
+  re-exports both.
 
 ## Requirements
 

package/TunnelShare-scf4e4pd.js

@@ -0,0 +1,9 @@
+// @bun
+import {
+  TunnelShare2
+} from "./index-smme4r47.js";
+import"./index-22d57v4c.js";
+import"./index-5b6tavv3.js";
+export {
+  TunnelShare2 as TunnelShare
+};

package/{agent.command-d2gfxfck.js → agent.command-ttn09rx3.js}

@@ -2,17 +2,16 @@
 import {
   Workspace,
   command
-} from "./index-mak3cd28.js";
-import"./index-q0y2jq9j.js";
-import"./index-2tv3fdx4.js";
-import"./index-6wwzs1bc.js";
-import"./index-by5gpp8x.js";
-import"./index-gyd220p2.js";
-import"./index-ktb5njgy.js";
-import"./index-h7yw2z9n.js";
+} from "./index-rmcw8yc8.js";
+import"./index-5b6tavv3.js";
+import"./index-ga6hygxr.js";
+import"./index-hj6w4ka1.js";
+import"./index-yy4s1j72.js";
+import"./index-9629w7ns.js";
+import"./index-0bq14vr1.js";
 import {
   AgentScript
-} from "./index-ne2qy0nk.js";
+} from "./index-4dn1p115.js";
 
 // pkgs/@akanjs/cli/agent/agent.command.ts
 class AgentCommand extends command("agent", [AgentScript], ({ public: target }) => ({

package/akanCode.js

@@ -0,0 +1,102 @@
+// @bun
+import {
+  AkanEditScope2,
+  DevLogFeedback2,
+  PreviewChrome2,
+  PreviewView2,
+  PreviewFeedback2,
+  TurnFeedback2,
+  AkanCli2,
+  AkanVerifier2,
+  VerifyFeedback2,
+  AkanToolPack2,
+  MailToolPack2,
+  McpUnauthorized2,
+  McpClient2,
+  McpToolPack2,
+  SessionToolPack2,
+  WebToolPack2,
+  AkanCodePlugins2,
+  AkanEnvKeys2,
+  akanSystemPrompt2,
+  CodeSessionIndex2,
+  AkanCodeServices2,
+  CodeAgentAsks2,
+  CodeAgentEventMapper2,
+  CodeAgentGate2,
+  CodeAgentUi2,
+  CodeMailbox2,
+  CodeSessionFork2,
+  CodeAgent2
+} from "./index-v5eayqqw.js";
+import {
+  akanCodeDefaultModel2,
+  akanCodeModel2,
+  akanCodeModelSupportsImages2,
+  akanCodeModelWarnings2,
+  CodeAgentStreamPrinter2
+} from "./index-c6eggbee.js";
+import {
+  SubagentPool2,
+  akanCodePaths2
+} from "./index-d0arnrm8.js";
+import"./index-7md2g9vw.js";
+import {
+  CodeAgentRpcHost2
+} from "./index-d2242ksy.js";
+import {
+  CodeTuiLines2,
+  CodeTuiAgents2,
+  CodeTuiClipboard2,
+  CodeTuiCommands2,
+  CodeTuiEditor2,
+  CodeTuiFiles2,
+  CodeTuiMarkdown2,
+  CodeTuiParts2
+} from "./index-wa5jbxj1.js";
+export {
+  AkanCli2 as AkanCli,
+  AkanCodePlugins2 as AkanCodePlugins,
+  AkanCodeServices2 as AkanCodeServices,
+  AkanEditScope2 as AkanEditScope,
+  AkanEnvKeys2 as AkanEnvKeys,
+  AkanToolPack2 as AkanToolPack,
+  AkanVerifier2 as AkanVerifier,
+  CodeAgent2 as CodeAgent,
+  CodeAgentAsks2 as CodeAgentAsks,
+  CodeAgentEventMapper2 as CodeAgentEventMapper,
+  CodeAgentGate2 as CodeAgentGate,
+  CodeAgentRpcHost2 as CodeAgentRpcHost,
+  CodeAgentStreamPrinter2 as CodeAgentStreamPrinter,
+  CodeAgentUi2 as CodeAgentUi,
+  CodeMailbox2 as CodeMailbox,
+  CodeSessionFork2 as CodeSessionFork,
+  CodeSessionIndex2 as CodeSessionIndex,
+  CodeTuiAgents2 as CodeTuiAgents,
+  CodeTuiClipboard2 as CodeTuiClipboard,
+  CodeTuiCommands2 as CodeTuiCommands,
+  CodeTuiEditor2 as CodeTuiEditor,
+  CodeTuiFiles2 as CodeTuiFiles,
+  CodeTuiLines2 as CodeTuiLines,
+  CodeTuiMarkdown2 as CodeTuiMarkdown,
+  CodeTuiParts2 as CodeTuiParts,
+  DevLogFeedback2 as DevLogFeedback,
+  MailToolPack2 as MailToolPack,
+  McpClient2 as McpClient,
+  McpToolPack2 as McpToolPack,
+  McpUnauthorized2 as McpUnauthorized,
+  PreviewChrome2 as PreviewChrome,
+  PreviewFeedback2 as PreviewFeedback,
+  PreviewView2 as PreviewView,
+  SessionToolPack2 as SessionToolPack,
+  SubagentPool2 as SubagentPool,
+  TurnFeedback2 as TurnFeedback,
+  VerifyFeedback2 as VerifyFeedback,
+  WebToolPack2 as WebToolPack,
+  akanCodeDefaultModel2 as akanCodeDefaultModel,
+  akanCodeModel2 as akanCodeModel,
+  akanCodeModelSupportsImages2 as akanCodeModelSupportsImages,
+  akanCodeModelWarnings2 as akanCodeModelWarnings,
+  akanCodePaths2 as akanCodePaths,
+  akanSystemPrompt2 as akanSystemPrompt
+};

package/application.command-7gweenv7.js

@@ -0,0 +1,179 @@
+// @bun
+import {
+  App,
+  Apps,
+  Sys,
+  Exec,
+  Workspace,
+  command
+} from "./index-rmcw8yc8.js";
+import"./index-5b6tavv3.js";
+import"./index-ga6hygxr.js";
+import {
+  getMobileTargetChoices
+} from "./index-hr5n7t4x.js";
+import"./index-khpfpcsd.js";
+import"./index-1db2cw0y.js";
+import {
+  ApplicationScript
+} from "./index-z50k041j.js";
+import"./index-7md2g9vw.js";
+import"./index-q44jbw48.js";
+
+// pkgs/@akanjs/cli/application/application.command.ts
+var mobileTargetOption = {
+  desc: "mobile target name or all",
+  ask: "Select mobile target",
+  enum: async ({ app }) => await getMobileTargetChoices(app)
+};
+var deviceOption = {
+  desc: "simulator, emulator or device to run on: its id or name (e.g. 'iPhone 17' or 'Pixel_10')",
+  default: ""
+};
+var teamOption = { flag: "T", desc: "Apple team id the signing is narrowed to", default: "" };
+var devEnvs = ["local", "debug", "develop", "main"];
+var buildEnvOption = { enum: devEnvs, desc: "backend environment", default: "debug" };
+var startEnvOption = { enum: devEnvs, desc: "backend environment", default: "local" };
+var releaseEnvOption = {
+  enum: ["debug", "develop", "main", "local"],
+  desc: "backend environment",
+  default: "main"
+};
+
+class ApplicationCommand extends command("application", [ApplicationScript], ({ public: target }) => ({
+  createApplication: target({ desc: "Create a new application in the workspace" }).arg("appName", String, { desc: "name of application" }).option("start", Boolean, { desc: "start application", default: false }).with(Workspace).exec(async function(appName, start, workspace) {
+    await this.applicationScript.createApplication(appName.toLowerCase().replace(/ /g, "-"), workspace, { start });
+  }),
+  removeApplication: target({ desc: "Remove an application from the workspace" }).with(App).exec(async function(app) {
+    await this.applicationScript.removeApplication(app);
+  }),
+  planSlice: target({ desc: "List the exact files an app needs to live in a workspace of its own" }).with(App).option("format", String, { desc: "output format", default: "text", enum: ["text", "json"] }).exec(async function(app, format) {
+    await this.applicationScript.planSlice(app, format);
+  }),
+  sync: target({ desc: "Sync dependencies and configuration for an app or library" }).with(Sys).exec(async function(sys) {
+    await this.applicationScript.sync(sys);
+  }),
+  script: target({ desc: "Run a custom script in the application" }).with(App).arg("filename", String, { desc: "name of script", nullable: true }).exec(async function(app, filename) {
+    await this.applicationScript.script(app, filename);
+  }),
+  console: target({ desc: "Open an interactive server console for the application" }).with(App).exec(async function(app) {
+    await this.applicationScript.console(app);
+  }),
+  logs: target({ desc: "Tail the running application's logs, filtered (attaches to akan-control.sock)" }).with(App).option("level", String, { desc: "minimum level: trace, verbose, debug, info, warn, error", nullable: true }).option("grep", String, { desc: "substring the message must contain", nullable: true }).option("endpoint", String, {
+    desc: "endpoint glob(s), comma-separated: mutation:*, query:userList",
+    nullable: true
+  }).option("trace", String, { desc: "one request's traceId", nullable: true }).option("child", String, { desc: "replica index(es), comma-separated", nullable: true }).option("role", String, {
+    flag: "R",
+    desc: "process role(s): gateway, federation, batch, all, rsc-worker",
+    nullable: true
+  }).option("origin", String, { desc: "call origin(s): http, websocket, mcp, internal, page", nullable: true }).option("since", String, {
+    desc: "only records newer than this: a duration ago in ms, s, m, h or d (30s, 5m, 2h), or an epoch-ms timestamp",
+    nullable: true
+  }).option("replay", Number, { flag: "n", desc: "records to replay from the buffer before following", default: 0 }).option("json", Boolean, { desc: "print NDJSON records instead of rendered lines", default: false }).option("follow", Boolean, { desc: "keep streaming; pass --follow false for history only", default: true }).option("runtimeDir", String, {
+    flag: "d",
+    desc: "runtime dir holding akan-control.sock (default: local/apps/<app>/runtime)",
+    nullable: true
+  }).exec(async function(app, level, grep, endpoint, trace, child, role, origin, since, replay, json, follow, runtimeDir) {
+    await this.applicationScript.logs(app, {
+      level,
+      grep,
+      endpoint,
+      trace,
+      child,
+      role,
+      origin,
+      since,
+      replay,
+      json,
+      follow,
+      runtimeDir
+    });
+  }),
+  build: target({ short: true, desc: "Build the application for production (frontend + backend)" }).with(App).option("write", Boolean, { desc: "write code generation", default: true }).option("fast", Boolean, { desc: "fast build", default: false }).option("quiet", Boolean, { desc: "hide build progress output", default: false }).exec(async function(app, write, fast, quiet) {
+    await this.applicationScript.build(app, { write, fast, quiet });
+  }),
+  typecheck: target({ short: true, desc: "Typecheck the application" }).with(App).option("write", Boolean, { desc: "write code generation", default: true }).option("clean", Boolean, { desc: "clear typecheck cache before running", default: false }).option("incremental", Boolean, { desc: "reuse TypeScript incremental cache", default: true }).exec(async function(app, write, clean, incremental) {
+    await this.applicationScript.typecheck(app, { write, clean, incremental });
+  }),
+  test: target({ desc: "Prepare and test an app, library, or package" }).with(Exec).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(exec, write) {
+    await this.applicationScript.test(exec, { write });
+  }),
+  buildIos: target({ short: true, desc: "Build the iOS app on the native runtime" }).with(App).option("target", String, mobileTargetOption).option("env", String, buildEnvOption).option("debug", Boolean, { desc: "debug build instead of release", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, debug, write) {
+    await this.applicationScript.buildIos(app, { target, env, profile: debug ? "debug" : "release", write });
+  }),
+  buildAndroid: target({ short: true, desc: "Build the Android app (apk) on the native runtime" }).with(App).option("target", String, mobileTargetOption).option("env", String, buildEnvOption).option("debug", Boolean, { desc: "debug build instead of release", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, debug, write) {
+    await this.applicationScript.buildAndroid(app, { target, env, profile: debug ? "debug" : "release", write });
+  }),
+  start: target({ short: true, desc: "Start development server(s) (frontend SSR + backend)" }).with(Apps).option("plain", Boolean, { desc: "print prefixed lines instead of the full-screen view", default: false }).option("kill", Boolean, { flag: "k", desc: "free the dev ports first, whoever is holding them", default: false }).option("concurrency", Number, {
+    desc: "apps to boot at a time (default: what this machine's memory and cores allow)",
+    nullable: true
+  }).option("dbup", Boolean, { desc: "start the local database first", default: true }).option("open", Boolean, { desc: "open web browser?", default: false }).option("share", Boolean, { desc: "also share each app on a public URL through an akan tunnel", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(apps, plain, kill, concurrency, dbup, open, share, write) {
+    await this.applicationScript.start(apps, { plain, kill, concurrency, dbup, open, share, write });
+  }),
+  startIos: target({ short: true, desc: "Run the iOS app in a simulator or on an iPhone, following `akan start`" }).with(App).option("target", String, mobileTargetOption).option("env", String, startEnvOption).option("release", Boolean, { desc: "run a release build of its own bundle instead", default: false }).option("device", String, deviceOption).option("team", String, teamOption).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, release, device, team, write) {
+    await this.applicationScript.startIos(app, {
+      target,
+      env,
+      operation: release ? "release" : "local",
+      device: device || undefined,
+      teamId: team || undefined,
+      write
+    });
+  }),
+  startAndroid: target({
+    short: true,
+    desc: "Run the Android app in an emulator or on a device, following `akan start`"
+  }).with(App).option("target", String, mobileTargetOption).option("env", String, startEnvOption).option("release", Boolean, { desc: "run a release build of its own bundle instead", default: false }).option("device", String, deviceOption).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, release, device, write) {
+    await this.applicationScript.startAndroid(app, {
+      target,
+      env,
+      operation: release ? "release" : "local",
+      device: device || undefined,
+      write
+    });
+  }),
+  startDesktop: target({
+    short: true,
+    desc: "Run the desktop app on this computer (macOS, Windows or Linux), following `akan start`"
+  }).with(App).option("target", String, mobileTargetOption).option("env", String, startEnvOption).option("release", Boolean, { desc: "run a release build of its own bundle instead", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, release, write) {
+    await this.applicationScript.startDesktop(app, { target, env, operation: release ? "release" : "local", write });
+  }),
+  releaseIos: target({ desc: "Build and sign the iOS app for the App Store (.ipa)" }).with(App).option("target", String, mobileTargetOption).option("env", String, releaseEnvOption).option("team", String, teamOption).option("adHoc", Boolean, { desc: "sign with an ad-hoc profile instead of app-store", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).option("allowLocalRelease", Boolean, { flag: "l", desc: "allow release with --env local", default: false }).exec(async function(app, target, env, team, adHoc, write, allowLocalRelease) {
+    await this.applicationScript.releaseIos(app, {
+      target,
+      env,
+      teamId: team || undefined,
+      adHoc,
+      write,
+      allowLocalRelease
+    });
+  }),
+  releaseAndroid: target({ desc: "Build and sign the Android app for the Play Store (aab, or apk)" }).with(App).option("assembleType", String, { enum: ["aab", "apk"], default: "aab" }).option("target", String, mobileTargetOption).option("env", String, releaseEnvOption).option("write", Boolean, { desc: "write code generation", default: true }).option("allowLocalRelease", Boolean, { flag: "l", desc: "allow release with --env local", default: false }).exec(async function(app, assembleType, target, env, write, allowLocalRelease) {
+    await this.applicationScript.releaseAndroid(app, assembleType, {
+      target,
+      env,
+      write,
+      allowLocalRelease
+    });
+  }),
+  dbup: target({ desc: "Start local database services for a database mode" }).with(Workspace).option("mode", String, {
+    desc: "database mode; left out, every mode the workspace's apps declare",
+    enum: ["single", "multiple", "cluster"],
+    nullable: true
+  }).exec(async function(workspace, mode) {
+    await this.applicationScript.dbupDeclared(workspace, mode);
+  }),
+  dbExport: target({ desc: "Write every model table of an app to one NDJSON file each" }).with(App).option("dir", String, { desc: "directory under the workspace to write", default: "local/transfer" }).exec(async function(app, dir) {
+    await this.applicationScript.transferDatabase(app, "export", dir);
+  }),
+  dbImport: target({ desc: "Read files db-export wrote into an app's database, in the mode the shell names" }).with(App).option("dir", String, { desc: "directory under the workspace to read", default: "local/transfer" }).exec(async function(app, dir) {
+    await this.applicationScript.transferDatabase(app, "import", dir);
+  }),
+  dbdown: target({ desc: "Stop local database services" }).with(Workspace).exec(async function(workspace) {
+    await this.applicationScript.dbdown(workspace);
+  })
+})) {
+}
+export {
+  ApplicationCommand
+};

package/{applicationBuildRunner-kxwbssgn.js → applicationBuildRunner-38exmejd.js}

@@ -1,17 +1,16 @@
 // @bun
 import {
   Spinner
-} from "./index-2tv3fdx4.js";
+} from "./index-ga6hygxr.js";
 import {
   AllRoutesBuilder,
   CsrArtifactBuilder,
   FontPruner,
   precompressArtifacts,
   SsrBaseArtifactBuilder
-} from "./index-a64esmtb.js";
-import"./index-w8kmx1b6.js";
-import"./index-q0y2jq9j.js";
-import"./index-hwkygn9s.js";
+} from "./index-aadpbnt2.js";
+import"./index-fgq75haa.js";
+import"./index-5b6tavv3.js";
 import"./index-n68jx79w.js";
 
 // pkgs/@akanjs/devkit/applicationBuildRunner.ts
@@ -51,6 +50,7 @@ class ApplicationBuildRunner {
   #app;
   #fast;
   #reporter;
+  #spinner;
   #startedAt = Date.now();
   #phases = [];
   constructor(app, { fast = false, reporter } = {}) {
@@ -59,21 +59,17 @@ class ApplicationBuildRunner {
     this.#reporter = reporter;
   }
   async build({ spinner = false } = {}) {
-    const phaseOptions = { spinner };
+    this.#spinner = spinner;
     const { web, assets } = await this.#app.getConfig();
-    await this.#runPhase("prepare", "Preparing output directory", () => this.#app.prepareCommand("build"), undefined, {
-      spinner
-    });
+    await this.#runPhase("prepare", "Preparing output directory", () => this.#app.prepareCommand("build"));
     if (!this.#fast)
-      await this.#runPhase("typecheck", "Typechecking", () => this.typecheck(), undefined, phaseOptions);
-    await this.#runPhase("backend", "Compiling backend", () => this.#buildBackend(), (result) => `${result.entrypoints} entrypoints, ${result.outputs} outputs`, phaseOptions);
-    await this.#runPhase("ssr", "Building SSR route artifacts", async () => web.ssr ? await this.#buildSsr() : null, (result) => result ? `${result.allRoutes.manifest.routeIds.length} routes, ${result.allRoutes.manifest.knownEntries.length} entries` : web.ssr ? "skipped" : "disabled by akan.config.ts web.ssr", phaseOptions);
-    await this.#runPhase("csr", "Building CSR assets", async () => web.csr ? await this.#buildCsr() : null, (result) => result?.outputDir ?? (web.csr ? "skipped" : "disabled by akan.config.ts web.csr"), phaseOptions);
-    await this.#runPhase("assets", "Trimming unread static assets", async () => assets.pruneFonts ? await new FontPruner(this.#app, assets).prune() : null, (result) => result ? `${result.removed.length} font file(s) dropped, ${ApplicationBuildRunner.formatBytes(result.freedBytes)} freed; ${result.kept.length} kept` : "disabled by akan.config.ts assets.pruneFonts", phaseOptions);
-    await this.#runPhase("compress", "Compressing static assets", () => precompressArtifacts(this.#app), (result) => result.files > 0 ? `${result.files} files, ${ApplicationBuildRunner.formatBytes(result.inputBytes)} -> gzip ${ApplicationBuildRunner.formatBytes(result.outputBytes)} / br ${ApplicationBuildRunner.formatBytes(result.brotliBytes)}` : "no files", phaseOptions);
-    await this.#runPhase("metadata", "Writing production metadata", () => this.#buildAppMeta(), undefined, {
-      spinner
-    });
+      await this.#runPhase("typecheck", "Typechecking", () => this.typecheck());
+    await this.#runPhase("backend", "Compiling backend", () => this.#buildBackend(), (result) => `${result.entrypoints} entrypoints, ${result.outputs} outputs`);
+    await this.#runPhase("ssr", "Building SSR route artifacts", async () => web.ssr ? await this.#buildSsr() : null, (result) => result ? `${result.allRoutes.manifest.routeIds.length} routes, ${result.allRoutes.manifest.knownEntries.length} entries` : web.ssr ? "skipped" : "disabled by akan.config.ts web.ssr");
+    await this.#runPhase("csr", "Building CSR assets", async () => web.csr ? await new CsrArtifactBuilder(this.#app, "build").build() : null, (result) => result?.outputDir ?? (web.csr ? "skipped" : "disabled by akan.config.ts web.csr"));
+    await this.#runPhase("assets", "Trimming unread static assets", async () => assets.pruneFonts ? await new FontPruner(this.#app, assets).prune() : null, (result) => result ? `${result.removed.length} font file(s) dropped, ${ApplicationBuildRunner.formatBytes(result.freedBytes)} freed; ${result.kept.length} kept` : "disabled by akan.config.ts assets.pruneFonts");
+    await this.#runPhase("compress", "Compressing static assets", () => precompressArtifacts(this.#app), (result) => result.files > 0 ? `${result.files} files, ${ApplicationBuildRunner.formatBytes(result.inputBytes)} -> gzip ${ApplicationBuildRunner.formatBytes(result.outputBytes)} / br ${ApplicationBuildRunner.formatBytes(result.brotliBytes)}` : "no files");
+    await this.#runPhase("metadata", "Writing production metadata", () => this.#buildAppMeta());
     return {
       phases: this.#phases,
       durationMs: Date.now() - this.#startedAt,
@@ -84,21 +80,20 @@ class ApplicationBuildRunner {
   async typecheck(options = {}) {
     const { clean = false, incremental = true } = options;
     await this.#app.getPageKeys({ refresh: true });
-    const { typecheckDir, tsconfigPath } = await this.#writeTypecheckTsconfig({ incremental });
+    const { typecheckDir, tsconfigPath } = await this.#writeTypecheckTsconfig(incremental);
     if (clean)
       await rm(path.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
     await this.#checkProjectInChildProcess(tsconfigPath);
   }
-  async#runPhase(id, label, task, summarize, options = {}) {
+  async#runPhase(id, label, task, summarize) {
     this.#reporter?.phaseStart?.({ id, label });
     const phaseStartedAt = Date.now();
-    const spinner = options.spinner ? new Spinner(label, { prefix: `${BUILD_PHASE_EMOJIS[id]} ${id}` }).start() : undefined;
+    const spinner = this.#spinner ? new Spinner(label, { prefix: `${BUILD_PHASE_EMOJIS[id]} ${id}` }).start() : undefined;
     try {
       const result = await task();
       const phase = { id, label, durationMs: Date.now() - phaseStartedAt, summary: summarize?.(result) };
       this.#phases.push(phase);
-      const summary = phase.summary ? `: ${phase.summary}` : "";
-      spinner?.succeed(`${label}${summary}`);
+      spinner?.succeed(`${label}${phase.summary ? `: ${phase.summary}` : ""}`);
       this.#reporter?.phaseDone?.(phase);
       return result;
     } catch (error) {
@@ -111,59 +106,72 @@ class ApplicationBuildRunner {
     const akanConfig = await this.#app.getConfig();
     await Promise.all([
       this.#app.dist.writeJson("package.json", akanConfig.getProductionPackageJson()),
-      this.#app.dist.writeFile(`${this.#app.dist.cwdPath}/Dockerfile`, akanConfig.dockerfile)
+      this.#app.dist.writeFile(`${this.#app.dist.cwdPath}/Dockerfile`, akanConfig.dockerfile),
+      this.#app.dist.writeJson("akan.build.json", {
+        buildId: await this.#resolveBuildId(),
+        akanVersion: akanConfig.akanVersion,
+        builtAt: new Date().toISOString()
+      })
     ]);
   }
+  async#resolveBuildId() {
+    const fromEnv = process.env.AKAN_BUILD_ID?.trim();
+    if (fromEnv)
+      return fromEnv;
+    const root = this.#app.workspace.workspaceRoot;
+    const sha = Bun.spawnSync(["git", "rev-parse", "--short=12", "HEAD"], { cwd: root, stderr: "ignore" });
+    if (sha.exitCode !== 0)
+      return null;
+    const dirty = Bun.spawnSync(["git", "status", "--porcelain", "--untracked-files=no"], {
+      cwd: root,
+      stderr: "ignore"
+    });
+    const suffix = dirty.exitCode === 0 && dirty.stdout.toString().trim() ? "-dirty" : "";
+    return `${sha.stdout.toString().trim()}${suffix}`;
+  }
   async#buildBackend() {
-    const akanConfig = await this.#app.getConfig();
-    const backendExternals = [
-      ...new Set([...akanConfig.externalLibs, ...SSR_RENDER_EXTERNALS, ...AKAN_OPTIONAL_BACKEND_EXTERNALS])
-    ];
-    const { web } = akanConfig;
+    const { externalLibs, web } = await this.#app.getConfig();
     const backendEntryPoints = [`${this.#app.cwdPath}/main.ts`, `${this.#app.cwdPath}/server.ts`];
     for (const entrypoint of backendEntryPoints) {
       if (!await Bun.file(entrypoint).exists())
         throw new Error(`Backend entrypoint not found: ${entrypoint}`);
     }
-    const backendResult = await this.#buildOrThrow("backend", {
-      entrypoints: backendEntryPoints,
+    const sharedConfig = {
       outdir: this.#app.dist.cwdPath,
       target: "bun",
       minify: AKAN_BACKEND_MINIFY,
       naming: { entry: "[name].[ext]", chunk: "chunk-[hash].[ext]" },
-      define: { "process.env.NODE_ENV": JSON.stringify("production") },
-      plugins: backendExternals.length > 0 ? [this.#createExternalSpecifiersPlugin(backendExternals)] : []
-    });
+      define: { "process.env.NODE_ENV": JSON.stringify("production") }
+    };
+    const backendConfig = { ...sharedConfig, plugins: [this.#createExternalSpecifiersPlugin(externalLibs)] };
+    const [mainResult, serverResult] = [
+      await this.#buildOrThrow("backend", { ...backendConfig, entrypoints: [backendEntryPoints[0]] }),
+      await this.#buildOrThrow("backend", { ...backendConfig, entrypoints: [backendEntryPoints[1]], splitting: true })
+    ];
     const rscWorkerResult = web.ssr ? await this.#buildOrThrow("rsc-worker", {
+      ...backendConfig,
       entrypoints: [this.#resolveRscWorkerBuildEntry()],
-      outdir: this.#app.dist.cwdPath,
-      target: "bun",
-      minify: AKAN_BACKEND_MINIFY,
-      naming: { entry: "[name].[ext]", chunk: "chunk-[hash].[ext]" },
-      conditions: ["react-server"],
-      define: { "process.env.NODE_ENV": JSON.stringify("production") },
-      plugins: backendExternals.length > 0 ? [this.#createExternalSpecifiersPlugin(backendExternals)] : []
+      conditions: ["react-server"]
     }) : null;
     const consoleRuntimeResult = await this.#buildOrThrow("console-runtime", {
+      ...sharedConfig,
       entrypoints: [this.#resolveConsoleRuntimeBuildEntry()],
-      outdir: this.#app.dist.cwdPath,
-      target: "bun",
-      minify: AKAN_BACKEND_MINIFY,
-      naming: { entry: "console-runtime.[ext]", chunk: "chunk-[hash].[ext]" },
-      define: { "process.env.NODE_ENV": JSON.stringify("production") }
+      naming: { entry: "console-runtime.[ext]", chunk: "chunk-[hash].[ext]" }
     });
     await this.#writeConsoleShim();
+    const results = [mainResult, serverResult, rscWorkerResult, consoleRuntimeResult];
     return {
       entrypoints: backendEntryPoints.length + (rscWorkerResult ? 2 : 1),
-      outputs: backendResult.outputs.length + (rscWorkerResult?.outputs.length ?? 0) + consoleRuntimeResult.outputs.length + 1
+      outputs: results.reduce((sum, result) => sum + (result?.outputs.length ?? 0), 1)
     };
   }
   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";
+    await Bun.write(path.join(this.#app.dist.cwdPath, "console.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 } });
@@ -192,9 +200,6 @@ void run().catch((error) => {
       return path.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
     }
   }
-  async#buildCsr() {
-    return await new CsrArtifactBuilder(this.#app, "build").build();
-  }
   async#buildSsr() {
     const pageKeys = await this.#app.getPageKeys();
     if (pageKeys.length === 0) {
@@ -205,7 +210,7 @@ void run().catch((error) => {
     const allRoutes = await new AllRoutesBuilder(this.#app, base.artifact, "build").build();
     return { base, allRoutes };
   }
-  async#writeTypecheckTsconfig({ incremental = true } = {}) {
+  async#writeTypecheckTsconfig(incremental) {
     const typecheckDir = path.join(this.#app.cwdPath, ".akan", "typecheck");
     await mkdir(typecheckDir, { recursive: true });
     const libPageIncludes = (await this.#app.getPageRoots()).filter((root) => root.keyPrefix).flatMap((root) => {
@@ -272,9 +277,9 @@ void run().catch((error) => {
       throw new AggregateError(result.logs, `[${label}] Bun.build failed`);
     return result;
   }
-  #createExternalSpecifiersPlugin(specifiers) {
-    const uniqueSpecifiers = [...new Set(specifiers)];
-    const escaped = uniqueSpecifiers.map((specifier) => specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  #createExternalSpecifiersPlugin(externalLibs) {
+    const specifiers = new Set([...externalLibs, ...SSR_RENDER_EXTERNALS, ...AKAN_OPTIONAL_BACKEND_EXTERNALS]);
+    const escaped = [...specifiers].map((specifier) => specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
     const filter = new RegExp(`^(${escaped.join("|")})(?:/.*)?$`);
     return {
       name: "akan-backend-externalize-specifiers",
@@ -283,13 +288,7 @@ void run().catch((error) => {
       }
     };
   }
-  static formatBytes(bytes) {
-    if (bytes < 1024)
-      return `${bytes}B`;
-    if (bytes < 1024 * 1024)
-      return `${(bytes / 1024).toFixed(1)}KB`;
-    return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
-  }
+  static formatBytes = FontPruner.formatBytes;
 }
 export {
   ApplicationBuildRunner