@wipcomputer/wip-ldm-os 0.4.73-alpha.2 → 0.4.73-alpha.21

package/src/bridge/core.ts

@@ -10,6 +10,31 @@ import { randomUUID } from "node:crypto";
 
 const execAsync = promisify(exec);
 
+// ── Settings ─────────────────────────────────────────────────────────
+// All tunable constants in one place. No magic numbers below this block.
+
+const GATEWAY_HOST = "127.0.0.1";
+const DEFAULT_GATEWAY_PORT = 18_789;         // openclaw.json gateway.port fallback
+const DEFAULT_INBOX_PORT = 18_790;           // env LESA_BRIDGE_INBOX_PORT fallback
+const GATEWAY_TIMEOUT_MS = 120_000;          // max wait for gateway chat response (2 min, agent turns can be long)
+const OP_CLI_TIMEOUT_MS = 10_000;            // max wait for 1Password CLI
+const EMBEDDING_API_URL = "https://api.openai.com/v1/embeddings";
+const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
+const DEFAULT_EMBEDDING_DIMS = 1_536;
+const VECTOR_SEARCH_ROW_LIMIT = 1_000;       // max rows scanned for cosine ranking
+const RECENCY_DECAY_RATE = 0.01;             // per-day decay multiplier
+const RECENCY_FLOOR = 0.5;                   // minimum recency weight
+const FRESHNESS_FRESH_DAYS = 3;
+const FRESHNESS_RECENT_DAYS = 7;
+const FRESHNESS_AGING_DAYS = 14;
+const DEFAULT_SEARCH_LIMIT = 5;              // default results for searchConversations
+const WORKSPACE_MAX_DEPTH = 4;               // findMarkdownFiles recursion limit
+const WORKSPACE_MAX_EXCERPTS = 5;            // max excerpts per file in search
+const WORKSPACE_MAX_RESULTS = 10;            // max files returned from workspace search
+const SKILL_EXEC_TIMEOUT_MS = 120_000;       // max wait for skill script execution
+const SKILL_EXEC_MAX_BUFFER = 10 * 1024 * 1024; // 10 MB stdout/stderr cap
+const MS_PER_DAY = 1_000 * 60 * 60 * 24;
+
 // ── Constants ─────────────────────────────────────────────────────────
 
 const HOME = process.env.HOME || homedir();
@@ -66,9 +91,9 @@ export function resolveConfig(overrides?: Partial<BridgeConfig>): BridgeConfig {
     openclawDir,
     workspaceDir: overrides?.workspaceDir || join(openclawDir, "workspace"),
     dbPath: overrides?.dbPath || join(openclawDir, "memory", "context-embeddings.sqlite"),
-    inboxPort: overrides?.inboxPort || parseInt(process.env.LESA_BRIDGE_INBOX_PORT || "18790", 10),
-    embeddingModel: overrides?.embeddingModel || "text-embedding-3-small",
-    embeddingDimensions: overrides?.embeddingDimensions || 1536,
+    inboxPort: overrides?.inboxPort || parseInt(process.env.LESA_BRIDGE_INBOX_PORT || String(DEFAULT_INBOX_PORT), 10),
+    embeddingModel: overrides?.embeddingModel || DEFAULT_EMBEDDING_MODEL,
+    embeddingDimensions: overrides?.embeddingDimensions || DEFAULT_EMBEDDING_DIMS,
   };
 }
 
@@ -88,9 +113,9 @@ export function resolveConfigMulti(overrides?: Partial<BridgeConfig>): BridgeCon
         openclawDir,
         workspaceDir: raw.workspaceDir || overrides?.workspaceDir || join(openclawDir, "workspace"),
         dbPath: raw.dbPath || overrides?.dbPath || join(openclawDir, "memory", "context-embeddings.sqlite"),
