thepopebot 1.2.75-beta.2 → 1.2.75-beta.21

package/config/CLAUDE.md

@@ -1,32 +1,4 @@
-# config/ — Configuration Files
-
-## Directory Structure
-
-```
-config/
-├── agent-chat/
-│   └── SYSTEM.md              # Agent chat system prompt (supports {{skills}}, {{datetime}})
-├── code-chat/
-│   └── SYSTEM.md              # Code workspace system prompt
-├── agent-job/
-│   ├── SOUL.md                # Agent personality/identity (used by Docker agent)
-│   ├── AGENT_JOB.md           # Agent runtime environment docs (used by Docker agent)
-│   └── SUMMARY.md             # Prompt for summarizing completed jobs
-├── cluster/
-│   ├── SYSTEM.md              # Cluster worker system prompt
-│   └── ROLE.md                # Per-role prompt template for cluster workers
-├── HEARTBEAT.md               # Self-monitoring behavior (cron task prompt)
-├── CRONS.json                 # Scheduled job definitions
-└── TRIGGERS.json              # Webhook trigger definitions
-```
-
-## Markdown File Includes
-
-Markdown files in `config/` support includes and built-in variables, powered by `lib/utils/render-md.js`.
-
-- **File includes**: `{{ filepath.md }}` — resolves relative to project root, recursive with circular detection. Missing files are left as-is.
-- **`{{datetime}}`** — Current ISO timestamp.
-- **`{{skills}}`** — Dynamic bullet list of active skill descriptions from `skills/active/*/SKILL.md` frontmatter. Never hardcode skill names — this is resolved at runtime.
+# config/ — Next.js Config Wrapper
 
 ## Next.js Config Wrapper (index.js)
 

package/config/instrumentation.js

