agent-devkit 0.3.3 → 0.3.5

package/dist/main.js

@@ -8,7 +8,7 @@ import React from "react";
 // package.json
 var package_default = {
   name: "agent-devkit",
-  version: "0.3.3",
+  version: "0.3.5",
   description: "Agent DevKit CLI and TUI runtime for specialist AI agents, capabilities and provider-aware workflows.",
   license: "MIT",
   type: "module",
@@ -50,7 +50,7 @@ var package_default = {
     "release:verify": "node scripts/verify-release-alignment.mjs",
     test: "npm run test:architecture && npm run test:infra && npm run test:app && npm run test:modules",
     "test:app": "vitest run src/app/cli/commands src/app/mcp src/app/tui src/package.test.ts",
-    "test:architecture": "vitest run src/architecture.test.ts src/modules/capability_registry.test.ts src/modules/capability_tool_runtime.test.ts src/modules/modules.registry.test.ts",
+    "test:architecture": "vitest run src/agent src/architecture.test.ts src/modules/capability_registry.test.ts src/modules/capability_tool_runtime.test.ts src/modules/modules.registry.test.ts",
     "test:infra": "vitest run src/infra",
     "test:module": "tsx scripts/test-modules.ts",
     "test:modules": "tsx scripts/test-modules.ts",
@@ -3648,6 +3648,43 @@ var ModelStore = class {
 
 // src/infra/brain/local_llama_provider.ts
 var nodeLlamaModuleName = "node-llama-cpp";
+function shouldSuppressNodeLlamaLog(line) {
+  return line.startsWith("[node-llama-cpp]");
+}
+var defaultLocalGenerationOptions = {
+  maxTokens: 512,
+  temperature: 0.25,
+  topK: 40,
+  topP: 0.9
+};
+async function suppressNodeLlamaLogs(operation) {
+  const originalWrite = process.stderr.write;
+  let pending = "";
+  const filteredWrite = ((chunk, encodingOrCallback, callback) => {
+    const encoding = typeof encodingOrCallback === "string" ? encodingOrCallback : "utf8";
+    const done = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+    const text2 = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString(encoding) : String(chunk);
+    const lines = `${pending}${text2}`.split(/\r?\n/);
+    pending = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!shouldSuppressNodeLlamaLog(line)) {
+        originalWrite.call(process.stderr, `${line}
+`);
+      }
+    }
+    done?.();
+    return true;
+  });
+  process.stderr.write = filteredWrite;
+  try {
+    return await operation();
+  } finally {
+    if (pending.length > 0 && !shouldSuppressNodeLlamaLog(pending)) {
+      originalWrite.call(process.stderr, pending);
+    }
+    process.stderr.write = originalWrite;
+  }
+}
 async function loadNodeLlama() {
   try {
     return Result.ok(await import(nodeLlamaModuleName));
@@ -3658,8 +3695,11 @@ async function loadNodeLlama() {
 function systemPromptFrom(prompt) {
   const { agent } = prompt;
   const lines = [
-    `You are ${agent.name}.`,
-    `Behavior: ${agent.behavior}. Tone: ${agent.tone}. Detail level: ${agent.detailLevel}.`
+    `You are ${agent.name}, the user's configured Agent DevKit personality.`,
+    "You operate inside Agent DevKit, a local AI agent toolkit exposed through the `agent` CLI, TUI and MCP.",
+    "Answer as the agent. Do not answer as the user, as a generic person, or as a generic chatbot.",
+    `Behavior: ${agent.behavior}. Tone: ${agent.tone}. Detail level: ${agent.detailLevel}.`,
+    "If the user asks personal questions about you, your personality or what you can do, answer from your configured persona and conversation abilities. Do not list generic human activities. Do not describe Agent DevKit internals unless the user explicitly asks about Agent DevKit, tools, commands, MCP, modules or project capabilities."
   ];
   if (agent.traits.length > 0) {
     lines.push(`Traits: ${agent.traits.join(", ")}.`);
@@ -3670,6 +3710,38 @@ function systemPromptFrom(prompt) {
       `Project: ${project.name}${project.description === void 0 ? "" : ` \u2014 ${project.description}`}.`
     );
   }
+  const { session } = prompt.context;
+  if (session !== void 0) {
+    lines.push(
+      `Session: ${session.id}. Title: ${session.title}. Messages: ${session.messageCount}.`
+    );
+  }
+  if (prompt.context.knowledge.length > 0) {
+    lines.push(
+      "",
+      "Agent DevKit knowledge:",
+      ...prompt.context.knowledge.map((knowledge) => `- ${knowledge.content}`)
+    );
+  }
+  if (prompt.tools.length > 0) {
+    lines.push(
+      "",
+      "Available tools:",
+      ...prompt.tools.map((tool) => `- ${tool.id} (${tool.risk}): ${tool.description}`)
+    );
+  }
+  lines.push(
+    "",
+    "Tool policy:",
+    `- Tool calls allowed: ${prompt.policies.allowToolCalls ? "yes" : "no"}.`,
+    `- Approval required: ${prompt.policies.approvalRequired ? "yes" : "no"}.`,
+    `- Max tool calls: ${prompt.policies.maxToolCalls}.`
+  );
+  if (!prompt.policies.allowToolCalls) {
+    lines.push(
+      "- In this mode, do not claim that you already executed actions. If the user asks for a concrete action, explain that direct tool execution is unavailable in this chat turn."
+    );
+  }
   lines.push(`Reply in ${prompt.output.language}.`);
   const history = prompt.messages.filter((message) => message.role === "user" || message.role === "assistant").slice(0, -1).map((message) => `${message.role === "user" ? "User" : agent.name}: ${message.content}`);
   if (history.length > 0) {
@@ -3727,30 +3799,32 @@ var LocalLlamaBrainProvider = class {
       return Result.fail(nodeLlama.unwrapError());
     }
     try {
-      const llama = nodeLlama.unwrap();
-      const loadedModel = await this.#loadModel(llama, model.unwrap().path);
-      const context = await loadedModel.createContext();
-      const session = new llama.LlamaChatSession({
-        contextSequence: context.getSequence(),
-        systemPrompt: systemPromptFrom(request.prompt)
-      });
-      const text2 = await session.prompt(request.prompt.task.userMessage, {
-        grammar: await this.#grammarFor(options.jsonSchema),
-        maxTokens: request.options.maxOutputTokens,
-        onTextChunk: options.onToken,
-        seed: request.options.seed,
-        temperature: request.options.temperature,
-        topK: request.options.topK,
-        topP: request.options.topP
-      });
-      const outputTokens = text2.split(/\s+/g).filter(Boolean).length;
-      return Result.ok({
-        finishReason: "stop",
-        model: model.unwrap().id,
-        provider: "local",
-        schema: "agent-devkit.brain-response/v1",
-        text: text2,
-        usage: { outputTokens }
+      return await suppressNodeLlamaLogs(async () => {
+        const llama = nodeLlama.unwrap();
+        const loadedModel = await this.#loadModel(llama, model.unwrap().path);
+        const context = await loadedModel.createContext();
+        const session = new llama.LlamaChatSession({
+          contextSequence: context.getSequence(),
+          systemPrompt: systemPromptFrom(request.prompt)
+        });
+        const text2 = await session.prompt(request.prompt.task.userMessage, {
+          grammar: await this.#grammarFor(options.jsonSchema),
+          maxTokens: request.options.maxOutputTokens ?? defaultLocalGenerationOptions.maxTokens,
+          onTextChunk: options.onToken,
+          seed: request.options.seed,
+          temperature: request.options.temperature ?? defaultLocalGenerationOptions.temperature,
+          topK: request.options.topK ?? defaultLocalGenerationOptions.topK,
+          topP: request.options.topP ?? defaultLocalGenerationOptions.topP
+        });
+        const outputTokens = text2.split(/\s+/g).filter(Boolean).length;
+        return Result.ok({
+          finishReason: "stop",
+          model: model.unwrap().id,
+          provider: "local",
+          schema: "agent-devkit.brain-response/v1",
+          text: text2,
+          usage: { outputTokens }
+        });
       });
     } catch {
       return Result.fail(ErrorCodes.BrainProviderUnavailable);
@@ -5326,6 +5400,33 @@ function characterName2(character) {
 function compact(value) {
   return value.replaceAll(/\s+/g, " ").trim();
 }
+var agentDevKitConversationKnowledge = [
+  {
+    content: "Agent DevKit is a local AI agent toolkit exposed through the `agent` CLI, a TUI and MCP. It helps users operate this project through capabilities, local state, sessions, projects, preferences, personalization, logs, secrets, dependencies and local models.",
+    id: "agent-devkit.identity",
+    source: "conversation.chat"
+  },
+  {
+    content: "When the user asks personal questions about you, your personality or what you can do, answer as the configured character using your behavior, tone, detail level and traits. Do not answer as a generic human and do not list unrelated human activities.",
+    id: "agent-devkit.self-description-rule",
+    source: "conversation.chat"
+  },
+  {
+    content: "Only describe Agent DevKit internals, modules, tools, MCP, CLI commands or project capabilities when the user explicitly asks about Agent DevKit, the project, tools, commands, MCP or capabilities.",
+    id: "agent-devkit.project-scope-rule",
+    source: "conversation.chat"
+  },
+  {
+    content: "This conversation mode can answer, keep session memory and use project context. Direct tool execution is disabled in this chat prompt.",
+    id: "agent-devkit.chat-mode-limits",
+    source: "conversation.chat"
+  },
+  {
+    content: "Current capability areas include project doctor/init/reset, package update, preferences, themes, aliases, personalization characters, logs, encrypted secrets, dependency inspection/planning, models, projects, sessions and conversation.",
+    id: "agent-devkit.capability-map",
+    source: "conversation.chat"
+  }
+];
 var ConversationChatRepository = class {
   repositoryId = "conversation.chat.repository";
   #clock;
@@ -5470,7 +5571,7 @@ var ConversationChatRepository = class {
         traits: input.character.profile.traits
       },
       context: {
-        knowledge: [],
+        knowledge: agentDevKitConversationKnowledge,
         project: input.project === void 0 ? void 0 : {
           description: input.project.description,
           id: input.project.id,
@@ -5575,6 +5676,38 @@ var conversationChatCapabilityConfig = defineCapabilityConfig({
   kind: "brain-assisted",
   risk: "writes-global-state"
 });
+function normalizeQuestion(value) {
+  return value.normalize("NFD").replaceAll(new RegExp("\\p{Diacritic}", "gu"), "").toLowerCase().replaceAll(/[^\p{Letter}\p{Number}\s]/gu, " ").replaceAll(/\s+/g, " ").trim();
+}
+function isSelfDescriptionQuestion(message) {
+  const normalized = normalizeQuestion(message);
+  return normalized === "o que voce pode fazer" || normalized === "o que voce faz" || normalized === "quais sao suas capacidades" || normalized === "quais suas capacidades" || normalized === "what can you do" || normalized === "what do you do";
+}
+function countPromptTokens(request) {
+  return request.prompt.messages.map((message) => message.content.split(/\s+/g).filter(Boolean).length).reduce((total, count) => total + count, 0);
+}
+function selfDescriptionResponse(request) {
+  if (!isSelfDescriptionQuestion(request.prompt.task.userMessage)) {
+    return void 0;
+  }
+  const { agent } = request.prompt;
+  const traits = agent.traits.length === 0 ? "sem tracos extras configurados" : agent.traits.join(", ");
+  const text2 = `${agent.name}: Eu posso conversar com voce mantendo o contexto da sessao, ajudar a raciocinar, organizar ideias, analisar informacoes e responder no meu estilo configurado. Minha postura e ${agent.behavior}, meu tom e ${agent.tone}, meu nivel de detalhe e ${agent.detailLevel}, e meus tracos atuais sao: ${traits}.`;
+  const inputTokens = countPromptTokens(request);
+  const outputTokens = text2.split(/\s+/g).filter(Boolean).length;
+  return {
+    finishReason: "stop",
+    model: "self-description",
+    provider: "system",
+    schema: "agent-devkit.brain-response/v1",
+    text: text2,
+    usage: {
+      inputTokens,
+      outputTokens,
+      totalTokens: inputTokens + outputTokens
+    }
+  };
+}
 var ConversationChatService = class extends BaseCapabilityService {
   inputSchema = ConversationChatOptionsSchema;
   outputSchema = ConversationChatResultSchema;
@@ -5622,7 +5755,11 @@ var ConversationChatService = class extends BaseCapabilityService {
       prompt: prepared.unwrap().prompt,
       schema: "agent-devkit.brain-request/v1"
     };
-    const brain = onToken !== void 0 && this.#brainProvider.generateStream !== void 0 ? await this.#brainProvider.generateStream(request, onToken) : await this.#brainProvider.generate(request);
+    const selfDescription = selfDescriptionResponse(request);
+    const brain = selfDescription === void 0 ? onToken !== void 0 && this.#brainProvider.generateStream !== void 0 ? await this.#brainProvider.generateStream(request, onToken) : await this.#brainProvider.generate(request) : Result.ok(selfDescription);
+    if (selfDescription !== void 0) {
+      onToken?.(selfDescription.text);
+    }
     if (brain.isErr()) {
       return Result.fail(brain.unwrapError());
     }
@@ -8016,7 +8153,7 @@ import {
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 
-// src/infra/agent/agent_runtime.ts
+// src/agent/agent.brain.ts
 import { z as z23 } from "zod";
 var AgentDecisionSchema = z23.discriminatedUnion("action", [
   z23.object({ action: z23.literal("tool"), input: z23.unknown(), tool: z23.string().min(1) }),
@@ -8032,10 +8169,68 @@ var agentDecisionJsonSchema = {
   },
   required: ["action"]
 };
+function maxToolCallsFor(tools) {
+  return Math.max(1, tools.length);
+}
+function buildToolDecisionPrompt(input) {
+  const toolList = input.tools.map((tool) => `- ${tool.id} (${tool.risk}): ${tool.description}`).join("\n");
+  const instruction = [
+    `Tarefa do usu\xE1rio: ${input.task}`,
+    "",
+    "Ferramentas dispon\xEDveis:",
+    toolList,
+    "",
+    'Responda SOMENTE com JSON. Para usar uma ferramenta: {"action":"tool","tool":"<id>","input":{...}}. Para responder ao usu\xE1rio: {"action":"final","reply":"<texto>"}. Uma a\xE7\xE3o por vez.'
+  ].join("\n");
+  return AgentPromptSchema.parse({
+    agent: {
+      behavior: "balanced",
+      characterId: "agent",
+      detailLevel: "concise",
+      name: "Agent",
+      tone: "direct",
+      traits: []
+    },
+    context: {
+      knowledge: [
+        {
+          content: "You are the Agent DevKit orchestration runtime. Choose tools only when they directly help complete the user's task.",
+          id: "agent.runtime.identity"
+        }
+      ]
+    },
+    locale: "pt-BR",
+    messages: input.transcript,
+    output: { format: "json", language: "pt-BR" },
+    policies: {
+      allowToolCalls: true,
+      approvalRequired: false,
+      maxToolCalls: maxToolCallsFor(input.tools)
+    },
+    schema: "agent-devkit.prompt/v1",
+    task: { userMessage: instruction },
+    tools: input.tools.map((tool) => ({
+      description: tool.description,
+      id: tool.id,
+      inputSchema: tool.inputSchema,
+      risk: tool.risk
+    }))
+  });
+}
+
+// src/agent/agent.policy.ts
+function isToolApproved(tool, input) {
+  if (input.approvedTools !== void 0) {
+    return input.approvedTools.includes(tool);
+  }
+  return input.approved === true;
+}
+
+// src/agent/agent.loop.ts
 function summarize(value) {
   const text2 = typeof value === "string" ? value : JSON.stringify(value ?? "");
   const compact2 = text2.replaceAll(/\s+/g, " ").trim();
-  return compact2.length > 240 ? `${compact2.slice(0, 240)}\u2026` : compact2;
+  return compact2.length > 240 ? `${compact2.slice(0, 240)}...` : compact2;
 }
 function observationSummary(result) {
   if (result.status === "succeeded") {
@@ -8043,7 +8238,7 @@ function observationSummary(result) {
   }
   return `${result.status}${result.error === void 0 ? "" : `: ${result.error.message}`}`;
 }
-var AgentRuntime = class {
+var AgentToolLoop = class {
   #brain;
   #tools;
   constructor(options) {
@@ -8063,7 +8258,11 @@ var AgentRuntime = class {
     }));
     const tools = this.#tools.listTools();
     for (let step = 0; step < maxSteps; step += 1) {
-      const prompt = this.#buildPrompt(input.task, transcript, tools);
+      const prompt = buildToolDecisionPrompt({
+        task: input.task,
+        tools,
+        transcript
+      });
       const request = {
         options: { provider: "local", role: "agent" },
         prompt,
@@ -8075,19 +8274,19 @@ var AgentRuntime = class {
       }
       const decision = AgentDecisionSchema.safeParse(structured.unwrap().json);
       if (!decision.success) {
-        return Result.ok({ reply: structured.unwrap().raw.trim(), steps });
+        return Result.ok({ mode: "task", reply: structured.unwrap().raw.trim(), steps });
       }
       if (decision.data.action === "final") {
         input.onEvent?.({ reply: decision.data.reply, type: "final" });
-        return Result.ok({ reply: decision.data.reply, steps });
+        return Result.ok({ mode: "task", reply: decision.data.reply, steps });
       }
       const tool = decision.data.tool;
       input.onEvent?.({ tool, type: "tool" });
       const execution = await this.#tools.execute({
-        approved: this.#isApproved(tool, input),
+        approved: isToolApproved(tool, input),
         capabilityId: tool,
         input: decision.data.input,
-        interface: "agent",
+        interface: input.interface ?? "agent",
         requestedBy: "agent.run"
       });
       const ok = execution.status === "succeeded";
@@ -8097,64 +8296,86 @@ var AgentRuntime = class {
       transcript.push({ content: `Observation from ${tool}: ${summary}`, role: "tool" });
       if (execution.status === "approval_required") {
         return Result.ok({
+          mode: "task",
           reply: `A ferramenta ${tool} requer aprova\xE7\xE3o expl\xEDcita. Reexecute autorizando para continuar.`,
           steps
         });
       }
     }
     return Result.ok({
+      mode: "task",
       reply: "Limite de passos do agente atingido sem uma resposta final.",
       steps
     });
   }
-  #isApproved(tool, input) {
-    if (input.approvedTools !== void 0) {
-      return input.approvedTools.includes(tool);
+};
+
+// src/agent/agent.runtime.ts
+function textInput(input) {
+  return (input.message ?? input.task ?? "").trim();
+}
+function resolveMode(input) {
+  if (input.mode === "chat" || input.mode === "task") {
+    return input.mode;
+  }
+  if (input.message !== void 0) {
+    return "chat";
+  }
+  return "task";
+}
+function chatInput(input, message) {
+  return {
+    characterId: input.characterId,
+    includeHistory: input.includeHistory,
+    interface: input.interface ?? "cli",
+    message,
+    projectId: input.projectId,
+    sessionId: input.sessionId
+  };
+}
+var AgentRuntime = class {
+  #conversation;
+  #toolLoop;
+  constructor(options) {
+    this.#conversation = options.conversation;
+    this.#toolLoop = new AgentToolLoop({
+      brainProvider: options.brainProvider,
+      toolRuntime: options.toolRuntime
+    });
+  }
+  async run(input) {
+    const message = textInput(input);
+    if (message.length === 0) {
+      return Result.fail(ErrorCodes.InvalidInput);
     }
-    return input.approved === true;
+    const mode = resolveMode(input);
+    if (mode === "chat") {
+      return this.#runChat(input, message);
+    }
+    return this.#toolLoop.run({ ...input, task: message });
   }
-  #buildPrompt(task, transcript, tools) {
-    const toolList = tools.map((tool) => `- ${tool.id} (${tool.risk}): ${tool.description}`).join("\n");
-    const instruction = [
-      `Tarefa do usu\xE1rio: ${task}`,
-      "",
-      "Ferramentas dispon\xEDveis:",
-      toolList,
-      "",
-      'Responda SOMENTE com JSON. Para usar uma ferramenta: {"action":"tool","tool":"<id>","input":{...}}. Para responder ao usu\xE1rio: {"action":"final","reply":"<texto>"}. Uma a\xE7\xE3o por vez.'
-    ].join("\n");
-    return AgentPromptSchema.parse({
-      agent: {
-        behavior: "balanced",
-        characterId: "agent",
-        detailLevel: "concise",
-        name: "Agent",
-        tone: "direct",
-        traits: []
-      },
-      context: { knowledge: [] },
-      locale: "pt-BR",
-      messages: transcript,
-      output: { format: "json", language: "pt-BR" },
-      policies: {
-        allowToolCalls: true,
-        approvalRequired: false,
-        maxToolCalls: maxToolCallsFor(tools)
-      },
-      schema: "agent-devkit.prompt/v1",
-      task: { userMessage: instruction },
-      tools: tools.map((tool) => ({
-        description: tool.description,
-        id: tool.id,
-        inputSchema: tool.inputSchema,
-        risk: tool.risk
-      }))
+  async #runChat(input, message) {
+    if (this.#conversation === void 0) {
+      return Result.fail(ErrorCodes.BrainProviderUnavailable);
+    }
+    const result = await this.#conversation.chat(chatInput(input, message), {
+      approved: input.approved,
+      interface: input.interface ?? "cli",
+      requestedBy: "agent.chat"
+    });
+    if (result.isErr()) {
+      return Result.fail(result.unwrapError());
+    }
+    const conversation = result.unwrap();
+    input.onEvent?.({ reply: conversation.reply, type: "final" });
+    return Result.ok({
+      conversation,
+      mode: "chat",
+      reply: conversation.reply,
+      steps: []
     });
   }
 };
-function maxToolCallsFor(tools) {
-  return Math.max(1, tools.length);
-}
 
 // src/app/mcp/mcp_result_mapper.ts
 function inputSchemaWithAgentControl(tool) {
@@ -8309,7 +8530,7 @@ function createAgentMcpServer(options) {
       if (task.length === 0) {
         return { content: [{ type: "text", text: "Missing 'task'." }], isError: true };
       }
-      const run = await agent.run({ approvedTools, task });
+      const run = await agent.run({ approvedTools, interface: "mcp", mode: "task", task });
       if (run.isErr()) {
         return {
           content: [{ type: "text", text: `Agent run failed: ${run.unwrapError()}` }],
@@ -9936,30 +10157,148 @@ import { homedir as homedir22 } from "os";
 
 // src/modules/conversation/capabilities/chat/chat.viewmodel.ts
 function formatConversationChatText(result) {
-  const lines = ["Agent:", result.reply, "", `Session: ${result.sessionId}`];
+  const agentName = result.prompt.agent.name.trim();
+  const reply2 = result.reply.trim();
+  const speakerPrefix = `${agentName}:`;
+  const normalizedReply = reply2.toLowerCase().startsWith(speakerPrefix.toLowerCase()) ? reply2 : `${speakerPrefix} ${reply2}`;
+  const metadata = [`Session: ${result.sessionId}`];
   if (result.projectId !== void 0) {
-    lines.push(`Project: ${result.projectId}`);
+    metadata.push(`Project: ${result.projectId}`);
   }
-  return lines.join("\n");
+  if (result.brain.model !== void 0 || result.brain.provider !== void 0) {
+    metadata.push(
+      `Model: ${[result.brain.provider, result.brain.model].filter(Boolean).join("/")}`
+    );
+  }
+  if (result.brain.usage !== void 0) {
+    const tokens = [
+      result.brain.usage.inputTokens === void 0 ? void 0 : `input ${result.brain.usage.inputTokens}`,
+      result.brain.usage.outputTokens === void 0 ? void 0 : `output ${result.brain.usage.outputTokens}`,
+      result.brain.usage.totalTokens === void 0 ? void 0 : `total ${result.brain.usage.totalTokens}`
+    ].filter(Boolean);
+    if (tokens.length > 0) {
+      metadata.push(`Tokens: ${tokens.join(", ")}`);
+    }
+  }
+  return [normalizedReply, "", ...metadata].join("\n");
 }
 
 // src/app/cli/rootConversation.ts
-async function runRootConversation(message) {
+var cliConversationStatePath = {
+  namespace: "conversation",
+  segments: ["cli-state.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) {
+  const state = await dataStore.readJson(cliConversationStatePath);
+  if (state.isErr()) {
+    return void 0;
+  }
+  const statePayload = state.unwrap();
+  if (!isCliConversationState(statePayload)) {
+    return void 0;
+  }
+  const current = await sessions.execute({
+    action: "show",
+    includeMessages: false,
+    sessionId: statePayload.activeSessionId
+  });
+  if (current.isErr()) {
+    return void 0;
+  }
+  const result = current.unwrap();
+  if (result.action !== "show" || result.session.origin !== "cli" || result.session.status !== "active") {
+    return void 0;
+  }
+  return result.session.id;
+}
+async function saveActiveCliSessionId(dataStore, sessionId) {
+  await dataStore.writeJson(
+    cliConversationStatePath,
+    {
+      activeSessionId: sessionId,
+      schema: "agent-devkit.cli-conversation-state/v1",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    { atomic: true }
+  );
+}
+function createConversationPort(chat) {
+  return {
+    chat: async (input, context) => {
+      const result = await chat.invoke(
+        {
+          action: "send",
+          characterId: input.characterId,
+          includeHistory: input.includeHistory,
+          message: input.message,
+          projectId: input.projectId,
+          sessionId: input.sessionId
+        },
+        context
+      );
+      return result.map((payload) => ({
+        brain: payload.brain,
+        projectId: payload.projectId,
+        raw: payload,
+        reply: payload.reply,
+        sessionId: payload.sessionId
+      }));
+    }
+  };
+}
+async function runRootConversation(message, options) {
+  const homeDirectory = homedir22();
+  const dataStore = new LocalAgentDataStore({
+    rootDirectory: `${homeDirectory}/.agent-devkit/data`
+  });
   const bindings = createConversationModuleBindings({
-    brainProvider: createBrainDockProvider({ stateDirectory: `${homedir22()}/.agent-devkit` }),
-    homeDirectory: homedir22()
+    brainProvider: createBrainDockProvider({ stateDirectory: `${homeDirectory}/.agent-devkit` }),
+    dataStore,
+    homeDirectory
   });
+  const contextBindings = createContextModuleBindings({ dataStore, homeDirectory });
   if (bindings.isErr()) {
     throw new Error(bindings.unwrapError());
   }
-  const result = await bindings.unwrap().capabilities.chat.execute({
-    action: "send",
-    message
+  if (contextBindings.isErr()) {
+    throw new Error(contextBindings.unwrapError());
+  }
+  const activeSessionId = await loadActiveCliSessionId(
+    dataStore,
+    contextBindings.unwrap().capabilities.sessions
+  );
+  const agent = new AgentRuntime({
+    brainProvider: createBrainDockProvider({ stateDirectory: `${homeDirectory}/.agent-devkit` }),
+    conversation: createConversationPort(bindings.unwrap().capabilities.chat),
+    toolRuntime: createCliToolRuntime({
+      currentVersion: options.currentVersion,
+      packageName: options.packageName
+    })
+  });
+  const result = await agent.run({
+    interface: "cli",
+    message,
+    mode: "chat",
+    sessionId: activeSessionId
   });
   if (result.isErr()) {
     throw new Error(result.unwrapError());
   }
-  console.log(formatConversationChatText(result.unwrap()));
+  const payload = result.unwrap();
+  const rawConversation = payload.conversation?.raw;
+  if (payload.conversation === void 0 || !isConversationChatResult(rawConversation)) {
+    throw new Error("Agent did not return a conversation result.");
+  }
+  await saveActiveCliSessionId(dataStore, payload.conversation.sessionId);
+  console.log(formatConversationChatText(rawConversation));
+}
+function isConversationChatResult(value) {
+  const candidate = value;
+  return typeof value === "object" && value !== null && candidate.action === "send" && typeof candidate.reply === "string" && typeof candidate.sessionId === "string";
 }
 
 // src/infra/helpers/redaction.ts
@@ -10300,7 +10639,10 @@ program.name("agent").description(translator.t("cli.root.description")).version(
       program.error(translator.t("cli.root.removedChatCommand"));
     }
     if (initialPrompt.length > 0) {
-      await runRootConversation(initialPrompt);
+      await runRootConversation(initialPrompt, {
+        currentVersion: package_default.version,
+        packageName: package_default.name
+      });
       return;
     }
     await ensureFirstRunModel(translator);