@wipcomputer/wip-ldm-os 0.4.12 → 0.4.15

package/SKILL.md

@@ -5,7 +5,7 @@ license: MIT
 interface: [cli, skill]
 metadata:
   display-name: "LDM OS"
-  version: "0.4.12"
+  version: "0.4.15"
   homepage: "https://github.com/wipcomputer/wip-ldm-os"
   author: "Parker Todd Brooks"
   category: infrastructure

package/bin/ldm.js

@@ -314,6 +314,28 @@ async function cmdInit() {
     }
   }
 
+  // Deploy process monitor (#75)
+  const monitorSrc = join(__dirname, '..', 'bin', 'process-monitor.sh');
+  const monitorDest = join(LDM_ROOT, 'bin', 'process-monitor.sh');
+  if (existsSync(monitorSrc)) {
+    mkdirSync(join(LDM_ROOT, 'bin'), { recursive: true });
+    cpSync(monitorSrc, monitorDest);
+    chmodSync(monitorDest, 0o755);
+    // Add cron entry if not already there
+    try {
+      const crontab = execSync('crontab -l 2>/dev/null', { encoding: 'utf8' });
+      if (!crontab.includes('process-monitor')) {
+        execSync(`(crontab -l 2>/dev/null; echo "*/3 * * * * ${monitorDest}") | crontab -`);
+        console.log(`  + process monitor installed (every 3 min, kills zombie processes)`);
+      }
+    } catch {
+      try {
+        execSync(`echo "*/3 * * * * ${monitorDest}" | crontab -`);
+        console.log(`  + process monitor installed (every 3 min)`);
+      } catch {}
+    }
+  }
+
   console.log('');
   console.log(`  LDM OS v${PKG_VERSION} initialized at ${LDM_ROOT}`);
   console.log('');
