@wipcomputer/wip-ldm-os 0.4.37 → 0.4.39

package/SKILL.md

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

package/bin/ldm.js

@@ -261,9 +261,42 @@ async function cmdInit() {
     join(LDM_ROOT, 'messages'),
     join(LDM_ROOT, 'shared', 'boot'),
     join(LDM_ROOT, 'shared', 'cron'),
+    join(LDM_ROOT, 'shared', 'rules'),
+    join(LDM_ROOT, 'shared', 'prompts'),
     join(LDM_ROOT, 'hooks'),
   ];
 
+  // Scaffold per-agent memory dirs
+  try {
+    const config = JSON.parse(readFileSync(join(LDM_ROOT, 'config.json'), 'utf8'));
+    const agents = config.agents || [];
+    const agentList = Array.isArray(agents) ? agents : Object.keys(agents);
+    for (const agentId of agentList) {
+      for (const sub of ['memory/daily', 'memory/journals', 'memory/sessions', 'memory/transcripts']) {
+        dirs.push(join(LDM_ROOT, 'agents', agentId, sub));
+      }
+    }
+
+    // Scaffold workspace output dirs if workspace is configured
+    const workspace = config.workspace;
+    if (workspace && existsSync(workspace)) {
+      // Per-agent workspace dirs
+      const agentNameMap = { 'cc-mini': 'cc-mini', 'cc-air': 'cc-air', 'oc-lesa-mini': 'Lēsa' };
+      for (const agentId of agentList) {
+        const teamName = agentNameMap[agentId] || agentId;
+        for (const sub of ['journals', 'automated/memory/summaries/daily', 'automated/memory/summaries/weekly', 'automated/memory/summaries/monthly', 'automated/memory/summaries/quarterly']) {
+          dirs.push(join(workspace, 'team', teamName, sub));
+        }
+      }
+      // Org-wide dirs
+      for (const track of ['team', 'dev']) {
+        for (const cadence of ['daily', 'weekly', 'monthly', 'quarterly']) {
+          dirs.push(join(workspace, 'operations', 'updates', track, cadence));
+        }
+      }
+    }
+  } catch {} // config.json may not exist on first init
+
   const existing = existsSync(VERSION_PATH);
 
   if (DRY_RUN) {
@@ -363,6 +396,87 @@ async function cmdInit() {
     }
   }
 