@@ -70,7 +70,7 @@ export async function register() {
   const { startClusterRuntime } = await import('../lib/cluster/runtime.js');
   startClusterRuntime();
 
-  // Start internal maintenance cron (cleanup expired agent job keys, etc.)
+  // Start internal maintenance cron (cleanup orphaned agent job keys, etc.)
   const { startMaintenanceCron } = await import('../lib/maintenance.js');
   startMaintenanceCron();
 

package/lib/CLAUDE.md

@@ -12,16 +12,16 @@ If the task needs to *think*, use `agent`. If it just needs to *do*, use `comman
 
 **Agent**: Creates a Docker Agent job via `createAgentJob()`. Pushes an `agent-job/*` branch and launches a local Docker container. The `job` string is the LLM task prompt. Agent backend selected via `agent_backend` in `agent-job.config.json`.
 
-**Command**: Runs a shell command on the event handler. Working directory: `cron/` for crons, `triggers/` for triggers.
+**Command**: Runs a shell command on the event handler. Working directory: project root.
 
 **Webhook**: Makes an HTTP request. `GET` skips the body; `POST` (default) sends `{ ...vars }` or `{ ...vars, data: <payload> }`.
 
 ## Cron Jobs
 
-Defined in `config/CRONS.json`, loaded by `lib/cron.js` at startup via `node-cron`. Each entry has `name`, `schedule` (cron expression), `type` (`agent`/`command`/`webhook`), and the corresponding action fields (`job`, `command`, or `url`/`method`/`headers`/`vars`). Set `enabled: false` to disable. Agent-type entries support optional `llm_provider` and `llm_model` fields to override the default LLM (passed to Docker agent via `agent-job.config.json`).
+Defined in `agent-job/CRONS.json`, loaded by `lib/cron.js` at startup via `node-cron`. Each entry has `name`, `schedule` (cron expression), `type` (`agent`/`command`/`webhook`), and the corresponding action fields (`job`, `command`, or `url`/`method`/`headers`/`vars`). Set `enabled: false` to disable. Agent-type entries support optional `llm_provider` and `llm_model` fields to override the default LLM (passed to Docker agent via `agent-job.config.json`).
 
 ## Webhook Triggers
 
-Defined in `config/TRIGGERS.json`, loaded by `lib/triggers.js`. Each trigger watches an endpoint path (`watch_path`) and fires an array of actions (fire-and-forget, after auth, before route handler). Actions use the same `type`/`job`/`command`/`url` fields as cron jobs, including optional `llm_provider`/`llm_model` overrides.
+Defined in `event-handler/TRIGGERS.json`, loaded by `lib/triggers.js`. Each trigger watches an endpoint path (`watch_path`) and fires an array of actions (fire-and-forget, after auth, before route handler). Actions use the same `type`/`job`/`command`/`url` fields as cron jobs, including optional `llm_provider`/`llm_model` overrides.
 
 Template tokens in `job` and `command` strings: `{{body}}`, `{{body.field}}`, `{{query}}`, `{{query.field}}`, `{{headers}}`, `{{headers.field}}`.

package/lib/ai/CLAUDE.md

@@ -5,12 +5,12 @@
 Two agent singletons, both using `createReactAgent` from `@langchain/langgraph/prebuilt` with `SqliteSaver` for conversation memory:
 
 **Agent Chat** — singleton via `getAgentChat()`:
-- System prompt: `config/agent-chat/SYSTEM.md` (rendered fresh each invocation via `render_md()`)
+- System prompt: `event-handler/agent-chat/SYSTEM.md` (rendered fresh each invocation via `render_md()`)
 - Tools: `agent_job`, `coding_agent`
 - Call `resetAgentChats()` to clear both singletons (required if hot-reloading)
 
 **Code Chat** — singleton via `getCodeChat()`:
-- System prompt: `config/code-chat/SYSTEM.md` (rendered fresh each invocation)
+- System prompt: `event-handler/code-chat/SYSTEM.md` (rendered fresh each invocation)
 - Tools: `coding_agent` (reads repo/branch/workspace from `runtime.configurable`)
 
 ## Adding a New Tool
@@ -73,7 +73,28 @@ Three-layer parser for Claude Code agents running in headless Docker containers:
 3. **Event mapper** (`mapLine()`) — Converts each line to chat events:
    - `assistant` messages: `text` blocks → `{ type: 'text' }`, `tool_use` blocks → `{ type: 'tool-call' }`
    - `user` messages: `tool_result` blocks → `{ type: 'tool-result' }` (priority: stdout > string content > array)
-   - `result` messages: → `{ type: 'text', _resultSummary }` (injected into LangGraph memory)
+   - `result` messages: → `{ type: 'text' }` (final summary from the agent)
    - Non-JSON lines (e.g. `NO_CHANGES`, `AGENT_FAILED`): wrapped as plain text events
 
 `parseHeadlessStream(dockerLogStream)` is an async generator consuming `http.IncomingMessage`. `mapLine()` is also reused by `lib/cluster/stream.js` for worker log parsing.
+
+### Tool Return Format
+
+The `coding_agent` tool (in `tools.js`) returns the **full container session** as a flat JSON array. This becomes the ToolMessage in LangGraph's checkpoint, giving the LLM complete context on the current turn. The array contains:
+
+- `{ type: 'meta', codingAgent, backendApi }` — first event, agent identity
+- `{ type: 'text', text }` — agent text output
+- `{ type: 'tool-call', toolCallId, toolName, args }` — agent tool invocations
+- `{ type: 'tool-result', toolCallId, result }` — tool execution results
+- `{ type: 'exit', exitCode }` — last event, container exit status
+
+On error before streaming starts: `[{ type: 'error', message }]`.
+
+### Adding a New Agent Mapper (line-mappers.js)
+
+Each coding agent CLI has its own mapper function (`mapClaudeCodeLine`, `mapPiLine`, `mapGeminiLine`, `mapCodexLine`, `mapOpenCodeLine`, `mapKimiLine`). When adding a new agent:
+
+1. Create `mapXxxLine(parsed)` in `line-mappers.js` that returns an array of `{ type, ... }` events
+2. Register it in `headless-stream.js`: add to imports, re-exports, and the `mapperMap` object
+3. Map the agent's JSON output to three event types: `{ type: 'text', text }`, `{ type: 'tool-call', toolCallId, toolName, args }`, `{ type: 'tool-result', toolCallId, result }`
+4. Return `[{ type: 'skip' }]` for noise events (session init, rate limits, etc.) to suppress them without triggering the unknown fallback

package/lib/ai/agent.js

@@ -3,7 +3,8 @@ import { SystemMessage } from '@langchain/core/messages';
 import { createModel } from './model.js';
 import { agentJobTool, agentChatCodingTool, codeChatCodingTool } from './tools.js';
 import { SqliteSaver } from '@langchain/langgraph-checkpoint-sqlite';
-import { agentJobPlanningMd, codePlanningMd, thepopebotDb } from '../paths.js';
+import path from 'path';
+import { PROJECT_ROOT } from '../paths.js';
 import { render_md } from '../utils/render-md.js';
 
 // Singletons on globalThis to survive Next.js webpack chunk duplication.
@@ -20,13 +21,14 @@ export async function getAgentChat() {
     const model = await createModel();
     const tools = [agentJobTool, agentChatCodingTool];
 
-    const checkpointer = SqliteSaver.fromConnString(thepopebotDb);
+    const dbPath = process.env.DATABASE_PATH || path.join(PROJECT_ROOT, 'data/db/thepopebot.sqlite');
+    const checkpointer = SqliteSaver.fromConnString(dbPath);
 
     globalThis.__popebotAgentChat = createReactAgent({
       llm: model,
       tools,
       checkpointSaver: checkpointer,
-      prompt: (state) => [new SystemMessage(render_md(agentJobPlanningMd)), ...state.messages],
+      prompt: (state) => [new SystemMessage(render_md(path.join(PROJECT_ROOT, 'event-handler/agent-chat/SYSTEM.md'))), ...state.messages],
     });
   }
   return globalThis.__popebotAgentChat;
@@ -41,13 +43,14 @@ export async function getCodeChat() {
     const model = await createModel();
     const tools = [codeChatCodingTool];
 
-    const checkpointer = SqliteSaver.fromConnString(thepopebotDb);
+    const dbPath = process.env.DATABASE_PATH || path.join(PROJECT_ROOT, 'data/db/thepopebot.sqlite');
+    const checkpointer = SqliteSaver.fromConnString(dbPath);
 
     globalThis.__popebotCodeChat = createReactAgent({
       llm: model,
       tools,
       checkpointSaver: checkpointer,
-      prompt: (state) => [new SystemMessage(render_md(codePlanningMd)), ...state.messages],
+      prompt: (state) => [new SystemMessage(render_md(path.join(PROJECT_ROOT, 'event-handler/code-chat/SYSTEM.md'))), ...state.messages],
     });
   }
   return globalThis.__popebotCodeChat;

package/lib/ai/async-channel.js

@@ -0,0 +1,51 @@
+/**
+ * Async push/pull queue. Producer calls push()/done(), consumer uses for-await.
+ */
+export function createChannel() {
+  const queue = [];
+  const waiters = [];
+  let isDone = false;
+
+  return {
+    push(value) {
+      if (waiters.length > 0) waiters.shift()(value);
+      else queue.push(value);
+    },
+    done() {
+      isDone = true;
+      while (waiters.length > 0) waiters.shift()(Symbol.for('done'));
+    },
+    async *[Symbol.asyncIterator]() {
+      while (true) {
+        if (queue.length > 0) {
+          yield queue.shift();
+        } else if (isDone) {
+          return;
+        } else {
+          const value = await new Promise(resolve => waiters.push(resolve));
+          if (value === Symbol.for('done')) return;
+          yield value;
+        }
+      }
+    }
+  };
+}
+
+/**
+ * Merge two async iterables — yields from whichever has data first.
+ * Completes when BOTH are exhausted.
+ */
+export async function* mergeAsyncIterables(iter1, iter2) {
+  const channel = createChannel();
+  let active = 2;
+
+  const consume = async (iter) => {
+    for await (const item of iter) channel.push(item);
+    if (--active === 0) channel.done();
+  };
+
+  consume(iter1);
+  consume(iter2);
+
+  yield* channel;
+}

package/lib/ai/headless-stream.js

@@ -10,6 +10,7 @@ export {
   mapGeminiLine,
   mapCodexLine,
   mapOpenCodeLine,
+  mapKimiLine,
 } from './line-mappers.js';
 
 import {
@@ -19,6 +20,7 @@ import {
   mapGeminiLine,
   mapCodexLine,
   mapOpenCodeLine,
+  mapKimiLine,
 } from './line-mappers.js';
 
 /**
@@ -41,6 +43,7 @@ export async function* parseHeadlessStream(dockerLogStream, codingAgent = 'claud
     'gemini-cli': mapGeminiLine,
     'codex-cli': mapCodexLine,
     'opencode': mapOpenCodeLine,
+    'kimi-cli': mapKimiLine,
   };
   const mapper = mapperMap[codingAgent] || mapClaudeCodeLine;
 

package/lib/ai/index.js

@@ -1,8 +1,10 @@
-import { HumanMessage, AIMessage } from '@langchain/core/messages';
+import { HumanMessage } from '@langchain/core/messages';
+import { createChannel, mergeAsyncIterables } from './async-channel.js';
 import { z } from 'zod';
 import { getAgentChat, getCodeChat } from './agent.js';
 import { createModel } from './model.js';
-import { agentJobSummaryMd } from '../paths.js';
+import path from 'path';
+import { PROJECT_ROOT } from '../paths.js';
 import { render_md } from '../utils/render-md.js';
 import { getChatById, createChat, saveMessage, updateChatTitle, linkChatToWorkspace } from '../db/chats.js';
 
@@ -178,16 +180,21 @@ async function* chatStream(threadId, message, attachments = [], options = {}) {
     }
   }
 
+  // Side channel: bridges the tool's live container output to this generator
+  const sideChannel = createChannel();
+  const streamCallback = (chunk) => {
+    if (chunk === null) sideChannel.done();
+    else sideChannel.push(chunk);
+  };
+
   try {
     const stream = await agent.stream(
       { messages: [new HumanMessage({ content: messageContent })] },
-      { configurable: { thread_id: threadId, workspaceId, repo, branch, codeModeType }, streamMode: 'messages' }
+      { configurable: { thread_id: threadId, workspaceId, repo, branch, codeModeType, streamCallback }, streamMode: 'messages' }
     );
 
-    let fullText = '';
     const toolCallNames = {};
     const pendingToolCalls = new Map();
-    let headlessContainer = null;
 
     // Accumulate raw tool call arg fragments across streaming chunks.
     // Each AIMessageChunk only carries its own delta — the first chunk
@@ -195,202 +202,170 @@ async function* chatStream(threadId, message, attachments = [], options = {}) {
     // chunks (input_json_delta) have only index with the partial JSON delta.
     const toolCallRawArgs = {};     // tool_call_id → accumulated args string
     const indexToToolCallId = {};   // chunk index → tool_call_id
+    const toolCallArgsEmitted = new Set(); // tool_call_ids whose complete args have been yielded
+
+    // Headless container streaming state
+    const headlessPendingToolCalls = new Map();
+    let pendingText = '';       // channel text, flushed to DB at tool boundaries
+    let llmTextAccum = '';      // langgraph text (direct response or LLM follow-up after container)
+
+    // Tag helper so mergeAsyncIterables can tell the two sources apart.
+    // The LangGraph wrapper also closes sideChannel when the agent stream
+    // finishes — this prevents a deadlock when no tool calls streamCallback.
+    async function* tagged(iter, source) {
+      for await (const item of iter) yield { _src: source, item };
+      if (source === 'lg') sideChannel.done();
+    }
 
-    for await (const event of stream) {
-      // streamMode: 'messages' yields [message, metadata] tuples
-      const msg = Array.isArray(event) ? event[0] : event;
-      const msgType = msg._getType?.();
-
-      if (msgType === 'ai') {
-        // Tool calls — AIMessage.tool_calls is an array of { id, name, args }
-        if (msg.tool_calls?.length > 0) {
-          for (const tc of msg.tool_calls) {
-            toolCallNames[tc.id] = tc.name;
-            pendingToolCalls.set(tc.id, { toolName: tc.name, args: tc.args });
-            yield {
-              type: 'tool-call',
-              toolCallId: tc.id,
-              toolName: tc.name,
-              args: tc.args,
-            };
-          }
-        }
-
-        // Accumulate raw tool call arg strings from streaming chunks
-        if (msg.tool_call_chunks?.length > 0) {
-          for (const c of msg.tool_call_chunks) {
-            if (c.id) {
-              indexToToolCallId[c.index] = c.id;
-              toolCallRawArgs[c.id] = (toolCallRawArgs[c.id] || '') + (c.args || '');
-            } else if (c.index != null && indexToToolCallId[c.index]) {
-              const id = indexToToolCallId[c.index];
-              toolCallRawArgs[id] = (toolCallRawArgs[id] || '') + (c.args || '');
+    try {
+      for await (const { _src, item } of mergeAsyncIterables(
+        tagged(stream, 'lg'),
+        tagged(sideChannel, 'ch')
+      )) {
+        if (_src === 'lg') {
+          // ── LangGraph agent stream ────────────────────────────────────────
+          const msg = Array.isArray(item) ? item[0] : item;
+          const msgType = msg._getType?.();
+
+          if (msgType === 'ai') {
+            // Tool calls — AIMessage.tool_calls is an array of { id, name, args }
+            if (msg.tool_calls?.length > 0) {
+              for (const tc of msg.tool_calls) {
+                toolCallNames[tc.id] = tc.name;
+                pendingToolCalls.set(tc.id, { toolName: tc.name, args: tc.args });
+                yield {
+                  type: 'tool-call',
+                  toolCallId: tc.id,
+                  toolName: tc.name,
+                  args: tc.args,
+                };
+              }
             }
-          }
-        }
-
-        // Text content (wrapped in structured object)
-        let text = '';
-        if (typeof msg.content === 'string') {
-          text = msg.content;
-        } else if (Array.isArray(msg.content)) {
-          text = msg.content
-            .filter((b) => b.type === 'text' && b.text)
-            .map((b) => b.text)
-            .join('');
-        }
 
-        if (text) {
-          fullText += text;
-          yield { type: 'text', text };
-        }
-      } else if (msgType === 'tool') {
-        // Parse complete args from accumulated raw fragments
-        const tc = pendingToolCalls.get(msg.tool_call_id);
-        const rawArgs = toolCallRawArgs[msg.tool_call_id];
-        let completeArgs;
-        try { completeArgs = rawArgs ? JSON.parse(rawArgs) : {}; } catch { completeArgs = {}; }
-
-        // Tool result — ToolMessage has tool_call_id and content
-        yield {
-          type: 'tool-result',
-          toolCallId: msg.tool_call_id,
-          toolName: tc?.toolName,
-          args: completeArgs,
-          result: msg.content,
-        };
-
-        // Save complete tool invocation as JSON
-        if (tc) {
-          persistMessage(threadId, 'assistant', JSON.stringify({
-            type: 'tool-invocation',
-            toolCallId: msg.tool_call_id,
-            toolName: tc.toolName,
-            state: 'output-available',
-            input: completeArgs,
-            output: msg.content,
-          }), options);
-          pendingToolCalls.delete(msg.tool_call_id);
-        }
+            // Accumulate raw tool call arg strings from streaming chunks
+            if (msg.tool_call_chunks?.length > 0) {
+              for (const c of msg.tool_call_chunks) {
+                if (c.id) {
+                  indexToToolCallId[c.index] = c.id;
+                  toolCallRawArgs[c.id] = (toolCallRawArgs[c.id] || '') + (c.args || '');
+                } else if (c.index != null && indexToToolCallId[c.index]) {
+                  const id = indexToToolCallId[c.index];
+                  toolCallRawArgs[id] = (toolCallRawArgs[id] || '') + (c.args || '');
+                }
+              }
+              // Re-yield tool-call with complete args once the JSON is fully streamed
+              for (const c of msg.tool_call_chunks) {
+                const id = c.id || indexToToolCallId[c.index];
+                if (id && toolCallRawArgs[id] && !toolCallArgsEmitted.has(id)) {
+                  try {
+                    const parsed = JSON.parse(toolCallRawArgs[id]);
+                    toolCallArgsEmitted.add(id);
+                    const tc = pendingToolCalls.get(id);
+                    if (tc) {
+                      tc.args = parsed;
+                      yield { type: 'tool-call', toolCallId: id, toolName: tc.toolName, args: parsed };
+                    }
+                  } catch {} // args not complete yet, keep accumulating
+                }
+              }
+            }
 
-        // Detect headless container tool result for Phase 2 streaming
-        const headlessToolName = toolCallNames[msg.tool_call_id];
-        if (headlessToolName === 'coding_agent') {
-          try {
-            const parsed = JSON.parse(msg.content);
-            if (parsed.status === 'started' && parsed.containerName) {
-              headlessContainer = { ...parsed, toolName: headlessToolName };
+            // Text content (wrapped in structured object)
+            let text = '';
+            if (typeof msg.content === 'string') {
+              text = msg.content;
+            } else if (Array.isArray(msg.content)) {
+              text = msg.content
+                .filter((b) => b.type === 'text' && b.text)
+                .map((b) => b.text)
+                .join('');
             }
-          } catch {}
-        }
-      }
-      // Skip other message types (human, system)
-    }
 
-    // Save assistant response to DB (defer if headless streaming follows)
-    if (fullText && !headlessContainer) {
-      persistMessage(threadId, 'assistant', fullText, options);
-    }
+            if (text) {
+              llmTextAccum += text;
+              yield { type: 'text', text };
+            }
+          } else if (msgType === 'tool') {
+            // Parse complete args from accumulated raw fragments
+            const tc = pendingToolCalls.get(msg.tool_call_id);
+            const rawArgs = toolCallRawArgs[msg.tool_call_id];
+            let completeArgs;
+            try { completeArgs = rawArgs ? JSON.parse(rawArgs) : {}; } catch { completeArgs = {}; }
+
+            // Tool result — ToolMessage has tool_call_id and content
+            yield {
+              type: 'tool-result',
+              toolCallId: msg.tool_call_id,
+              toolName: tc?.toolName,
+              args: completeArgs,
+              result: msg.content,
+            };
 
-    // Phase 2: Stream headless container output live
-    if (headlessContainer) {
-      try {
-        const { tailContainerLogs, waitForContainer, removeContainer } =
-          await import('../tools/docker.js');
-        const { parseHeadlessStream } = await import('./headless-stream.js');
-
-        const logStream = await tailContainerLogs(headlessContainer.containerName);
-
-        // Collect conversation parts during streaming, add to memory in one batch at the end
-        let resultSummary = '';
-        const memoryParts = [];
-        const headlessPendingToolCalls = new Map();
-        let pendingText = '';
-
-        let lastEmittedText = '';
-        for await (const chunk of parseHeadlessStream(logStream, headlessContainer.codingAgent)) {
-          // Result summary: skip if duplicate, otherwise ensure it starts on a new line
-          if (chunk._resultSummary && chunk.type === 'text') {
-            resultSummary = chunk._resultSummary;
-            if (pendingText.trim() && chunk.text.trim() === pendingText.trim()) {
-              continue;
+            // Save complete tool invocation as JSON
+            if (tc) {
+              persistMessage(threadId, 'assistant', JSON.stringify({
+                type: 'tool-invocation',
+                toolCallId: msg.tool_call_id,
+                toolName: tc.toolName,
+                state: 'output-available',
+                input: completeArgs,
+                output: msg.content,
+              }), options);
+              pendingToolCalls.delete(msg.tool_call_id);
             }
-            chunk = { ...chunk, text: '\n\n' + chunk.text };
           }
-          yield chunk;
+          // Skip other message types (human, system)
+
+        } else {
+          // ── Side channel: headless container chunks ───────────────────────
+          const chunk = item;
+
           if (chunk.type === 'text') {
-            fullText += chunk.text;
-            memoryParts.push(chunk.text);
             pendingText += chunk.text;
+            yield chunk;
           } else if (chunk.type === 'tool-call') {
             // Flush accumulated text before tool call
             if (pendingText) {
               persistMessage(threadId, 'assistant', pendingText, options);
               pendingText = '';
             }
-            memoryParts.push('[tool-call] ' + chunk.toolName + ': ' + JSON.stringify(chunk.args));
             headlessPendingToolCalls.set(chunk.toolCallId, { toolName: chunk.toolName, args: chunk.args });
+            yield chunk;
           } else if (chunk.type === 'tool-result') {
-            memoryParts.push('[tool-result] ' + chunk.result);
-            const tc = headlessPendingToolCalls.get(chunk.toolCallId);
-            if (tc) {
+            // Enrich with args from matching tool-call (required by api.js tool-input-available update)
+            const htc = headlessPendingToolCalls.get(chunk.toolCallId);
+            const enriched = htc ? { ...chunk, args: htc.args, toolName: htc.toolName } : chunk;
+            yield enriched;
+            if (htc) {
               persistMessage(threadId, 'assistant', JSON.stringify({
                 type: 'tool-invocation',
                 toolCallId: chunk.toolCallId,
-                toolName: tc.toolName,
+                toolName: htc.toolName,
                 state: 'output-available',
-                input: tc.args,
+                input: htc.args,
                 output: chunk.result,
               }), options);
               headlessPendingToolCalls.delete(chunk.toolCallId);
             }
+          } else {
+            // unknown/meta events pass through unchanged
+            yield chunk;
           }
-          if (chunk._resultSummary) resultSummary = chunk._resultSummary;
-        }
-
-        // Flush remaining accumulated text
-        if (pendingText) {
-          persistMessage(threadId, 'assistant', pendingText, options);
-          pendingText = '';
-        }
-
-        // Container has exited by now (tailContainerLogs follows until EOF)
-        const exitCode = await waitForContainer(headlessContainer.containerName);
-        await removeContainer(headlessContainer.containerName);
-
-        if (exitCode === 0) {
-          const completionMsg = codeModeType === 'plan'
-            ? '\n\nPlanning complete.'
-            : '\n\nCoding complete.';
-          yield { type: 'text', text: completionMsg };
-          fullText += completionMsg;
-          persistMessage(threadId, 'assistant', completionMsg, options);
-        } else {
-          const failureMsg = '\n\nTask exited with errors.';
-          yield { type: 'text', text: failureMsg };
-          fullText += failureMsg;
-          persistMessage(threadId, 'assistant', failureMsg, options);
         }
+      }
+    } finally {
+      // Ensure no dangling promise when tool was never called
+      sideChannel.done();
+    }
 
-        // Inject full conversation into LangGraph memory using the correct agent
-        if (memoryParts.length > 0) {
-          await agent.updateState(
-            { configurable: { thread_id: threadId } },
-            { messages: [new AIMessage(memoryParts.join('\n'))] }
-          );
-        }
-        // Also inject the summary separately for concise follow-up context
-        if (resultSummary) {
-          await agent.updateState(
-            { configurable: { thread_id: threadId } },
-            { messages: [new AIMessage(resultSummary)] }
-          );
-        }
+    // Flush remaining channel text
+    if (pendingText) {
+      persistMessage(threadId, 'assistant', pendingText, options);
+    }
 
-      } catch (err) {
-        console.error('[chatStream] headless stream error:', err);
-        yield { type: 'text', text: '\n\nError streaming headless output: ' + err.message };
-      }
+    // Persist LLM text (direct response with no tool, or LLM follow-up after container)
+    if (llmTextAccum) {
+      persistMessage(threadId, 'assistant', llmTextAccum, options);
     }
 
   } catch (err) {
@@ -410,7 +385,7 @@ async function autoTitle(threadId, firstMessage) {
 
     const model = await createModel({ maxTokens: 250 });
     const response = await model.withStructuredOutput(z.object({ title: z.string() })).invoke([
-      ['system', 'Generate a descriptive (8-12 word) title for this chat based on the user\'s first message.'],
+      ['system', 'Title this chat in 2-5 words. Name the subject matter only. Never start with "User". Never describe what the user is doing — just the topic. Always produce a title, even for vague messages — infer the likely topic.'],
       ['human', firstMessage],
     ]);
     if (response.title.trim()) {
@@ -434,10 +409,11 @@ async function autoTitle(threadId, firstMessage) {
 async function summarizeAgentJob(results) {
   try {
     const model = await createModel({ maxTokens: 1024 });
-    const systemPrompt = render_md(agentJobSummaryMd);
+    const summaryMdPath = path.join(PROJECT_ROOT, 'event-handler/SUMMARY.md');
+    const systemPrompt = render_md(summaryMdPath);
 
     if (!systemPrompt) {
-      console.error(`[summarizeAgentJob] Empty system prompt — agent-job/SUMMARY.md not found or empty at: ${agentJobSummaryMd}`);
+      console.error(`[summarizeAgentJob] Empty system prompt — event-handler/SUMMARY.md not found or empty at: ${summaryMdPath}`);
     }
 
     const userMessage = [