@@ -782,6 +804,10 @@ async function cmdInstallCatalog() {
 
   // Update from npm via catalog repos (#55)
   for (const entry of npmUpdates) {
+    if (!entry.catalogRepo) {
+      console.log(`  Skipping ${entry.name}: no catalog repo (install manually with ldm install <org/repo>)`);
+      continue;
+    }
     console.log(`  Updating ${entry.name} v${entry.currentVersion} -> v${entry.latestVersion} (from ${entry.catalogRepo})...`);
     try {
       execSync(`ldm install ${entry.catalogRepo}`, { stdio: 'inherit' });
@@ -1529,6 +1555,66 @@ async function cmdStackInstall() {
   console.log('');
 }
 
+// ── ldm catalog show ──
+
+function cmdCatalogShow() {
+  const subcommand = args[1];
+  const target = args[2];
+
+  if (subcommand === 'show' && target) {
+    const entry = loadCatalog().find(c => c.id === target || c.name.toLowerCase() === target.toLowerCase());
+    if (!entry) {
+      console.error(`  Unknown component: "${target}"`);
+      console.error('  Run: ldm catalog');
+      process.exit(1);
+    }
+
+    console.log('');
+    console.log(`  ${entry.name}`);
+    console.log('  ────────────────────────────────────');
+    console.log(`  ${entry.description}`);
+    console.log('');
+    console.log(`  Status: ${entry.status}`);
+    if (entry.repo) console.log(`  Repo: github.com/${entry.repo}`);
+    if (entry.npm) console.log(`  npm: ${entry.npm}`);
+
+    const inst = entry.installs;
+    if (inst) {
+      console.log('');
+      console.log('  What gets installed:');
+      if (inst.cli) console.log(`    CLI: ${Array.isArray(inst.cli) ? inst.cli.join(', ') : inst.cli}`);
+      if (inst.mcp) console.log(`    MCP tools: ${Array.isArray(inst.mcp) ? inst.mcp.join(', ') : inst.mcp}`);
+      if (inst.ocPlugin) console.log(`    OpenClaw plugin: ${inst.ocPlugin}`);
+      if (inst.ccHook) console.log(`    CC hooks: ${inst.ccHook}`);
+      if (inst.cron) console.log(`    Cron: ${inst.cron}`);
+      if (inst.data) console.log(`    Data: ${inst.data}`);
+      if (inst.tools) console.log(`    Tools: ${inst.tools}`);
+      if (inst.web) console.log(`    Web: ${inst.web}`);
+      if (inst.runtime) console.log(`    Runtime: ${inst.runtime}`);
+      if (inst.plugins) console.log(`    Plugins: ${inst.plugins}`);
+      if (inst.skill) console.log(`    Skill: ${inst.skill}`);
+      if (inst.docs) console.log(`    Docs: ${inst.docs}`);
+      if (inst.note) console.log(`    Note: ${inst.note}`);
+    }
+
+    console.log('');
+    return;
+  }
+
+  // Default: list all catalog items
+  const components = loadCatalog();
+  console.log('');
+  console.log('  Catalog');
+  console.log('  ────────────────────────────────────');
+  for (const c of components) {
+    console.log(`  ${c.id}: ${c.name} (${c.status})`);
+    console.log(`    ${c.description}`);
+    console.log('');
+  }
+  console.log('  Show details: ldm catalog show <name>');
+  console.log('');
+}
+
 // ── Main ──
 
 async function main() {
@@ -1603,6 +1689,9 @@ async function main() {
     case 'stack':
       await cmdStack();
       break;
+    case 'catalog':
+      cmdCatalogShow();
+      break;
     case 'updates':
       await cmdUpdates();
       break;

package/bin/process-monitor.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+# LDM OS Process Monitor
+# Kills zombie npm/ldm processes, cleans stale locks.
+# Run via healthcheck (every 3 min) or standalone cron.
+
+LOG="/tmp/ldm-process-monitor.log"
+KILLED=0
+
+log() { echo "[$(date '+%H:%M:%S')] $1" >> "$LOG"; }
+
+# 1. Kill npm view/list processes older than 30s
+for pid in $(ps -eo pid,etime,args | grep -E "npm (view|list)" | grep -v grep | awk '{
+  split($2, t, /[:-]/);
+  if (length(t) >= 3) secs = t[1]*3600 + t[2]*60 + t[3];
+  else if (length(t) == 2) secs = t[1]*60 + t[2];
+  else secs = t[1];
+  if (secs > 30) print $1
+}'); do
+  kill -9 "$pid" 2>/dev/null && KILLED=$((KILLED + 1))
+done
+
+# 2. Kill orphaned ldm install (parent is init/launchd)
+for pid in $(pgrep -f "ldm install" 2>/dev/null); do
+  ppid=$(ps -p "$pid" -o ppid= 2>/dev/null | tr -d ' ')
+  if [ "$ppid" = "1" ]; then
+    kill -9 "$pid" 2>/dev/null && KILLED=$((KILLED + 1))
+  fi
+done
+
+# 3. Kill npm install null (should never exist)
+for pid in $(pgrep -f "npm install null" 2>/dev/null); do
+  kill -9 "$pid" 2>/dev/null && KILLED=$((KILLED + 1))
+done
+
+# 4. Kill ldm install --version zombies older than 10s
+for pid in $(ps -eo pid,etime,args | grep "ldm install --version" | grep -v grep | awk '{
+  split($2, t, /[:-]/);
+  if (length(t) >= 2) secs = t[1]*60 + t[2];
+  else secs = t[1];
+  if (secs > 10) print $1
+}'); do
+  kill -9 "$pid" 2>/dev/null && KILLED=$((KILLED + 1))
+done
+
+# 5. Clean stale lockfile
+LOCK="$HOME/.ldm/state/.ldm-install.lock"
+if [ -f "$LOCK" ]; then
+  lock_pid=$(python3 -c "import json; print(json.load(open('$LOCK'))['pid'])" 2>/dev/null)
+  if [ -n "$lock_pid" ] && ! kill -0 "$lock_pid" 2>/dev/null; then
+    rm -f "$LOCK"
+    log "Cleaned stale lockfile (PID $lock_pid dead)"
+    KILLED=$((KILLED + 1))
+  fi
+fi
+
+# Log if we killed anything
+if [ "$KILLED" -gt 0 ]; then
+  log "Killed $KILLED zombie process(es)"
+fi
+
+# Alert if node count is high
+NODE_COUNT=$(pgrep -fl node 2>/dev/null | wc -l | tr -d ' ')
+if [ "$NODE_COUNT" -gt 150 ]; then
+  log "WARNING: $NODE_COUNT node processes running"
+fi

package/catalog.json

@@ -37,7 +37,15 @@
       "cliMatches": ["crystal"],
       "recommended": true,
       "status": "stable",
-      "postInstall": "crystal doctor"
+      "postInstall": "crystal doctor",
+      "installs": {
+        "cli": ["crystal"],
+        "mcp": ["crystal_search", "crystal_remember", "crystal_forget"],
+        "ocPlugin": "agent_end hook (conversation capture every turn)",
+        "ccHook": "Stop hook (crystal capture + daily log)",
+        "cron": "crystal-capture.sh (every 1 min, backup capture)",
+        "data": "~/.ldm/memory/crystal.db (shared vector DB)"
+      }
     },
     {
       "id": "wip-ai-devops-toolbox",
@@ -49,7 +57,13 @@
       "cliMatches": ["wip-release", "wip-repos", "wip-file-guard", "wip-install"],
       "recommended": false,
       "status": "stable",
-      "postInstall": null
+      "postInstall": null,
+      "installs": {
+        "cli": ["wip-release", "wip-repos", "wip-file-guard", "wip-install"],
+        "mcp": ["wip-release", "wip-repos", "wip-license-hook", "wip-repo-permissions-hook"],
+        "ccHook": "branch-guard (blocks writes on main), file-guard (protects identity files), repo-permissions (workspace boundaries)",
+        "tools": "12 sub-tools: release, repos, file-guard, license-hook, license-guard, repo-permissions-hook, deploy-public, post-merge-rename, repo-init, readme-format, branch-guard, universal-installer"
+      }
     },
     {
       "id": "wip-1password",
@@ -61,7 +75,11 @@
       "cliMatches": [],
       "recommended": false,
       "status": "stable",
-      "postInstall": null
+      "postInstall": null,
+      "installs": {
+        "mcp": ["op_list_items", "op_read_secret", "op_test"],
+        "ocPlugin": "op-secrets (headless 1Password via service account)"
+      }
     },
     {
       "id": "wip-markdown-viewer",
@@ -73,7 +91,11 @@
       "cliMatches": ["mdview"],
       "recommended": false,
       "status": "stable",
-      "postInstall": null
+      "postInstall": null,
+      "installs": {
+        "cli": ["mdview"],
+        "web": "localhost:3000 (live reload markdown renderer)"
+      }
     },
     {
       "id": "wip-xai-grok",
@@ -85,7 +107,10 @@
       "cliMatches": [],
       "recommended": false,
       "status": "stable",
-      "postInstall": null
+      "postInstall": null,
+      "installs": {
+        "mcp": ["grok_search_web", "grok_search_x", "grok_imagine", "grok_edit_image", "grok_generate_video", "grok_poll_video"]
+      }
     },
     {
       "id": "wip-xai-x",
@@ -97,7 +122,10 @@
       "cliMatches": [],
       "recommended": false,
       "status": "stable",
-      "postInstall": null
+      "postInstall": null,
+      "installs": {
+        "mcp": ["x_fetch_post", "x_search_recent", "x_get_bookmarks", "x_get_user", "x_post_tweet", "x_delete_tweet", "x_upload_media"]
+      }
     },
     {
       "id": "openclaw",
@@ -109,7 +137,12 @@
       "cliMatches": ["openclaw"],
       "recommended": false,
       "status": "stable",
-      "postInstall": null
+      "postInstall": null,
+      "installs": {
+        "cli": ["openclaw"],
+        "runtime": "24/7 agent gateway on localhost:18789",
+        "plugins": "Extensions system at ~/.openclaw/extensions/"
+      }
     },
     {
       "id": "dream-weaver-protocol",
@@ -121,19 +154,28 @@
       "cliMatches": [],
       "recommended": false,
       "status": "stable",
-      "postInstall": null
+      "postInstall": null,
+      "installs": {
+        "skill": "SKILL.md (protocol documentation for agents)",
+        "docs": "19-page paper on memory consolidation. No runtime components."
+      }
     },
     {
       "id": "wip-bridge",
       "name": "Bridge",
       "description": "Cross-platform agent bridge. Enables Claude Code CLI to talk to OpenClaw CLI without a human in the middle.",
       "npm": null,
-      "repo": "wipcomputer/wip-bridge",
+      "repo": "wipcomputer/wip-bridge-deprecated",
       "registryMatches": ["wip-bridge", "lesa-bridge"],
       "cliMatches": [],
       "recommended": false,
-      "status": "stable",
-      "postInstall": null
+      "status": "included",
+      "postInstall": null,
+      "installs": {
+        "note": "Included with LDM OS v0.3.0+. No separate install needed.",
+        "mcp": ["lesa_send_message", "lesa_check_inbox", "lesa_conversation_search", "lesa_memory_search", "lesa_read_workspace", "oc_skills_list"],
+        "cli": ["lesa"]
+      }
     }
   ]
 }

package/dist/bridge/chunk-LT4KM3AD.js

@@ -0,0 +1,423 @@
+// core.ts
+import { execSync, exec } from "child_process";
+import { readdirSync, readFileSync, existsSync, statSync } from "fs";
+import { join, relative, resolve } from "path";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var HOME = process.env.HOME || "/Users/lesa";
+var LDM_ROOT = process.env.LDM_ROOT || join(HOME, ".ldm");
+function resolveConfig(overrides) {
+  const openclawDir = overrides?.openclawDir || process.env.OPENCLAW_DIR || join(process.env.HOME || "~", ".openclaw");
+  return {
+    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
+  };
+}
+function resolveConfigMulti(overrides) {
+  const ldmConfig = join(LDM_ROOT, "config.json");
+  if (existsSync(ldmConfig)) {
+    try {
+      const raw = JSON.parse(readFileSync(ldmConfig, "utf-8"));
+      const openclawDir = raw.openclawDir || process.env.OPENCLAW_DIR || join(HOME, ".openclaw");
+      return {
+        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
+      };
+    } catch {
+    }
+  }
+  return resolveConfig(overrides);
+}
+var cachedApiKey = void 0;
+function resolveApiKey(openclawDir) {
+  if (cachedApiKey !== void 0) return cachedApiKey;
+  if (process.env.OPENAI_API_KEY) {
+    cachedApiKey = process.env.OPENAI_API_KEY;
+    return cachedApiKey;
+  }
+  const tokenPath = join(openclawDir, "secrets", "op-sa-token");
+  if (existsSync(tokenPath)) {
+    try {
+      const saToken = readFileSync(tokenPath, "utf-8").trim();
+      const key = execSync(
+        `op read "op://Agent Secrets/OpenAI API/api key" 2>/dev/null`,
+        {
+          env: { ...process.env, OP_SERVICE_ACCOUNT_TOKEN: saToken },
+          timeout: 1e4,
+          encoding: "utf-8"
+        }
+      ).trim();
+      if (key && key.startsWith("sk-")) {
+        cachedApiKey = key;
+        return cachedApiKey;
+      }
+    } catch {
+    }
+  }
+  cachedApiKey = null;
+  return null;
+}
+var cachedGatewayConfig = null;
+function resolveGatewayConfig(openclawDir) {
+  if (cachedGatewayConfig) return cachedGatewayConfig;
+  const configPath = join(openclawDir, "openclaw.json");
+  if (!existsSync(configPath)) {
+    throw new Error(`OpenClaw config not found: ${configPath}`);
+  }
+  const config = JSON.parse(readFileSync(configPath, "utf-8"));
+  const token = config?.gateway?.auth?.token;
+  const port = config?.gateway?.port || 18789;
+  if (!token) {
+    throw new Error("No gateway.auth.token found in openclaw.json");
+  }
+  cachedGatewayConfig = { token, port };
+  return cachedGatewayConfig;
+}
+var inboxQueue = [];
+function pushInbox(msg) {
+  inboxQueue.push(msg);
+  return inboxQueue.length;
+}
+function drainInbox() {
+  const messages = [...inboxQueue];
+  inboxQueue.length = 0;
+  return messages;
+}
+function inboxCount() {
+  return inboxQueue.length;
+}
+async function sendMessage(openclawDir, message, options) {
+  const { token, port } = resolveGatewayConfig(openclawDir);
+  const agentId = options?.agentId || "main";
+  const senderLabel = options?.senderLabel || "Claude Code";
+  const response = await fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: agentId,
+      user: "main",
+      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();
+  const reply = data.choices?.[0]?.message?.content;
+  if (!reply) {
+    throw new Error("No response content from gateway");
+  }
+  return reply;
+}
+async function getQueryEmbedding(text, apiKey, model = "text-embedding-3-small", dimensions = 1536) {
+  const response = await fetch("https://api.openai.com/v1/embeddings", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      input: [text],
+      model,
+      dimensions
+    })
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`OpenAI embeddings failed (${response.status}): ${body}`);
+  }
+  const data = await response.json();
+  return data.data[0].embedding;
+}
+function blobToEmbedding(blob) {
+  const floats = [];
+  for (let i = 0; i < blob.length; i += 4) {
+    floats.push(blob.readFloatLE(i));
+  }
+  return floats;
+}
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+function recencyWeight(ageDays) {
+  return Math.max(0.5, 1 - ageDays * 0.01);
+}
+function freshnessLabel(ageDays) {
+  if (ageDays < 3) return "fresh";
+  if (ageDays < 7) return "recent";
+  if (ageDays < 14) return "aging";
+  return "stale";
+}
+async function searchConversations(config, query, limit = 5) {
+  const Database = (await import("better-sqlite3")).default;
+  if (!existsSync(config.dbPath)) {
+    throw new Error(`Database not found: ${config.dbPath}`);
+  }
+  const db = new Database(config.dbPath, { readonly: true });
+  db.pragma("journal_mode = WAL");
+  try {
+    const apiKey = resolveApiKey(config.openclawDir);
+    if (apiKey) {
+      const queryEmbedding = await getQueryEmbedding(
+        query,
+        apiKey,
+        config.embeddingModel,
+        config.embeddingDimensions
+      );
+      const rows = db.prepare(
+        `SELECT chunk_text, role, session_key, timestamp, embedding
+           FROM conversation_chunks
+           WHERE embedding IS NOT NULL
+           ORDER BY timestamp DESC
+           LIMIT 1000`
+      ).all();
+      const now = Date.now();
+      return rows.map((row) => {
+        const cosine = cosineSimilarity(queryEmbedding, blobToEmbedding(row.embedding));
+        const ageDays = (now - row.timestamp) / (1e3 * 60 * 60 * 24);
+        const weight = recencyWeight(ageDays);
+        return {
+          text: row.chunk_text,
+          role: row.role,
+          sessionKey: row.session_key,
+          date: new Date(row.timestamp).toISOString().split("T")[0],
+          similarity: cosine * weight,
+          recencyScore: weight,
+          freshness: freshnessLabel(ageDays)
+        };
+      }).sort((a, b) => (b.similarity || 0) - (a.similarity || 0)).slice(0, limit);
+    } else {
+      const rows = db.prepare(
+        `SELECT chunk_text, role, session_key, timestamp
+           FROM conversation_chunks
+           WHERE chunk_text LIKE ?
+           ORDER BY timestamp DESC
+           LIMIT ?`
+      ).all(`%${query}%`, limit);
+      return rows.map((row) => ({
+        text: row.chunk_text,
+        role: row.role,
+        sessionKey: row.session_key,
+        date: new Date(row.timestamp).toISOString().split("T")[0]
+      }));
+    }
+  } finally {
+    db.close();
+  }
+}
+function findMarkdownFiles(dir, maxDepth = 4, depth = 0) {
+  if (depth > maxDepth || !existsSync(dir)) return [];
+  const files = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...findMarkdownFiles(fullPath, maxDepth, depth + 1));
+    } else if (entry.name.endsWith(".md")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function searchWorkspace(workspaceDir, query) {
+  const files = findMarkdownFiles(workspaceDir);
+  const queryLower = query.toLowerCase();
+  const words = queryLower.split(/\s+/).filter((w) => w.length > 2);
+  const results = [];
+  for (const filePath of files) {
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const contentLower = content.toLowerCase();
+      let score = 0;
+      for (const word of words) {
+        if (contentLower.indexOf(word) !== -1) score++;
+      }
+      if (score === 0) continue;
+      const lines = content.split("\n");
+      const excerpts = [];
+      for (let i = 0; i < lines.length && excerpts.length < 5; i++) {
+        const lineLower = lines[i].toLowerCase();
+        if (words.some((w) => lineLower.includes(w))) {
+          const start = Math.max(0, i - 1);
+          const end = Math.min(lines.length, i + 2);
+          excerpts.push(lines.slice(start, end).join("\n"));
+        }
+      }
+      results.push({ path: relative(workspaceDir, filePath), excerpts, score });
+    } catch {
+    }
+  }
+  return results.sort((a, b) => b.score - a.score).slice(0, 10);
+}
+function parseSkillFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const yaml = match[1];
+  const name = yaml.match(/^name:\s*(.+)$/m)?.[1]?.trim();
+  const description = yaml.match(/^description:\s*(.+)$/m)?.[1]?.trim();
+  let emoji;
+  const emojiMatch = yaml.match(/"emoji":\s*"([^"]+)"/);
+  if (emojiMatch) emoji = emojiMatch[1];
+  let requires;
+  const requiresMatch = yaml.match(/"requires":\s*\{([^}]+)\}/);
+  if (requiresMatch) {
+    requires = {};
+    const pairs = requiresMatch[1].matchAll(/"(\w+)":\s*\[([^\]]*)\]/g);
+    for (const pair of pairs) {
+      const values = pair[2].match(/"([^"]+)"/g)?.map((v) => v.replace(/"/g, "")) || [];
+      requires[pair[1]] = values;
+    }
+  }
+  return { name, description, emoji, requires };
+}
+function discoverSkills(openclawDir) {
+  const skills = [];
+  const seen = /* @__PURE__ */ new Set();
+  const extensionsDir = join(openclawDir, "extensions");
+  if (!existsSync(extensionsDir)) return skills;
+  for (const ext of readdirSync(extensionsDir, { withFileTypes: true })) {
+    if (!ext.isDirectory() || ext.name.startsWith(".")) continue;
+    const extDir = join(extensionsDir, ext.name);
+    const searchDirs = [
+      { dir: join(extDir, "node_modules", "openclaw", "skills"), source: "builtin" },
+      { dir: join(extDir, "skills"), source: "custom" }
+    ];
+    for (const { dir, source } of searchDirs) {
+      if (!existsSync(dir)) continue;
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+        const skillDir = join(dir, entry.name);
+        const skillMd = join(skillDir, "SKILL.md");
+        if (!existsSync(skillMd)) continue;
+        if (seen.has(entry.name)) continue;
+        seen.add(entry.name);
+        try {
+          const content = readFileSync(skillMd, "utf-8");
+          const frontmatter = parseSkillFrontmatter(content);
+          const scriptsDir = join(skillDir, "scripts");
+          let scripts = [];
+          let hasScripts = false;
+          if (existsSync(scriptsDir) && statSync(scriptsDir).isDirectory()) {
+            scripts = readdirSync(scriptsDir).filter(
+              (f) => f.endsWith(".sh") || f.endsWith(".py")
+            );
+            hasScripts = scripts.length > 0;
+          }
+          skills.push({
+            name: frontmatter.name || entry.name,
+            description: frontmatter.description || `OpenClaw skill: ${entry.name}`,
+            skillDir,
+            hasScripts,
+            scripts,
+            source,
+            emoji: frontmatter.emoji,
+            requires: frontmatter.requires
+          });
+        } catch {
+        }
+      }
+    }
+  }
+  return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function executeSkillScript(skillDir, scripts, scriptName, args) {
+  const scriptsDir = join(skillDir, "scripts");
+  let script;
+  if (scriptName) {
+    if (!scripts.includes(scriptName)) {
+      throw new Error(`Script "${scriptName}" not found. Available: ${scripts.join(", ")}`);
+    }
+    script = scriptName;
+  } else if (scripts.length === 1) {
+    script = scripts[0];
+  } else {
+    const sh = scripts.find((s) => s.endsWith(".sh"));
+    script = sh || scripts[0];
+  }
+  const scriptPath = join(scriptsDir, script);
+  const interpreter = script.endsWith(".py") ? "python3" : "bash";
+  try {
+    const { stdout, stderr } = await execAsync(
+      `${interpreter} "${scriptPath}" ${args}`,
+      {
+        env: { ...process.env },
+        timeout: 12e4,
+        maxBuffer: 10 * 1024 * 1024
+        // 10MB
+      }
+    );
+    return stdout || stderr || "(no output)";
+  } catch (err) {
+    const output = err.stdout || err.stderr || err.message;
+    throw new Error(`Script failed (exit ${err.code || "?"}): ${output}`);
+  }
+}
+function readWorkspaceFile(workspaceDir, filePath) {
+  const resolved = resolve(workspaceDir, filePath);
+  if (!resolved.startsWith(resolve(workspaceDir))) {
+    throw new Error("Path must be within workspace/");
+  }
+  if (!existsSync(resolved)) {
+    const dir = resolved.endsWith(".md") ? join(resolved, "..") : resolved;
+    if (existsSync(dir) && statSync(dir).isDirectory()) {
+      const files = findMarkdownFiles(dir, 1);
+      const listing = files.map((f) => relative(workspaceDir, f)).join("\n");
+      throw new Error(`File not found: ${filePath}
+
+Available files:
+${listing}`);
+    }
+    throw new Error(`File not found: ${filePath}`);
+  }
+  return {
+    content: readFileSync(resolved, "utf-8"),
+    relativePath: relative(workspaceDir, resolved)
+  };
+}
+
+export {
+  LDM_ROOT,
+  resolveConfig,
+  resolveConfigMulti,
+  resolveApiKey,
+  resolveGatewayConfig,
+  pushInbox,
+  drainInbox,
+  inboxCount,
+  sendMessage,
+  getQueryEmbedding,
+  blobToEmbedding,
+  cosineSimilarity,
+  searchConversations,
+  findMarkdownFiles,
+  searchWorkspace,
+  discoverSkills,
+  executeSkillScript,
+  readWorkspaceFile
+};