+  // Deploy backup + restore scripts (#119)
+  const backupSrc = join(__dirname, '..', 'scripts', 'ldm-backup.sh');
+  const backupDest = join(LDM_ROOT, 'bin', 'ldm-backup.sh');
+  if (existsSync(backupSrc)) {
+    mkdirSync(join(LDM_ROOT, 'bin'), { recursive: true });
+    cpSync(backupSrc, backupDest);
+    chmodSync(backupDest, 0o755);
+    console.log(`  + ldm-backup.sh deployed to ~/.ldm/bin/`);
+  }
+  const restoreSrc = join(__dirname, '..', 'scripts', 'ldm-restore.sh');
+  const restoreDest = join(LDM_ROOT, 'bin', 'ldm-restore.sh');
+  if (existsSync(restoreSrc)) {
+    cpSync(restoreSrc, restoreDest);
+    chmodSync(restoreDest, 0o755);
+    console.log(`  + ldm-restore.sh deployed to ~/.ldm/bin/`);
+  }
+  const summarySrc = join(__dirname, '..', 'scripts', 'ldm-summary.sh');
+  const summaryDest = join(LDM_ROOT, 'bin', 'ldm-summary.sh');
+  if (existsSync(summarySrc)) {
+    cpSync(summarySrc, summaryDest);
+    chmodSync(summaryDest, 0o755);
+    console.log(`  + ldm-summary.sh deployed to ~/.ldm/bin/`);
+  }
+
+  // Deploy shared rules to ~/.ldm/shared/rules/ and to harnesses
+  const rulesSrc = join(__dirname, '..', 'shared', 'rules');
+  const rulesDest = join(LDM_ROOT, 'shared', 'rules');
+  if (existsSync(rulesSrc)) {
+    mkdirSync(rulesDest, { recursive: true });
+    let rulesCount = 0;
+    for (const file of readdirSync(rulesSrc)) {
+      if (!file.endsWith('.md')) continue;
+      cpSync(join(rulesSrc, file), join(rulesDest, file));
+      rulesCount++;
+    }
+    if (rulesCount > 0) {
+      console.log(`  + ${rulesCount} shared rules deployed to ~/.ldm/shared/rules/`);
+
+      // Deploy to Claude Code harness (~/.claude/rules/)
+      const claudeRules = join(HOME, '.claude', 'rules');
+      if (existsSync(join(HOME, '.claude'))) {
+        mkdirSync(claudeRules, { recursive: true });
+        for (const file of readdirSync(rulesDest)) {
+          if (!file.endsWith('.md')) continue;
+          cpSync(join(rulesDest, file), join(claudeRules, file));
+        }
+        console.log(`  + rules deployed to ~/.claude/rules/`);
+      }
+
+      // Deploy to OpenClaw harness (~/.openclaw/workspace/DEV-RULES.md)
+      const ocWorkspace = join(HOME, '.openclaw', 'workspace');
+      if (existsSync(ocWorkspace)) {
+        let combined = '# Dev Rules (deployed by ldm install)\n\n';
+        combined += '> Do not edit this file. It is regenerated by `ldm install`.\n';
+        combined += '> Source: ~/.ldm/shared/rules/\n\n';
+        for (const file of readdirSync(rulesDest).sort()) {
+          if (!file.endsWith('.md')) continue;
+          combined += readFileSync(join(rulesDest, file), 'utf8') + '\n\n---\n\n';
+        }
+        writeFileSync(join(ocWorkspace, 'DEV-RULES.md'), combined);
+        console.log(`  + rules deployed to ~/.openclaw/workspace/DEV-RULES.md`);
+      }
+    }
+  }
+
+  // Deploy shared prompts to ~/.ldm/shared/prompts/
+  const promptsSrc = join(__dirname, '..', 'shared', 'prompts');
+  const promptsDest = join(LDM_ROOT, 'shared', 'prompts');
+  if (existsSync(promptsSrc)) {
+    mkdirSync(promptsDest, { recursive: true });
+    let promptsCount = 0;
+    for (const file of readdirSync(promptsSrc)) {
+      if (!file.endsWith('.md')) continue;
+      cpSync(join(promptsSrc, file), join(promptsDest, file));
+      promptsCount++;
+    }
+    if (promptsCount > 0) {
+      console.log(`  + ${promptsCount} shared prompts deployed to ~/.ldm/shared/prompts/`);
+    }
+  }
+
   console.log('');
   console.log(`  LDM OS v${PKG_VERSION} initialized at ${LDM_ROOT}`);
   console.log('');

package/docs/bridge/README.md

@@ -4,7 +4,7 @@
 
 ## Your AIs talk to each other.
 
-Cross-platform agent communication. Bridge (MCP), Agent Client Protocol (ACP-Client, Zed Industries), and Agent Communication Protocol (ACP-Comm, IBM/Linux Foundation). Three protocols, one system. Claude Code sends a message, OpenClaw responds. OpenClaw sends a task, Claude Code executes it.
+Cross-platform agent communication. Claude Code talks to Claude Code. Claude Code talks to OpenClaw. OpenClaw talks back. Bridge (MCP), Agent Client Protocol (ACP-Client, Zed Industries), and Agent Communication Protocol (ACP-Comm, IBM/Linux Foundation). Three protocols, one system.
 
 ## Three Protocols, One System
 
@@ -16,7 +16,7 @@ LDM OS uses three complementary protocols. Bridge is one of them.
 | **Protocol** | MCP (JSON-RPC over stdio) | JSON-RPC over stdio + WebSocket | REST/HTTP |
 | **Built by** | WIP Computer | Zed Industries | IBM / Linux Foundation |
 | **In LDM OS** | Core (v0.3.0+) | Available via OpenClaw | Planned (Cloud Relay) |
-| **What it connects** | Claude Code <-> OpenClaw agents | IDEs (Zed, VS Code) <-> agents | Cloud agents <-> each other |
+| **What it connects** | CC <-> CC + CC <-> OpenClaw agents | IDEs (Zed, VS Code) <-> agents | Cloud agents <-> each other |
 | **Memory access** | Yes (search + read across agents) | No | No |
 | **Skill sharing** | Yes (OpenClaw skills as MCP tools) | No | No |
 | **Where it runs** | Localhost only | Localhost (stdio) + remote (WebSocket) | Cloud (HTTP endpoints) |
