@agentprojectcontext/apx 1.17.0 → 1.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentprojectcontext/apx",
-  "version": "1.17.0",
+  "version": "1.19.0",
   "description": "APX — unified CLI + daemon for the Agent Project Context (APC) standard.",
   "publishConfig": {
     "access": "public"
@@ -35,10 +35,6 @@
   },
   "packageManager": "pnpm@10.25.0",
   "dependencies": {
-    "@langchain/anthropic": "^0.3.34",
-    "@langchain/community": "^0.3.59",
-    "@langchain/core": "^0.3.80",
-    "@langchain/ollama": "^0.2.4",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opentui/core": "^0.2.8",
     "@opentui/keymap": "^0.2.8",
@@ -56,7 +52,6 @@
     "express": "^4.21.0",
     "fuzzysort": "^3.1.0",
     "jsonc-parser": "^3.3.1",
-    "langchain": "^0.3.37",
     "node-fetch": "^3.3.2",
     "open": "^11.0.0",
     "opentui-spinner": "^0.0.6",

package/src/cli/commands/status.js

@@ -79,17 +79,43 @@ export async function cmdStatus() {
   }
 
   // ── Telegram ───────────────────────────────────────────────────────────────
+  // Prefer the daemon's live view (real polling state). Fall back to the
+  // config file only when the daemon is unreachable. The config check must
+  // honour BOTH the legacy top-level bot_token AND per-channel tokens.
   console.log(sec("Telegram"));
   const tg = cfg.telegram || {};
-  if (tg.enabled && tg.bot_token) {
-    console.log(`  ${ok("enabled")}`);
-    console.log(`${key("chat_id")}${val(tg.chat_id || "(not set)")}`);
-    console.log(`${key("bot_token")}${DI}${maskToken(tg.bot_token)}${R}`);
-    if (tg.channels?.length) {
-      console.log(`${key("channels")}${val(tg.channels.length + " configured")}`);
+  let tgLive = null;
+  if (daemonOk) {
+    try { tgLive = await http.get("/telegram/status"); } catch {}
+  }
+
+  if (tgLive) {
+    const channels = tgLive.channels || [];
+    const polling = channels.filter((c) => c.polling).length;
+    if (!tgLive.enabled) {
+      console.log(`  ${off("disabled in config")}   run: ${CY}apx setup${R}`);
+    } else if (channels.length === 0) {
+      console.log(`  ${off("enabled, no channels")}   run: ${CY}apx setup${R}`);
+    } else if (polling === 0) {
+      console.log(`  ${err("enabled, not polling")}   run: ${CY}apx telegram start${R}`);
+    } else {
+      console.log(`  ${ok("polling")}   ${val(`${polling}/${channels.length} channel${channels.length !== 1 ? "s" : ""}`)}`);
+    }
+    for (const c of channels) {
+      const mark = c.polling ? `${GR}●${R}` : `${RE}○${R}`;
+      const tok = c.bot_token_present ? "" : ` ${DI}(no token)${R}`;
+      const lastErr = c.last_error ? `  ${RE}${c.last_error}${R}` : "";
+      console.log(`${key(c.name)}${mark} ${DI}chat ${c.chat_id || "(unset)"}${R}${tok}${lastErr}`);
     }
   } else {
-    console.log(`  ${off("disabled")}   run: ${CY}apx setup${R}`);
+    // Daemon down — best-effort from config. Token may be top-level or per-channel.
+    const hasToken = !!tg.bot_token || (tg.channels || []).some((c) => c.bot_token);
+    if (tg.enabled && hasToken) {
+      console.log(`  ${off("configured")}   ${DI}daemon down — start it to see live status${R}`);
+      console.log(`${key("channels")}${val((tg.channels?.length || 1) + " configured")}`);
+    } else {
+      console.log(`  ${off("disabled")}   run: ${CY}apx setup${R}`);
+    }
   }
 
   // ── Projects ───────────────────────────────────────────────────────────────
@@ -114,11 +140,6 @@ export async function cmdStatus() {
   console.log();
 }
 
-function maskToken(token) {
-  if (!token || token.length < 12) return "***";
-  return token.slice(0, 6) + "…" + token.slice(-4);
-}
-
 function formatUptime(s) {
   if (!s) return "?";
   if (s < 60) return `${s}s`;

package/src/cli/commands/telegram.js

@@ -36,6 +36,29 @@ export async function cmdTelegramStatus() {
   }
 }
 
+export async function cmdTelegramStart() {
+  const r = await http.post("/telegram/start", {});
+  const channels = r.status?.channels || [];
+  const polling = channels.filter((c) => c.polling).length;
+  if (channels.length === 0) {
+    console.log("⚠️  no telegram channels configured — run: apx telegram setup");
+    return;
+  }
+  if (polling === 0) {
+    console.log("⚠️  polling did not start — check telegram.enabled in ~/.apx/config.json and that a bot_token is set");
+    for (const c of channels) {
+      if (c.last_error) console.log(`   ${c.name}: ${c.last_error}`);
+    }
+    return;
+  }
+  console.log(`✅ telegram polling (${polling}/${channels.length} channel${channels.length !== 1 ? "s" : ""})`);
+}
+
+export async function cmdTelegramStop() {
+  await http.post("/telegram/stop", {});
+  console.log("⏹  telegram polling stopped (config unchanged — apx telegram start to resume)");
+}
+
 export function cmdTelegramSetup() {
   console.log(`Edit ~/.apx/config.json — telegram section:
 

package/src/cli/index.js

@@ -52,6 +52,8 @@ import {
   cmdTelegramSend,
   cmdTelegramStatus,
   cmdTelegramSetup,
+  cmdTelegramStart,
+  cmdTelegramStop,
 } from "./commands/telegram.js";
 import { cmdMessagesTail, cmdMessagesSearch, cmdMessagesChat } from "./commands/messages.js";
 import { cmdLog } from "./commands/log.js";
@@ -598,13 +600,15 @@ const HELP_TOPICS = new Map(Object.entries({
   telegram: topic({
     title: "apx telegram",
     summary: "Configure, inspect, and send through the Telegram bridge.",
-    usage: ["apx telegram <send|status|setup> [args] [--flags]"],
+    usage: ["apx telegram <send|status|start|stop|setup> [args] [--flags]"],
     commands: [
       ["send \"text\"", "Send a Telegram message."],
       ["status", "Show Telegram plugin status."],
+      ["start", "Start polling on every configured channel."],
+      ["stop", "Stop polling (config stays intact)."],
       ["setup", "Print setup guidance."],
     ],
-    examples: ["apx telegram status", "apx telegram send \"hello\" --chat 123456"],
+    examples: ["apx telegram status", "apx telegram start", "apx telegram send \"hello\" --chat 123456"],
   }),
   "telegram send": topic({
     title: "apx telegram send",
@@ -626,6 +630,18 @@ const HELP_TOPICS = new Map(Object.entries({
     usage: ["apx telegram status"],
     examples: ["apx telegram status"],
   }),
+  "telegram start": topic({
+    title: "apx telegram start",
+    summary: "Start Telegram polling on every configured channel.",
+    usage: ["apx telegram start"],
+    examples: ["apx telegram start"],
+  }),
+  "telegram stop": topic({
+    title: "apx telegram stop",
+    summary: "Stop Telegram polling (config stays intact; resume with apx telegram start).",
+    usage: ["apx telegram stop"],
+    examples: ["apx telegram stop"],
+  }),
   "telegram setup": topic({
     title: "apx telegram setup",
     summary: "Print Telegram setup guidance.",
@@ -1441,6 +1457,8 @@ async function dispatch(cmd, rest) {
         const a = parseArgs(rest.slice(1));
         if (sub === "send") await cmdTelegramSend(a);
         else if (sub === "status") await cmdTelegramStatus();
+        else if (sub === "start") await cmdTelegramStart();
+        else if (sub === "stop") await cmdTelegramStop();
         else if (sub === "setup") cmdTelegramSetup();
         else die(`unknown telegram subcommand: ${sub || "(none)"}`);
         break;

package/src/core/config.js

@@ -50,7 +50,7 @@ const DEFAULT_CONFIG = {
     name: "apx",
     model: "",                          // e.g. "ollama:llama3.2:3b"
     system: "",                         // optional override; defaults baked into super-agent.js
-    permission_mode: "automatico",       // total | automatico | permiso
+    permission_mode: "total",            // total | automatico | permiso
     allowed_tools: [],                   // used by permission_mode="permiso"
   },
   engines: {

package/src/daemon/api.js

@@ -442,6 +442,28 @@ export function buildApi({ projects, registries, plugins, scheduler, version, st
     res.json(telegram.status());
   });
 
+  // POST /telegram/start  — (re)start polling for every configured channel.
+  app.post("/telegram/start", (_req, res) => {
+    if (!telegram) return res.status(503).json({ error: "telegram plugin not loaded" });
+    try {
+      telegram.start();
+      res.json({ ok: true, status: telegram.status() });
+    } catch (e) {
+      res.status(502).json({ error: e.message });
+    }
+  });
+
+  // POST /telegram/stop  — stop polling on every channel (config stays intact).
+  app.post("/telegram/stop", (_req, res) => {
+    if (!telegram) return res.status(503).json({ error: "telegram plugin not loaded" });
+    try {
+      telegram.stop();
+      res.json({ ok: true, status: telegram.status() });
+    } catch (e) {
+      res.status(502).json({ error: e.message });
+    }
+  });
+
   app.post("/telegram/send", async (req, res) => {
     const { chat_id, text, channel } = req.body || {};
     if (!text) return res.status(400).json({ error: "text required" });

package/src/daemon/plugins/telegram.js

@@ -344,6 +344,8 @@ class ChannelPoller {
     while (this.polling) {
       try {
         const updates = await this._getUpdates();
+        // A successful poll clears any stale error so status reflects recovery.
+        this.lastError = null;
         for (const u of updates) {
           await this._handleUpdate(u);
           this.offset = u.update_id + 1;

package/src/daemon/super-agent.js

@@ -42,6 +42,11 @@ You are **APX** — Manuel's personal assistant running on his Mac.
 You are NOT a code analyzer, NOT a generic chatbot, NOT a tutor.
 You are an **action agent**: you USE TOOLS to do real things on Manuel's system.
 
+# Sobre Manuel (el usuario)
+- Se llama **Manuel**, es un desarrollador argentino.
+- Está en **Argentina**, timezone **UTC-3**. Cuando hables de horarios, asumí UTC-3 salvo que diga otra cosa.
+- Habla **español rioplatense** (voseo). Hablale así.
+
 # Language — non-negotiable
 ALWAYS reply in **Spanish (rioplatense, voseo when natural)** unless Manuel
 explicitly writes to you in another language for that turn. The user is an
@@ -49,6 +54,17 @@ Argentinian developer; English replies feel broken to him. If you find
 yourself writing English, stop and rewrite in Spanish before sending.
 This rule beats every other formatting hint below.
 
+# Cómo se reciben los mensajes de audio
+Cuando el usuario manda un audio por Telegram, el sistema lo transcribe
+automáticamente y te lo entrega en este formato:
+[audio] <texto transcripto del audio>
+
+Cuando veas "[audio]" al inicio del mensaje, significa que el usuario HABLÓ ese
+mensaje — lo que viene después es la transcripción exacta de lo que dijo.
+Tratalo exactamente igual que si el usuario lo hubiera escrito, pero sabiendo
+que fue hablado. Nunca le digas al usuario que "no escuchaste nada" o que "no
+hay ningún audio" — el audio YA fue procesado y lo tenés en texto delante tuyo.
+
 # What you must NOT do
 - Do NOT explain code or write essays about "the provided snippet".
 - Do NOT describe what a tool *would* do — call it and report the result.
@@ -57,15 +73,39 @@ This rule beats every other formatting hint below.
 - If a user message is short or ambiguous, ASK one short clarifying question
   in Spanish — do not invent a topic.
 
-# How you operate
-You are the **APX dispatcher** — the daemon-level agent that runs above all APC projects.
-
-APX is a local daemon + CLI for APC projects. User-level runtime state lives under ~/.apx/:
-- ~/.apx/config.json: daemon config, engines, Telegram, super-agent settings
-- ~/.apx/projects/default: your default APX workspace; use it for system-level work when the user does not name a project
-- ~/.apx/agents: vault of reusable agent templates
-- ~/.apx/messages: global channel logs such as Telegram
+# Qué es APX y qué sos vos
+**Vos SOS el superagente de APX.** No sos un modelo genérico — sos el agente
+dispatcher que corre dentro del daemon de APX, y el usuario te habla por Telegram.
+
+APX es un daemon + CLI local para proyectos APC (Agent Project Context):
+- El daemon corre en localhost:7430 y mantiene estado en ~/.apx/
+- ~/.apx/config.json: config del daemon, engines, Telegram, ajustes del superagente
+- ~/.apx/projects/default: tu workspace por defecto; usalo para trabajo de sistema cuando el usuario no nombra un proyecto
+- ~/.apx/agents: vault de templates de agentes reutilizables
+- ~/.apx/messages: logs de canales globales como Telegram
+- Los **proyectos** son carpetas en disco con AGENTS.md y .apc/project.json (agentes, memorias, skills, hints de MCP, comandos, routines). Por ahora el único proyecto del usuario se llama \`default\`.
+
+Comandos de la CLI de APX (por si el usuario pregunta cómo hacer algo):
+- \`apx daemon start|stop|status|logs\` — controlar el daemon
+- \`apx status\` — estado completo de un vistazo (daemon, superagente, engines, Telegram, proyectos)
+- \`apx code\` — asistente de coding en terminal (TUI)
+- \`apx log\` / \`apx log -f\` — ver/seguir el log unificado en ~/.apx/logs/apx.log
+- \`apx update\` — actualizar APX a la última versión de npm
+- \`apx search <query>\` — buscar en mensajes/proyectos
+- \`apx project add <path>\` — registrar un proyecto
+- \`apx telegram status|start|stop|send\` — controlar el canal de Telegram
+- \`apx routine list|add|run\` — routines programadas
+- \`apx permission show|set\` — modo de permisos
+- \`apx setup\` — wizard de configuración inicial
+
+Tus tools (resumen — usalas, no las describas): list_projects / list_agents /
+list_mcps / list_skills para inventario; read_file / list_files / read_agent_memory
+para leer; write_file / add_project / import_agent para mutar; run_shell para
+comandos; call_agent / call_runtime para delegar; send_telegram para mandar
+mensajes/fotos/audio; load_skill para traer docs; web_search / browser_screenshot
+para la web; set_identity para cambiar tu nombre/personalidad.
 
+# How you operate
 APC projects are filesystem projects anywhere on disk with AGENTS.md and .apc/project.json. They contain agents, memories, skills, MCP hints, commands, and routines. The default workspace is not a user project; it is your APX home workspace. Registered projects are listed below as a tiny index; call tools for details.
 
 Useful CLI facts:
@@ -74,6 +114,7 @@ Useful CLI facts:
 - Routine design: if the user asks for an agent to think, decide, write, or reply, create an exec_agent routine with spec.agent and spec.prompt. If the user asks APX itself to orchestrate tools or Telegram, create a super_agent routine. If the request is only a deterministic command, create a shell routine. If unclear, ask one short question: "agent routine or simple command routine?"
 - Routine schedules: APX supports standard cron expressions (e.g. '*/5 * * * *'), OR 'every:<number><s|m|h|d>' (e.g. 'every:60s'), OR 'once:<iso-8601>'.
 - Safe read-only shell checks such as apx --help, apx routine list, docker ps, find, ls, rg, grep can run in automatico without asking.
+- Búsquedas en el filesystem: usá herramientas específicas y eficientes — \`find <dir> -name <patrón>\`, \`fd <patrón>\`, \`rg <texto>\` / \`grep -rn <texto>\`, o glob patterns concretos. NUNCA uses \`ls -R\` ni \`ls\` recursivo sobre directorios grandes (volúmenes, home, raíz) — es lento, primitivo y trae basura. Acotá siempre el directorio de búsqueda y el patrón.
 
 Channel context:
 - If the context note says Telegram, you are replying through Telegram. Use plain text, brief replies, no markdown tables, no code fences unless needed, no long dumps.
@@ -226,19 +267,6 @@ export async function runSuperAgent({
   const sa = globalConfig.super_agent;
   const activeModel = overrideModel || sa.model;
 
-  // Engine toggle: if config.super_agent.engine === "langchain", delegate to
-  // the LangChain AgentExecutor adapter. Default stays "native" (this loop).
-  // The toggle exists so we can A/B the two paths on the user's actual chat
-  // without committing to a full migration. See super-agent-langchain.js.
-  if (sa.engine === "langchain") {
-    const { runSuperAgentLangChain } = await import("./super-agent-langchain.js");
-    return runSuperAgentLangChain({
-      globalConfig, projects, plugins, registries,
-      prompt, previousMessages, contextNote,
-      onEvent, onToken, signal,
-    });
-  }
-
   // Tiny project hint — JUST names + ids, no detail. The model is expected to
   // call list_agents / list_mcps / read_agent_memory / etc. for everything
   // else. Keeping this short forces actual tool use instead of letting the
@@ -248,7 +276,7 @@ export async function runSuperAgent({
     .map((p) => `  ${p.id}: ${p.id === 0 ? "[default]" : "[project]"} "${p.name}" (${p.path})`)
     .join("\n");
 
-  const permissionMode = sa.permission_mode || "automatico";
+  const permissionMode = sa.permission_mode || "total";
   const allowedTools = Array.isArray(sa.allowed_tools) ? sa.allowed_tools : [];
   const permissionNote = [
     "# Permission mode",

package/src/tui/context/sdk-apx.tsx

@@ -4,6 +4,7 @@ import { onCleanup } from "solid-js"
 import fs from "node:fs"
 import os from "node:os"
 import path from "node:path"
+import { spawn } from "node:child_process"
 
 const TOKEN_PATH = path.join(os.homedir(), ".apx", "daemon.token")
 
@@ -20,6 +21,9 @@ export type ApxEvent =
   | { type: "chunk"; sessionID: string; chunk: string }
   | { type: "final"; sessionID: string; text: string; usage?: { input_tokens: number; output_tokens: number } }
   | { type: "error"; sessionID: string; error: string }
+  | { type: "shell.start"; sessionID: string; shellID: string; command: string; cwd: string }
+  | { type: "shell.output"; sessionID: string; shellID: string; stream: "stdout" | "stderr"; chunk: string }
+  | { type: "shell.done"; sessionID: string; shellID: string; exitCode: number | null; signal: NodeJS.Signals | null }
 
 export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
   name: "SDK",
@@ -102,6 +106,27 @@ export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
       return (data as any).id as string
     }
 
+    function runShell(sessionID: string, command: string, cwd: string = process.cwd()): Promise<{ shellID: string; exitCode: number | null }> {
+      const shellID = `sh-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`
+      emitter.emit("event", { type: "shell.start", sessionID, shellID, command, cwd })
+      return new Promise((resolve) => {
+        const child = spawn(command, { shell: true, cwd, env: process.env })
+        child.stdout?.on("data", (buf) => {
+          emitter.emit("event", { type: "shell.output", sessionID, shellID, stream: "stdout", chunk: buf.toString() })
+        })
+        child.stderr?.on("data", (buf) => {
+          emitter.emit("event", { type: "shell.output", sessionID, shellID, stream: "stderr", chunk: buf.toString() })
+        })
+        child.on("error", (err) => {
+          emitter.emit("event", { type: "shell.output", sessionID, shellID, stream: "stderr", chunk: `[spawn error] ${err.message}\n` })
+        })
+        child.on("close", (code, signal) => {
+          emitter.emit("event", { type: "shell.done", sessionID, shellID, exitCode: code, signal })
+          resolve({ shellID, exitCode: code })
+        })
+      })
+    }
+
     async function listSessions(): Promise<Array<{ id: string; title: string; updatedAt?: number }>> {
       try {
         const token = readToken()
@@ -146,7 +171,12 @@ export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
         fork: async (_opts: any) => ({ data: undefined, error: new Error("not supported") }),
         abort: async (_opts: any) => {},
         prompt: async (_opts: any) => {},
-        shell: async (_opts: any) => {},
+        shell: async (opts: { sessionID?: string; command?: string; cwd?: string }) => {
+          if (!opts?.command) return { data: undefined }
+          const sid = opts.sessionID || (await createSession())
+          const r = await runShell(sid, opts.command, opts.cwd)
+          return { data: r }
+        },
         command: async (_opts: any) => {},
         refresh: async () => {},
         update: async (_opts: any) => ({ data: undefined }),
@@ -180,6 +210,7 @@ export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
       streamChat,
       createSession,
       listSessions,
+      runShell,
     }
   },
 })

package/src/tui/context/sync-apx.tsx

@@ -13,10 +13,15 @@ export type ApxSession = {
 export type ApxMessage = {
   id: string
   sessionID: string
-  role: "user" | "assistant"
+  role: "user" | "assistant" | "shell"
   text: string
   streaming?: boolean
   error?: boolean
+  // Shell-specific
+  shellID?: string
+  command?: string
+  cwd?: string
+  exitCode?: number | null
 }
 
 export const { use: useApxSync, provider: ApxSyncProvider } = createSimpleContext({
@@ -78,6 +83,55 @@ export const { use: useApxSync, provider: ApxSyncProvider } = createSimpleContex
         setStore("previousMessages", (prev) => [...prev, { role: "assistant", content: e.text }])
       }
 
+      if (ev.type === "shell.start") {
+        const e = ev
+        setStore(
+          "messages",
+          produce((draft) => {
+            ;(draft[e.sessionID] ??= []).push({
+              id: e.shellID,
+              sessionID: e.sessionID,
+              role: "shell",
+              text: "",
+              streaming: true,
+              shellID: e.shellID,
+              command: e.command,
+              cwd: e.cwd,
+            })
+          }),
+        )
+      }
+
+      if (ev.type === "shell.output") {
+        const e = ev
+        setStore(
+          "messages",
+          produce((draft) => {
+            const msgs = draft[e.sessionID]
+            if (!msgs) return
+            const target = msgs.find((m) => m.role === "shell" && m.shellID === e.shellID)
+            if (target) target.text += e.chunk
+          }),
+        )
+      }
+
+      if (ev.type === "shell.done") {
+        const e = ev
+        setStore(
+          "messages",
+          produce((draft) => {
+            const msgs = draft[e.sessionID]
+            if (!msgs) return
+            const target = msgs.find((m) => m.role === "shell" && m.shellID === e.shellID)
+            if (target) {
+              target.streaming = false
+              target.exitCode = e.exitCode
+              if (e.signal) target.text += `\n[killed by signal ${e.signal}]`
+            }
+          }),
+        )
+      }
+
       if (ev.type === "error") {
         const e = ev
         setStore(
@@ -121,6 +175,11 @@ export const { use: useApxSync, provider: ApxSyncProvider } = createSimpleContex
       return id
     }
 
+    async function runShell(command: string, cwd?: string) {
+      const sessionID = await ensureSession()
+      await sdk.runShell(sessionID, command, cwd ?? process.cwd())
+    }
+
     async function sendMessage(text: string) {
       const sessionID = await ensureSession()
       const userMsg: ApxMessage = {
@@ -172,6 +231,7 @@ export const { use: useApxSync, provider: ApxSyncProvider } = createSimpleContex
         async refresh() {},
       },
       sendMessage,
+      runShell,
       ensureSession,
     }
   },

package/src/tui/routes/session/index.tsx

@@ -47,6 +47,35 @@ function AssistantBubble(props: { msg: ApxMessage }) {
   )
 }
 
+function ShellBubble(props: { msg: ApxMessage }) {
+  const { theme } = useTheme()
+  const header = () => {
+    const code = props.msg.exitCode
+    const status = props.msg.streaming
+      ? "running"
+      : code === 0
+        ? "exit 0"
+        : code == null
+          ? "ended"
+          : `exit ${code}`
+    return `$ ${props.msg.command ?? ""}  · ${status}`
+  }
+  const body = () => props.msg.text || (props.msg.streaming ? "…" : "(no output)")
+  return (
+    <box flexDirection="column" marginBottom={1} paddingLeft={2} paddingRight={2}>
+      <text color={theme.warning ?? theme.primary} bold>
+        {header()}
+      </text>
+      <text
+        color={props.msg.exitCode && props.msg.exitCode !== 0 ? theme.error : theme.text}
+        wrap
+      >
+        {body()}
+      </text>
+    </box>
+  )
+}
+
 export function Session() {
   const dims = useTerminalDimensions()
   const { theme } = useTheme()
@@ -109,7 +138,11 @@ export function Session() {
     inputEl.clear()
     setSending(true)
     try {
-      await sync.sendMessage(text)
+      if (text.startsWith("!") && text.length > 1) {
+        await sync.runShell(text.slice(1).trim())
+      } else {
+        await sync.sendMessage(text)
+      }
     } catch (e) {
       toast.error(e instanceof Error ? e : new Error(String(e)))
     } finally {
@@ -132,17 +165,17 @@ export function Session() {
             fallback={
               <box paddingLeft={2} paddingTop={2}>
                 <text color={theme.textMuted} italic>
-                  Type a message and press Enter to start chatting.
+                  Type a message to chat, or prefix with ! to run a shell command (e.g. !ls).
                 </text>
               </box>
             }
           >
             <For each={messages()}>
-              {(msg) => (
-                <Show when={msg.role === "user"} fallback={<AssistantBubble msg={msg} />}>
-                  <UserBubble msg={msg} />
-                </Show>
-              )}
+              {(msg) => {
+                if (msg.role === "user") return <UserBubble msg={msg} />
+                if (msg.role === "shell") return <ShellBubble msg={msg} />
+                return <AssistantBubble msg={msg} />
+              }}
             </For>
           </Show>
           <box height={1} />
@@ -163,7 +196,7 @@ export function Session() {
               inputEl = r
               promptRef.set(makeRef(r))
             }}
-            placeholder={sending() ? "Waiting for response…" : "Ask anything... (Enter to send)"}
+            placeholder={sending() ? "Waiting for response…" : "Ask anything... (prefix ! to run shell, e.g. !ls)"}
             placeholderColor={theme.textMuted}
             textColor={theme.text}
             focusedTextColor={theme.text}

package/src/daemon/super-agent-langchain.js

@@ -1,296 +0,0 @@
-// LangChain adapter for the APX super-agent.
-//
-// Lives alongside the native loop in super-agent.js. Selected via
-// config.super_agent.engine === "langchain" (default: "native"). The two
-// implementations expose the same shape:
-//
-//   { text, usage, name, trace }   ← return value
-//   { globalConfig, projects, plugins, registries, prompt,
-//     previousMessages, contextNote, onEvent, onToken, signal }   ← input
-//
-// Why a toggle and not a replacement: the native loop carries APX-specific
-// features (pseudo-tool fallback for Ollama 500, ghost-response detection,
-// permission_mode gates wired through tool handlers, identity-block injection,
-// ACK_ONLY_TOOLS streak guard). Re-implementing all of those inside LangChain
-// is a large refactor; meanwhile the toggle lets us A/B both paths and pick
-// the one that actually behaves better with gemma4-class models on the
-// user's hardware.
-//
-// LangChain version compat: written against @langchain/core ^0.3 +
-// langchain ^0.3 + @langchain/anthropic ^0.3 + @langchain/ollama ^0.2.
-//
-// Limitations vs native loop (acknowledged in v1):
-//   - permission_mode confirmations are still enforced inside each tool
-//     handler (they return {error: "requires_confirmation: ..."}), but
-//     the loop has no UI to ask the user mid-run, so confirmable tools
-//     just fail-fast as they do today.
-//   - Pseudo-tool fallback (for Ollama 500 on structured tools) is NOT
-//     implemented here — if the underlying engine fails, the call
-//     propagates. Use engine === "native" for that case.
-
-import { AgentExecutor, createToolCallingAgent } from "langchain/agents";
-import { ChatPromptTemplate, MessagesPlaceholder } from "@langchain/core/prompts";
-import { DynamicStructuredTool } from "@langchain/core/tools";
-import { HumanMessage, AIMessage, ToolMessage } from "@langchain/core/messages";
-import { z } from "zod";
-
-import { TOOL_SCHEMAS, makeToolHandlers } from "./super-agent-tools.js";
-import { readIdentity } from "../core/identity.js";
-import { logInfo, logWarn, logError } from "../core/logging.js";
-
-const MAX_ITER_DEFAULT = 15;
-
-// ---------------------------------------------------------------------------
-// JSON-Schema → Zod converter
-// ---------------------------------------------------------------------------
-// LangChain's DynamicStructuredTool wants a Zod schema. APX's tools ship JSON
-// Schema (in the OpenAI function-calling shape). We translate just enough for
-// the parameter types APX actually uses: string, number, boolean, object,
-// array, enum, optional/required. Anything more exotic falls back to z.any().
-function jsonSchemaToZod(schema) {
-  if (!schema || typeof schema !== "object") return z.any();
-  // OpenAI function shape: { type: "function", function: { parameters: {...} } }
-  const root = schema.function?.parameters || schema.parameters || schema;
-  return objectToZod(root);
-}
-
-function objectToZod(obj) {
-  if (!obj || obj.type !== "object" || !obj.properties) {
-    return z.object({}).passthrough();
-  }
-  const required = new Set(obj.required || []);
-  const shape = {};
-  for (const [key, prop] of Object.entries(obj.properties)) {
-    let s = propToZod(prop);
-    if (!required.has(key)) s = s.optional();
-    if (prop?.description) s = s.describe(prop.description);
-    shape[key] = s;
-  }
-  return z.object(shape);
-}
-
-function propToZod(prop) {
-  if (!prop || typeof prop !== "object") return z.any();
-  if (Array.isArray(prop.enum) && prop.enum.length > 0) {
-    return z.enum(prop.enum);
-  }
-  switch (prop.type) {
-    case "string":  return z.string();
-    case "number":  return z.number();
-    case "integer": return z.number().int();
-    case "boolean": return z.boolean();
-    case "array":   return z.array(prop.items ? propToZod(prop.items) : z.any());
-    case "object":  return objectToZod(prop);
-    default:        return z.any();
-  }
-}
-
-// ---------------------------------------------------------------------------
-// APX tool → LangChain DynamicStructuredTool
-// ---------------------------------------------------------------------------
-function buildLangChainTools(handlers, schemas, { trace, onEvent }) {
-  return schemas.map((s) => {
-    const name = s.function.name;
-    const handler = handlers[name];
-    if (!handler) {
-      logWarn("super-agent-lc", `no handler for tool ${name} — skipping`);
-      return null;
-    }
-    return new DynamicStructuredTool({
-      name,
-      description: s.function.description || "",
-      schema: jsonSchemaToZod(s),
-      func: async (args) => {
-        const traceId = `lc:${trace.length + 1}`;
-        if (typeof onEvent === "function") {
-          try {
-            await onEvent({
-              type: "tool_start",
-              trace: { id: traceId, tool: name, args, pending: true },
-            });
-          } catch {}
-        }
-        try {
-          const result = await handler(args || {});
-          trace.push({ id: traceId, tool: name, args, result });
-          if (typeof onEvent === "function") {
-            try { await onEvent({ type: "tool_result", trace: { id: traceId, tool: name, args, result } }); } catch {}
-          }
-          return typeof result === "string" ? result : JSON.stringify(result);
-        } catch (e) {
-          const errObj = { error: e.message };
-          trace.push({ id: traceId, tool: name, args, result: errObj });
-          if (typeof onEvent === "function") {
-            try { await onEvent({ type: "tool_result", trace: { id: traceId, tool: name, args, result: errObj } }); } catch {}
-          }
-          return JSON.stringify(errObj);
-        }
-      },
-    });
-  }).filter(Boolean);
-}
-
-// ---------------------------------------------------------------------------
-// Engine factory — picks an @langchain ChatModel based on modelId
-// ---------------------------------------------------------------------------
-async function makeLangChainModel(modelId, config) {
-  // modelId grammar matches engines/index.js: "<provider>:<model>" or
-  // an inferable bare model id ("claude-…" → anthropic, etc).
-  const [providerRaw, ...rest] = String(modelId || "").split(":");
-  let provider = providerRaw.toLowerCase();
-  let model = rest.join(":");
-  if (!model) {
-    // bare id — infer like engines/index.js
-    if (/^claude/i.test(providerRaw)) { provider = "anthropic"; model = providerRaw; }
-    else if (/^gpt|^o[134]/i.test(providerRaw)) { provider = "openai"; model = providerRaw; }
-    else if (/^gemini/i.test(providerRaw)) { provider = "gemini"; model = providerRaw; }
-    else { provider = "ollama"; model = providerRaw; }
-  }
-  const providerCfg = (config && config.engines && config.engines[provider]) || {};
-
-  if (provider === "anthropic") {
-    const { ChatAnthropic } = await import("@langchain/anthropic");
-    const apiKey = providerCfg.api_key || process.env.ANTHROPIC_API_KEY;
-    if (!apiKey) throw new Error("anthropic: no api_key set");
-    return new ChatAnthropic({ apiKey, model, temperature: 1.0, maxTokens: 1024 });
-  }
-  if (provider === "ollama") {
-    const { ChatOllama } = await import("@langchain/ollama");
-    const baseUrl = providerCfg.base_url || process.env.OLLAMA_HOST || "http://localhost:11434";
-    return new ChatOllama({ baseUrl, model, temperature: 0.7 });
-  }
-  if (provider === "openai") {
-    // Lazy import — only required if the user picks openai.
-    const { ChatOpenAI } = await import("@langchain/openai").catch(() => ({}));
-    if (!ChatOpenAI) throw new Error("openai: install @langchain/openai to use this provider with the langchain engine");
-    const apiKey = providerCfg.api_key || process.env.OPENAI_API_KEY;
-    if (!apiKey) throw new Error("openai: no api_key set");
-    return new ChatOpenAI({ apiKey, model, temperature: 1.0 });
-  }
-  throw new Error(`langchain engine: unknown provider "${provider}" (modelId="${modelId}")`);
-}
-
-// ---------------------------------------------------------------------------
-// Convert APX "previousMessages" rows ({role, content}) → LangChain messages
-// ---------------------------------------------------------------------------
-function toLangChainHistory(previousMessages) {
-  return (previousMessages || []).map((m) => {
-    if (m.role === "user")      return new HumanMessage(m.content || "");
-    if (m.role === "assistant") return new AIMessage(m.content || "");
-    if (m.role === "tool") {
-      // LangChain ToolMessage requires a tool_call_id; APX doesn't track ids
-      // in the FS history, so we use a synthetic one. The agent only sees
-      // the content anyway.
-      return new ToolMessage({ content: m.content || "", tool_call_id: m.tool_name || "tool" });
-    }
-    return new HumanMessage(m.content || "");
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Public entry — same contract as runSuperAgent in super-agent.js
-// ---------------------------------------------------------------------------
-export async function runSuperAgentLangChain({
-  globalConfig,
-  projects,
-  plugins,
-  registries,
-  prompt,
-  previousMessages = [],
-  contextNote = "",
-  systemOverride = null,
-  onEvent,
-  onToken,
-  signal,
-}) {
-  const sa = globalConfig?.super_agent || {};
-  if (!sa.model) throw new Error("super-agent (langchain): no model configured");
-
-  const identity = (() => { try { return readIdentity(); } catch { return null; } })();
-  const userLang = globalConfig?.user?.language || "en";
-
-  // System prompt — we reuse the native module's DEFAULT_SYSTEM unless the
-  // caller passes systemOverride. This keeps the personality / language /
-  // hard-rules consistent across both engines.
-  const { DEFAULT_SYSTEM, buildIdentityBlock } = await import("./super-agent.js");
-  const identityBlock = buildIdentityBlock(identity, userLang);
-  const systemPieces = [
-    systemOverride || sa.system || DEFAULT_SYSTEM,
-    identityBlock,
-    contextNote,
-  ].filter(Boolean);
-  // LangChain ChatPromptTemplate uses f-string formatting and will try to
-  // resolve any `{name}` it finds in the system text as an input variable.
-  // The APX prompt naturally contains literal `{path: <CWD>}` examples and
-  // JSON-like snippets, so we double every `{` and `}` to escape them.
-  const systemText = systemPieces.join("\n\n").replace(/[{}]/g, (c) => c + c);
-
-  const trace = [];
-  const handlers = makeToolHandlers({
-    projects, plugins, registries, globalConfig,
-    implicitConfirmation: false,
-  });
-  const tools = buildLangChainTools(handlers, TOOL_SCHEMAS, { trace, onEvent });
-
-  logInfo("super-agent-lc", "starting AgentExecutor", {
-    model: sa.model, tools: tools.length, prev: previousMessages.length,
-  });
-
-  const llm = await makeLangChainModel(sa.model, globalConfig);
-
-  const promptTemplate = ChatPromptTemplate.fromMessages([
-    ["system", systemText],
-    new MessagesPlaceholder("chat_history"),
-    ["human", "{input}"],
-    new MessagesPlaceholder("agent_scratchpad"),
-  ]);
-
-  const agent = await createToolCallingAgent({ llm, tools, prompt: promptTemplate });
-
-  const executor = new AgentExecutor({
-    agent,
-    tools,
-    maxIterations: Number(sa.max_iterations) > 0 ? Number(sa.max_iterations) : MAX_ITER_DEFAULT,
-    returnIntermediateSteps: true,
-    handleParsingErrors: true,
-    // verbose is noisy; we already log via core/logging.js
-  });
-
-  const t0 = Date.now();
-  let result;
-  try {
-    if (typeof onEvent === "function") {
-      try { await onEvent({ type: "model_start", iteration: 1 }); } catch {}
-    }
-    result = await executor.invoke({
-      input: prompt,
-      chat_history: toLangChainHistory(previousMessages),
-    }, { signal });
-  } catch (e) {
-    logError("super-agent-lc", `executor failed in ${Date.now() - t0}ms`, { error: e.message });
-    throw e;
-  }
-
-  // result.output is the final text. result.intermediateSteps is an array
-  // of { action, observation }; we already pushed each into `trace` from the
-  // DynamicStructuredTool wrappers, so we don't double-record them here.
-  const text = String(result.output || "");
-  logInfo("super-agent-lc", `done in ${Date.now() - t0}ms`, {
-    text_len: text.length,
-    tool_calls: trace.length,
-  });
-
-  return {
-    text,
-    // LangChain doesn't surface token counts uniformly across providers;
-    // leave 0/0 so the caller's bookkeeping doesn't break. Real values
-    // would require provider-specific callback handlers.
-    usage: { input_tokens: 0, output_tokens: 0 },
-    name: sa.name || "apx",
-    trace,
-  };
-}
-
-export function isLangChainEngineSelected(cfg) {
-  return cfg?.super_agent?.engine === "langchain";
-}