agent-devkit 0.5.7 → 0.6.0

package/dist/main.js

@@ -8,7 +8,7 @@ import React from "react";
 // package.json
 var package_default = {
   name: "agent-devkit",
-  version: "0.5.7",
+  version: "0.6.0",
   description: "Agent DevKit CLI and TUI runtime for specialist AI agents, capabilities and provider-aware workflows.",
   license: "MIT",
   type: "module",
@@ -4295,6 +4295,9 @@ function createEnvironmentSurface() {
 // src/app/cli/toolRuntime.ts
 import { homedir as homedir12 } from "os";
 
+// src/infra/brain/claude_cli_provider.ts
+import { execFile } from "child_process";
+
 // src/infra/helpers/tool_schema_summary.ts
 var MAX_VARIANTS = 12;
 var MAX_PROPS = 10;
@@ -4506,9 +4509,9 @@ var ModelStore = class {
             await once(writeStream, "drain");
           }
         }
-        await new Promise((resolve9, reject) => {
+        await new Promise((resolve11, reject) => {
           writeStream.on("error", reject);
-          writeStream.end(() => resolve9());
+          writeStream.end(() => resolve11());
         });
       } finally {
         reader.releaseLock();
@@ -4756,6 +4759,16 @@ var LocalLlamaBrainProvider = class {
   constructor(options = {}) {
     this.#store = options.store ?? new ModelStore({ stateDirectory: options.stateDirectory });
   }
+  describe() {
+    return {
+      id: "local",
+      kind: "local",
+      supports: { embeddings: false, stream: true, structured: true }
+    };
+  }
+  async isAvailable() {
+    return (await this.#ensureNodeLlama()).isOk();
+  }
   generate(request) {
     return this.#run(request);
   }
@@ -4875,6 +4888,96 @@ var LocalLlamaBrainProvider = class {
   }
 };
 
+// src/infra/brain/claude_cli_provider.ts
+var defaultCommand = "claude";
+var defaultTimeoutMs = 12e4;
+var maxOutputBufferBytes = 16 * 1024 * 1024;
+function defaultExecutor(command, args, options) {
+  return new Promise((resolve11) => {
+    execFile(
+      command,
+      args,
+      { maxBuffer: maxOutputBufferBytes, timeout: options.timeoutMs },
+      (error, stdout, stderr) => {
+        if (error !== null) {
+          resolve11(Result.fail(ErrorCodes.BrainProviderUnavailable));
+          return;
+        }
+        resolve11(Result.ok({ stderr, stdout }));
+      }
+    );
+  });
+}
+function parsePayload(stdout) {
+  try {
+    const payload = JSON.parse(stdout);
+    if (typeof payload === "object" && payload !== null && typeof payload.result === "string") {
+      const inputTokens = typeof payload.usage?.input_tokens === "number" ? payload.usage.input_tokens : void 0;
+      const outputTokens2 = typeof payload.usage?.output_tokens === "number" ? payload.usage.output_tokens : void 0;
+      const usage = inputTokens === void 0 && outputTokens2 === void 0 ? void 0 : { inputTokens, outputTokens: outputTokens2 };
+      return { text: payload.result, usage };
+    }
+  } catch {
+  }
+  return { text: stdout.trim() };
+}
+var ClaudeCliBrainProvider = class {
+  #command;
+  #executor;
+  #timeoutMs;
+  #availability;
+  constructor(options = {}) {
+    this.#command = options.command ?? defaultCommand;
+    this.#executor = options.executor ?? defaultExecutor;
+    this.#timeoutMs = options.timeoutMs ?? defaultTimeoutMs;
+  }
+  describe() {
+    return {
+      id: "claude-cli",
+      kind: "cli",
+      supports: { embeddings: false, stream: false, structured: false }
+    };
+  }
+  async isAvailable() {
+    if (this.#availability !== void 0) {
+      return this.#availability;
+    }
+    const probed = await this.#executor(this.#command, ["--version"], { timeoutMs: 1e4 });
+    this.#availability = probed.isOk();
+    return this.#availability;
+  }
+  async generate(request) {
+    if (!await this.isAvailable()) {
+      return Result.fail(ErrorCodes.BrainProviderUnavailable);
+    }
+    const promptText = [
+      systemPromptFrom(request.prompt),
+      "",
+      `User: ${request.prompt.task.userMessage}`
+    ].join("\n");
+    const args = ["-p", promptText, "--output-format", "json"];
+    if (request.options.model !== void 0) {
+      args.push("--model", request.options.model);
+    }
+    const executed = await this.#executor(this.#command, args, { timeoutMs: this.#timeoutMs });
+    if (executed.isErr()) {
+      return Result.fail(executed.unwrapError());
+    }
+    const { text: text2, usage } = parsePayload(executed.unwrap().stdout);
+    if (text2.length === 0) {
+      return Result.fail(ErrorCodes.BrainProviderUnavailable);
+    }
+    return Result.ok({
+      finishReason: "stop",
+      model: request.options.model,
+      provider: "claude-cli",
+      schema: "agent-devkit.brain-response/v1",
+      text: text2,
+      usage
+    });
+  }
+};
+
 // src/infra/brain/mock_provider.ts
 function reply(request) {
   const text2 = `Entendi. Vou responder no contexto da sess\xE3o atual: "${request.prompt.task.userMessage}".`;
@@ -4894,6 +4997,16 @@ function reply(request) {
   };
 }
 var MockBrainProvider = class {
+  describe() {
+    return {
+      id: "mock",
+      kind: "local",
+      supports: { embeddings: false, stream: true, structured: true }
+    };
+  }
+  async isAvailable() {
+    return true;
+  }
   async generate(request) {
     return Result.ok(reply(request));
   }
@@ -4911,83 +5024,183 @@ var MockBrainProvider = class {
   }
 };
 
+// src/infra/brain/structured_text_fallback.ts
+function extractJsonObject(text2) {
+  const start = text2.indexOf("{");
+  const end = text2.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text2.slice(start, end + 1));
+  } catch {
+    return void 0;
+  }
+}
+function withJsonInstruction(request, jsonSchema) {
+  const instruction = [
+    request.prompt.task.userMessage,
+    "",
+    "Responda SOMENTE com um objeto JSON v\xE1lido que satisfa\xE7a este JSON Schema:",
+    JSON.stringify(jsonSchema),
+    "Sem markdown, sem cercas de c\xF3digo, sem texto antes ou depois do JSON."
+  ].join("\n");
+  return {
+    ...request,
+    prompt: {
+      ...request.prompt,
+      output: { ...request.prompt.output, format: "json" },
+      task: { ...request.prompt.task, userMessage: instruction }
+    }
+  };
+}
+function withRepairInstruction(request, previousRaw) {
+  const instruction = [
+    request.prompt.task.userMessage,
+    "",
+    "A resposta anterior n\xE3o era um JSON v\xE1lido:",
+    previousRaw.slice(0, 800),
+    "Corrija e responda apenas com o objeto JSON v\xE1lido."
+  ].join("\n");
+  return {
+    ...request,
+    prompt: { ...request.prompt, task: { ...request.prompt.task, userMessage: instruction } }
+  };
+}
+async function generateStructuredViaText(provider, request, jsonSchema) {
+  const constrained = withJsonInstruction(request, jsonSchema);
+  const first = await provider.generate(constrained);
+  if (first.isErr()) {
+    return Result.fail(first.unwrapError());
+  }
+  const firstRaw = first.unwrap().text;
+  const firstJson = extractJsonObject(firstRaw);
+  if (firstJson !== void 0) {
+    return Result.ok({ json: firstJson, raw: firstRaw });
+  }
+  const repaired = await provider.generate(withRepairInstruction(constrained, firstRaw));
+  if (repaired.isErr()) {
+    return Result.fail(repaired.unwrapError());
+  }
+  const repairedRaw = repaired.unwrap().text;
+  const repairedJson = extractJsonObject(repairedRaw);
+  if (repairedJson === void 0) {
+    return Result.fail(ErrorCodes.InvalidInput);
+  }
+  return Result.ok({ json: repairedJson, raw: repairedRaw });
+}
+
 // src/infra/brain/brain_dock.ts
-var defaultProvider = "local";
+var defaultRouting = {
+  agent: ["claude-cli", "local", "mock"],
+  chat: ["claude-cli", "local", "mock"],
+  embed: ["local"]
+};
 var fallbackProvider = "mock";
+var defaultRole = "chat";
 function shouldFallback(error) {
   return error === ErrorCodes.BrainProviderUnavailable || error === ErrorCodes.ModelNotFound;
 }
+function chainFromEnv(role) {
+  const raw = process.env[`AGENT_DEVKIT_BRAIN_${role.toUpperCase()}`];
+  if (raw === void 0) {
+    return void 0;
+  }
+  const chain = raw.split(",").map((id) => id.trim()).filter((id) => id.length > 0);
+  return chain.length > 0 ? chain : void 0;
+}
+function resolveRouting(overrides = {}) {
+  const roles = ["agent", "chat", "embed"];
+  const routing = { ...defaultRouting };
+  for (const role of roles) {
+    routing[role] = overrides[role] ?? chainFromEnv(role) ?? routing[role];
+  }
+  return routing;
+}
 var BrainDockProvider = class {
   #factories;
   #instances = /* @__PURE__ */ new Map();
+  #routing;
   constructor(options = {}) {
+    this.#routing = resolveRouting(options.routing);
     this.#factories = /* @__PURE__ */ new Map([
+      ["claude-cli", () => new ClaudeCliBrainProvider()],
       ["local", () => new LocalLlamaBrainProvider({ stateDirectory: options.stateDirectory })],
       ["mock", () => new MockBrainProvider()]
     ]);
+    for (const [id, factory] of Object.entries(options.providers ?? {})) {
+      this.#factories.set(id, factory);
+    }
+  }
+  async describeProviders() {
+    const statuses = [];
+    for (const id of this.#factories.keys()) {
+      const provider = this.#resolveById(id);
+      const descriptor = provider.describe?.() ?? {
+        id,
+        kind: "local",
+        supports: { embeddings: false, stream: false, structured: false }
+      };
+      const available = await provider.isAvailable?.() ?? true;
+      statuses.push({ ...descriptor, available });
+    }
+    return statuses;
+  }
+  routingPolicy() {
+    return { ...this.#routing };
   }
   async generate(request) {
-    const provider = this.#resolve(request);
-    const response = await provider.generate(request);
-    if (response.isOk() || request.options.provider === fallbackProvider || !shouldFallback(response.unwrapError())) {
+    return this.#withChain(request, (provider, chained) => provider.generate(chained));
+  }
+  async generateStream(request, onToken) {
+    return this.#withChain(request, async (provider, chained) => {
+      if (provider.generateStream !== void 0) {
+        return provider.generateStream(chained, onToken);
+      }
+      const response = await provider.generate(chained);
+      if (response.isOk()) {
+        onToken(response.unwrap().text);
+      }
       return response;
-    }
-    return this.#resolveById(fallbackProvider).generate({
-      ...request,
-      options: { ...request.options, provider: fallbackProvider }
     });
   }
