@wipcomputer/wip-ldm-os 0.4.66 → 0.4.68

package/SKILL.md

@@ -9,7 +9,7 @@ license: MIT
 compatibility: Requires git, npm, node. Node.js 18+.
 metadata:
   display-name: "LDM OS"
-  version: "0.4.66"
+  version: "0.4.68"
   homepage: "https://github.com/wipcomputer/wip-ldm-os"
   author: "Parker Todd Brooks"
   category: infrastructure

package/bin/scaffold.sh

@@ -10,8 +10,11 @@ CC_HOME="${LDM_HOME}/agents/cc"
 SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
 TEMPLATES="${SCRIPT_DIR}/templates/cc"
 
-# Existing soul files
-CC_DOCS="${HOME}/Documents/wipcomputer--mac-mini-01/staff/Parker/Claude Code - Mini/documents"
+# Resolve workspace from LDM config or default
+WORKSPACE=$(python3 -c "import json; print(json.load(open('$HOME/.ldm/config.json')).get('workspace','$HOME/wipcomputerinc'))" 2>/dev/null || echo "$HOME/wipcomputerinc")
+
+# Existing soul files (now under workspace/team/cc-mini/)
+CC_DOCS="${WORKSPACE}/team/cc-mini/documents"
 CC_SOUL="${CC_DOCS}/cc-soul"
 
 echo "=== LDM OS Scaffold ==="

package/dist/bridge/{chunk-5EOEBBUV.js → chunk-LF7EMFBY.js}

@@ -1,9 +1,10 @@
 // core.ts
 import { execSync, exec } from "child_process";
-import { readdirSync, readFileSync, existsSync, statSync } from "fs";
+import { readdirSync, readFileSync, writeFileSync, existsSync, statSync, mkdirSync, renameSync, unlinkSync } from "fs";
 import { join, relative, resolve } from "path";
 import { homedir } from "os";
 import { promisify } from "util";
+import { randomUUID } from "crypto";
 var execAsync = promisify(exec);
 var HOME = process.env.HOME || homedir();
 var LDM_ROOT = process.env.LDM_ROOT || join(HOME, ".ldm");
@@ -82,18 +83,180 @@ function resolveGatewayConfig(openclawDir) {
   cachedGatewayConfig = { token, port };
   return cachedGatewayConfig;
 }