@@ -37,13 +37,23 @@ All three are Apache 2.0 compatible with our MIT + AGPL license. See [ACP docs](
 | `oc_skills_list` | List all OpenClaw skills. |
 | `oc_skill_*` | Run any OpenClaw skill with scripts. |
 
+## Session Discovery
+
+Multiple Claude Code sessions can discover each other via the Agent Register. On boot, Recall registers each session at `~/.ldm/sessions/`. Any session can list all running sessions with `ldm sessions`.
+
+The registry tracks agent ID (cc-mini, cc-air), PID, working directory, and start time. Stale sessions (dead PIDs) are auto-cleaned on read. See `lib/sessions.mjs`.
+
 ## Message Flow
 
+**CC <-> OpenClaw:**
 ```
 CC  --lesa_send_message-->  OpenClaw Gateway (localhost:18789)  -->  Lesa
 CC  <--lesa_check_inbox---  HTTP Inbox (localhost:18790)        <--  Lesa
 ```
 
+**CC <-> CC:**
+Multiple Claude Code sessions communicate via the file-based message bus and session registry at `~/.ldm/sessions/`. Each session registers on boot and can discover peers. No broker daemon required.
+
 Both directions are live. Everything is localhost. No cloud.
 
 ## Part of LDM OS

package/docs/bridge/TECHNICAL.md

@@ -3,7 +3,9 @@
 ## Architecture
 
 ```
-Claude Code CLI
+Claude Code CLI (cc-mini, cc-air, or any CC session)
+  |
+  |-- On boot --> registerSession() --> ~/.ldm/sessions/{name}.json (session discovery)
   |
   |-- MCP stdio --> wip-bridge MCP server (single process)
   |                   |
@@ -22,6 +24,13 @@ Claude Code CLI
   |                   |-- lesa_memory_search --> filesystem (workspace/*.md)
   |                   |
   |                   |-- oc_skill_* --> exec scripts in ~/.openclaw/extensions/*/skills/
+
+CC <-> CC (multi-session):
+  CC session A --> registerSession() --> ~/.ldm/sessions/a.json
+  CC session B --> registerSession() --> ~/.ldm/sessions/b.json
+  CC session A --> listSessions()    --> discovers session B (agent ID, PID, cwd)
+  CC session B --> listSessions()    --> discovers session A
+  Communication via file-based message bus at ~/.ldm/sessions/
 ```
 
 ## MCP Tools
@@ -65,6 +74,22 @@ Bridge starts a localhost-only HTTP server on port 18790:
 
 Messages are held in memory. `lesa_check_inbox` drains the queue.
 
+## Session Discovery
+
+On boot, Recall registers the session via `registerSession()` from `lib/sessions.mjs`. Each session writes a JSON file to `~/.ldm/sessions/{name}.json` containing:
+
+- `name` — session identifier
+- `agentId` — agent identity (e.g. `cc-mini`, `cc-air`)
+- `pid` — process ID (used for liveness checks)
+- `startTime` — ISO timestamp
+- `cwd` — working directory
+
+`listSessions()` reads all session files, validates PID liveness (signal 0 probe), and auto-cleans stale entries. Filter by `agentId` to find specific agents. `sessionCount()` returns a quick count of live sessions.
+
+CLI: `ldm sessions` lists all active sessions.
+
+This enables CC-to-CC awareness without a broker daemon. Any session can discover any other session on the machine.
+
 ## Key Files
 
 | File | What |
@@ -72,6 +97,7 @@ Messages are held in memory. `lesa_check_inbox` drains the queue.
 | `src/bridge/core.ts` | Pure logic: config, messaging, search, skills |
 | `src/bridge/mcp-server.ts` | MCP server: tool registration, inbox HTTP server |
 | `src/bridge/cli.ts` | CLI wrapper (`lesa` command) |
+| `lib/sessions.mjs` | Session registration, discovery, PID liveness |
 | `dist/bridge/` | Compiled output (ships with npm package) |
 
 ## Node Communication (Future)

package/docs/recall/TECHNICAL.md

@@ -39,3 +39,9 @@ The hook runs with a 15-second timeout. If any file is missing, it's skipped sil
 ## Session Registration
 
 On boot, Recall also registers the session in the Agent Register (`~/.ldm/sessions/`). This enables other sessions to discover this one via `ldm sessions`.
+
+## Connection to Total Recall
+
+Recall loads context at session start. [Total Recall](../total-recall/TECHNICAL.md) fills the memory that Recall serves. Total Recall imports historical conversations, generates multi-cadence summaries (daily/weekly/monthly/quarterly), and writes everything to Memory Crystal. On the next session start, Recall picks up the new data automatically.
+
+Without Total Recall, Recall only has what was captured going forward. With Total Recall, Recall has the complete history.

package/docs/total-recall/README.md

@@ -0,0 +1,84 @@
+###### WIP Computer
+
+# Total Recall
+
+## Connect your AI accounts. Bring every memory home. Never lose a conversation again.
+
+Total Recall is LDM OS's memory import and consolidation system. It connects to AI platforms, imports conversation history, and uses Dream Weaver to consolidate raw data into searchable, structured memories in Memory Crystal.
+
+It also generates multi-cadence summaries (daily, weekly, monthly, quarterly) for every agent.
+
+## The Pipeline
+
+```
+1. CONNECT    -> Sign into your AI accounts (Anthropic, OpenAI, xAI, etc.)
+2. IMPORT     -> Pull every conversation (API, data export, or automation)
+3. RELIVE     -> Dream Weaver processes raw conversations into memories
+4. CRYSTAL    -> Consolidated memories stored in Memory Crystal
+5. SUMMARIZE  -> Multi-cadence summaries (daily/weekly/monthly/quarterly)
+6. MONITOR    -> System check alerts when any agent stops capturing
+```
+
+## Two Modes
+
+### Going Forward (daily)
+
+Each agent writes its own daily summary. Persistent agents (OpenClaw, Letta) write from their own context. Ephemeral agents (Claude Code, Codex) get script-generated summaries from crystal + daily logs. Org-wide summaries combine all agents.
+
+```bash
+~/.ldm/bin/ldm-summary.sh daily              # today
+~/.ldm/bin/ldm-summary.sh daily --team-only  # team track only
+~/.ldm/bin/ldm-summary.sh daily --dev-only   # dev track only
+```
+
+### Backfill (historical)
+
+Import and summarize everything from day 1. Uses `--force` to generate for all agents regardless of harness type.
+
+```bash
+~/.ldm/bin/ldm-summary.sh daily --date 2026-02-10 --force   # one day
+bash scripts/backfill-summaries.sh                            # all days
+```
+
+## Output Locations
+
+### Per-agent
+```
+~/wipcomputerinc/team/{agent}/automated/memory/summaries/
+  daily/YYYY-MM-DD.md
+  weekly/YYYY-MM-DD.md
+  monthly/YYYY-MM.md
+  quarterly/YYYY-QX.md
+```
+
+### Org-wide
+```
+~/wipcomputerinc/operations/updates/
+  team/daily/YYYY-MM-DD.md    <- conversations, decisions, insights
+  dev/daily/YYYY-MM-DD.md     <- code shipped, PRs, releases
+```
+
+## Recursive Consolidation
+
+Each level reads the level below:
+
+```
+Transcripts + Crystal -> Daily summaries
+7 dailies             -> Weekly summary
+4 weeklies            -> Monthly summary
+3 monthlies           -> Quarterly summary
+```
+
+This is the Dream Weaver paper's consolidation architecture applied at four cadences.
+
+## Connection to Recall
+
+[Recall](../recall/README.md) loads context at session start. Total Recall fills the memory that Recall serves. Without Total Recall, Recall only has what was captured going forward. With Total Recall, Recall has the complete history.
+
+## Part of LDM OS
+
+Total Recall is included with LDM OS. Summaries activate after `ldm init`. External imports are opt-in per platform.
+
+---
+
+[Technical Reference](./TECHNICAL.md)

package/docs/total-recall/TECHNICAL.md

@@ -0,0 +1,124 @@
+# Total Recall ... Technical Reference
+
+## Architecture
+
+```
+~/.ldm/agents/{agentId}/memory/    <- SOURCE (raw data per agent)
+  daily/                            <- daily logs
+  journals/                         <- Dream Weaver journals
+  sessions/                         <- session exports (.md)
+  transcripts/                      <- raw JSONL
+       |
+       v
+Dream Weaver (prompts at ~/.ldm/shared/prompts/)
+       |
+       v
+~/wipcomputerinc/team/{agent}/automated/memory/summaries/
+  daily/ weekly/ monthly/ quarterly/     <- per-agent summaries
+       |
+       v (combine all agents)
+~/wipcomputerinc/operations/updates/
+  team/ daily/ weekly/ monthly/ quarterly/  <- org-wide team
+  dev/  daily/ weekly/ monthly/ quarterly/  <- org-wide dev (from git)
+```
+
+## Harness Logic
+
+Each agent in `~/.ldm/config.json` has a harness type:
+
+| Harness | Behavior | Examples |
+|---------|----------|---------|
+| Persistent (openclaw, letta, hermes) | Agent writes own summaries via prompt | Lesa |
+| Ephemeral (claude-code, codex) | Script generates from crystal + daily logs | CC |
+
+```
+for each agent:
+  if persistent AND summary file exists: skip (agent wrote it)
+  if persistent AND file missing AND --force: generate via script
+  if ephemeral: always generate via script
+```
+
+## Key Files
+
+| File | What |
+|------|------|
+| `scripts/ldm-summary.sh` | Orchestrator. Per-agent search, org-wide combine. |
+| `scripts/backfill-summaries.sh` | Loop: dailies -> weeklies -> monthlies -> quarterly |
+| `shared/prompts/daily-agent-summary.md` | Prompt for daily per-agent summary |
+| `shared/prompts/weekly-agent-summary.md` | Prompt for weekly (reads 7 dailies) |
+| `shared/prompts/monthly-agent-summary.md` | Prompt for monthly (reads 4 weeklies) |
+| `shared/prompts/quarterly-agent-summary.md` | Prompt for quarterly (reads 3 monthlies) |
+| `shared/prompts/org-daily-team.md` | Prompt for combining agent summaries |
+| `shared/prompts/daily-dev.md` | Prompt for git log summary |
+| `bin/ldm.js` | Installer. Deploys scripts + prompts. Scaffolds dirs. |
+
+## Data Sources
+
+### Team track (conversations, decisions)
+
+- `~/.ldm/agents/{agentId}/memory/daily/{date}.md` ... raw daily log
+- `crystal search --agent {id} --since {date} --until {date+1}` ... crystal chunks for that day
+- Both fed to Dream Weaver prompt to produce the summary
+
+### Dev track (code shipped)
+
+- `git log --since={date} --until={date+1} --oneline --all` across all repos in workspace
+- Fed to prompt to produce factual dev summary
+
+## Config
+
+`~/wipcomputerinc/settings/config.json`:
+
+```json
+"summaries": {
+  "cadences": ["daily", "weekly", "monthly", "quarterly"],
+  "tracks": ["team", "dev"],
+  "schedule": {
+    "daily": "06:00",
+    "weekly": "Monday 07:00",
+    "monthly": "1st 08:00",
+    "quarterly": "1st of Q 09:00"
+  },
+  "perAgent": "team/{agent}/automated/memory/summaries/",
+  "orgWide": "operations/updates/"
+}
+```
+
+`~/.ldm/config.json`:
+
+```json
+"agents": ["cc-mini", "oc-lesa-mini"]
+```
+
+## Schedule
+
+Cron via LDM Dev Tools.app:
+
+```
+0 6 * * *         ldm-summary.sh daily
+0 7 * * 1         ldm-summary.sh weekly      (Monday)
+0 8 1 * *         ldm-summary.sh monthly     (1st of month)
+0 9 1 1,4,7,10 *  ldm-summary.sh quarterly   (1st of quarter)
+```
+
+## External Imports (Future)
+
+Total Recall will also import from external platforms:
+
+| Platform | Method | Status |
+|----------|--------|--------|
+| Anthropic (Claude) | API / data export | Planned |
+| OpenAI (ChatGPT) | API / data export | Planned |
+| xAI (Grok) | API | Planned |
+| X (Twitter) | Full archive import | Planned |
+| Apple Music | Listening history | Planned |
+| Browser | Chrome/Safari extension | Planned |
+
+Each import follows the same pipeline: CONNECT -> IMPORT -> RELIVE -> CRYSTAL.
+
+## Connection to Other Components
+
+- **[Recall](../recall/TECHNICAL.md)** ... loads context at session start. Total Recall fills what Recall serves.
+- **[Bridge](../bridge/TECHNICAL.md)** ... agent-to-agent communication. Summaries are shared via the workspace, not Bridge.
+- **[Memory Crystal](https://github.com/wipcomputer/memory-crystal)** ... storage + search. Total Recall writes to Crystal. Crystal search provides data for summaries.
+- **[Dream Weaver](https://github.com/wipcomputer/dream-weaver-protocol)** ... consolidation engine. Prompts invoke Dream Weaver via `claude -p`.

package/package.json

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