-  async generateStream(request, onToken) {
-    const provider = this.#resolve(request);
-    if (provider.generateStream !== void 0) {
-      const response2 = await provider.generateStream(request, onToken);
-      if (response2.isOk() || request.options.provider === fallbackProvider || !shouldFallback(response2.unwrapError())) {
-        return response2;
+  async generateStructured(request, jsonSchema) {
+    return this.#withChain(request, (provider, chained) => {
+      if (provider.generateStructured !== void 0) {
+        return provider.generateStructured(chained, jsonSchema);
       }
-      return this.#resolveById(fallbackProvider).generateStream?.(
-        {
-          ...request,
-          options: { ...request.options, provider: fallbackProvider }
-        },
-        onToken
-      ) ?? this.#resolveById(fallbackProvider).generate({
-        ...request,
-        options: { ...request.options, provider: fallbackProvider }
-      });
-    }
-    const response = await provider.generate(request);
-    if (response.isOk()) {
-      onToken(response.unwrap().text);
+      return generateStructuredViaText(provider, chained, jsonSchema);
+    });
+  }
+  #chainFor(request) {
+    if (request.options.provider !== void 0) {
+      return request.options.provider === fallbackProvider ? [fallbackProvider] : [request.options.provider, fallbackProvider];
     }
-    return response;
+    return this.#routing[request.options.role ?? defaultRole];
   }
-  async generateStructured(request, jsonSchema) {
-    const provider = this.#resolve(request);
-    if (provider.generateStructured !== void 0) {
-      const response = await provider.generateStructured(request, jsonSchema);
-      if (response.isOk() || request.options.provider === fallbackProvider || !shouldFallback(response.unwrapError())) {
+  async #withChain(request, operation) {
+    const chain = this.#chainFor(request);
+    let lastError = ErrorCodes.BrainProviderUnavailable;
+    for (const id of chain) {
+      const provider = this.#resolveById(id);
+      const chained = {
+        ...request,
+        options: { ...request.options, provider: id }
+      };
+      const response = await operation(provider, chained);
+      if (response.isOk() || !shouldFallback(response.unwrapError())) {
         return response;
       }
-      return this.#resolveById(fallbackProvider).generateStructured?.(
-        {
-          ...request,
-          options: { ...request.options, provider: fallbackProvider }
-        },
-        jsonSchema
-      ) ?? Result.fail(ErrorCodes.BrainProviderUnavailable);
+      lastError = response.unwrapError();
     }
-    return Result.fail(ErrorCodes.BrainProviderUnavailable);
-  }
-  #resolve(request) {
-    const id = request.options.provider ?? defaultProvider;
-    return this.#resolveById(id);
+    return Result.fail(lastError);
   }
   #resolveById(id) {
     const cached = this.#instances.get(id);
     if (cached !== void 0) {
       return cached;
     }
-    const factory = this.#factories.get(id) ?? this.#factories.get(defaultProvider);
+    const factory = this.#factories.get(id);
     const provider = factory === void 0 ? new MockBrainProvider() : factory();
     this.#instances.set(id, provider);
     return provider;
@@ -8787,12 +9000,13 @@ import { z as z27 } from "zod";
 
 // src/infra/bases/brain.ts
 import { z as z26 } from "zod";
