@akanjs/cli 3.0.0-beta.13 → 3.0.0-beta.15

package/{index-h7yw2z9n.js → index-twq9p2sp.js}

@@ -6,7 +6,7 @@ import {
 // pkgs/@akanjs/devkit/prompter.ts
 import fsPromise from "fs/promises";
 import { input, select } from "@inquirer/prompts";
-class Prompter {
+class Prompter2 {
   static async#getGuidelineRoot() {
     const dirname = getDirname2(import.meta.url);
     const candidates = [`${dirname}/guidelines`, `${dirname}/../cli/guidelines`];
@@ -19,27 +19,27 @@ class Prompter {
     return candidates[0];
   }
   static async selectGuideline() {
-    const guideNames = await Prompter.listGuidelines();
+    const guideNames = await Prompter2.listGuidelines();
     return await select({
       message: "Select a guideline",
       choices: guideNames.map((name) => ({ name, value: name }))
     });
   }
   static async listGuidelines() {
-    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    const guidelineRoot = await Prompter2.#getGuidelineRoot();
     return (await fsPromise.readdir(guidelineRoot)).filter((name) => !name.startsWith("_")).sort();
   }
   static async getGuideJson(guideName) {
-    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    const guidelineRoot = await Prompter2.#getGuidelineRoot();
     const filePath = `${guidelineRoot}/${guideName}/${guideName}.generate.json`;
     const guideJson = await fsPromise.readFile(filePath, "utf-8");
     return JSON.parse(guideJson);
   }
   static async getInstruction(guideName) {
-    const guideNames = await Prompter.listGuidelines();
+    const guideNames = await Prompter2.listGuidelines();
     if (!guideNames.includes(guideName))
       throw new Error(`Unknown guideline "${guideName}". Available: ${guideNames.join(", ")}`);
-    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    const guidelineRoot = await Prompter2.#getGuidelineRoot();
     return await fsPromise.readFile(`${guidelineRoot}/${guideName}/${guideName}.instruction.md`, "utf-8");
   }
   static async getUpdateRequest(guideName) {
@@ -67,7 +67,7 @@ ${request}
 `;
   }
   async getDocumentation(guideName) {
-    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    const guidelineRoot = await Prompter2.#getGuidelineRoot();
     const filePath = `${guidelineRoot}/${guideName}/${guideName}.instruction.md`;
     const document = await fsPromise.readFile(filePath, "utf-8");
     return `\`\`\`markdown
@@ -77,4 +77,4 @@ ${document}
   }
 }
 
-export { Prompter };
+export { Prompter2 };

package/index-v156f836.js

@@ -0,0 +1,234 @@
+// @bun
+import {
+  runner,
+  script
+} from "./index-gca9y01h.js";
+import {
+  ModuleExecutor
+} from "./index-p1j0cyvd.js";
+import {
+  sourceFile,
+  moduleSourcePaths,
+  generatedFilesForSync,
+  createPassedPrimitiveReport,
+  bilingualLabelForField,
+  bilingualDescriptionForField
+} from "./index-1p146w4s.js";
+import {
+  PageScript
+} from "./index-f4gpcp98.js";
+import {
+  pluralizeName
+} from "./index-nz8prx9g.js";
+
+// pkgs/@akanjs/cli/module/module.script.ts
+import { capitalize as capitalize2 } from "akanjs/common";
+
+// pkgs/@akanjs/cli/module/module.runner.ts
+import { capitalize } from "akanjs/common";
+var purposeByModule = {
+  budget: "Budget represents planned or actual money allocated inside the app.",
+  project: "Project represents a project workspace or business initiative managed by the app.",
+  task: "Task represents work items that move through the app workflow."
+};
+var moduleAbstractContent = (moduleName) => {
+  const title = capitalize(moduleName);
+  const label = bilingualLabelForField(moduleName);
+  const purpose = purposeByModule[moduleName] ?? `${title} represents ${label.en.toLowerCase()} records managed by the app.`;
+  return `# ${title} Module Abstract
+
+## Purpose
+
+${purpose}
+
+## Domain Rules
+
+- Keep ${label.en.toLowerCase()} data consistent with user-facing dictionary labels.
+
+## Data Meaning
+
+${label.en} (${label.ko}) is the primary business concept for this module.
+
+## Workflows
+
+No lifecycle workflow yet.
+
+## Agent Notes
+
+- Read this abstract before changing the module.
+- Update this file when business invariants, workflows, or public behavior change.
+- Do not update this file for formatting-only, import-only, or style-only changes.
+
+## Related Modules
+
+- None yet.
+`;
+};
+var localModuleFilename = (moduleName, pathKey) => moduleSourcePaths(moduleName)[pathKey].replace(`lib/${moduleName}/`, "");
+
+class ModuleRunner extends runner("module") {
+  async createService(module) {
+    const serviceName = module.name.replace(/^_+/, "");
+    await module.applyTemplate({
+      basePath: `.`,
+      template: "service",
+      dict: { model: serviceName, sysName: module.sys.name }
+    });
+    const [abstractContent, dictionaryContent, serviceContent, signalContent, storeContent] = await Promise.all([
+      module.readFile(`${serviceName}.abstract.md`),
+      module.readFile(`${serviceName}.dictionary.ts`),
+      module.readFile(`${serviceName}.service.ts`),
+      module.readFile(`${serviceName}.signal.ts`),
+      module.readFile(`${serviceName}.store.ts`)
+    ]);
+    return {
+      abstract: { filename: `${serviceName}.abstract.md`, content: abstractContent },
+      dictionary: { filename: `${serviceName}.dictionary.ts`, content: dictionaryContent },
+      service: { filename: `${serviceName}.service.ts`, content: serviceContent },
+      signal: { filename: `${serviceName}.signal.ts`, content: signalContent },
+      store: { filename: `${serviceName}.store.ts`, content: storeContent }
+    };
+  }
+  async removeModule(module) {
+    await module.sys.removeDir(`lib/${module.name}`);
+  }
+  async createComponentTemplate(module, type) {
+    await module.sys.applyTemplate({
+      basePath: `./lib/${module.name}`,
+      template: `module/__Model__.${capitalize(type)}.tsx`,
+      dict: { model: module.name, sysName: module.sys.name, sysType: module.sys.type }
+    });
+    return {
+      component: {
+        filename: `${capitalize(module.name)}.${capitalize(type)}.tsx`,
+        content: await module.sys.readFile(`lib/${module.name}/${capitalize(module.name)}.${capitalize(type)}.tsx`)
+      }
+    };
+  }
+  async createModuleTemplate(module) {
+    const names = pluralizeName(module.name);
+    const modelLabel = bilingualLabelForField(module.name);
+    const modelDescription = bilingualDescriptionForField(module.name);
+    const filenames = {
+      abstract: localModuleFilename(module.name, "abstract"),
+      constant: localModuleFilename(module.name, "constant"),
+      dictionary: localModuleFilename(module.name, "dictionary"),
+      service: localModuleFilename(module.name, "service"),
+      store: localModuleFilename(module.name, "store"),
+      signal: localModuleFilename(module.name, "signal"),
+      unit: localModuleFilename(module.name, "unit"),
+      view: localModuleFilename(module.name, "view"),
+      template: localModuleFilename(module.name, "template"),
+      zone: localModuleFilename(module.name, "zone"),
+      util: localModuleFilename(module.name, "util")
+    };
+    await module.applyTemplate({
+      basePath: `.`,
+      template: "module",
+      dict: {
+        model: module.name,
+        models: names,
+        sysName: module.sys.name,
+        sysType: module.sys.type,
+        modelLabelEn: modelLabel.en,
+        modelLabelKo: modelLabel.ko,
+        modelDescEn: modelDescription.en,
+        modelDescKo: modelDescription.ko
+      }
+    });
+    await module.writeFile(filenames.abstract, moduleAbstractContent(module.name));
+    const [
+      abstractContent,
+      constantContent,
+      dictionaryContent,
+      serviceContent,
+      storeContent,
+      signalContent,
+      unitContent,
+      viewContent,
+      templateContent,
+      zoneContent,
+      utilContent
+    ] = await Promise.all([
+      module.readFile(filenames.abstract),
+      module.readFile(filenames.constant),
+      module.readFile(filenames.dictionary),
+      module.readFile(filenames.service),
+      module.readFile(filenames.store),
+      module.readFile(filenames.signal),
+      module.readFile(filenames.unit),
+      module.readFile(filenames.view),
+      module.readFile(filenames.template),
+      module.readFile(filenames.zone),
+      module.readFile(filenames.util)
+    ]);
+    return {
+      abstract: { filename: filenames.abstract, content: abstractContent },
+      constant: { filename: filenames.constant, content: constantContent },
+      dictionary: { filename: filenames.dictionary, content: dictionaryContent },
+      service: { filename: filenames.service, content: serviceContent },
+      store: { filename: filenames.store, content: storeContent },
+      signal: { filename: filenames.signal, content: signalContent },
+      unit: { filename: filenames.unit, content: unitContent },
+      view: { filename: filenames.view, content: viewContent },
+      template: { filename: filenames.template, content: templateContent },
+      zone: { filename: filenames.zone, content: zoneContent },
+      util: { filename: filenames.util, content: utilContent }
+    };
+  }
+}
+
+// pkgs/@akanjs/cli/module/module.script.ts
+var moduleChangedFiles = (sys, moduleName, files) => Object.values(files).map((file) => sourceFile(sys, `lib/${moduleName}/${file.filename}`, "create", "Module source file was created."));
+
+class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
+  async createModuleTemplate(sys, name, { page = false } = {}) {
+    const mod = ModuleExecutor.from(sys, name);
+    const files = await this.moduleRunner.createModuleTemplate(mod);
+    if (page && sys.type === "app")
+      await this.pageScript.createCrudPage(mod, { app: sys, basePath: null, single: false });
+    await sys.scan();
+    return createPassedPrimitiveReport({
+      command: "create-module",
+      changedFiles: moduleChangedFiles(sys, name, files),
+      generatedFiles: generatedFilesForSync(sys, "Generated files were refreshed after module creation."),
+      target: sys.name
+    });
+  }
+  async removeModule(mod) {
+    await this.moduleRunner.removeModule(mod);
+  }
+  async createService(sys, name) {
+    const service = ModuleExecutor.from(sys, `_${name}`);
+    const files = await this.moduleRunner.createService(service);
+    await sys.scan();
+    return createPassedPrimitiveReport({
+      command: "create-service",
+      changedFiles: moduleChangedFiles(sys, `_${name}`, files),
+      generatedFiles: generatedFilesForSync(sys, "Generated files were refreshed after service creation."),
+      target: sys.name
+    });
+  }
+  async createTest(workspace, name) {}
+  async createTemplate(mod) {
+    return await this.#createComponent(mod, "template");
+  }
+  async createUnit(mod) {
+    return await this.#createComponent(mod, "unit");
+  }
+  async createView(mod) {
+    return await this.#createComponent(mod, "view");
+  }
+  async#createComponent(mod, type) {
+    const { component } = await this.moduleRunner.createComponentTemplate(mod, type);
+    return createPassedPrimitiveReport({
+      command: `create-${type}`,
+      changedFiles: [
+        sourceFile(mod.sys, `lib/${mod.name}/${component.filename}`, "create", `${capitalize2(type)} UI source was created.`)
+      ],
+      target: mod.sys.name
+    });
+  }
+}
+
+export { ModuleScript };

package/index-v1y3cx0k.js

@@ -0,0 +1,61 @@
+// @bun
+import {
+  runner,
+  script
+} from "./index-gca9y01h.js";
+import {
+  generatedFilesForSync,
+  createPassedPrimitiveReport,
+  scalarChangedFiles
+} from "./index-1p146w4s.js";
+import {
+  pluralizeName
+} from "./index-nz8prx9g.js";
+
+// pkgs/@akanjs/cli/scalar/scalar.runner.ts
+class ScalarRunner extends runner("scalar") {
+  async applyScalarTemplate(sys, scalarName) {
+    await sys.applyTemplate({
+      basePath: "./lib/__scalar",
+      template: "__scalar",
+      dict: { model: scalarName, models: pluralizeName(scalarName), sysName: sys.name },
+      overwrite: false
+    });
+    return {
+      abstract: {
+        filename: `${scalarName}.abstract.md`,
+        content: await sys.readFile(`lib/__scalar/${scalarName}/${scalarName}.abstract.md`)
+      },
+      constant: {
+        filename: `${scalarName}.constant.ts`,
+        content: await sys.readFile(`lib/__scalar/${scalarName}/${scalarName}.constant.ts`)
+      },
+      dictionary: {
+        filename: `${scalarName}.dictionary.ts`,
+        content: await sys.readFile(`lib/__scalar/${scalarName}/${scalarName}.dictionary.ts`)
+      },
+      document: {
+        filename: `${scalarName}.document.ts`,
+        content: await sys.readFile(`lib/__scalar/${scalarName}/${scalarName}.document.ts`)
+      }
+    };
+  }
+}
+
+// pkgs/@akanjs/cli/scalar/scalar.script.ts
+class ScalarScript extends script("scalar", [ScalarRunner]) {
+  async createScalar(sys, scalarName) {
+    const files = await this.scalarRunner.applyScalarTemplate(sys, scalarName);
+    return createPassedPrimitiveReport({
+      command: "create-scalar",
+      changedFiles: scalarChangedFiles(sys, scalarName, files),
+      generatedFiles: generatedFilesForSync(sys),
+      target: sys.name
+    });
+  }
+  async removeScalar(sys, scalarName) {
+    await sys.removeDir(`lib/__scalar/${scalarName}`);
+  }
+}
+
+export { ScalarScript };

package/{index-t8gvwcrx.js → index-va2je2qm.js}

@@ -2,13 +2,13 @@
 import {
   runner,
   script
-} from "./index-b3ae16mg.js";
+} from "./index-gca9y01h.js";
 import {
   FileSys
 } from "./index-q0y2jq9j.js";
 import {
   PkgExecutor
-} from "./index-5nyznra1.js";
+} from "./index-p1j0cyvd.js";
 import {
   TypeScriptDependencyScanner2
 } from "./index-kcxmv48c.js";

package/index-wfwknnje.js

@@ -0,0 +1,124 @@
+// @bun
+// pkgs/@akanjs/devkit/codeAgent/agent/akanCodeModel.ts
+var akanCodeDefaultModel2 = { provider: "deepseek", id: "deepseek-v4-flash" };
+var catalogueMissesImages = new Set(["deepseek/deepseek-v4-flash"]);
+var correctInputs = (model) => {
+  if (!model || model.input.includes("image"))
+    return model;
+  if (!catalogueMissesImages.has(`${model.provider}/${model.id}`))
+    return model;
+  return { ...model, input: [...model.input, "image"] };
+};
+var akanCodeModel2 = async (registry, ref) => {
+  if (ref) {
+    const requested = registry.find(ref.provider, ref.id);
+    if (!requested)
+      throw new Error(`Unknown model: ${ref.provider}/${ref.id}`);
+    if (!registry.hasConfiguredAuth(requested))
+      throw new Error(`No API key configured for ${ref.provider}. Set ${ref.provider.toUpperCase()}_API_KEY.`);
+    return correctInputs(requested);
+  }
+  const fallback = registry.find(akanCodeDefaultModel2.provider, akanCodeDefaultModel2.id);
+  if (fallback && registry.hasConfiguredAuth(fallback))
+    return correctInputs(fallback);
+  return correctInputs(registry.getAvailable()[0]);
+};
+var akanCodeModelSupportsImages2 = (model) => !!model?.input.includes("image");
+var akanCodeModelWarnings2 = (model, compactionFloor) => {
+  if (!model)
+    return [];
+  if (model.contextWindow >= compactionFloor)
+    return [];
+  return [
+    `${model.provider}/${model.id} declares a ${model.contextWindow}-token context window, below the ${compactionFloor} the compaction policy needs, so every turn will compact immediately. Check the model entry in ~/.akan/code/models.json.`
+  ];
+};
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeAgentStreamPrinter.ts
+import { codeAgentEventLabel } from "akanjs/common";
+import chalk from "chalk";
+
+class CodeAgentStreamPrinter2 {
+  #options;
+  #write;
+  #streaming = false;
+  constructor(options = {}) {
+    this.#options = options;
+    this.#write = options.write ?? ((text) => process.stdout.write(text));
+  }
+  print(event) {
+    if (this.#options.json)
+      return this.#write(`${JSON.stringify(event)}
+`);
+    switch (event.type) {
+      case "text_delta":
+        this.#streaming = true;
+        return this.#write(event.text);
+      case "thinking_delta":
+        if (!this.#options.thinking)
+          return;
+        this.#streaming = true;
+        return this.#write(chalk.dim(event.text));
+      case "message":
+        return;
+      case "tool_start":
+        return this.#line(chalk.cyan(`\u2192 ${event.tool.title}`));
+      case "tool_progress":
+        return;
+      case "tool_end":
+        return this.#line(CodeAgentStreamPrinter2.#toolEnd(event));
+      case "session":
+        return this.#line(chalk.dim(codeAgentEventLabel(event)));
+      case "turn_end":
+        if (event.stopReason === "truncated")
+          return this.#line(chalk.yellow(codeAgentEventLabel(event)));
+        return;
+      case "turn_start":
+      case "idle":
+      case "queue":
+      case "context":
+        return;
+      case "question":
+        return this.#line(chalk.yellow(`? ${event.question.prompt}`));
+      case "approval":
+        return this.#line(chalk.yellow(`approve? ${event.request.summary}`));
+      case "notice":
+        return this.#line(CodeAgentStreamPrinter2.#notice(event.level, event.message));
+      case "error":
+        return this.#line(chalk.red(`error: ${event.message}`));
+      default:
+        return this.#line(chalk.dim(codeAgentEventLabel(event)));
+    }
+  }
+  finish() {
+    if (this.#streaming)
+      this.#write(`
+`);
+    this.#streaming = false;
+  }
+  #line(text) {
+    if (this.#streaming)
+      this.#write(`
+`);
+    this.#streaming = false;
+    this.#write(`${text}
+`);
+  }
+  static #toolEnd(event) {
+    if (event.outcome === "ok")
+      return chalk.green(`\u2713 ${event.tool.title}`);
+    if (event.outcome === "blocked")
+      return chalk.yellow(`\u29B8 ${event.tool.title} \u2014 ${event.output}`);
+    return chalk.red(`\u2717 ${event.tool.title} \u2014 ${event.output.split(`
+`)[0] ?? ""}`);
+  }
+  static #notice(level, message) {
+    if (level === "error")
+      return chalk.red(message);
+    if (level === "warning")
+      return chalk.yellow(message);
+    return chalk.dim(message);
+  }
+}
+
+export { akanCodeDefaultModel2, akanCodeModel2, akanCodeModelSupportsImages2, akanCodeModelWarnings2, CodeAgentStreamPrinter2 };

package/index-x7g1qzpt.js

@@ -0,0 +1,121 @@
+// @bun
+// pkgs/@akanjs/devkit/codeAgent/agent/SubagentPool.ts
+import { codeAgentReadOnlyBuiltins } from "akanjs/common";
+import { Type } from "typebox";
+var maxResultChars = 8000;
+
+class SubagentPool2 {
+  static kinds = {
+    explore: {
+      readOnly: true,
+      desc: "reads, searches and reports back. It cannot write a file or run a command."
+    },
+    code: {
+      readOnly: false,
+      desc: "makes the change itself, with the same tools as this session."
+    }
+  };
+  static defaultKind = "explore";
+  #options;
+  #running = 0;
+  #spent = 0;
+  constructor(options) {
+    this.#options = options;
+  }
+  static extensionFor(options) {
+    if (!options.parent.tools.subagent)
+      return;
+    if (options.depth >= options.parent.tools.subagent.maxDepth)
+      return;
+    const pool = new SubagentPool2(options);
+    return { name: "akan-subagent", factory: (pi) => pool.#register(pi) };
+  }
+  static toolName = "task";
+  #register(pi) {
+    pi.registerTool({
+      name: SubagentPool2.toolName,
+      label: "Task",
+      description: "Run a focused sub-agent on one self-contained question and get back its answer. Use it for searching and reading that would otherwise fill this conversation \u2014 the sub-agent's own reading does not come back, only its answer. Give it everything it needs: it cannot see this conversation.",
+      promptSnippet: "task: run a sub-agent on one self-contained question and get back only its answer",
+      parameters: Type.Object({
+        description: Type.String({ description: "Three to five words naming the task, for the activity log." }),
+        prompt: Type.String({
+          description: "The complete instruction. The sub-agent sees nothing of this conversation."
+        }),
+        type: Type.Optional(Type.Union(Object.entries(SubagentPool2.kinds).map(([kind, spec]) => Type.Literal(kind, { description: spec.desc })), { description: `What the sub-agent may do. Defaults to ${SubagentPool2.defaultKind}.` }))
+      }),
+      execute: async (_id, params, signal) => {
+        const kind = params.type ?? SubagentPool2.defaultKind;
+        const refusal = this.#refuse();
+        if (refusal)
+          return { content: [{ type: "text", text: refusal }], details: undefined, isError: true };
+        this.#running += 1;
+        this.#options.onNotice?.(`${kind} sub-agent \xB7 ${params.description}`);
+        try {
+          const text = await this.#run(kind, params.prompt, signal);
+          return { content: [{ type: "text", text }], details: undefined };
+        } finally {
+          this.#running -= 1;
+        }
+      }
+    });
+  }
+  #refuse() {
+    const budget = this.#options.parent.tools.subagent;
+    if (!budget)
+      return "Sub-agents are disabled by this profile.";
+    if (this.#running >= budget.maxConcurrent)
+      return `Too many sub-agents are already running (limit ${budget.maxConcurrent}). Wait for one to finish.`;
+    if (this.#spent >= budget.budget)
+      return `The sub-agent token budget (${budget.budget}) is spent. Do the rest of this work yourself.`;
+    return;
+  }
+  static childOf(parent, kind) {
+    const budget = parent.tools.subagent;
+    return {
+      ...parent,
+      name: `${parent.name}:${kind}`,
+      tools: {
+        ...parent.tools,
+        builtin: SubagentPool2.kinds[kind].readOnly ? parent.tools.builtin.filter((tool) => codeAgentReadOnlyBuiltins.includes(tool)) : parent.tools.builtin,
+        subagent: budget ? { ...budget, maxDepth: budget.maxDepth } : false
+      },
+      session: { store: "memory", crossSession: false },
+      ui: { canPrompt: false },
+      context: { projectFiles: false, skills: parent.context.skills }
+    };
+  }
+  async#run(kind, prompt, signal) {
+    const { CodeAgent } = await import("./CodeAgent-d3wvbq8q.js");
+    const budget = this.#options.parent.tools.subagent;
+    const child = SubagentPool2.childOf(this.#options.parent, kind);
+    const agent = await CodeAgent.create({
+      workspace: this.#options.workspace,
+      cwd: this.#options.cwd,
+      profile: child,
+      apps: [],
+      depth: this.#options.depth + 1
+    });
+    const abort = () => void agent.abort();
+    signal?.addEventListener("abort", abort, { once: true });
+    try {
+      let answer = "";
+      agent.on((event) => {
+        if (event.type === "message" && event.role === "assistant")
+          answer = event.text;
+      });
+      await agent.prompt(prompt);
+      await agent.waitForIdle();
+      this.#spent += agent.tokensUsed;
+      const ceiling = budget ? budget.budget : 0;
+      this.#options.onNotice?.(`${kind} sub-agent finished, ${agent.tokensUsed} tokens (${this.#spent} of ${ceiling} spent)`);
+      return answer.length > maxResultChars ? `${answer.slice(0, maxResultChars)}
+\u2026(truncated)` : answer || "(no answer)";
+    } finally {
+      signal?.removeEventListener("abort", abort);
+      agent.dispose();
+    }
+  }
+}
+
+export { SubagentPool2 };

package/index.js

@@ -4,9 +4,9 @@ import {
   getTargetMetas,
   getTargetCommandNames,
   runCommands
-} from "./index-b3ae16mg.js";
+} from "./index-gca9y01h.js";
 import"./index-q0y2jq9j.js";
-import"./index-5nyznra1.js";
+import"./index-p1j0cyvd.js";
 import"./index-6wwzs1bc.js";
 
 // pkgs/@akanjs/cli/commandManifest.ts
@@ -14,24 +14,25 @@ import path from "path";
 
 // pkgs/@akanjs/cli/commandModules.ts
 var commandModules = {
-  workspace: async () => (await import("./workspace.command-p6td4qad.js")).WorkspaceCommand,
-  agent: async () => (await import("./agent.command-7357vxd8.js")).AgentCommand,
-  application: async () => (await import("./application.command-8s8ns95d.js")).ApplicationCommand,
-  library: async () => (await import("./library.command-1f9h2ex6.js")).LibraryCommand,
-  localRegistry: async () => (await import("./localRegistry.command-w6w35j4r.js")).LocalRegistryCommand,
-  package: async () => (await import("./package.command-y2rh4np7.js")).PackageCommand,
-  module: async () => (await import("./module.command-8zkq0q9q.js")).ModuleCommand,
-  page: async () => (await import("./page.command-e5h29fyt.js")).PageCommand,
-  context: async () => (await import("./context.command-wsjt98c1.js")).ContextCommand,
-  cloud: async () => (await import("./cloud.command-p5dnhft9.js")).CloudCommand,
-  subspace: async () => (await import("./subspace.command-3w5x13a1.js")).SubspaceCommand,
-  guideline: async () => (await import("./guideline.command-snqzfyt0.js")).GuidelineCommand,
-  scalar: async () => (await import("./scalar.command-a1ewkmab.js")).ScalarCommand,
-  primitive: async () => (await import("./primitive.command-qm7tybpn.js")).PrimitiveCommand,
-  quality: async () => (await import("./quality.command-5evdd263.js")).QualityCommand,
-  repair: async () => (await import("./repair.command-c2amvt74.js")).RepairCommand,
-  workflow: async () => (await import("./workflow.command-y3fct1rq.js")).WorkflowCommand,
-  tunnel: async () => (await import("./tunnel.command-09n8h4s1.js")).TunnelCommand
+  workspace: async () => (await import("./workspace.command-4ahrhp3k.js")).WorkspaceCommand,
+  agent: async () => (await import("./agent.command-9cg8m87z.js")).AgentCommand,
+  code: async () => (await import("./code.command-ca7rpmez.js")).CodeCommand,
+  application: async () => (await import("./application.command-x75men32.js")).ApplicationCommand,
+  library: async () => (await import("./library.command-n89re6cx.js")).LibraryCommand,
+  localRegistry: async () => (await import("./localRegistry.command-1mmnegph.js")).LocalRegistryCommand,
+  package: async () => (await import("./package.command-9dv0p6zq.js")).PackageCommand,
+  module: async () => (await import("./module.command-4m82zgfp.js")).ModuleCommand,
+  page: async () => (await import("./page.command-q86b0m0z.js")).PageCommand,
+  context: async () => (await import("./context.command-9kbm0527.js")).ContextCommand,
+  cloud: async () => (await import("./cloud.command-a09wggfq.js")).CloudCommand,
+  subspace: async () => (await import("./subspace.command-005rz1x6.js")).SubspaceCommand,
+  guideline: async () => (await import("./guideline.command-qvrh5pnx.js")).GuidelineCommand,
+  scalar: async () => (await import("./scalar.command-e2rpkhqy.js")).ScalarCommand,
+  primitive: async () => (await import("./primitive.command-kaneasq6.js")).PrimitiveCommand,
+  quality: async () => (await import("./quality.command-sgapx315.js")).QualityCommand,
+  repair: async () => (await import("./repair.command-efc5gdbq.js")).RepairCommand,
+  workflow: async () => (await import("./workflow.command-z1xcm4c7.js")).WorkflowCommand,
+  tunnel: async () => (await import("./tunnel.command-66j9estx.js")).TunnelCommand
 };
 var commandModuleIds = Object.keys(commandModules);