package/dist/bridge/cli.js

@@ -8,13 +8,13 @@ import {
   searchConversations,
   searchWorkspace,
   sendMessage
-} from "./chunk-KWGJCDGS.js";
+} from "./chunk-LT4KM3AD.js";
 
 // cli.ts
 import { existsSync, statSync } from "fs";
 var config = resolveConfig();
 function usage() {
-  console.log(`lesa-bridge: Claude Code CLI \u2194 OpenClaw TUI agent bridge
+  console.log(`wip-bridge: Claude Code CLI \u2194 OpenClaw TUI agent bridge
 
 Usage:
   lesa send <message>         Send a message to the OpenClaw agent
@@ -119,7 +119,7 @@ async function main() {
       break;
     }
     case "status": {
-      console.log(`lesa-bridge status`);
+      console.log(`wip-bridge status`);
       console.log(`  OpenClaw dir:  ${config.openclawDir}`);
       console.log(`  Workspace:     ${config.workspaceDir}`);
       console.log(`  Database:      ${config.dbPath}`);
@@ -128,7 +128,7 @@ async function main() {
       break;
     }
     case "diagnose": {
-      console.log("lesa-bridge diagnose\n");
+      console.log("wip-bridge diagnose\n");
       let issues = 0;
       if (existsSync(config.openclawDir)) {
         console.log(`  \u2713 OpenClaw dir exists: ${config.openclawDir}`);

package/dist/bridge/core.js

@@ -17,7 +17,7 @@ import {
   searchConversations,
   searchWorkspace,
   sendMessage
-} from "./chunk-KWGJCDGS.js";
+} from "./chunk-LT4KM3AD.js";
 export {
   LDM_ROOT,
   blobToEmbedding,

package/dist/bridge/mcp-server.js

@@ -9,7 +9,7 @@ import {
   searchConversations,
   searchWorkspace,
   sendMessage
-} from "./chunk-KWGJCDGS.js";
+} from "./chunk-LT4KM3AD.js";
 
 // mcp-server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -59,11 +59,11 @@ function startInboxServer(cfg) {
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
         const queued = pushInbox(msg);
-        console.error(`lesa-bridge inbox: message from ${msg.from}`);
+        console.error(`wip-bridge inbox: message from ${msg.from}`);
         try {
           server.sendLoggingMessage({
             level: "info",
-            logger: "lesa-bridge",
+            logger: "wip-bridge",
             data: `[OpenClaw \u2192 Claude Code] ${msg.from}: ${msg.message}`
           });
         } catch {
@@ -85,14 +85,14 @@ function startInboxServer(cfg) {
     res.end(JSON.stringify({ error: "not found" }));
   });
   httpServer.listen(cfg.inboxPort, "127.0.0.1", () => {
-    console.error(`lesa-bridge inbox listening on 127.0.0.1:${cfg.inboxPort}`);
+    console.error(`wip-bridge inbox listening on 127.0.0.1:${cfg.inboxPort}`);
   });
   httpServer.on("error", (err) => {
-    console.error(`lesa-bridge inbox server error: ${err.message}`);
+    console.error(`wip-bridge inbox server error: ${err.message}`);
   });
 }
 var server = new McpServer({
-  name: "lesa-bridge",
+  name: "wip-bridge",
   version: "0.3.0"
 });
 server.registerTool(
@@ -264,7 +264,7 @@ function registerSkillTools(skills) {
 ${lines.join("\n")}` }] };
     }
   );
-  console.error(`lesa-bridge: registered ${executableSkills.length} skill tools + oc_skills_list (${skills.length} total skills)`);
+  console.error(`wip-bridge: registered ${executableSkills.length} skill tools + oc_skills_list (${skills.length} total skills)`);
 }
 async function main() {
   startInboxServer(config);
@@ -272,11 +272,11 @@ async function main() {
     const skills = discoverSkills(config.openclawDir);
     registerSkillTools(skills);
   } catch (err) {
-    console.error(`lesa-bridge: skill discovery failed: ${err.message}`);
+    console.error(`wip-bridge: skill discovery failed: ${err.message}`);
   }
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error(`lesa-bridge MCP server running (openclaw: ${config.openclawDir})`);
+  console.error(`wip-bridge MCP server running (openclaw: ${config.openclawDir})`);
 }
 main().catch((error) => {
   console.error("Fatal error:", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wipcomputer/wip-ldm-os",
-  "version": "0.4.12",
+  "version": "0.4.15",
   "type": "module",
   "description": "LDM OS: identity, memory, and sovereignty infrastructure for AI agents",
   "main": "src/boot/boot-hook.mjs",

package/src/bridge/core.ts

@@ -185,9 +185,11 @@ export async function sendMessage(
 ): Promise<string> {
   const { token, port } = resolveGatewayConfig(openclawDir);
   const agentId = options?.agentId || "main";
-  const user = options?.user || "claude-code";
   const senderLabel = options?.senderLabel || "Claude Code";
 
+  // 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: {
@@ -196,7 +198,7 @@ export async function sendMessage(
     },
     body: JSON.stringify({
       model: agentId,
-      user,
+      user: "main",
       messages: [
         {
           role: "user",