-var inboxQueue = [];
+var MESSAGES_DIR = join(LDM_ROOT, "messages");
+var PROCESSED_DIR = join(MESSAGES_DIR, "_processed");
+var _sessionAgentId = "cc-mini";
+var _sessionName = process.env.LDM_SESSION_NAME || "default";
+function setSessionIdentity(agentId, sessionName) {
+  _sessionAgentId = agentId;
+  _sessionName = sessionName;
+}
+function getSessionIdentity() {
+  return { agentId: _sessionAgentId, sessionName: _sessionName };
+}
+function parseTarget(to) {
+  if (to === "*") return { agent: "*", session: "*" };
+  const colonIdx = to.indexOf(":");
+  if (colonIdx === -1) return { agent: to, session: "default" };
+  return { agent: to.slice(0, colonIdx), session: to.slice(colonIdx + 1) };
+}
+function messageMatchesSession(msgTo, agentId, sessionName) {
+  if (msgTo === "*" || msgTo === "all") return true;
+  const target = parseTarget(msgTo);
+  if (target.agent !== "*" && target.agent !== agentId) return false;
+  if (target.session === "*") return true;
+  return target.session === sessionName;
+}
 function pushInbox(msg) {
-  inboxQueue.push(msg);
-  return inboxQueue.length;
+  try {
+    mkdirSync(MESSAGES_DIR, { recursive: true });
+    const id = randomUUID();
+    const data = {
+      id,
+      type: msg.type || "chat",
+      from: msg.from || "unknown",
+      to: msg.to || `${_sessionAgentId}:${_sessionName}`,
+      body: msg.body || msg.message || "",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      read: false
+    };
+    writeFileSync(join(MESSAGES_DIR, `${id}.json`), JSON.stringify(data, null, 2) + "\n");
+    return inboxCount();
+  } catch {
+    return 0;
+  }
 }
 function drainInbox() {
-  const messages = [...inboxQueue];
-  inboxQueue.length = 0;
-  return messages;
+  try {
+    if (!existsSync(MESSAGES_DIR)) return [];
+    const files = readdirSync(MESSAGES_DIR).filter((f) => f.endsWith(".json"));
+    const messages = [];
+    for (const file of files) {
+      const filePath = join(MESSAGES_DIR, file);
+      try {
+        const data = JSON.parse(readFileSync(filePath, "utf-8"));
+        if (!messageMatchesSession(data.to, _sessionAgentId, _sessionName)) continue;
+        if (!data.body && data.message) data.body = data.message;
+        messages.push(data);
+        try {
+          mkdirSync(PROCESSED_DIR, { recursive: true });
+          renameSync(filePath, join(PROCESSED_DIR, file));
+        } catch {
+          try {
+            unlinkSync(filePath);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    messages.sort((a, b) => (a.timestamp || "").localeCompare(b.timestamp || ""));
+    return messages;
+  } catch {
+    return [];
+  }
 }
 function inboxCount() {
-  return inboxQueue.length;
+  try {
+    if (!existsSync(MESSAGES_DIR)) return 0;
+    const files = readdirSync(MESSAGES_DIR).filter((f) => f.endsWith(".json"));
+    let count = 0;
+    for (const file of files) {
+      try {
+        const data = JSON.parse(readFileSync(join(MESSAGES_DIR, file), "utf-8"));
+        if (messageMatchesSession(data.to, _sessionAgentId, _sessionName)) count++;
+      } catch {
+      }
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+function inboxCountBySession() {
+  const counts = {};
+  try {
+    if (!existsSync(MESSAGES_DIR)) return counts;
+    const files = readdirSync(MESSAGES_DIR).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const data = JSON.parse(readFileSync(join(MESSAGES_DIR, file), "utf-8"));
+        const to = data.to || "unknown";
+        counts[to] = (counts[to] || 0) + 1;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return counts;
+}
+function sendLdmMessage(opts) {
+  try {
+    mkdirSync(MESSAGES_DIR, { recursive: true });
+    const id = randomUUID();
+    const data = {
+      id,
+      type: opts.type || "chat",
+      from: opts.from || `${_sessionAgentId}:${_sessionName}`,
+      to: opts.to,
+      body: opts.body,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      read: false
+    };
+    writeFileSync(join(MESSAGES_DIR, `${id}.json`), JSON.stringify(data, null, 2) + "\n");
+    return id;
+  } catch {
+    return null;
+  }
+}
+var SESSIONS_DIR = join(LDM_ROOT, "sessions");
+function registerBridgeSession() {
+  try {
+    mkdirSync(SESSIONS_DIR, { recursive: true });
+    const fileName = `${_sessionAgentId}--${_sessionName}.json`;
+    const data = {
+      name: _sessionName,
+      agentId: _sessionAgentId,
+      pid: process.pid,
+      startTime: (/* @__PURE__ */ new Date()).toISOString(),
+      cwd: process.cwd(),
+      alive: true
+    };
+    writeFileSync(join(SESSIONS_DIR, fileName), JSON.stringify(data, null, 2) + "\n");
+    return data;
+  } catch {
+    return null;
+  }
+}
+function listActiveSessions(agentFilter) {
+  try {
+    if (!existsSync(SESSIONS_DIR)) return [];
+    const files = readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+    const sessions = [];
+    for (const file of files) {
+      try {
+        const filePath = join(SESSIONS_DIR, file);
+        const data = JSON.parse(readFileSync(filePath, "utf-8"));
+        let alive = false;
+        try {
+          process.kill(data.pid, 0);
+          alive = true;
+        } catch {
+          try {
+            unlinkSync(filePath);
+          } catch {
+          }
+          continue;
+        }
+        if (agentFilter && data.agentId !== agentFilter) continue;
+        sessions.push({ ...data, alive });
+      } catch {
+      }
+    }
+    return sessions;
+  } catch {
+    return [];
+  }
 }
 async function sendMessage(openclawDir, message, options) {
   const { token, port } = resolveGatewayConfig(openclawDir);
@@ -409,9 +572,15 @@ export {
   resolveConfigMulti,
   resolveApiKey,
   resolveGatewayConfig,
+  setSessionIdentity,
+  getSessionIdentity,
   pushInbox,
   drainInbox,
   inboxCount,
+  inboxCountBySession,
+  sendLdmMessage,
+  registerBridgeSession,
+  listActiveSessions,
   sendMessage,
   getQueryEmbedding,
   blobToEmbedding,

package/dist/bridge/cli.js

@@ -8,7 +8,7 @@ import {
   searchConversations,
   searchWorkspace,
   sendMessage
-} from "./chunk-5EOEBBUV.js";
+} from "./chunk-LF7EMFBY.js";
 
 // cli.ts
 import { existsSync, statSync } from "fs";

package/dist/bridge/core.d.ts

@@ -12,9 +12,14 @@ interface GatewayConfig {
     port: number;
 }
 interface InboxMessage {
+    id: string;
+    type: string;
     from: string;
-    message: string;
+    to: string;
+    body: string;
+    message?: string;
     timestamp: string;
+    read: boolean;
 }
 interface ConversationResult {
     text: string;
@@ -39,9 +44,65 @@ declare function resolveConfig(overrides?: Partial<BridgeConfig>): BridgeConfig;
 declare function resolveConfigMulti(overrides?: Partial<BridgeConfig>): BridgeConfig;
 declare function resolveApiKey(openclawDir: string): string | null;
 declare function resolveGatewayConfig(openclawDir: string): GatewayConfig;
-declare function pushInbox(msg: InboxMessage): number;
+declare function setSessionIdentity(agentId: string, sessionName: string): void;
+declare function getSessionIdentity(): {
+    agentId: string;
+    sessionName: string;
+};
+/**
+ * Write a message to the file-based inbox.
+ * Creates a JSON file at ~/.ldm/messages/{uuid}.json.
+ */
+declare function pushInbox(msg: {
+    from: string;
+    message?: string;
+    body?: string;
+    to?: string;
+    type?: string;
+}): number;
+/**
+ * Read and drain all messages for this session from the inbox.
+ * Moves processed messages to ~/.ldm/messages/_processed/.
+ */
 declare function drainInbox(): InboxMessage[];
+/**
+ * Count pending messages for this session without draining.
+ */
 declare function inboxCount(): number;
+/**
+ * Get pending message counts broken down by session.
+ * Used by GET /status to show per-session counts.
+ */
+declare function inboxCountBySession(): Record<string, number>;
+/**
+ * Send a message to another agent or session via the file-based inbox.
+ * Phase 4: Cross-agent messaging. Works for any agent, any session.
+ * This is the file-based path. For OpenClaw agents, use sendMessage() (gateway).
+ */
+declare function sendLdmMessage(opts: {
+    from?: string;
+    to: string;
+    body: string;
+    type?: string;
+}): string | null;
+interface SessionInfo {
+    name: string;
+    agentId: string;
+    pid: number;
+    startTime: string;
+    cwd: string;
+    alive: boolean;
+    meta?: Record<string, unknown>;
+}
+/**
+ * Register this bridge session in ~/.ldm/sessions/.
+ * Uses the agent--session naming convention.
+ */
+declare function registerBridgeSession(): SessionInfo | null;
+/**
+ * List active sessions. Validates PID liveness and cleans stale entries.
+ */
+declare function listActiveSessions(agentFilter?: string): SessionInfo[];
 declare function sendMessage(openclawDir: string, message: string, options?: {
     agentId?: string;
     user?: string;
@@ -71,4 +132,4 @@ declare function discoverSkills(openclawDir: string): SkillInfo[];
 declare function executeSkillScript(skillDir: string, scripts: string[], scriptName: string | undefined, args: string): Promise<string>;
 declare function readWorkspaceFile(workspaceDir: string, filePath: string): WorkspaceFileResult;
 
-export { type BridgeConfig, type ConversationResult, type GatewayConfig, type InboxMessage, LDM_ROOT, type SkillInfo, type WorkspaceFileResult, type WorkspaceSearchResult, blobToEmbedding, cosineSimilarity, discoverSkills, drainInbox, executeSkillScript, findMarkdownFiles, getQueryEmbedding, inboxCount, pushInbox, readWorkspaceFile, resolveApiKey, resolveConfig, resolveConfigMulti, resolveGatewayConfig, searchConversations, searchWorkspace, sendMessage };
+export { type BridgeConfig, type ConversationResult, type GatewayConfig, type InboxMessage, LDM_ROOT, type SessionInfo, type SkillInfo, type WorkspaceFileResult, type WorkspaceSearchResult, blobToEmbedding, cosineSimilarity, discoverSkills, drainInbox, executeSkillScript, findMarkdownFiles, getQueryEmbedding, getSessionIdentity, inboxCount, inboxCountBySession, listActiveSessions, pushInbox, readWorkspaceFile, registerBridgeSession, resolveApiKey, resolveConfig, resolveConfigMulti, resolveGatewayConfig, searchConversations, searchWorkspace, sendLdmMessage, sendMessage, setSessionIdentity };

package/dist/bridge/core.js

@@ -7,17 +7,23 @@ import {
   executeSkillScript,
   findMarkdownFiles,
   getQueryEmbedding,
+  getSessionIdentity,
   inboxCount,
+  inboxCountBySession,
+  listActiveSessions,
   pushInbox,
   readWorkspaceFile,
+  registerBridgeSession,
   resolveApiKey,
   resolveConfig,
   resolveConfigMulti,
   resolveGatewayConfig,
   searchConversations,
   searchWorkspace,
-  sendMessage
-} from "./chunk-5EOEBBUV.js";
+  sendLdmMessage,
+  sendMessage,
+  setSessionIdentity
+} from "./chunk-LF7EMFBY.js";
 export {
   LDM_ROOT,
   blobToEmbedding,
@@ -27,14 +33,20 @@ export {
   executeSkillScript,
   findMarkdownFiles,
   getQueryEmbedding,
+  getSessionIdentity,
   inboxCount,
+  inboxCountBySession,
+  listActiveSessions,
   pushInbox,
   readWorkspaceFile,
+  registerBridgeSession,
   resolveApiKey,
   resolveConfig,
   resolveConfigMulti,
   resolveGatewayConfig,
   searchConversations,
   searchWorkspace,
-  sendMessage
+  sendLdmMessage,
+  sendMessage,
+  setSessionIdentity
 };

package/dist/bridge/mcp-server.js

@@ -2,14 +2,20 @@ import {
   discoverSkills,
   drainInbox,
   executeSkillScript,
+  getSessionIdentity,
   inboxCount,
+  inboxCountBySession,
+  listActiveSessions,
   pushInbox,
   readWorkspaceFile,
+  registerBridgeSession,
   resolveConfig,
   searchConversations,
   searchWorkspace,
-  sendMessage
-} from "./chunk-5EOEBBUV.js";
+  sendLdmMessage,
+  sendMessage,
+  setSessionIdentity
+} from "./chunk-LF7EMFBY.js";
 
 // mcp-server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -17,9 +23,10 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { createServer } from "http";
 import { appendFileSync, mkdirSync } from "fs";
 import { join } from "path";
+import { homedir } from "os";
 import { z } from "zod";
 var config = resolveConfig();
-var METRICS_DIR = join(process.env.HOME || "/Users/lesa", ".openclaw", "memory");
+var METRICS_DIR = join(process.env.HOME || homedir(), ".openclaw", "memory");
 var METRICS_PATH = join(METRICS_DIR, "search-metrics.jsonl");
 function logSearchMetric(tool, query, resultCount) {
   try {
@@ -53,18 +60,20 @@ function startInboxServer(cfg) {
     if (req.method === "POST" && req.url === "/message") {
       try {
         const body = JSON.parse(await readBody(req));
-        const msg = {
+        const { agentId, sessionName } = getSessionIdentity();
+        const queued = pushInbox({
           from: body.from || "agent",
-          message: body.message,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        const queued = pushInbox(msg);
-        console.error(`wip-bridge inbox: message from ${msg.from}`);
+          body: body.body || body.message || "",
+          to: body.to || `${agentId}:${sessionName}`,
+          type: body.type || "chat"
+        });
+        const messageBody = body.body || body.message || "";
+        console.error(`wip-bridge inbox: message from ${body.from || "agent"} to ${body.to || "default"}`);
         try {
           server.sendLoggingMessage({
             level: "info",
             logger: "wip-bridge",
-            data: `[OpenClaw \u2192 Claude Code] ${msg.from}: ${msg.message}`
+            data: `[inbox] ${body.from || "agent"}: ${messageBody}`
           });
         } catch {
         }
@@ -77,8 +86,16 @@ function startInboxServer(cfg) {
       return;
     }
     if (req.method === "GET" && req.url === "/status") {
+      const pending = inboxCount();
+      const bySession = inboxCountBySession();
       res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ ok: true, pending: inboxCount() }));
+      res.end(JSON.stringify({ ok: true, pending, bySession }));
+      return;
+    }
+    if (req.method === "GET" && req.url === "/sessions") {
+      const sessions = listActiveSessions();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, sessions }));
       return;
     }
     res.writeHead(404, { "Content-Type": "application/json" });
@@ -191,7 +208,7 @@ server.registerTool(
 server.registerTool(
   "lesa_check_inbox",
   {
-    description: "Check for pending messages from the OpenClaw agent. The agent can push messages via the inbox HTTP endpoint (POST localhost:18790/message). Call this to see if the agent has sent anything. Returns all pending messages and clears the queue.",
+    description: "Check for pending messages in the file-based inbox (~/.ldm/messages/). Messages can come from OpenClaw agents, other Claude Code sessions, or CLI. Returns all pending messages for this session and marks them as read.",
     inputSchema: {}
   },
   async () => {
@@ -199,13 +216,38 @@ server.registerTool(
     if (messages.length === 0) {
       return { content: [{ type: "text", text: "No pending messages." }] };
     }
-    const text = messages.map((m) => `**${m.from}** (${m.timestamp}):
-${m.message}`).join("\n\n---\n\n");
+    const text = messages.map((m) => `**${m.from}** [${m.type}] (${m.timestamp}):
+${m.body || m.message}`).join("\n\n---\n\n");
     return { content: [{ type: "text", text: `${messages.length} message(s):
 
 ${text}` }] };
   }
 );
+server.registerTool(
+  "ldm_send_message",
+  {
+    description: "Send a message to any agent or session via the file-based inbox (~/.ldm/messages/). Works for agent-to-agent communication. For OpenClaw agents (like Lesa), use lesa_send_message instead (goes through the gateway). This tool writes directly to the shared inbox.\n\nTarget formats:\n  'cc-mini' ... default session\n  'cc-mini:brainstorm' ... named session\n  'cc-mini:*' ... broadcast to all sessions of that agent\n  '*' ... broadcast to all agents",
+    inputSchema: {
+      to: z.string().describe("Target: 'agent', 'agent:session', 'agent:*', or '*'"),
+      message: z.string().describe("Message body"),
+      type: z.string().optional().default("chat").describe("Message type: chat, system, task (default: chat)")
+    }
+  },
+  async ({ to, message, type }) => {
+    const { agentId, sessionName } = getSessionIdentity();
+    const id = sendLdmMessage({
+      from: `${agentId}:${sessionName}`,
+      to,
+      body: message,
+      type
+    });
+    if (id) {
+      return { content: [{ type: "text", text: `Message sent (id: ${id}) to ${to}` }] };
+    } else {
+      return { content: [{ type: "text", text: "Failed to send message." }], isError: true };
+    }
+  }
+);
 function registerSkillTools(skills) {
   const executableSkills = skills.filter((s) => s.hasScripts);
   const toolNameMap = /* @__PURE__ */ new Map();
@@ -267,6 +309,14 @@ ${lines.join("\n")}` }] };
   console.error(`wip-bridge: registered ${executableSkills.length} skill tools + oc_skills_list (${skills.length} total skills)`);
 }
 async function main() {
+  const agentId = process.env.LDM_AGENT_ID || "cc-mini";
+  const sessionName = process.env.LDM_SESSION_NAME || "default";
+  setSessionIdentity(agentId, sessionName);
+  console.error(`wip-bridge: session identity: ${agentId}:${sessionName}`);
+  const session = registerBridgeSession();
+  if (session) {
+    console.error(`wip-bridge: registered session ${agentId}--${sessionName} (pid ${session.pid})`);
+  }
   startInboxServer(config);
   try {
     const skills = discoverSkills(config.openclawDir);

package/lib/deploy.mjs

@@ -12,7 +12,7 @@ import { execSync } from 'node:child_process';
 import {
   existsSync, readFileSync, writeFileSync, copyFileSync, cpSync, mkdirSync,
   lstatSync, readlinkSync, unlinkSync, chmodSync, readdirSync,
-  renameSync, rmSync, statSync,
+  renameSync, rmSync, statSync, symlinkSync,
 } from 'node:fs';
 import { join, basename, resolve, dirname } from 'node:path';
 import { tmpdir } from 'node:os';
@@ -221,6 +221,46 @@ function findExistingInstalls(toolName, pkg, ocPluginConfig) {
   return matches;
 }
 
+// ── Local dependency resolution ──
+// Repos with file: dependencies (e.g. memory-crystal -> dream-weaver-protocol)
+// fail to build in a clone context where the sibling directory doesn't exist.
+// This function resolves those deps from the local LDM installation. No internet needed.
+
+function resolveLocalDeps(repoPath) {
+  const pkg = readJSON(join(repoPath, 'package.json'));
+  if (!pkg) return;
+
+  const allDeps = { ...pkg.dependencies, ...pkg.optionalDependencies };
+  let resolved = 0;
+
+  for (const [name, spec] of Object.entries(allDeps)) {
+    if (typeof spec !== 'string' || !spec.startsWith('file:')) continue;
+
+    // This is a file: dependency that won't resolve in a clone
+    const extDir = join(LDM_EXTENSIONS, name);
+    if (existsSync(extDir)) {
+      const targetModules = join(repoPath, 'node_modules', name);
+      if (!existsSync(targetModules)) {
+        mkdirSync(join(repoPath, 'node_modules'), { recursive: true });
+        // Handle scoped packages (e.g. @scope/name)
+        const scopeDir = dirname(targetModules);
+        if (scopeDir !== join(repoPath, 'node_modules')) {
+          mkdirSync(scopeDir, { recursive: true });
+        }
+        symlinkSync(extDir, targetModules);
+        log(`Linked local dep: ${name} -> ${extDir}`);
+        resolved++;
+      }
+    } else {
+      log(`Dep ${name} not installed at ${extDir}, build may fail for this feature`);
+    }
+  }
+
+  if (resolved > 0) {
+    ok(`Resolved ${resolved} file: dep(s) from local LDM installation`);
+  }
+}
+
 // ── Build step (fix #6) ──
 
 function runBuildIfNeeded(repoPath) {
@@ -228,13 +268,20 @@ function runBuildIfNeeded(repoPath) {
   if (!pkg) return true;
 
   const hasBuildScript = !!pkg.scripts?.build;
-  const hasTsConfig = existsSync(join(repoPath, 'tsconfig.json'));
-  const hasDist = existsSync(join(repoPath, 'dist'));
+  const distDir = join(repoPath, 'dist');
+  const hasPopulatedDist = existsSync(distDir) && readdirSync(distDir).length > 0;
 
-  // Build if: has a build script AND (no dist/ or tsconfig exists implying TS)
-  if (hasBuildScript && (!hasDist || hasTsConfig)) {
+  // Skip build if dist/ already has files (pre-built from npm or GitHub clone).
+  if (hasPopulatedDist) {
+    log(`Skipping build: dist/ already exists with ${readdirSync(distDir).length} files`);
+  } else if (hasBuildScript) {
     log(`Building ${pkg.name || basename(repoPath)}...`);
     try {
+      // Resolve file: deps from local LDM extensions before npm install.
+      // Without this, npm install fails for repos like memory-crystal that
+      // depend on file:../dream-weaver-protocol-private (sibling doesn't exist in clones).
+      resolveLocalDeps(repoPath);
+
       // Install deps first if node_modules is missing
       if (!existsSync(join(repoPath, 'node_modules'))) {
         execSync('npm install', { cwd: repoPath, stdio: 'pipe' });
@@ -1089,4 +1136,4 @@ export function disableExtension(name) {
 
 // ── Exports for ldm CLI ──
 
-export { loadRegistry, saveRegistry, updateRegistry, readJSON, writeJSON, runBuildIfNeeded, CORE_EXTENSIONS };
+export { loadRegistry, saveRegistry, updateRegistry, readJSON, writeJSON, runBuildIfNeeded, resolveLocalDeps, CORE_EXTENSIONS };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wipcomputer/wip-ldm-os",
-  "version": "0.4.66",
+  "version": "0.4.68",
   "type": "module",
   "description": "LDM OS: identity, memory, and sovereignty infrastructure for AI agents",
   "engines": {

package/src/boot/boot-hook.mjs

@@ -101,9 +101,9 @@ function getDefaultConfig() {
     maxTotalLines: 2000,
     steps: {
       sharedContext: { path: '~/.openclaw/workspace/SHARED-CONTEXT.md', label: 'SHARED-CONTEXT.md', stepNumber: 2, critical: true },
-      journals: { dir: '~/Documents/wipcomputer--mac-mini-01/staff/Parker/Claude Code - Mini/documents/journals', label: 'Most Recent Journal (Parker)', stepNumber: 3, maxLines: 80, strategy: 'most-recent' },
+      journals: { dir: '~/.ldm/agents/cc-mini/memory/journals', label: 'Most Recent CC Journal (Legacy)', stepNumber: 3, maxLines: 80, strategy: 'most-recent' },
       workspaceDailyLogs: { dir: '~/.openclaw/workspace/memory', label: 'Workspace Daily Logs', stepNumber: 4, maxLines: 40, strategy: 'daily-logs', days: ['today', 'yesterday'] },
-      fullHistory: { label: 'Full History', stepNumber: 5, reminder: 'Read on cold start: staff/Parker/Claude Code - Mini/documents/cc-full-history.md' },
+      fullHistory: { label: 'Full History', stepNumber: 5, reminder: 'Read on cold start: team/cc-mini/documents/cc-full-history.md' },
       context: { path: '~/.ldm/agents/cc-mini/CONTEXT.md', label: 'CC CONTEXT.md', stepNumber: 6, critical: true },
       soul: { path: '~/.ldm/agents/cc-mini/SOUL.md', label: 'CC SOUL.md', stepNumber: 7 },
       ccJournals: { dir: '~/.ldm/agents/cc-mini/memory/journals', label: 'Most Recent CC Journal', stepNumber: 8, maxLines: 80, strategy: 'most-recent' },
@@ -212,26 +212,53 @@ async function main() {
     }
   }
 
-  // ── Register session (fire-and-forget) ──
+  // ── Register session (fire-and-forget, Phase 2) ──
   try {
     const { registerSession } = await import('../../lib/sessions.mjs');
-    const name = process.env.CLAUDE_SESSION_NAME || basename(input?.cwd || process.cwd()) || `session-${process.pid}`;
+    const agentId = config?.agentId || 'unknown';
+    const sessionName = process.env.LDM_SESSION_NAME || process.env.CLAUDE_SESSION_NAME || basename(input?.cwd || process.cwd()) || 'default';
+    // Register with agent--session naming convention
     registerSession({
-      name,
-      agentId: config?.agentId || 'unknown',
+      name: `${agentId}--${sessionName}`,
+      agentId,
       pid: process.ppid || process.pid,
-      meta: { cwd: input?.cwd },
+      meta: { cwd: input?.cwd, sessionName },
     });
   } catch {}
 
-  // ── Check pending messages ──
+  // ── Check pending messages (Phase 3: boot hook delivery) ──
+  // Scans ~/.ldm/messages/ for messages addressed to this agent.
+  // Supports targeting: "cc-mini", "cc-mini:session", "cc-mini:*", "*", "all".
+  // Does NOT mark as read. The MCP check_inbox tool handles that.
   try {
     const { readMessages } = await import('../../lib/messages.mjs');
-    const sessionName = process.env.CLAUDE_SESSION_NAME || basename(input?.cwd || process.cwd()) || 'unknown';
-    const pending = readMessages(sessionName, { markRead: false });
-    if (pending.length > 0) {
-      const msgLines = pending.map(m => `  [${m.type}] ${m.from}: ${m.body}`).join('\n');
-      sections.push(`== Pending Messages (${pending.length}) ==\n${msgLines}`);
+    const agentId = config?.agentId || 'cc-mini';
+    const sessionName = process.env.LDM_SESSION_NAME || process.env.CLAUDE_SESSION_NAME || basename(input?.cwd || process.cwd()) || 'default';
+
+    // Read messages using the existing lib/messages.mjs.
+    // It filters by exact sessionName or "all" broadcast.
+    // We also need to check for agent-level targeting (e.g. "cc-mini", "cc-mini:*").
+    const directMessages = readMessages(sessionName, { markRead: false });
+    const agentMessages = readMessages(agentId, { markRead: false });
+    const agentSessionMessages = readMessages(`${agentId}:${sessionName}`, { markRead: false });
+    const agentBroadcast = readMessages(`${agentId}:*`, { markRead: false });
+    const globalBroadcast = readMessages('*', { markRead: false });
+
+    // Deduplicate by message ID
+    const seen = new Set();
+    const allPending = [];
+    for (const msg of [...directMessages, ...agentMessages, ...agentSessionMessages, ...agentBroadcast, ...globalBroadcast]) {
+      if (msg.id && seen.has(msg.id)) continue;
+      if (msg.id) seen.add(msg.id);
+      allPending.push(msg);
+    }
+
+    // Sort by timestamp
+    allPending.sort((a, b) => (a.timestamp || '').localeCompare(b.timestamp || ''));
+
+    if (allPending.length > 0) {
+      const msgLines = allPending.map(m => `  [${m.type || 'chat'}] from ${m.from}: ${m.body}`).join('\n');
+      sections.push(`== Pending Messages (${allPending.length}) ==\nYou have ${allPending.length} pending message(s). Use check_inbox to read and acknowledge them.\n${msgLines}`);
     }
   } catch {}
 

package/src/bridge/core.ts

@@ -2,10 +2,11 @@
 // Handles messaging, memory search, and workspace access for OpenClaw agents.
 
 import { execSync, exec } from "node:child_process";
-import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
+import { readdirSync, readFileSync, writeFileSync, existsSync, statSync, mkdirSync, renameSync, unlinkSync } from "node:fs";
 import { join, relative, resolve } from "node:path";
 import { homedir } from "node:os";
 import { promisify } from "node:util";
+import { randomUUID } from "node:crypto";
 
 const execAsync = promisify(exec);
 
@@ -31,9 +32,14 @@ export interface GatewayConfig {
 }
 
 export interface InboxMessage {
+  id: string;
+  type: string;
   from: string;
-  message: string;
+  to: string;
+  body: string;
+  message?: string; // legacy compat: alias for body
   timestamp: string;
+  read: boolean;
 }
 
 export interface ConversationResult {
@@ -158,23 +164,285 @@ export function resolveGatewayConfig(openclawDir: string): GatewayConfig {
   return cachedGatewayConfig;
 }
 
-// ── Inbox ────────────────────────────────────────────────────────────
+// ── Inbox (file-based via ~/.ldm/messages/) ─────────────────────────
+//
+// Phase 1: Replaces the in-memory queue with JSON files on disk.
+// Phase 2: Adds session targeting (agent:session format).
+// Phase 4: Cross-agent delivery to any agent via the same directory.
+//
+// Uses the existing lib/messages.mjs format. Each message is a JSON file
+// at ~/.ldm/messages/{uuid}.json. Read means move to _processed/.
+
+const MESSAGES_DIR = join(LDM_ROOT, "messages");
+const PROCESSED_DIR = join(MESSAGES_DIR, "_processed");
+
+// Session identity for this bridge process.
+// Set via LDM_SESSION_NAME env or defaults to "default".
+let _sessionAgentId = "cc-mini";
+let _sessionName = process.env.LDM_SESSION_NAME || "default";
+
+export function setSessionIdentity(agentId: string, sessionName: string): void {
+  _sessionAgentId = agentId;
+  _sessionName = sessionName;
+}
 
-const inboxQueue: InboxMessage[] = [];
+export function getSessionIdentity(): { agentId: string; sessionName: string } {
+  return { agentId: _sessionAgentId, sessionName: _sessionName };
+}
 
-export function pushInbox(msg: InboxMessage): number {
-  inboxQueue.push(msg);
-  return inboxQueue.length;
+/**
+ * Parse a "to" field into agent and session parts.
+ * Formats: "cc-mini" (default session), "cc-mini:brainstorm" (named),
+ *          "cc-mini:*" (broadcast to all sessions of agent), "*" (all)
+ */
+function parseTarget(to: string): { agent: string; session: string } {
+  if (to === "*") return { agent: "*", session: "*" };
+  const colonIdx = to.indexOf(":");
+  if (colonIdx === -1) return { agent: to, session: "default" };
+  return { agent: to.slice(0, colonIdx), session: to.slice(colonIdx + 1) };
 }
 
+/**
+ * Check if a message's "to" field matches this session.
+ * Matches: exact agent + session, agent broadcast (agent:*),
+ *          global broadcast (*), or agent with default session.
+ */
+function messageMatchesSession(msgTo: string, agentId: string, sessionName: string): boolean {
+  // Global broadcast
+  if (msgTo === "*" || msgTo === "all") return true;
+
+  const target = parseTarget(msgTo);
+
+  // Different agent entirely
+  if (target.agent !== "*" && target.agent !== agentId) return false;
+
+  // Agent broadcast (agent:*)
+  if (target.session === "*") return true;
+
+  // Exact session match
+  return target.session === sessionName;
+}
+
+/**
+ * Write a message to the file-based inbox.
+ * Creates a JSON file at ~/.ldm/messages/{uuid}.json.
+ */
+export function pushInbox(msg: { from: string; message?: string; body?: string; to?: string; type?: string }): number {
+  try {
+    mkdirSync(MESSAGES_DIR, { recursive: true });
+    const id = randomUUID();
+    const data: InboxMessage = {
+      id,
+      type: msg.type || "chat",
+      from: msg.from || "unknown",
+      to: msg.to || `${_sessionAgentId}:${_sessionName}`,
+      body: msg.body || msg.message || "",
+      timestamp: new Date().toISOString(),
+      read: false,
+    };
+    writeFileSync(join(MESSAGES_DIR, `${id}.json`), JSON.stringify(data, null, 2) + "\n");
+
+    // Return count of pending messages for this session
+    return inboxCount();
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Read and drain all messages for this session from the inbox.
+ * Moves processed messages to ~/.ldm/messages/_processed/.
+ */
 export function drainInbox(): InboxMessage[] {
-  const messages = [...inboxQueue];
-  inboxQueue.length = 0;
-  return messages;
+  try {
+    if (!existsSync(MESSAGES_DIR)) return [];
+
+    const files = readdirSync(MESSAGES_DIR).filter(f => f.endsWith(".json"));
+    const messages: InboxMessage[] = [];
+
+    for (const file of files) {
+      const filePath = join(MESSAGES_DIR, file);
+      try {
+        const data = JSON.parse(readFileSync(filePath, "utf-8")) as InboxMessage;
+
+        // Check if this message is addressed to us
+        if (!messageMatchesSession(data.to, _sessionAgentId, _sessionName)) continue;
+
+        // Normalize: ensure body is populated (legacy compat)
+        if (!data.body && data.message) data.body = data.message;
+
+        messages.push(data);
+
+        // Move to processed
+        try {
+          mkdirSync(PROCESSED_DIR, { recursive: true });
+          renameSync(filePath, join(PROCESSED_DIR, file));
+        } catch {
+          // If rename fails, try to delete
+          try { unlinkSync(filePath); } catch {}
+        }
+      } catch {
+        // Skip malformed files
+      }
+    }
+
+    // Sort by timestamp (oldest first)
+    messages.sort((a, b) => (a.timestamp || "").localeCompare(b.timestamp || ""));
+    return messages;
+  } catch {
+    return [];
+  }
 }
 
+/**
+ * Count pending messages for this session without draining.
+ */
 export function inboxCount(): number {
-  return inboxQueue.length;
+  try {
+    if (!existsSync(MESSAGES_DIR)) return 0;
+
+    const files = readdirSync(MESSAGES_DIR).filter(f => f.endsWith(".json"));
+    let count = 0;
+
+    for (const file of files) {
+      try {
+        const data = JSON.parse(readFileSync(join(MESSAGES_DIR, file), "utf-8"));
+        if (messageMatchesSession(data.to, _sessionAgentId, _sessionName)) count++;
+      } catch {
+        // Skip malformed
+      }
+    }
+
+    return count;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Get pending message counts broken down by session.
+ * Used by GET /status to show per-session counts.
+ */
+export function inboxCountBySession(): Record<string, number> {
+  const counts: Record<string, number> = {};
+  try {
+    if (!existsSync(MESSAGES_DIR)) return counts;
+
+    const files = readdirSync(MESSAGES_DIR).filter(f => f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const data = JSON.parse(readFileSync(join(MESSAGES_DIR, file), "utf-8"));
+        const to = data.to || "unknown";
+        counts[to] = (counts[to] || 0) + 1;
+      } catch {}
+    }
+  } catch {}
+  return counts;
+}
+
+/**
+ * Send a message to another agent or session via the file-based inbox.
+ * Phase 4: Cross-agent messaging. Works for any agent, any session.
+ * This is the file-based path. For OpenClaw agents, use sendMessage() (gateway).
+ */
+export function sendLdmMessage(opts: {
+  from?: string;
+  to: string;
+  body: string;
+  type?: string;
+}): string | null {
+  try {
+    mkdirSync(MESSAGES_DIR, { recursive: true });
+    const id = randomUUID();
+    const data: InboxMessage = {
+      id,
+      type: opts.type || "chat",
+      from: opts.from || `${_sessionAgentId}:${_sessionName}`,
+      to: opts.to,
+      body: opts.body,
+      timestamp: new Date().toISOString(),
+      read: false,
+    };
+    writeFileSync(join(MESSAGES_DIR, `${id}.json`), JSON.stringify(data, null, 2) + "\n");
+    return id;
+  } catch {
+    return null;
+  }
+}
+
+// ── Session management (Phase 2) ────────────────────────────────────
+
+const SESSIONS_DIR = join(LDM_ROOT, "sessions");
+
+export interface SessionInfo {
+  name: string;
+  agentId: string;
+  pid: number;
+  startTime: string;
+  cwd: string;
+  alive: boolean;
+  meta?: Record<string, unknown>;
+}
+
+/**
+ * Register this bridge session in ~/.ldm/sessions/.
+ * Uses the agent--session naming convention.
+ */
+export function registerBridgeSession(): SessionInfo | null {
+  try {
+    mkdirSync(SESSIONS_DIR, { recursive: true });
+    const fileName = `${_sessionAgentId}--${_sessionName}.json`;
+    const data: SessionInfo = {
+      name: _sessionName,
+      agentId: _sessionAgentId,
+      pid: process.pid,
+      startTime: new Date().toISOString(),
+      cwd: process.cwd(),
+      alive: true,
+    };
+    writeFileSync(join(SESSIONS_DIR, fileName), JSON.stringify(data, null, 2) + "\n");
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * List active sessions. Validates PID liveness and cleans stale entries.
+ */
+export function listActiveSessions(agentFilter?: string): SessionInfo[] {
+  try {
+    if (!existsSync(SESSIONS_DIR)) return [];
+
+    const files = readdirSync(SESSIONS_DIR).filter(f => f.endsWith(".json"));
+    const sessions: SessionInfo[] = [];
+
+    for (const file of files) {
+      try {
+        const filePath = join(SESSIONS_DIR, file);
+        const data = JSON.parse(readFileSync(filePath, "utf-8")) as SessionInfo;
+
+        // PID liveness check
+        let alive = false;
+        try {
+          process.kill(data.pid, 0);
+          alive = true;
+        } catch {
+          // Dead PID. Clean up.
+          try { unlinkSync(filePath); } catch {}
+          continue;
+        }
+
+        if (agentFilter && data.agentId !== agentFilter) continue;
+
+        sessions.push({ ...data, alive });
+      } catch {}
+    }
+
+    return sessions;
+  } catch {
+    return [];
+  }
 }
 
 // ── Send message to OpenClaw agent ───────────────────────────────────

package/src/bridge/mcp-server.ts

@@ -6,14 +6,21 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { createServer, IncomingMessage, ServerResponse } from "node:http";
 import { appendFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
+import { homedir } from "node:os";
 import { z } from "zod";
 
 import {
   resolveConfig,
   sendMessage,
+  sendLdmMessage,
   drainInbox,
   pushInbox,
   inboxCount,
+  inboxCountBySession,
+  setSessionIdentity,
+  getSessionIdentity,
+  registerBridgeSession,
+  listActiveSessions,
   searchConversations,
   searchWorkspace,
   readWorkspaceFile,
@@ -28,7 +35,7 @@ import {
 
 const config = resolveConfig();
 
-const METRICS_DIR = join(process.env.HOME || '/Users/lesa', '.openclaw', 'memory');
+const METRICS_DIR = join(process.env.HOME || homedir(), '.openclaw', 'memory');
 const METRICS_PATH = join(METRICS_DIR, 'search-metrics.jsonl');
 
 function logSearchMetric(tool: string, query: string, resultCount: number) {
@@ -64,22 +71,27 @@ function startInboxServer(cfg: BridgeConfig): void {
       return;
     }
 
+    // POST /message: Write to file-based inbox (Phase 1 + 2 + 4)
+    // Accepts: { from, message|body, to?, type? }
+    // The "to" field supports: "cc-mini", "cc-mini:brainstorm", "cc-mini:*", "*"
     if (req.method === "POST" && req.url === "/message") {
       try {
         const body = JSON.parse(await readBody(req));
-        const msg: InboxMessage = {
+        const { agentId, sessionName } = getSessionIdentity();
+        const queued = pushInbox({
           from: body.from || "agent",
-          message: body.message,
-          timestamp: new Date().toISOString(),
-        };
-        const queued = pushInbox(msg);
-        console.error(`wip-bridge inbox: message from ${msg.from}`);
+          body: body.body || body.message || "",
+          to: body.to || `${agentId}:${sessionName}`,
+          type: body.type || "chat",
+        });
+        const messageBody = body.body || body.message || "";
+        console.error(`wip-bridge inbox: message from ${body.from || "agent"} to ${body.to || "default"}`);
 
         try {
           server.sendLoggingMessage({
             level: "info",
             logger: "wip-bridge",
-            data: `[OpenClaw → Claude Code] ${msg.from}: ${msg.message}`,
+            data: `[inbox] ${body.from || "agent"}: ${messageBody}`,
           });
         } catch {}
 
@@ -92,9 +104,20 @@ function startInboxServer(cfg: BridgeConfig): void {
       return;
     }
 
+    // GET /status: Pending message counts (Phase 1 + 2)
     if (req.method === "GET" && req.url === "/status") {
+      const pending = inboxCount();
+      const bySession = inboxCountBySession();
       res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ ok: true, pending: inboxCount() }));
+      res.end(JSON.stringify({ ok: true, pending, bySession }));
+      return;
+    }
+
+    // GET /sessions: List active sessions (Phase 2)
+    if (req.method === "GET" && req.url === "/sessions") {
+      const sessions = listActiveSessions();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, sessions }));
       return;
     }
 
@@ -107,6 +130,8 @@ function startInboxServer(cfg: BridgeConfig): void {
   });
 
   httpServer.on("error", (err: Error) => {
+    // Port already bound by another bridge process. That's fine.
+    // This process reads from filesystem directly via check_inbox.
     console.error(`wip-bridge inbox server error: ${err.message}`);
   });
 }
@@ -240,14 +265,14 @@ server.registerTool(
   }
 );
 
-// Tool 5: Check inbox for messages from the OpenClaw agent
+// Tool 5: Check inbox for messages (file-based, Phase 1)
 server.registerTool(
   "lesa_check_inbox",
   {
     description:
-      "Check for pending messages from the OpenClaw agent. The agent can push messages " +
-      "via the inbox HTTP endpoint (POST localhost:18790/message). Call this to see if " +
-      "the agent has sent anything. Returns all pending messages and clears the queue.",
+      "Check for pending messages in the file-based inbox (~/.ldm/messages/). " +
+      "Messages can come from OpenClaw agents, other Claude Code sessions, or CLI. " +
+      "Returns all pending messages for this session and marks them as read.",
     inputSchema: {},
   },
   async () => {
@@ -258,13 +283,49 @@ server.registerTool(
     }
 
     const text = messages
-      .map((m) => `**${m.from}** (${m.timestamp}):\n${m.message}`)
+      .map((m) => `**${m.from}** [${m.type}] (${m.timestamp}):\n${m.body || m.message}`)
       .join("\n\n---\n\n");
 
     return { content: [{ type: "text" as const, text: `${messages.length} message(s):\n\n${text}` }] };
   }
 );
 
+// Tool 6: Send message to any agent via file-based inbox (Phase 4)
+server.registerTool(
+  "ldm_send_message",
+  {
+    description:
+      "Send a message to any agent or session via the file-based inbox (~/.ldm/messages/). " +
+      "Works for agent-to-agent communication. For OpenClaw agents (like Lesa), use lesa_send_message " +
+      "instead (goes through the gateway). This tool writes directly to the shared inbox.\n\n" +
+      "Target formats:\n" +
+      "  'cc-mini' ... default session\n" +
+      "  'cc-mini:brainstorm' ... named session\n" +
+      "  'cc-mini:*' ... broadcast to all sessions of that agent\n" +
+      "  '*' ... broadcast to all agents",
+    inputSchema: {
+      to: z.string().describe("Target: 'agent', 'agent:session', 'agent:*', or '*'"),
+      message: z.string().describe("Message body"),
+      type: z.string().optional().default("chat").describe("Message type: chat, system, task (default: chat)"),
+    },
+  },
+  async ({ to, message, type }) => {
+    const { agentId, sessionName } = getSessionIdentity();
+    const id = sendLdmMessage({
+      from: `${agentId}:${sessionName}`,
+      to,
+      body: message,
+      type,
+    });
+
+    if (id) {
+      return { content: [{ type: "text" as const, text: `Message sent (id: ${id}) to ${to}` }] };
+    } else {
+      return { content: [{ type: "text" as const, text: "Failed to send message." }], isError: true };
+    }
+  }
+);
+
 // ── OpenClaw Skill Bridge ────────────────────────────────────────────
 
 function registerSkillTools(skills: SkillInfo[]): void {
@@ -350,6 +411,18 @@ function registerSkillTools(skills: SkillInfo[]): void {
 // ── Start ────────────────────────────────────────────────────────────
 
 async function main() {
+  // Phase 2: Set session identity from env or defaults
+  const agentId = process.env.LDM_AGENT_ID || "cc-mini";
+  const sessionName = process.env.LDM_SESSION_NAME || "default";
+  setSessionIdentity(agentId, sessionName);
+  console.error(`wip-bridge: session identity: ${agentId}:${sessionName}`);
+
+  // Phase 2: Register session in ~/.ldm/sessions/
+  const session = registerBridgeSession();
+  if (session) {
+    console.error(`wip-bridge: registered session ${agentId}--${sessionName} (pid ${session.pid})`);
+  }
+
   startInboxServer(config);
 
   // Discover and register OpenClaw skills