+var BrainRoleSchema = z26.enum(["agent", "chat", "embed"]);
 var BrainGenerationOptionsSchema = z26.object({
   maxInputTokens: z26.number().int().positive().optional(),
   maxOutputTokens: z26.number().int().positive().optional(),
   model: z26.string().min(1).optional(),
-  provider: z26.enum(["local", "mock"]).default("local"),
-  role: z26.enum(["agent", "chat"]).optional(),
+  provider: z26.string().min(1).optional(),
+  role: BrainRoleSchema.optional(),
   seed: z26.number().int().optional(),
   stop: z26.array(z26.string().min(1)).optional(),
   stream: z26.boolean().optional(),
@@ -8801,7 +9015,7 @@ var BrainGenerationOptionsSchema = z26.object({
   topP: z26.number().min(0).max(1).optional()
 }).strict();
 var BrainRequestSchema = z26.object({
-  options: BrainGenerationOptionsSchema.default({ provider: "local" }),
+  options: BrainGenerationOptionsSchema.default({}),
   prompt: AgentPromptSchema,
   schema: z26.literal("agent-devkit.brain-request/v1")
 }).strict();
@@ -8912,7 +9126,7 @@ var ConversationChatService = class extends BaseCapabilityService {
       return Result.fail(prepared.unwrapError());
     }
     const request = {
-      options: { provider: "local", ...parsed.data.brain, role: "chat" },
+      options: { ...parsed.data.brain, role: "chat" },
       prompt: prepared.unwrap().prompt,
       schema: "agent-devkit.brain-request/v1"
     };
@@ -11481,9 +11695,9 @@ function createSecretsSurface() {
 }
 
 // src/modules/self/capabilities/update/update.repository.ts
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 import { promisify } from "util";
-var execFileAsync = promisify(execFile);
+var execFileAsync = promisify(execFile2);
 var UpdateRepository = class {
   repositoryId = "self.update.repository";
   async getPackageVersions(packageName) {
@@ -12369,6 +12583,19 @@ var agentRouteJsonSchema = {
   },
   required: ["action"]
 };
+var AgentDomainRouteSchema = z41.discriminatedUnion("action", [
+  z41.object({ action: z41.literal("domains"), domains: z41.array(z41.string().min(1)).min(1) }),
+  z41.object({ action: z41.literal("final"), reply: z41.string() })
+]);
+var agentDomainRouteJsonSchema = {
+  type: "object",
+  properties: {
+    action: { type: "string", enum: ["domains", "final"] },
+    domains: { type: "array", items: { type: "string" } },
+    reply: { type: "string" }
+  },
+  required: ["action"]
+};
 var AgentPlanStepSchema = z41.object({
   dependsOn: z41.array(z41.string().min(1)).default([]),
   id: z41.string().min(1),
@@ -12515,6 +12742,24 @@ async function buildToolDecisionPrompt(input) {
     }
   });
 }
+async function buildDomainDecisionPrompt(input) {
+  return promptComposer.compose("core/domain-decision", {
+    agent: input.agent ?? agentPersona,
+    context: {
+      knowledge: recoveredKnowledge({
+        contextSnapshot: input.contextSnapshot,
+        memories: input.memories
+      }),
+      project: input.contextSnapshot?.project,
+      session: input.contextSnapshot?.session
+    },
+    messages: input.transcript,
+    variables: {
+      domains: input.domains.map((domain) => `- ${domain.id} (${domain.toolCount} tools): ${domain.summary}`).join("\n"),
+      task: input.task
+    }
+  });
+}
 async function buildTaskPlanPrompt(input) {
   return promptComposer.compose("core/task-plan", {
     agent: input.agent ?? agentPersona,
@@ -12623,6 +12868,178 @@ function approvalGrantForTool(tool, input) {
   });
 }
 
+// src/agent/agent.router.ts
+var defaultMaxToolsPerDecision = 20;
+var maxDomainSummaryLength = 200;
+function truncate(text2, length) {
+  const compact3 = text2.replaceAll(/\s+/g, " ").trim();
+  return compact3.length > length ? `${compact3.slice(0, length)}...` : compact3;
+}
+function approximatePromptTokens(prompt) {
+  return Math.ceil(JSON.stringify(prompt).length / 4);
+}
+function domainsFor(tools, knowledge) {
+  const byModule = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    const grouped = byModule.get(tool.moduleId) ?? [];
+    grouped.push(tool);
+    byModule.set(tool.moduleId, grouped);
+  }
+  const knowledgeById = new Map(knowledge.map((module) => [module.moduleId, module]));
+  return [...byModule.entries()].map(([moduleId, moduleTools]) => {
+    const surface = knowledgeById.get(moduleId);
+    const parts = [];
+    if (surface !== void 0 && surface.summary.length > 0) {
+      parts.push(surface.summary);
+    }
+    if (surface !== void 0 && surface.whenToUse.length > 0) {
+      parts.push(`Use when: ${surface.whenToUse.join(" ")}`);
+    }
+    if (parts.length === 0) {
+      parts.push(
+        moduleTools.slice(0, 3).map((tool) => tool.description).join(" ")
+      );
+    }
+    return {
+      id: moduleId,
+      summary: truncate(parts.join(" "), maxDomainSummaryLength),
+      toolCount: moduleTools.length
+    };
+  });
+}
+var AgentToolRouter = class {
+  #maxToolsPerDecision;
+  constructor(options = {}) {
+    this.#maxToolsPerDecision = options.maxToolsPerDecision ?? defaultMaxToolsPerDecision;
+  }
+  async route(input) {
+    const scoped = await this.#scopeTools(input);
+    if (scoped.isErr()) {
+      return Result.fail(scoped.unwrapError());
+    }
+    const scopedValue = scoped.unwrap();
+    if ("reply" in scopedValue) {
+      return Result.ok(scopedValue);
+    }
+    return this.#decideTool(input, scopedValue.tools);
+  }
+  async #scopeTools(input) {
+    if (input.tools.length <= this.#maxToolsPerDecision) {
+      return Result.ok({ tools: input.tools });
+    }
+    const domains = domainsFor(input.tools, input.knowledge);
+    const prompt = await buildDomainDecisionPrompt({
+      agent: input.agent,
+      contextSnapshot: input.contextSnapshot,
+      domains,
+      memories: input.memories,
+      task: input.task,
+      transcript: input.transcript
+    });
+    if (prompt.isErr()) {
+      await input.onEvent?.({
+        payload: { code: prompt.unwrapError(), phase: "route-domains-prompt" },
+        type: "error"
+      });
+      return Result.fail(prompt.unwrapError());
+    }
+    const routed = await input.generateStructured(
+      {
+        options: { role: "agent" },
+        prompt: prompt.unwrap(),
+        schema: "agent-devkit.brain-request/v1"
+      },
+      agentDomainRouteJsonSchema
+    );
+    if (routed.isErr()) {
+      await input.onEvent?.({
+        payload: { code: routed.unwrapError(), phase: "route-domains" },
+        type: "error"
+      });
+      return Result.fail(routed.unwrapError());
+    }
+    const route = AgentDomainRouteSchema.safeParse(routed.unwrap().json);
+    if (!route.success) {
+      await input.onEvent?.({
+        payload: { phase: "route-domains", raw: routed.unwrap().raw },
+        type: "error"
+      });
+      return Result.fail(ErrorCodes.InvalidInput);
+    }
+    if (route.data.action === "final") {
+      return Result.ok({ reply: route.data.reply });
+    }
+    const selected = new Set(route.data.domains.slice(0, 2));
+    const known = new Set(domains.map((domain) => domain.id));
+    const validSelection = [...selected].filter((domain) => known.has(domain));
+    const scoped = validSelection.length === 0 ? input.tools : input.tools.filter((tool) => selected.has(tool.moduleId));
+    await input.onEvent?.({
+      payload: {
+        approximatePromptTokens: approximatePromptTokens(prompt.unwrap()),
+        domainCount: domains.length,
+        domains: validSelection,
+        phase: "route-domains",
+        scopedToolCount: Math.min(scoped.length, this.#maxToolsPerDecision),
+        totalToolCount: input.tools.length
+      },
+      type: "thought"
+    });
+    return Result.ok({ tools: scoped.slice(0, this.#maxToolsPerDecision) });
+  }
+  async #decideTool(input, tools) {
+    const prompt = await buildToolDecisionPrompt({
+      agent: input.agent,
+      contextSnapshot: input.contextSnapshot,
+      knowledge: input.knowledge.filter(
+        (module) => tools.some((tool) => tool.moduleId === module.moduleId)
+      ),
+      memories: input.memories,
+      task: input.task,
+      tools,
+      transcript: input.transcript
+    });
+    if (prompt.isErr()) {
+      await input.onEvent?.({
+        payload: { code: prompt.unwrapError(), phase: "route-prompt" },
+        type: "error"
+      });
+      return Result.fail(prompt.unwrapError());
+    }
+    const routed = await input.generateStructured(
+      {
+        options: { role: "agent" },
+        prompt: prompt.unwrap(),
+        schema: "agent-devkit.brain-request/v1"
+      },
+      agentRouteJsonSchema
+    );
+    if (routed.isErr()) {
+      await input.onEvent?.({
+        payload: { code: routed.unwrapError(), phase: "route" },
+        type: "error"
+      });
+      return Result.fail(routed.unwrapError());
+    }
+    const route = AgentRouteSchema.safeParse(routed.unwrap().json);
+    if (!route.success) {
+      await input.onEvent?.({
+        payload: { phase: "route", raw: routed.unwrap().raw },
+        type: "error"
+      });
+      return Result.fail(ErrorCodes.InvalidInput);
+    }
+    await input.onEvent?.({
+      payload: {
+        approximatePromptTokens: approximatePromptTokens(prompt.unwrap()),
+        phase: "route-tool",
+        toolCount: tools.length
+      },
+      type: "thought"
+    });
+    return route.data.action === "final" ? Result.ok({ reply: route.data.reply }) : Result.ok({ tool: route.data.tool });
+  }
+};
+
 // src/agent/agent.loop.ts
 function summarize(value) {
   const text2 = typeof value === "string" ? value : JSON.stringify(value ?? "");
@@ -12648,6 +13065,7 @@ var AgentToolLoop = class {
   #contextAssembler;
   #knowledge;
   #memoryRetriever;
+  #router;
   #tools;
   constructor(options) {
     this.#agent = options.agent;
@@ -12655,6 +13073,7 @@ var AgentToolLoop = class {
     this.#contextAssembler = options.contextAssembler;
     this.#knowledge = options.knowledge;
     this.#memoryRetriever = options.memoryRetriever;
+    this.#router = options.router ?? new AgentToolRouter();
     this.#tools = options.toolRuntime;
   }
   async run(input, context) {
@@ -12976,7 +13395,7 @@ var AgentToolLoop = class {
     });
     const planned = prompt.isErr() ? void 0 : await input.generateStructured(
       {
-        options: { provider: "local", role: "agent" },
+        options: { role: "agent" },
         prompt: prompt.unwrap(),
         schema: "agent-devkit.brain-request/v1"
       },
@@ -13065,7 +13484,7 @@ var AgentToolLoop = class {
       return Result.fail(prompt.unwrapError());
     }
     const request = {
-      options: { provider: "local", role: "agent" },
+      options: { role: "agent" },
       prompt: prompt.unwrap(),
       schema: "agent-devkit.brain-request/v1"
     };
@@ -13075,47 +13494,29 @@ var AgentToolLoop = class {
     }
     return Result.ok(produced.unwrap().json ?? {});
   }
+  /**
+   * Decision phase adapter: hierarchical routing lives in `AgentToolRouter`
+   * (domain stage + tool stage); the loop only forwards context and events.
+   */
   async #routeToolOrFinal(input) {
-    const routePrompt = await buildToolDecisionPrompt({
+    const routed = await this.#router.route({
       agent: input.agent,
       contextSnapshot: input.contextSnapshot,
+      generateStructured: input.generateStructured,
       knowledge: input.knowledge,
       memories: input.memories,
+      onEvent: async (event) => {
+        await input.context?.eventSink?.appendEvent(event);
+      },
       task: input.input.task,
       tools: input.tools,
       transcript: input.transcript
     });
-    if (routePrompt.isErr()) {
-      await input.context?.eventSink?.appendEvent({
-        payload: { code: routePrompt.unwrapError(), phase: "route-prompt" },
-        type: "error"
-      });
-      return Result.fail(routePrompt.unwrapError());
-    }
-    const routed = await input.generateStructured(
-      {
-        options: { provider: "local", role: "agent" },
-        prompt: routePrompt.unwrap(),
-        schema: "agent-devkit.brain-request/v1"
-      },
-      agentRouteJsonSchema
-    );
     if (routed.isErr()) {
-      await input.context?.eventSink?.appendEvent({
-        payload: { code: routed.unwrapError(), phase: "route" },
-        type: "error"
-      });
       return Result.fail(routed.unwrapError());
     }
-    const route = AgentRouteSchema.safeParse(routed.unwrap().json);
-    if (!route.success) {
-      await input.context?.eventSink?.appendEvent({
-        payload: { phase: "route", raw: routed.unwrap().raw },
-        type: "error"
-      });
-      return Result.fail(ErrorCodes.InvalidInput);
-    }
-    return route.data.action === "final" ? Result.ok({ reply: route.data.reply }) : Result.ok(route.data.tool);
+    const decision = routed.unwrap();
+    return "reply" in decision ? Result.ok(decision) : Result.ok(decision.tool);
   }
   async #reflect(input) {
     const prompt = await buildReflectionPrompt(input);
@@ -13124,7 +13525,7 @@ var AgentToolLoop = class {
     }
     const reflected = await input.generateStructured(
       {
-        options: { provider: "local", role: "agent" },
+        options: { role: "agent" },
         prompt: prompt.unwrap(),
         schema: "agent-devkit.brain-request/v1"
       },
@@ -13151,7 +13552,7 @@ var AgentToolLoop = class {
     }
     const summarized = await input.generateStructured(
       {
-        options: { provider: "local", role: "agent" },
+        options: { role: "agent" },
         prompt: prompt.unwrap(),
         schema: "agent-devkit.brain-request/v1"
       },
@@ -13828,8 +14229,8 @@ async function startMcpHttpServer(options) {
       }
     }
   });
-  await new Promise((resolve9) => {
-    httpServer.listen(options.port, options.host, resolve9);
+  await new Promise((resolve11) => {
+    httpServer.listen(options.port, options.host, resolve11);
   });
   return httpServer;
 }
@@ -14371,6 +14772,36 @@ function registerModelsCommand(program2, options) {
       }
     )
   );
+  const providersCommand = modelsCommand.command("providers").description(options.translator.t("cli.models.providers.description")).option("--json", options.translator.t("cli.models.providers.option.json"));
+  providersCommand.action(
+    options.usageLogging.track(
+      {
+        area: "system",
+        command: "models.providers",
+        createStateIfMissing: false,
+        options: () => providersCommand.opts()
+      },
+      async (commandOptions) => {
+        const dock = createBrainDockProvider({ stateDirectory: `${homedir16()}/.agent-devkit` });
+        const providers = await dock.describeProviders();
+        const routing = dock.routingPolicy();
+        if (wantsJson(commandOptions) === true) {
+          console.log(JSON.stringify({ providers, routing }, null, 2));
+          return;
+        }
+        for (const provider of providers) {
+          const supports = Object.entries(provider.supports).filter(([, enabled]) => enabled).map(([name]) => name).join(", ");
+          console.log(
+            `${provider.available ? "\u25CF" : "\u25CB"} ${provider.id} (${provider.kind})${supports.length > 0 ? ` \u2014 ${supports}` : ""}`
+          );
+        }
+        console.log("");
+        for (const [role, chain] of Object.entries(routing)) {
+          console.log(`${role}: ${chain.join(" \u2192 ")}`);
+        }
+      }
+    )
+  );
   const useCommand = modelsCommand.command("use").argument("<id>", options.translator.t("cli.models.argument.id")).description(options.translator.t("cli.models.use.description")).option("--agent", options.translator.t("cli.models.use.option.agent")).option("--chat", options.translator.t("cli.models.use.option.chat")).option("--json", options.translator.t("cli.models.option.json"));
   useCommand.action(
     options.usageLogging.track(
@@ -15841,11 +16272,20 @@ function cliConversationStatePathForScope(scope) {
     segments: [`cli-state-${sanitizeCliScope(scope)}.json`]
   };
 }
+function conversationStatePathForScope(invocationInterface, scope) {
+  if (invocationInterface === "cli") {
+    return cliConversationStatePathForScope(scope);
+  }
+  return {
+    namespace: "conversation",
+    segments: [`${invocationInterface}-state-${sanitizeCliScope(scope)}.json`]
+  };
+}
 function isCliConversationState(value) {
   const record = value;
   return typeof value === "object" && value !== null && "activeSessionId" in value && "schema" in value && typeof record.activeSessionId === "string" && record.activeSessionId.length > 0 && record.schema === "agent-devkit.cli-conversation-state/v1";
 }
-async function loadActiveCliSessionId(dataStore, sessions, statePath) {
+async function loadActiveCliSessionId(dataStore, sessions, statePath, expectedOrigin) {
   const state = await dataStore.readJson(statePath);
   if (state.isErr()) {
     return void 0;
@@ -15863,7 +16303,7 @@ async function loadActiveCliSessionId(dataStore, sessions, statePath) {
     return void 0;
   }
   const result = current.unwrap();
-  if (result.action !== "show" || result.session.origin !== "cli" || result.session.status !== "active") {
+  if (result.action !== "show" || result.session.origin !== expectedOrigin || result.session.status !== "active") {
     return void 0;
   }
   return result.session.id;
@@ -15903,8 +16343,9 @@ function createConversationPort(chat) {
     }
   };
 }
-async function runRootConversation(message, options) {
+function createCliAgentEnvironment(options) {
   const homeDirectory = homedir25();
+  const invocationInterface = options.interface ?? "cli";
   const dataStore = new LocalAgentDataStore({
     rootDirectory: `${homeDirectory}/.agent-devkit/data`
   });
@@ -15935,12 +16376,8 @@ async function runRootConversation(message, options) {
   if (contextBindings.isErr()) {
     throw new Error(contextBindings.unwrapError());
   }
-  const cliStatePath = cliConversationStatePathForScope(currentCliSessionScope());
-  const activeSessionId = await loadActiveCliSessionId(
-    dataStore,
-    contextBindings.unwrap().capabilities.sessions,
-    cliStatePath
-  );
+  const sessions = contextBindings.unwrap().capabilities.sessions;
+  const cliStatePath = conversationStatePathForScope(invocationInterface, currentCliSessionScope());
   const agent = new AgentRuntime({
     brainProvider: createBrainDockProvider({ stateDirectory: `${homeDirectory}/.agent-devkit` }),
     conversation: createConversationPort(bindings.unwrap().capabilities.chat),
@@ -15952,7 +16389,17 @@ async function runRootConversation(message, options) {
       packageName: options.packageName
     })
   });
-  const result = await agent.run({
+  return {
+    agent,
+    loadActiveSessionId: () => loadActiveCliSessionId(dataStore, sessions, cliStatePath, invocationInterface),
+    saveActiveSessionId: (sessionId) => saveActiveCliSessionId(dataStore, sessionId, cliStatePath),
+    sessions
+  };
+}
+async function runRootConversation(message, options) {
+  const environment = createCliAgentEnvironment(options);
+  const activeSessionId = await environment.loadActiveSessionId();
+  const result = await environment.agent.run({
     interface: "cli",
     message,
     mode: "chat",
@@ -15966,7 +16413,7 @@ async function runRootConversation(message, options) {
   if (payload.conversation === void 0 || !isConversationChatResult(rawConversation)) {
     throw new Error("Agent did not return a conversation result.");
   }
-  await saveActiveCliSessionId(dataStore, payload.conversation.sessionId, cliStatePath);
+  await environment.saveActiveSessionId(payload.conversation.sessionId);
   console.log(formatConversationChatText(rawConversation));
 }
 function isConversationChatResult(value) {
@@ -16050,21 +16497,748 @@ var CliUsageLoggingMiddleware = class {
 };
 
 // src/app/tui/App.tsx
+import { Box as Box12, Text as Text14 } from "ink";
+import { useCallback, useEffect as useEffect2, useRef as useRef2, useState as useState5 } from "react";
+
+// src/app/tui/commands.ts
+function parseTuiCommand(value, pendingApproval) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return { type: "empty" };
+  }
+  if (pendingApproval) {
+    const answer = trimmed.toLowerCase();
+    if (answer === "s" || answer === "sim" || answer === "y" || answer === "yes") {
+      return { type: "approve-yes" };
+    }
+    if (answer === "n" || answer === "nao" || answer === "n\xE3o" || answer === "no") {
+      return { type: "approve-no" };
+    }
+  }
+  if (trimmed === "/sessions" || trimmed === "/sessoes" || trimmed === "/sess\xF5es") {
+    return { type: "sessions" };
+  }
+  if (trimmed === "/task") {
+    return { type: "empty" };
+  }
+  if (trimmed.startsWith("/task ")) {
+    const task = trimmed.slice("/task ".length).trim();
+    return task.length === 0 ? { type: "empty" } : { type: "task", task };
+  }
+  return { type: "chat", message: trimmed };
+}
+function approvalRequiredTool(steps) {
+  const waiting = [...steps].reverse().find((step) => !step.ok && step.summary.startsWith("approval_required"));
+  return waiting?.tool;
+}
+function moodForEvent(event) {
+  if (event.type === "tool") {
+    return "working";
+  }
+  if (event.type === "observation") {
+    return event.ok === false ? "concerned" : "working";
+  }
+  if (event.type === "final") {
+    return "happy";
+  }
+  return "thinking";
+}
+
+// src/app/tui/design/components/KbdBar.tsx
 import { Box, Text } from "ink";
-import { jsx, jsxs } from "react/jsx-runtime";
-function App({ initialPrompt, translator: translator2 }) {
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx(Text, { bold: true, children: translator2.t("tui.title") }),
-    /* @__PURE__ */ jsx(Text, { children: translator2.t("tui.foundation") }),
-    initialPrompt ? /* @__PURE__ */ jsx(Text, { children: translator2.t("tui.prompt", { prompt: initialPrompt }) }) : /* @__PURE__ */ jsx(Text, { children: translator2.t("tui.helpHint") })
+
+// src/app/tui/design/TokensContext.tsx
+import { createContext, useContext, useMemo } from "react";
+
+// src/app/tui/design/tokens.ts
+function resolveTokens(theme, semantics) {
+  const colors2 = theme.colors;
+  const toColor = (tokenName) => colors2[tokenName] ?? theme.colors.textMuted;
+  return {
+    theme,
+    semantics,
+    glyphs: semantics.glyphs,
+    color: (name) => theme.colors[name],
+    statusColor: (status) => toColor(semantics.status[status]),
+    riskColor: (risk) => toColor(semantics.risk[risk])
+  };
+}
+
+// src/app/tui/design/TokensContext.tsx
+import { jsx } from "react/jsx-runtime";
+var TokensContext = createContext(null);
+function TokensProvider({ theme, semantics, kit, children }) {
+  const value = useMemo(
+    () => ({ ...resolveTokens(theme, semantics), kit }),
+    [theme, semantics, kit]
+  );
+  return /* @__PURE__ */ jsx(TokensContext.Provider, { value, children });
+}
+function useTokens() {
+  const value = useContext(TokensContext);
+  if (value === null) {
+    throw new Error("useTokens must be used within a TokensProvider.");
+  }
+  return value;
+}
+
+// src/app/tui/design/components/KbdBar.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function KbdBar({ keys }) {
+  const tokens2 = useTokens();
+  return /* @__PURE__ */ jsx2(Box, { gap: 2, children: keys.map((key) => /* @__PURE__ */ jsx2(Text, { color: tokens2.color("textDim"), children: key }, key)) });
+}
+
+// src/app/tui/design/components/Kit.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { useState as useState2 } from "react";
+
+// src/app/tui/design/kit_cells.ts
+function applyOverrides(grid, overrides) {
+  for (const [row, col, char] of overrides) {
+    const line2 = grid[row];
+    if (line2 !== void 0 && col >= 0 && col < line2.length) {
+      line2[col] = char;
+    }
+  }
+}
+function kitCells(kit, mood, blink, background) {
+  const grid = kit.base.map((line2) => line2.split(""));
+  const moodDefinition = kit.moods[mood] ?? kit.moods.idle;
+  if (moodDefinition !== void 0) {
+    applyOverrides(grid, moodDefinition.overrides);
+  }
+  if (blink) {
+    applyOverrides(grid, kit.blink.overrides);
+  }
+  const palette = { ...kit.palette };
+  if (moodDefinition?.body !== void 0) {
+    palette.B = moodDefinition.body;
+  }
+  if (moodDefinition?.dark !== void 0) {
+    palette.D = moodDefinition.dark;
+  }
+  const colorFor = (char) => {
+    const value = palette[char];
+    return value === void 0 || value === "transparent" ? background : value;
+  };
+  const cellAt = (row, col) => grid[row]?.[col] ?? ".";
+  const rows = [];
+  for (let row = 0; row + 1 < kit.base.length; row += 2) {
+    const cells = [];
+    for (let col = 0; col < kit.size.cols; col += 1) {
+      cells.push({ top: colorFor(cellAt(row, col)), bottom: colorFor(cellAt(row + 1, col)) });
+    }
+    rows.push(cells);
+  }
+  return rows;
+}
+
+// src/app/tui/design/useTimers.ts
+import { useEffect, useRef, useState } from "react";
+function useInterval(callback, delayMs) {
+  const saved = useRef(callback);
+  saved.current = callback;
+  useEffect(() => {
+    if (delayMs === null) {
+      return;
+    }
+    const id = setInterval(() => saved.current(), delayMs);
+    return () => clearInterval(id);
+  }, [delayMs]);
+}
+function useBlink(periodMs = 3600, durationMs3 = 150) {
+  const [blinking, setBlinking] = useState(false);
+  useInterval(() => {
+    setBlinking(true);
+    setTimeout(() => setBlinking(false), durationMs3);
+  }, periodMs);
+  return blinking;
+}
+
+// src/app/tui/design/components/Kit.tsx
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+var spinnerFrames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function Kit({ mood = "idle", animate = true }) {
+  const tokens2 = useTokens();
+  const blink = useBlink();
+  const [frame, setFrame] = useState2(0);
+  const badge = tokens2.kit.moods[mood]?.badge;
+  const isSpinner = badge === "spinner";
+  useInterval(
+    () => setFrame((current) => (current + 1) % spinnerFrames.length),
+    animate && isSpinner ? 90 : null
+  );
+  const rows = kitCells(tokens2.kit, mood, animate && blink, tokens2.color("background"));
+  const keyedRows = rows.map((cells) => ({
+    cells: cells.map((cell, colIndex) => ({
+      ...cell,
+      key: `${cell.top}-${cell.bottom}-${colIndex}`
+    })),
+    key: cells.map((cell) => `${cell.top}/${cell.bottom}`).join("|")
+  }));
+  const badgeText = isSpinner ? spinnerFrames[frame] ?? "" : badge;
+  return /* @__PURE__ */ jsx3(Box2, { flexDirection: "column", children: keyedRows.map((row, rowIndex) => /* @__PURE__ */ jsxs(Box2, { children: [
+    row.cells.map((cell) => /* @__PURE__ */ jsx3(Text2, { color: cell.top, backgroundColor: cell.bottom, children: "\u2580" }, cell.key)),
+    rowIndex === 0 && badgeText !== void 0 && badgeText.length > 0 ? /* @__PURE__ */ jsxs(Text2, { color: tokens2.color("primaryStrong"), children: [
+      " ",
+      badgeText
+    ] }) : null
+  ] }, row.key)) });
+}
+
+// src/app/tui/design/components/Pill.tsx
+import { Text as Text3 } from "ink";
+import { jsxs as jsxs2 } from "react/jsx-runtime";
+
+// src/app/tui/design/components/ProgressBar.tsx
+import { Box as Box3, Text as Text4 } from "ink";
+import { jsxs as jsxs3 } from "react/jsx-runtime";
+
+// src/app/tui/design/components/PromptInput.tsx
+import { Box as Box4, Text as Text5, useInput } from "ink";
+import { useState as useState3 } from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function PromptInput({ placeholder, onSubmit, isActive = true }) {
+  const tokens2 = useTokens();
+  const [value, setValue] = useState3("");
+  useInput(
+    (input, key) => {
+      if (key.return) {
+        onSubmit?.(value);
+        setValue("");
+      } else if (key.backspace || key.delete) {
+        setValue((current) => current.slice(0, -1));
+      } else if (input.length > 0 && !key.ctrl && !key.meta) {
+        setValue((current) => current + input);
+      }
+    },
+    { isActive }
+  );
+  const showPlaceholder = value.length === 0 && placeholder !== void 0;
+  return /* @__PURE__ */ jsxs4(Box4, { gap: 1, children: [
+    /* @__PURE__ */ jsx4(Text5, { color: tokens2.color("primary"), children: tokens2.glyphs.prompt }),
+    /* @__PURE__ */ jsx4(Text5, { color: showPlaceholder ? tokens2.color("textDim") : tokens2.color("text"), children: showPlaceholder ? placeholder : value })
   ] });
 }
 
-// src/infra/logging/json_technical_logger.ts
+// src/app/tui/design/components/primitives.tsx
+import { Text as Text6 } from "ink";
+import { jsx as jsx5 } from "react/jsx-runtime";
+
+// src/app/tui/design/components/SelectionList.tsx
+import { Box as Box5, Text as Text7, useInput as useInput2 } from "ink";
+import { useState as useState4 } from "react";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function SelectionList({ items, onSelect, isActive = true }) {
+  const tokens2 = useTokens();
+  const [index, setIndex] = useState4(0);
+  useInput2(
+    (_input, key) => {
+      if (items.length === 0) {
+        return;
+      }
+      if (key.upArrow) {
+        setIndex((current) => (current - 1 + items.length) % items.length);
+      } else if (key.downArrow) {
+        setIndex((current) => (current + 1) % items.length);
+      } else if (key.return) {
+        onSelect?.(items[index]?.value ?? "");
+      }
+    },
+    { isActive }
+  );
+  return /* @__PURE__ */ jsx6(Box5, { flexDirection: "column", children: items.map((item, itemIndex) => {
+    const selected = itemIndex === index;
+    return /* @__PURE__ */ jsxs5(Box5, { gap: 1, children: [
+      /* @__PURE__ */ jsx6(Text7, { color: tokens2.color("primary"), children: selected ? tokens2.glyphs.prompt : " " }),
+      /* @__PURE__ */ jsx6(Text7, { color: selected ? tokens2.color("text") : tokens2.color("textMuted"), children: item.label }),
+      item.hint !== void 0 ? /* @__PURE__ */ jsx6(Text7, { color: tokens2.statusColor("ok"), children: item.hint }) : null
+    ] }, item.value);
+  }) });
+}
+
+// src/app/tui/design/components/SpeechBubble.tsx
+import { Box as Box6, Text as Text8 } from "ink";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function SpeechBubble({
+  text: text2,
+  mood = "thinking",
+  label,
+  animate = true
+}) {
+  const tokens2 = useTokens();
+  return /* @__PURE__ */ jsxs6(Box6, { gap: 1, children: [
+    /* @__PURE__ */ jsx7(Kit, { mood, animate }),
+    /* @__PURE__ */ jsxs6(
+      Box6,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: tokens2.color("border"),
+        paddingX: 1,
+        children: [
+          label !== void 0 ? /* @__PURE__ */ jsx7(Text8, { color: tokens2.color("textDim"), children: label }) : null,
+          /* @__PURE__ */ jsx7(Text8, { color: tokens2.color("text"), children: text2 })
+        ]
+      }
+    )
+  ] });
+}
+
+// src/app/tui/design/components/StatCard.tsx
+import { Box as Box7, Text as Text9 } from "ink";
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+
+// src/app/tui/design/components/StepList.tsx
+import { Box as Box8, Text as Text10 } from "ink";
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+
+// src/app/tui/design/components/Table.tsx
+import { Box as Box9, Text as Text11 } from "ink";
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+
+// src/app/tui/design/layouts/Panel.tsx
+import { Box as Box10, Text as Text12 } from "ink";
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+
+// src/app/tui/design/layouts/TerminalChrome.tsx
+import { Box as Box11, Text as Text13 } from "ink";
+import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
+
+// src/app/tui/tokens.ts
+import { existsSync as existsSync9 } from "fs";
 import { homedir as homedir26 } from "os";
+import { dirname as dirname24, resolve as resolve10 } from "path";
+import { fileURLToPath as fileURLToPath19 } from "url";
+
+// src/infra/assets/design_catalog.ts
+import { existsSync as existsSync8 } from "fs";
+import { dirname as dirname23, resolve as resolve9 } from "path";
+import { fileURLToPath as fileURLToPath18 } from "url";
+
+// src/infra/bases/design.ts
+import { z as z42 } from "zod";
+var DesignSemanticsSchema = z42.object({
+  schema: z42.literal("agent-devkit.design-semantics/v1"),
+  status: z42.object({
+    ok: z42.string().min(1),
+    attention: z42.string().min(1),
+    blocked: z42.string().min(1),
+    "needs-setup": z42.string().min(1),
+    pending: z42.string().min(1)
+  }),
+  risk: z42.object({
+    destructive: z42.string().min(1),
+    "external-write": z42.string().min(1),
+    "read-only": z42.string().min(1),
+    "writes-global-state": z42.string().min(1),
+    "writes-project-state": z42.string().min(1)
+  }),
+  glyphs: z42.object({
+    prompt: z42.string().min(1),
+    check: z42.string().min(1),
+    bulletActive: z42.string().min(1),
+    bulletIdle: z42.string().min(1),
+    progressFull: z42.string().min(1),
+    progressEmpty: z42.string().min(1)
+  })
+});
+var KitCellOverrideSchema = z42.tuple([z42.number().int(), z42.number().int(), z42.string().min(1)]);
+var KitMoodSchema = z42.object({
+  overrides: z42.array(KitCellOverrideSchema).default([]),
+  body: z42.string().optional(),
+  dark: z42.string().optional(),
+  badge: z42.string().optional()
+});
+var KitSpriteSchema = z42.object({
+  schema: z42.literal("agent-devkit.kit/v1"),
+  size: z42.object({
+    rows: z42.number().int().positive(),
+    cols: z42.number().int().positive()
+  }),
+  palette: z42.record(z42.string().min(1), z42.string().min(1)),
+  base: z42.array(z42.string().min(1)).min(1),
+  blink: KitMoodSchema,
+  moods: z42.record(z42.string().min(1), KitMoodSchema)
+});
+
+// src/infra/assets/design_catalog.ts
+function defaultAssetsRoot3() {
+  const moduleDirectory13 = dirname23(fileURLToPath18(import.meta.url));
+  const candidates = [
+    resolve9(moduleDirectory13, "../../assets"),
+    resolve9(moduleDirectory13, "../src/assets"),
+    resolve9(process.cwd(), "src/assets")
+  ];
+  return candidates.find((candidate) => existsSync8(candidate)) ?? resolve9(process.cwd(), "src/assets");
+}
+var DesignCatalog = class {
+  #loader;
+  #semantics;
+  #kit;
+  constructor(options = {}) {
+    this.#loader = options.loader ?? new AssetLoader({ rootDirectory: defaultAssetsRoot3() });
+  }
+  async semantics() {
+    if (this.#semantics !== void 0) {
+      return Result.ok(this.#semantics);
+    }
+    const payload = await this.#loader.loadJson("design", "semantics.json");
+    if (payload.isErr()) {
+      return Result.fail(payload.unwrapError());
+    }
+    const parsed = DesignSemanticsSchema.safeParse(payload.unwrap());
+    if (!parsed.success) {
+      return Result.fail(ErrorCodes.InvalidInput);
+    }
+    this.#semantics = parsed.data;
+    return Result.ok(this.#semantics);
+  }
+  async kit() {
+    if (this.#kit !== void 0) {
+      return Result.ok(this.#kit);
+    }
+    const payload = await this.#loader.loadJson("design", "kit.json");
+    if (payload.isErr()) {
+      return Result.fail(payload.unwrapError());
+    }
+    const parsed = KitSpriteSchema.safeParse(payload.unwrap());
+    if (!parsed.success) {
+      return Result.fail(ErrorCodes.InvalidInput);
+    }
+    this.#kit = parsed.data;
+    return Result.ok(this.#kit);
+  }
+};
+
+// src/app/tui/tokens.ts
+function assetsRoot() {
+  const moduleDirectory13 = dirname24(fileURLToPath19(import.meta.url));
+  const candidates = [
+    resolve10(moduleDirectory13, "../../assets"),
+    resolve10(moduleDirectory13, "../src/assets"),
+    resolve10(process.cwd(), "src/assets")
+  ];
+  return candidates.find((candidate) => existsSync9(candidate)) ?? resolve10(process.cwd(), "src/assets");
+}
+async function activeThemeId() {
+  const bindings = createUserModuleBindings({ homeDirectory: homedir26() });
+  if (bindings.isErr()) {
+    return "default-purple";
+  }
+  const preferences = await bindings.unwrap().capabilities.preferences.execute({ action: "view" });
+  if (preferences.isErr()) {
+    return "default-purple";
+  }
+  const payload = preferences.unwrap();
+  return "preferences" in payload ? payload.preferences.theme : "default-purple";
+}
+async function loadTuiTokens() {
+  const loader = new AssetLoader({ rootDirectory: assetsRoot() });
+  const catalog = new DesignCatalog({ loader });
+  const themeId = await activeThemeId();
+  const themePayload = await loader.loadJson("themes", `${themeId}.json`);
+  const fallbackPayload = themePayload.isErr() ? await loader.loadJson("themes", "default-purple.json") : themePayload;
+  const theme = ThemeDefinitionSchema.safeParse(
+    fallbackPayload.isOk() ? fallbackPayload.unwrap() : void 0
+  );
+  const semantics = await catalog.semantics();
+  const kit = await catalog.kit();
+  if (!theme.success || semantics.isErr() || kit.isErr()) {
+    throw new Error("TUI design assets could not be loaded.");
+  }
+  return { kit: kit.unwrap(), semantics: semantics.unwrap(), theme: theme.data };
+}
+
+// src/app/tui/App.tsx
+import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
+var visibleMessages = 10;
+var happyMoodMs = 1500;
+var messageSequence = 0;
+function nextMessageId() {
+  messageSequence += 1;
+  return messageSequence;
+}
+function App({ currentVersion, initialPrompt, packageName, translator: translator2 }) {
+  const [tokens2, setTokens] = useState5();
+  const [bootError, setBootError] = useState5();
+  const [messages, setMessages] = useState5([]);
+  const [mood, setMood] = useState5("idle");
+  const [busy, setBusy] = useState5(false);
+  const [pendingApproval, setPendingApproval] = useState5();
+  const [view, setView] = useState5("chat");
+  const [sessionItems, setSessionItems] = useState5([]);
+  const environmentRef = useRef2(void 0);
+  const sessionIdRef = useRef2(void 0);
+  const moodTimerRef = useRef2(void 0);
+  const pushMessage = useCallback((role, text2) => {
+    setMessages((current) => [...current, { id: nextMessageId(), role, text: text2 }]);
+  }, []);
+  const settleMood = useCallback((finalMood) => {
+    setMood(finalMood);
+    if (moodTimerRef.current !== void 0) {
+      clearTimeout(moodTimerRef.current);
+    }
+    moodTimerRef.current = setTimeout(() => setMood("idle"), happyMoodMs);
+  }, []);
+  const runChat = useCallback(
+    async (message) => {
+      const environment = environmentRef.current;
+      if (environment === void 0) {
+        return;
+      }
+      setBusy(true);
+      setMood("thinking");
+      pushMessage("user", message);
+      const result = await environment.agent.run({
+        interface: "tui",
+        message,
+        mode: "chat",
+        sessionId: sessionIdRef.current
+      });
+      if (result.isErr()) {
+        pushMessage("info", translator2.t("tui.error", { error: result.unwrapError() }));
+        settleMood("concerned");
+        setBusy(false);
+        return;
+      }
+      const payload = result.unwrap();
+      if (payload.conversation !== void 0) {
+        sessionIdRef.current = payload.conversation.sessionId;
+        await environment.saveActiveSessionId(payload.conversation.sessionId);
+      }
+      pushMessage("agent", payload.reply);
+      settleMood("happy");
+      setBusy(false);
+    },
+    [pushMessage, settleMood, translator2.t]
+  );
+  const runTask = useCallback(
+    async (task, approvedTools) => {
+      const environment = environmentRef.current;
+      if (environment === void 0) {
+        return;
+      }
+      setBusy(true);
+      setMood("thinking");
+      if (approvedTools === void 0) {
+        pushMessage("user", `/task ${task}`);
+      }
+      const onEvent = (event) => {
+        setMood(moodForEvent(event));
+        if (event.type === "tool") {
+          pushMessage("info", `\u2192 ${event.tool}`);
+        }
+        if (event.type === "observation") {
+          pushMessage("info", `${event.ok ? "\u2713" : "\u2717"} ${event.tool}: ${event.summary}`);
+        }
+      };
+      const result = await environment.agent.run({
+        approvedTools,
+        interface: "tui",
+        mode: "task",
+        onEvent,
+        sessionId: sessionIdRef.current,
+        task
+      });
+      if (result.isErr()) {
+        pushMessage("info", translator2.t("tui.error", { error: result.unwrapError() }));
+        settleMood("concerned");
+        setBusy(false);
+        return;
+      }
+      const payload = result.unwrap();
+      const waitingTool = approvalRequiredTool(payload.steps);
+      pushMessage("agent", payload.reply);
+      if (waitingTool !== void 0) {
+        setPendingApproval({ task, tool: waitingTool });
+        pushMessage("info", translator2.t("tui.approvalRequired", { tool: waitingTool }));
+        setMood("concerned");
+        setBusy(false);
+        return;
+      }
+      settleMood("happy");
+      setBusy(false);
+    },
+    [pushMessage, settleMood, translator2.t]
+  );
+  const openSessions = useCallback(async () => {
+    const environment = environmentRef.current;
+    if (environment === void 0) {
+      return;
+    }
+    const listed = await environment.sessions.execute({
+      action: "list",
+      limit: 10,
+      status: "active"
+    });
+    if (listed.isErr() || listed.unwrap().action !== "list") {
+      pushMessage("info", translator2.t("tui.sessionsListFailed"));
+      return;
+    }
+    const payload = listed.unwrap();
+    const items = payload.action === "list" ? payload.sessions.map((session) => ({
+      hint: session.sessionId,
+      label: session.title,
+      value: session.sessionId
+    })) : [];
+    if (items.length === 0) {
+      pushMessage("info", translator2.t("tui.sessionsEmpty"));
+      return;
+    }
+    setSessionItems(items);
+    setView("sessions");
+  }, [pushMessage, translator2.t]);
+  const submit = useCallback(
+    (value) => {
+      if (busy) {
+        return;
+      }
+      const command = parseTuiCommand(value, pendingApproval !== void 0);
+      if (command.type === "empty") {
+        return;
+      }
+      if (command.type === "approve-yes" && pendingApproval !== void 0) {
+        const approval = pendingApproval;
+        setPendingApproval(void 0);
+        pushMessage("info", translator2.t("tui.approvalAccepted", { tool: approval.tool }));
+        void runTask(approval.task, [approval.tool]);
+        return;
+      }
+      if (command.type === "approve-no" && pendingApproval !== void 0) {
+        setPendingApproval(void 0);
+        pushMessage("info", translator2.t("tui.approvalDenied"));
+        setMood("idle");
+        return;
+      }
+      if (command.type === "sessions") {
+        void openSessions();
+        return;
+      }
+      if (command.type === "task") {
+        void runTask(command.task);
+        return;
+      }
+      if (command.type === "chat") {
+        void runChat(command.message);
+      }
+    },
+    [busy, openSessions, pendingApproval, pushMessage, runChat, runTask, translator2.t]
+  );
+  useEffect2(() => {
+    let mounted = true;
+    (async () => {
+      try {
+        const [loadedTokens, environment] = await Promise.all([
+          loadTuiTokens(),
+          Promise.resolve(
+            createCliAgentEnvironment({ currentVersion, interface: "tui", packageName })
+          )
+        ]);
+        const activeSessionId = await environment.loadActiveSessionId();
+        if (!mounted) {
+          return;
+        }
+        environmentRef.current = environment;
+        sessionIdRef.current = activeSessionId;
+        setTokens(loadedTokens);
+      } catch (error) {
+        if (mounted) {
+          setBootError(error instanceof Error ? error.message : String(error));
+        }
+      }
+    })();
+    return () => {
+      mounted = false;
+      if (moodTimerRef.current !== void 0) {
+        clearTimeout(moodTimerRef.current);
+      }
+    };
+  }, [currentVersion, packageName]);
+  useEffect2(() => {
+    if (tokens2 !== void 0 && initialPrompt !== void 0 && initialPrompt.length > 0) {
+      void runChat(initialPrompt);
+    }
+  }, [tokens2, initialPrompt, runChat]);
+  if (bootError !== void 0) {
+    return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx13(Text14, { bold: true, color: "red", children: translator2.t("tui.title") }),
+      /* @__PURE__ */ jsx13(Text14, { children: bootError })
+    ] });
+  }
+  if (tokens2 === void 0) {
+    return /* @__PURE__ */ jsxs12(Text14, { children: [
+      translator2.t("tui.title"),
+      "..."
+    ] });
+  }
+  const recent = messages.slice(-visibleMessages);
+  const lastAgentMessage = [...messages].reverse().find((message) => message.role === "agent");
+  return /* @__PURE__ */ jsx13(TokensProvider, { kit: tokens2.kit, semantics: tokens2.semantics, theme: tokens2.theme, children: /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingX: 1, gap: 1, children: [
+    /* @__PURE__ */ jsxs12(Box12, { gap: 2, children: [
+      /* @__PURE__ */ jsx13(Kit, { mood }),
+      /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", justifyContent: "center", children: [
+        /* @__PURE__ */ jsxs12(Text14, { bold: true, children: [
+          packageName,
+          " v",
+          currentVersion
+        ] }),
+        /* @__PURE__ */ jsx13(Text14, { dimColor: true, children: sessionIdRef.current === void 0 ? translator2.t("tui.newSession") : translator2.t("tui.session", { sessionId: sessionIdRef.current }) })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx13(Box12, { flexDirection: "column", children: recent.map(
+      (message) => message.role === "agent" && message.id === lastAgentMessage?.id ? /* @__PURE__ */ jsx13(SpeechBubble, { mood, text: message.text }, message.id) : /* @__PURE__ */ jsxs12(
+        Text14,
+        {
+          dimColor: message.role === "info",
+          color: message.role === "user" ? "cyan" : void 0,
+          children: [
+            message.role === "user" ? "\u276F " : message.role === "info" ? "\xB7 " : "",
+            message.text
+          ]
+        },
+        message.id
+      )
+    ) }),
+    view === "sessions" ? /* @__PURE__ */ jsx13(
+      SelectionList,
+      {
+        items: sessionItems,
+        onSelect: (value) => {
+          sessionIdRef.current = value;
+          void environmentRef.current?.saveActiveSessionId(value);
+          setView("chat");
+          pushMessage("info", translator2.t("tui.sessionResumed", { sessionId: value }));
+        }
+      }
+    ) : /* @__PURE__ */ jsx13(
+      PromptInput,
+      {
+        isActive: !busy,
+        onSubmit: submit,
+        placeholder: pendingApproval !== void 0 ? translator2.t("tui.approvalPlaceholder") : busy ? translator2.t("tui.thinking") : translator2.t("tui.helpHint")
+      }
+    ),
+    /* @__PURE__ */ jsx13(
+      KbdBar,
+      {
+        keys: [
+          translator2.t("tui.kbd.send"),
+          translator2.t("tui.kbd.task"),
+          "/sessions",
+          translator2.t("tui.kbd.exit")
+        ]
+      }
+    )
+  ] }) });
+}
+
+// src/infra/logging/json_technical_logger.ts
+import { homedir as homedir27 } from "os";
 import { join as join18 } from "path";
 function defaultStateDirectory4() {
-  return join18(homedir26(), ".agent-devkit");
+  return join18(homedir27(), ".agent-devkit");
 }
 function logFileName(timestamp) {
   return `technical-${timestamp.toISOString().slice(0, 10)}.jsonl`;
@@ -16153,10 +17327,10 @@ var JsonTechnicalLogger = class {
 };
 
 // src/infra/logging/json_usage_logger.ts
-import { homedir as homedir27 } from "os";
+import { homedir as homedir28 } from "os";
 import { join as join19 } from "path";
 function defaultStateDirectory5() {
-  return join19(homedir27(), ".agent-devkit");
+  return join19(homedir28(), ".agent-devkit");
 }
 function logFileName2(timestamp) {
   return `usage-${timestamp.toISOString().slice(0, 10)}.jsonl`;
@@ -16266,7 +17440,13 @@ program.name("agent").description(translator.t("cli.root.description")).version(
       return;
     }
     await ensureFirstRunModel(translator);
-    render(React.createElement(App, { translator }));
+    render(
+      React.createElement(App, {
+        currentVersion: package_default.version,
+        packageName: package_default.name,
+        translator
+      })
+    );
   })
 );
 registerDoctorCommand(program, { appVersion: package_default.version, translator, usageLogging });