-        inboxPort: raw.inboxPort || overrides?.inboxPort || parseInt(process.env.LESA_BRIDGE_INBOX_PORT || "18790", 10),
-        embeddingModel: raw.embeddingModel || overrides?.embeddingModel || "text-embedding-3-small",
-        embeddingDimensions: raw.embeddingDimensions || overrides?.embeddingDimensions || 1536,
+        inboxPort: raw.inboxPort || overrides?.inboxPort || parseInt(process.env.LESA_BRIDGE_INBOX_PORT || String(DEFAULT_INBOX_PORT), 10),
+        embeddingModel: raw.embeddingModel || overrides?.embeddingModel || DEFAULT_EMBEDDING_MODEL,
+        embeddingDimensions: raw.embeddingDimensions || overrides?.embeddingDimensions || DEFAULT_EMBEDDING_DIMS,
       };
     } catch {
       // LDM config unreadable, fall through to legacy
@@ -123,7 +148,7 @@ export function resolveApiKey(openclawDir: string): string | null {
         `op read "op://Agent Secrets/OpenAI API/api key" 2>/dev/null`,
         {
           env: { ...process.env, OP_SERVICE_ACCOUNT_TOKEN: saToken },
-          timeout: 10000,
+          timeout: OP_CLI_TIMEOUT_MS,
           encoding: "utf-8",
         }
       ).trim();
@@ -154,7 +179,7 @@ export function resolveGatewayConfig(openclawDir: string): GatewayConfig {
 
   const config = JSON.parse(readFileSync(configPath, "utf-8"));
   const token = config?.gateway?.auth?.token;
-  const port = config?.gateway?.port || 18789;
+  const port = config?.gateway?.port || DEFAULT_GATEWAY_PORT;
 
   if (!token) {
     throw new Error("No gateway.auth.token found in openclaw.json");
@@ -450,49 +475,84 @@ export function listActiveSessions(agentFilter?: string): SessionInfo[] {
 export async function sendMessage(
   openclawDir: string,
   message: string,
-  options?: { agentId?: string; user?: string; senderLabel?: string }
+  options?: { agentId?: string; user?: string; senderLabel?: string; fireAndForget?: boolean }
 ): Promise<string> {
   const { token, port } = resolveGatewayConfig(openclawDir);
   const agentId = options?.agentId || "main";
   const senderLabel = options?.senderLabel || "Claude Code";
+  const fireAndForget = options?.fireAndForget ?? false;
 
   // Send user: "main" to route to the main session (agent:main:main).
   // This ensures Parker sees CC's messages in the same stream as iMessage.
   // The OpenClaw gateway treats user: "main" as "use the default session."
-  const response = await fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/json",
-      "x-openclaw-scopes": "operator.read,operator.write",
-      "x-openclaw-session-key": `agent:${agentId}:main`,
-    },
-    body: JSON.stringify({
-      model: `openclaw/${agentId}`,
-      messages: [
-        {
-          role: "user",
-          content: `[${senderLabel}]: ${message}`,
-        },
-      ],
-    }),
+  const requestBody = JSON.stringify({
+    model: `openclaw/${agentId}`,
+    messages: [
+      {
+        role: "user",
+        content: `[${senderLabel}]: ${message}`,
+      },
+    ],
   });
 
-  if (!response.ok) {
-    const body = await response.text();
-    throw new Error(`Gateway returned ${response.status}: ${body}`);
-  }
-
-  const data = (await response.json()) as {
-    choices: Array<{ message: { content: string } }>;
+  const requestHeaders: Record<string, string> = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    "x-openclaw-scopes": "operator.read,operator.write",
+    "x-openclaw-session-key": `agent:${agentId}:main`,
   };
 
-  const reply = data.choices?.[0]?.message?.content;
-  if (!reply) {
-    throw new Error("No response content from gateway");
+  const url = `http://${GATEWAY_HOST}:${port}/v1/chat/completions`;
+
+  // Fire-and-forget: send the request and return immediately.
+  // The message is queued in the gateway. Lēsa processes it when she's ready.
+  // No timeout. No waiting. Like dropping a letter in a mailbox.
+  if (fireAndForget) {
+    fetch(url, {
+      method: "POST",
+      headers: requestHeaders,
+      body: requestBody,
+    }).catch(() => {}); // Ignore errors silently
+    return "Message sent (queued). Response will arrive in the TUI.";
   }
 
-  return reply;
+  // Synchronous: wait for the full response.
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), GATEWAY_TIMEOUT_MS);
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: requestHeaders,
+      body: requestBody,
+      signal: controller.signal,
+    });
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Gateway returned ${response.status}: ${body}`);
+    }
+
+    const data = (await response.json()) as {
+      choices: Array<{ message: { content: string } }>;
+    };
+
+    const reply = data.choices?.[0]?.message?.content;
+    if (!reply) {
+      throw new Error("No response content from gateway");
+    }
+
+    return reply;
+  } catch (err: any) {
+    clearTimeout(timeoutId);
+    if (err.name === "AbortError") {
+      throw new Error(
+        "Gateway timeout: Lesa may be busy or the gateway is processing another request. Try again in a moment."
+      );
+    }
+    throw err;
+  }
 }
 
 // ── Embedding helpers ────────────────────────────────────────────────
@@ -500,10 +560,10 @@ export async function sendMessage(
 export async function getQueryEmbedding(
   text: string,
   apiKey: string,
-  model = "text-embedding-3-small",
-  dimensions = 1536
+  model = DEFAULT_EMBEDDING_MODEL,
+  dimensions = DEFAULT_EMBEDDING_DIMS
 ): Promise<number[]> {
-  const response = await fetch("https://api.openai.com/v1/embeddings", {
+  const response = await fetch(EMBEDDING_API_URL, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${apiKey}`,
@@ -549,15 +609,15 @@ export function cosineSimilarity(a: number[], b: number[]): number {
 // ── Recency scoring ─────────────────────────────────────────────────
 
 function recencyWeight(ageDays: number): number {
-  // Linear decay with floor at 0.5. Old stuff never fully disappears
+  // Linear decay with floor. Old stuff never fully disappears
   // but fresh context wins ties. ~50 days to hit the floor.
-  return Math.max(0.5, 1.0 - ageDays * 0.01);
+  return Math.max(RECENCY_FLOOR, 1.0 - ageDays * RECENCY_DECAY_RATE);
 }
 
 function freshnessLabel(ageDays: number): "fresh" | "recent" | "aging" | "stale" {
-  if (ageDays < 3) return "fresh";
-  if (ageDays < 7) return "recent";
-  if (ageDays < 14) return "aging";
+  if (ageDays < FRESHNESS_FRESH_DAYS) return "fresh";
+  if (ageDays < FRESHNESS_RECENT_DAYS) return "recent";
+  if (ageDays < FRESHNESS_AGING_DAYS) return "aging";
   return "stale";
 }
 
@@ -566,7 +626,7 @@ function freshnessLabel(ageDays: number): "fresh" | "recent" | "aging" | "stale"
 export async function searchConversations(
   config: BridgeConfig,
   query: string,
-  limit = 5
+  limit = DEFAULT_SEARCH_LIMIT
 ): Promise<ConversationResult[]> {
   // Lazy import to avoid requiring better-sqlite3 if not needed
   const Database = (await import("better-sqlite3")).default;
@@ -593,7 +653,7 @@ export async function searchConversations(
            FROM conversation_chunks
            WHERE embedding IS NOT NULL
            ORDER BY timestamp DESC
-           LIMIT 1000`
+           LIMIT ${VECTOR_SEARCH_ROW_LIMIT}`
         )
         .all() as Array<{
         chunk_text: string;
@@ -607,7 +667,7 @@ export async function searchConversations(
       return rows
         .map((row) => {
           const cosine = cosineSimilarity(queryEmbedding, blobToEmbedding(row.embedding));
-          const ageDays = (now - row.timestamp) / (1000 * 60 * 60 * 24);
+          const ageDays = (now - row.timestamp) / MS_PER_DAY;
           const weight = recencyWeight(ageDays);
           return {
             text: row.chunk_text,
@@ -652,7 +712,7 @@ export async function searchConversations(
 
 // ── Workspace search ─────────────────────────────────────────────────
 
-export function findMarkdownFiles(dir: string, maxDepth = 4, depth = 0): string[] {
+export function findMarkdownFiles(dir: string, maxDepth = WORKSPACE_MAX_DEPTH, depth = 0): string[] {
   if (depth > maxDepth || !existsSync(dir)) return [];
 
   const files: string[] = [];
@@ -687,7 +747,7 @@ export function searchWorkspace(workspaceDir: string, query: string): WorkspaceS
 
       const lines = content.split("\n");
       const excerpts: string[] = [];
-      for (let i = 0; i < lines.length && excerpts.length < 5; i++) {
+      for (let i = 0; i < lines.length && excerpts.length < WORKSPACE_MAX_EXCERPTS; i++) {
         const lineLower = lines[i].toLowerCase();
         if (words.some((w) => lineLower.includes(w))) {
           const start = Math.max(0, i - 1);
@@ -702,7 +762,7 @@ export function searchWorkspace(workspaceDir: string, query: string): WorkspaceS
     }
   }
 
-  return results.sort((a, b) => b.score - a.score).slice(0, 10);
+  return results.sort((a, b) => b.score - a.score).slice(0, WORKSPACE_MAX_RESULTS);
 }
 
 // ── Read workspace file ──────────────────────────────────────────────
@@ -858,8 +918,8 @@ export async function executeSkillScript(
       `${interpreter} "${scriptPath}" ${args}`,
       {
         env: { ...process.env },
-        timeout: 120000,
-        maxBuffer: 10 * 1024 * 1024, // 10MB
+        timeout: SKILL_EXEC_TIMEOUT_MS,
+        maxBuffer: SKILL_EXEC_MAX_BUFFER,
       }
     );
     return stdout || stderr || "(no output)";

package/src/bridge/mcp-server.ts

@@ -4,7 +4,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createServer, IncomingMessage, ServerResponse } from "node:http";
-import { appendFileSync, mkdirSync } from "node:fs";
+import { appendFileSync, mkdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { z } from "zod";
@@ -242,7 +242,18 @@ server.registerTool(
   }
 );
 
-// Tool 4: Send a message to the OpenClaw agent
+// Tool 4: Send a message to the OpenClaw agent (async, non-blocking)
+//
+// Sends via fire-and-forget to the gateway so CC is not blocked waiting for
+// the reply. The message hits Lēsa's full pipeline (visible in Parker's TUI).
+// Lēsa's reply arrives in the file inbox (~/.ldm/messages/) which CC picks up
+// via the UserPromptSubmit hook or check_inbox tool.
+//
+// Also writes the outbound message to the file inbox as a "sent" record so
+// there's a complete file trail of both sides of the conversation.
+//
+// Changed 2026-04-06: was synchronous (blocked up to 120s). Now async.
+// See ai/product/bugs/bridge/2026-04-06--cc-mini--bridge-async-inbox-plan.md
 server.registerTool(
   "lesa_send_message",
   {
@@ -250,15 +261,35 @@ server.registerTool(
       "Send a message to the OpenClaw agent through the gateway. Routes through the agent's " +
       "full pipeline: memory, tools, personality, workspace. Use this for direct communication: " +
       "asking questions, sharing findings, coordinating work, or having a discussion. " +
-      "Messages are prefixed with [Claude Code] so the agent knows the source.",
+      "Messages are prefixed with [Claude Code] so the agent knows the source.\n\n" +
+      "This is async: returns immediately after sending. The agent's reply will arrive in " +
+      "your inbox (check via lesa_check_inbox or it appears automatically on your next turn).",
     inputSchema: {
       message: z.string().describe("Message to send to the OpenClaw agent"),
     },
   },
   async ({ message }) => {
     try {
-      const reply = await sendMessage(config.openclawDir, message);
-      return { content: [{ type: "text" as const, text: reply }] };
+      // 1. Fire-and-forget to gateway (Lēsa sees it in TUI, Parker sees it)
+      await sendMessage(config.openclawDir, message, { fireAndForget: true });
+
+      // 2. Write outbound record to file inbox so the conversation trail is complete
+      const { agentId, sessionName } = getSessionIdentity();
+      sendLdmMessage({
+        from: `${agentId}:${sessionName}`,
+        to: "lesa",
+        body: message,
+        type: "chat",
+      });
+
+      return {
+        content: [{
+          type: "text" as const,
+          text: `Sent to Lēsa: "${message}"\n\nMessage delivered to the gateway (fire-and-forget). ` +
+            `Lēsa will process it through her full pipeline. Her reply will arrive in your inbox. ` +
+            `Use lesa_check_inbox to check, or it will appear automatically on your next turn.`,
+        }],
+      };
     } catch (err: any) {
       return { content: [{ type: "text" as const, text: `Error sending message: ${err.message}` }], isError: true };
     }
@@ -410,12 +441,50 @@ function registerSkillTools(skills: SkillInfo[]): void {
 
 // ── Start ────────────────────────────────────────────────────────────
 
+/**
+ * Resolve session name from Claude Code's session metadata.
+ *
+ * CC writes session files to ~/.claude/sessions/<pid>.json with the
+ * /rename label as the "name" field. The bridge MCP server is a child
+ * process of CC, so process.ppid gives the CC PID. Reading the parent's
+ * session file gives us the label automatically, no env var needed.
+ *
+ * Fallback chain: CC session file -> LDM_SESSION_NAME env -> "default"
+ */
+function resolveSessionName(): string {
+  // 1. Try CC session file for parent PID
+  try {
+    const ccSessionPath = join(
+      process.env.HOME || homedir(),
+      ".claude",
+      "sessions",
+      `${process.ppid}.json`
+    );
+    const data = JSON.parse(readFileSync(ccSessionPath, "utf-8"));
+    if (data.name && typeof data.name === "string") {
+      return data.name;
+    }
+  } catch {
+    // No session file for parent PID. Normal for non-CC harnesses.
+  }
+
+  // 2. Try env var (explicit override)
+  if (process.env.LDM_SESSION_NAME) {
+    return process.env.LDM_SESSION_NAME;
+  }
+
+  // 3. Default
+  return "default";
+}
+
 async function main() {
-  // Phase 2: Set session identity from env or defaults
+  // Set session identity: auto-detect from CC session metadata, env, or default
   const agentId = process.env.LDM_AGENT_ID || "cc-mini";
-  const sessionName = process.env.LDM_SESSION_NAME || "default";
+  const sessionName = resolveSessionName();
   setSessionIdentity(agentId, sessionName);
-  console.error(`wip-bridge: session identity: ${agentId}:${sessionName}`);
+  console.error(`wip-bridge: session identity: ${agentId}:${sessionName} (resolved from ${
+    sessionName !== "default" ? "CC session file or env" : "default"
+  })`);
 
   // Phase 2: Register session in ~/.ldm/sessions/
   const session = registerBridgeSession();

package/src/bridge/openclaw.ts

@@ -0,0 +1,14 @@
+// openclaw.ts ... Bridge plugin entry point.
+// Skill-only plugin: all functionality lives in skills/ and the MCP server
+// (mcp-server.js) which is launched out-of-process. No tools, CLI, or HTTP
+// routes are registered with the OpenClaw runtime.
+//
+// This file exists only so OpenClaw's plugin loader can discover the plugin
+// when package.json declares `openclaw.extensions: ["./dist/openclaw.js"]`.
+// Without it, gateway startup logs a "plugin not found" warning.
+
+export default {
+  register(api: any) {
+    api.logger.info('lesa-bridge plugin registered (skill-only; MCP server runs out of process)');
+  },
+};

package/src/hooks/inbox-check-hook.mjs

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+/**
+ * LDM OS Inbox Check Hook
+ * UserPromptSubmit hook for Claude Code.
+ * Scans ~/.ldm/messages/ for pending messages addressed to this agent
+ * and surfaces them as additionalContext before CC responds.
+ *
+ * Follows guard.mjs pattern: stdin JSON in, stdout JSON out, exit 0 always.
+ * Does NOT mark messages as read... that's what lesa_check_inbox does.
+ * Zero external dependencies beyond node:fs and node:path.
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
+
+const HOME = homedir();
+const MESSAGES_DIR = join(HOME, '.ldm', 'messages');
+const LDM_CONFIG_PATH = join(HOME, '.ldm', 'config.json');
+const TAG = '[inbox-check-hook]';
+
+// ── Helpers ──
+
+function readJSON(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function getAgentId() {
+  // Try LDM config first
+  const config = readJSON(LDM_CONFIG_PATH);
+  if (config?.agents) {
+    // Find the agent entry for this machine's claude-code harness
+    for (const [id, agent] of Object.entries(config.agents)) {
+      if (agent.harness === 'claude-code') return id;
+    }
+  }
+  return 'cc-mini';
+}
+
+function getSessionName(input) {
+  return (
+    process.env.LDM_SESSION_NAME ||
+    process.env.CLAUDE_SESSION_NAME ||
+    basename(input?.cwd || process.cwd()) ||
+    'default'
+  );
+}
+
+/**
+ * Check if a message's "to" field matches this agent.
+ * Supported targets:
+ *   - exact agent ID (e.g. "cc-mini")
+ *   - agent:session (e.g. "cc-mini:my-session")
+ *   - agent:* (e.g. "cc-mini:*" ... all sessions of this agent)
+ *   - "*" or "all" ... broadcast to everyone
+ *   - exact session name match
+ */
+function messageMatchesAgent(to, agentId, sessionName) {
+  if (!to) return false;
+
+  // Broadcast targets
+  if (to === '*' || to === 'all') return true;
+
+  // Exact agent ID
+  if (to === agentId) return true;
+
+  // Agent wildcard: "cc-mini:*"
+  if (to === `${agentId}:*`) return true;
+
+  // Agent + specific session: "cc-mini:my-session"
+  if (to === `${agentId}:${sessionName}`) return true;
+
+  // Direct session name match
+  if (to === sessionName) return true;
+
+  return false;
+}
+
+// ── Main ──
+
+async function main() {
+  let raw = '';
+  for await (const chunk of process.stdin) raw += chunk;
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    // Bad input... exit clean with no context
+    process.stdout.write(JSON.stringify({}));
+    process.exit(0);
+  }
+
+  // Fast exit if messages dir doesn't exist
+  if (!existsSync(MESSAGES_DIR)) {
+    process.stdout.write(JSON.stringify({}));
+    process.exit(0);
+  }
+
+  const agentId = getAgentId();
+  const sessionName = getSessionName(input);
+
+  // Scan for pending messages
+  let files;
+  try {
+    files = readdirSync(MESSAGES_DIR).filter(f => f.endsWith('.json'));
+  } catch {
+    process.stdout.write(JSON.stringify({}));
+    process.exit(0);
+  }
+
+  // Fast exit if no message files
+  if (files.length === 0) {
+    process.stdout.write(JSON.stringify({}));
+    process.exit(0);
+  }
+
+  const pending = [];
+  const seen = new Set();
+
+  for (const file of files) {
+    const data = readJSON(join(MESSAGES_DIR, file));
+    if (!data) continue;
+
+    // Skip already-read messages (if the field exists)
+    if (data.read === true) continue;
+
+    // Check if addressed to us
+    if (!messageMatchesAgent(data.to, agentId, sessionName)) continue;
+
+    // Deduplicate by message ID
+    if (data.id && seen.has(data.id)) continue;
+    if (data.id) seen.add(data.id);
+
+    pending.push(data);
+  }
+
+  // Fast exit if nothing pending
+  if (pending.length === 0) {
+    process.stdout.write(JSON.stringify({}));
+    process.exit(0);
+  }
+
+  // Sort by timestamp (oldest first)
+  pending.sort((a, b) => (a.timestamp || '').localeCompare(b.timestamp || ''));
+
+  // Format output
+  const msgLines = pending
+    .map(m => `[${m.type || 'chat'}] from ${m.from || 'unknown'} (${m.timestamp || 'no timestamp'}):\n  ${m.body || '(empty)'}`)
+    .join('\n\n');
+
+  const additionalContext =
+    `== Pending Messages (${pending.length}) ==\n` +
+    `You have ${pending.length} unread message(s). Review them and respond if needed. Use lesa_check_inbox to mark as read when done.\n\n` +
+    msgLines;
+
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: 'UserPromptSubmit',
+      additionalContext,
+    },
+  };
+
+  process.stdout.write(JSON.stringify(output));
+  process.stderr.write(`${TAG} ${pending.length} pending message(s) for ${agentId}:${sessionName}\n`);
+  process.exit(0);
+}
+
+main().catch(() => {
+  process.stdout.write(JSON.stringify({}));
+  process.exit(0);
+});