@wipcomputer/wip-ldm-os 0.4.56 → 0.4.58

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.56"
+  version: "0.4.58"
   homepage: "https://github.com/wipcomputer/wip-ldm-os"
   author: "Parker Todd Brooks"
   category: infrastructure

package/bin/ldm.js

@@ -531,6 +531,69 @@ async function cmdInit() {
     }
   } catch {}
 
+  // Deploy personalized docs to settings/docs/ (from templates + config.json)
+  const docsSrc = join(__dirname, '..', 'shared', 'docs');
+  if (existsSync(docsSrc)) {
+    let workspacePath = '';
+    try {
+      const ldmConfig = JSON.parse(readFileSync(join(LDM_ROOT, 'config.json'), 'utf8'));
+      workspacePath = (ldmConfig.workspace || '').replace('~', HOME);
+
+      if (workspacePath && existsSync(workspacePath)) {
+        const docsDest = join(workspacePath, 'settings', 'docs');
+        mkdirSync(docsDest, { recursive: true });
+        let docsCount = 0;
+
+        // Build template values from BOTH configs:
+        // ~/.ldm/config.json (harnesses, workspace) + settings/config.json (agents, paths, org)
+        const settingsConfig = JSON.parse(readFileSync(join(workspacePath, 'settings', 'config.json'), 'utf8'));
+        const sc = settingsConfig;
+        const lc = ldmConfig;
+
+        // Agents from settings config (rich objects with harness/machine/prefix)
+        const agentsObj = sc.agents || {};
+        const agentsList = Object.entries(agentsObj).map(([id, a]) => `${id} (${a.harness} on ${a.machine})`).join(', ');
+        const agentsDetail = Object.entries(agentsObj).map(([id, a]) => `- **${id}**: ${a.harness} on ${a.machine}, branch prefix \`${a.prefix}/\``).join('\n');
+
+        // Harnesses from ldm config
+        const harnessConfig = lc.harnesses || {};
+        const harnessesDetected = Object.entries(harnessConfig).filter(([,h]) => h.detected).map(([name]) => name);
+        const harnessesList = harnessesDetected.length > 0 ? harnessesDetected.join(', ') : 'run ldm install to detect';
+
+        const templateVars = {
+          'name': sc.name || '',
+          'org': sc.org || '',
+          'timezone': sc.timezone || '',
+          'paths.workspace': (sc.paths?.workspace || '').replace('~', HOME),
+          'paths.ldm': (sc.paths?.ldm || '').replace('~', HOME),
+          'paths.openclaw': (sc.paths?.openclaw || '').replace('~', HOME),
+          'paths.icloud': (sc.paths?.icloud || '').replace('~', HOME),
+          'memory.local': (sc.memory?.local || '').replace('~', HOME),
+          'deploy.website': sc.deploy?.website || '',
+          'backup.keep': String(sc.backup?.keep || 7),
+          'agents_list': agentsList,
+          'agents_detail': agentsDetail,
+          'harnesses_list': harnessesList,
+        };
+
+        for (const file of readdirSync(docsSrc)) {
+          if (!file.endsWith('.tmpl')) continue;
+          let content = readFileSync(join(docsSrc, file), 'utf8');
+          // Replace template vars
+          content = content.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+            return templateVars[key.trim()] || match;
+          });
+          const outName = file.replace('.tmpl', '');
+          writeFileSync(join(docsDest, outName), content);
+          docsCount++;
+        }
+        if (docsCount > 0) {
+          console.log(`  + ${docsCount} personalized doc(s) deployed to ${docsDest.replace(HOME, '~')}/`);
+        }
+      }
+    } catch {}
+  }
+
   console.log('');
   console.log(`  LDM OS v${PKG_VERSION} initialized at ${LDM_ROOT}`);
   console.log('');
@@ -1728,6 +1791,57 @@ function cmdStatus() {
 
 // ── ldm sessions ──
 
+// ── ldm backup ──
+
+async function cmdBackup() {
+  const BACKUP_SCRIPT = join(LDM_ROOT, 'bin', 'ldm-backup.sh');
+
+  if (!existsSync(BACKUP_SCRIPT)) {
+    console.error('  x Backup script not found at ' + BACKUP_SCRIPT);
+    console.error('  Run: ldm install (deploys the backup script)');
+    process.exit(1);
+  }
+
+  const backupArgs = [];
+  if (DRY_RUN) backupArgs.push('--dry-run');
+
+  // --pin: mark the latest backup to skip rotation
+  const pinIndex = args.indexOf('--pin');
+  if (pinIndex !== -1) {
+    const reason = args[pinIndex + 1] || 'pinned';
+    // Find latest backup dir
+    const backupRoot = join(LDM_ROOT, 'backups');
+    const dirs = readdirSync(backupRoot)
+      .filter(d => d.match(/^20\d\d-\d\d-\d\d--/))
+      .sort()
+      .reverse();
+    if (dirs.length === 0) {
+      console.error('  x No backups found to pin.');
+      process.exit(1);
+    }
+    const latest = dirs[0];
+    const pinFile = join(backupRoot, latest, '.pinned');
+    writeFileSync(pinFile, `Pinned: ${reason}\nDate: ${new Date().toISOString()}\n`);
+    console.log(`  + Pinned backup ${latest}: ${reason}`);
+    console.log('  This backup will be skipped during rotation.');
+    return;
+  }
+
+  console.log('  Running backup...');
+  console.log('');
+  try {
+    execSync(`bash "${BACKUP_SCRIPT}" ${backupArgs.join(' ')}`, {
+      stdio: 'inherit',
+      timeout: 600000,
+    });
+  } catch (e) {
+    console.error('  x Backup failed: ' + e.message);
+    process.exit(1);
+  }
+}
+
+// ── ldm sessions ──
+
 async function cmdSessions() {
   const { listSessions } = await import('../lib/sessions.mjs');
   const sessions = listSessions({ includeStale: CLEANUP_FLAG });
@@ -2779,6 +2893,9 @@ async function main() {
     case 'worktree':
       await cmdWorktree();
       break;
+    case 'backup':
+      await cmdBackup();
+      break;
     default:
       console.error(`  Unknown command: ${command}`);
       console.error(`  Run: ldm --help`);

package/package.json

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

package/scripts/ldm-backup.sh

@@ -193,16 +193,26 @@ echo "--- ~/.claude/ ---"
 
 if [ -n "$WORKSPACE" ] && [ -d "$WORKSPACE" ]; then
   echo "--- $WORKSPACE/ ---"
-  tar -cf "$DEST/wipcomputerinc.tar" \
-    --exclude "node_modules" \
-    --exclude ".git/objects" \
-    --exclude ".DS_Store" \
-    --exclude "*/staff/cc-mini/documents/backups" \
-    --exclude "*/_temp/backups" \
-    --exclude "*/_trash" \
-    -C "$(dirname "$WORKSPACE")" "$(basename "$WORKSPACE")" 2>/dev/null \
-    && echo "  workspace:               tar OK" \
-    || echo "  workspace:               tar FAILED"
+
+  # Size guard: estimate workspace size before tarring
+  ESTIMATED_KB=$(du -sk --exclude="node_modules" --exclude=".git" --exclude="_temp/_archive" --exclude="_trash" "$WORKSPACE" 2>/dev/null | cut -f1 || echo "0")
+  MAX_KB=10000000  # 10GB
+  if [ "$ESTIMATED_KB" -gt "$MAX_KB" ] 2>/dev/null; then
+    echo "  ERROR: Workspace estimated at ${ESTIMATED_KB}KB (>10GB). Aborting tar to prevent disk fill."
+    echo "  Check for large directories: du -sh $WORKSPACE/*/"
+  else
+    tar -cf "$DEST/wipcomputerinc.tar" \
+      --exclude "node_modules" \
+      --exclude ".git/objects" \
+      --exclude ".DS_Store" \
+      --exclude "*/staff/cc-mini/documents/backups" \
+      --exclude "*/_temp/backups" \
+      --exclude "*/_temp/_archive" \
+      --exclude "*/_trash" \
+      -C "$(dirname "$WORKSPACE")" "$(basename "$WORKSPACE")" 2>/dev/null \
+      && echo "  workspace:               tar OK (est ${ESTIMATED_KB}KB)" \
+      || echo "  workspace:               tar FAILED"
+  fi
 fi
 
 # ── 5. iCloud offsite ──
@@ -235,6 +245,11 @@ BACKUP_COUNT=$(ls -1d "$BACKUP_ROOT"/20??-??-??--* 2>/dev/null | wc -l | tr -d '
 if [ "$BACKUP_COUNT" -gt "$KEEP" ]; then
   REMOVE_COUNT=$((BACKUP_COUNT - KEEP))
   ls -1d "$BACKUP_ROOT"/20??-??-??--* | head -n "$REMOVE_COUNT" | while read OLD; do
+    # Skip pinned backups
+    if [ -f "$OLD/.pinned" ]; then
+      echo "  Skipped (pinned): $(basename "$OLD")"
+      continue
+    fi
     rm -rf "$OLD"
     echo "  Removed: $(basename "$OLD")"
   done

package/shared/docs/README.md.tmpl

@@ -0,0 +1,35 @@
+# System Documentation
+
+These docs are automatically maintained. Do not edit them directly.
+
+Updates come from two sources:
+- **config.json** ... when you change your org settings, the "Your System" sections regenerate
+- **System hooks** ... when tools are installed, updated, or reconfigured, the relevant docs update automatically
+
+If something is wrong, update `settings/config.json` or run `ldm install`. The docs will follow.
+
+## What's Here
+
+| Doc | What it covers |
+|-----|---------------|
+| `what-is-ldm-os.md` | What LDM OS is, what it installs, key commands |
+| `what-is-dotldm.md` | The `~/.ldm/` runtime directory explained |
+| `directory-map.md` | What lives where and why |
+| `how-worktrees-work.md` | Git worktrees, the _worktrees/ convention |
+| `how-backup-works.md` | Daily backup, iCloud offsite, restore |
+| `how-releases-work.md` | The full release pipeline |
+| `how-install-works.md` | ldm install, the install prompt, dogfooding |
+| `how-agents-work.md` | Agents, harnesses, bridge, memory |
+| `how-rules-and-commands-work.md` | Rules, commands, skills, and .ldm/ -> harness deployment |
+| `system-directories.md` | Every directory in the system, what manages it |
+| `how-web-skills-work-placeholder.md` | Deploying skills to claude.ai web app |
+| `local-first-principle.md` | Local-first, relay-optional. Why and how. |
+| `acknowledgements.md` | External ideas, code, and inspiration we draw from |
+
+## Structure
+
+Each doc has two sections:
+1. **Universal** ... how the feature works for everyone (top of file)
+2. **Your System** ... your specific configuration (bottom, after the `---` separator)
+
+Universal content comes from the LDM OS repo. "Your System" content is generated from your `settings/config.json`.

package/shared/docs/acknowledgements.md.tmpl

@@ -0,0 +1,207 @@
+# Acknowledgements
+
+Ideas, code, and inspiration from the community. If we use it, we credit it.
+
+## How This Works
+
+When any tool, plan, doc, or code draws from external work, add an entry here. This is checked by the license guard during releases. If an acknowledgement is missing, the release blocks.
+
+## Sources
+
+### Cyril (@cyrilXBT)
+
+**What:** Post framing Obsidian + Claude Code as a "personal JARVIS." Your vault is your knowledge base, Claude reads it, your AI answers from your own thinking.
+
+**Where we use it:** The plan for Obsidian as an LDMOS UI layer. The insight that `~/wipcomputerinc/` is already an Obsidian-compatible vault. The onboarding path for Obsidian users.
+
+**Link:** (X post by @cyrilXBT, 2026-03-23 snapshot)
+
+**License:** Public post
+
+**Date referenced:** 2026-03-23
+
+---
+
+### Louis (@louislva)
+
+**What:** claude-peers-mcp ... multiple Claude Code instances discover each other and exchange messages via SQLite broker + `claude/channel` push delivery.
+
+**Where we use it:** Session status broadcast, `claude/channel` push delivery evaluation, auto-summarization on connect. Bridge priorities from comparison analysis. No code ported.
+
+**Link:** https://github.com/louislva/claude-peers-mcp
+
+**License:** (check repo license, 2026-03-23 snapshot)
+
+**Date referenced:** 2026-03-23
+
+---
+
+### Matt Van Horn (@mvanhorn)
+
+**What:** Plan-first, voice-driven, multi-session Claude Code workflow. 70 plan files, 263 commits in 30 days. Compound Engineering plugin, Monologue voice input, /last30days research skill.
+
+**Where we use it:** Plan-first convention for LDMOS, voice input evaluation, Compound Engineering plugin evaluation. Validates cc-mini remote pattern and Dream Weaver consolidation.
+
+**Link:** @mvanhorn reply to @kevinrose on IDE usage (X post, 2026-03-23 snapshot)
+
+**License:** Public post
+
+**Date referenced:** 2026-03-23
+
+---
+
+### Internet Vin (@internetvin)
+
+**What:** Obsidian + Claude Code as personal operating system. Custom commands (/trace, /connect, /ideas, /graduate, /ghost, /challenge). "Human writes vault, agent reads it." "Markdown files are the oxygen of LLMs."
+
+**Where we use it:** Inspiration for LDMOS shared commands. Validates sovereignty covenant ("human writes, agent reads"). Validates workspace-as-vault architecture.
+
+**Link:** Startup Ideas Pod episode (https://www.youtube.com/watch?v=6MBq1paspVU)
+
+**License:** Public content
+
+**Date referenced:** 2026-03-23
+
+---
+
+### Akshay Pachaar (@akshay_pachaar)
+
+**What:** "Anatomy of the .claude/ folder" ... comprehensive guide to CLAUDE.md, rules/, commands/, skills/, agents/, and settings.json.
+
+**Where we use it:** The .ldm/ as source / .claude/ as deployment target architecture. The rules/ folder split. Path-scoped rules via YAML frontmatter. The commands/ pattern for workflow automation.
+
+**Link:** https://x.com/akshay_pachaar/status/2035341800739877091
+
+**License:** Article (public X post, 2026-03-23 snapshot)
+
+**Date referenced:** 2026-03-23
+
+---
+
+### Gary Tan (@garrytan)
+
+**What:** gstack CLI ... engineering workflow skills (brainstorming, planning, code review, QA, shipping, retrospectives). Pioneered the pattern of packaging structured workflows as AI skills.
+
+**Where we use it:** The concept of packaging LDM OS workflows as uploadable skills for the Claude web app. The skill-per-folder structure with SKILL.md frontmatter for auto-triggering.
+
+**Link:** https://github.com/gstack-com/gstack
+
+**License:** (check repo license, 2026-03-23 snapshot)
+
+**Date referenced:** 2026-03-23
+
+---
+
+### Hruthik Kommuru (@HruthikKommuru)
+
+**What:** gstack Web Skills ... adapted gstack CLI skills for the Claude web app (claude.ai). 12 skills uploaded via Customize → Skills. Proved that CLI workflows can be packaged as web-compatible SKILL.md files.
+
+**Where we use it:** The pattern for deploying LDM OS skills to claude.ai as a third harness deployment target. The upload workflow (Customize → Skills → upload folder).
+
+**Link:** https://github.com/HruthikKommuru/CaludeSkills-Web-Gstack
+
+**License:** (check repo license, 2026-03-23 snapshot)
+
+**Date referenced:** 2026-03-23
+
+---
+
+### Ole Lehmann (@itsolelehmann)
+
+**What:** "I deleted half my Claude setup and every output got BETTER." Over-prompting analysis: stacked rules contradict, repeat, and slow the model down. Audit prompt that checks each rule against 5 criteria (default behavior, conflicts, duplicates, one-off fixes, vague instructions). Addition by subtraction.
+
+**Where we use it:** `ldm audit-rules` command (#183). The 5-check framework for classifying instruction rules. The process: cut, test 3 common tasks, add back only what broke.
+
+**Link:** https://x.com/itsolelehmann/status/2036065138147471665
+
+**License:** Public post
+
+**Date referenced:** 2026-03-24
+
+---
+
+### m13v (mediar-ai)
+
+**What:** Concurrent MCP server race condition report. Practical advice on per-agent auth tokens, SQLite over HTTP performance, and CLAUDE.md fallback instructions.
+
+**Where we use it:** Crystal relay architecture (issues #163, #164, #165, #166). Per-agent auth token design. Fallback instruction pattern in per-repo CLAUDE.md template.
+
+**Link:** https://github.com/wipcomputer/wip-ldm-os/issues/163#issuecomment-4106934493
+
+**Repo:** https://github.com/mediar-ai/mcp-server-macos-use
+
+**License:** MIT (2026-03-22 snapshot)
+
+**Date referenced:** 2026-03-22
+
+---
+
+### Tobi Lutke (@toaborern)
+
+**What:** QMD ... personal memory system using sqlite-vec, FTS5, BM25+vector hybrid search with Reciprocal Rank Fusion (RRF), LLM re-ranking.
+
+**Where we use it:** Memory Crystal's entire search architecture. We ported the RRF fusion algorithm (~40 lines), the sqlite-vec + FTS5 hybrid search pattern, the two-step query approach (MATCH first, metadata lookup second), and BM25 score normalization. Crystal adds conversation capture, multi-agent scoping, recency weighting, remember/forget lifecycle, and private mode on top.
+
+**Link:** https://github.com/tobi/qmd
+
+**License:** MIT (2024-2026 snapshot, referenced 2026-02-16)
+
+**Date referenced:** 2026-02-16
+
+---
+
+### OpenViking (Volcengine / ByteDance)
+
+**What:** Open-source context database for AI agents. Filesystem management paradigm, tiered context loading (L0/L1/L2), directory recursive retrieval, 6-category memory extraction with merge rules, session compression with structured commit.
+
+**Where we use it:** Architecture inspiration for Memory Crystal augmentations. Specifically: structured memory categories with merge/non-merge rules (MC #59), memory dedup pipeline (MC #60), tiered content loading concept (MC #61), virtual hierarchy in search (MC #62). All augment existing Dream Weaver and Crystal systems. No code ported.
+
+**Link:** https://github.com/volcengine/OpenViking / https://openviking.ai/
+
+**License:** Apache 2.0 (2025). Actual open source. Real code in the repo. Self-hostable with Docker and Helm. The engine is in the repo, not behind an API. This is how it should be done.
+
+**Date referenced:** 2026-03-23
+
+---
+
+### Supermemory (supermemoryai)
+
+**What:** ASMR (Agentic Search and Memory Retrieval) ... multi-agent memory architecture. Parallel observer agents for categorized ingestion, 5 specialized search agents (facts, context, timelines, relationships, temporal), aggregator LLM for ensemble consensus. ~99% SOTA on LongMemEval.
+
+**Where we use it:** Architecture inspiration for Memory Crystal's search pipeline. The ideas of parallel categorized ingestion, specialized retrieval agents, and ensemble consensus. We implement from the published technique description, not from their code.
+
+**Link:** https://supermemory.ai / https://github.com/supermemoryai/supermemory
+
+**License:** MIT (2025), except `skills/supermemory/` which is Apache 2.0 (2026). But **open core, not open source.** The MIT repo contains only SDKs, API clients, a browser extension, and a D3 visualization widget. The actual memory engine, ingestion pipeline, search backend, vector store, knowledge graph, temporal reasoning, and the ASMR multi-agent orchestration are proprietary cloud services behind `api.supermemory.ai`. The `supermemory` npm package is an HTTP client. No database drivers, no vector search, no ingestion code in the repo. No Dockerfile, no self-hosting docs, no schema files. `.env.example` points to their cloud API. Pricing: free tier (1M tokens/mo), Pro ($19/mo), Scale ($399/mo).
+
+**Our position:** This is not OSS. Calling a client-side wrapper "MIT open source" while keeping the engine proprietary is misleading. OSS means you can run the whole system yourself. If you can't `git clone && docker compose up` and have a working system, it's a marketing label on an SDK. We acknowledge the ideas. We don't endorse the licensing practice.
+
+**Date referenced:** 2026-03-23
+
+---
+
+## Format
+
+When adding an entry:
+
+```markdown
+### Name (@handle)
+
+**What:** One line describing what they contributed or inspired.
+
+**Where we use it:** Which plan, doc, code, or feature draws from their work.
+
+**Link:** URL to the original source.
+
+**License:** License name (YYYY-MM-DD snapshot)
+
+**Date referenced:** YYYY-MM-DD
+```
+
+Always record the license and the date you referenced it. Licenses can change. The snapshot date proves what license was in effect when we drew from the work.
+
+## License Guard Integration
+
+(placeholder ... license guard does not yet check acknowledgements.md)
+
+The release pipeline should verify that any new external reference in code or plans has a matching entry here. `wip-release` calls `license_audit` which checks this file.

package/shared/docs/directory-map.md.tmpl

@@ -0,0 +1,78 @@
+# Directory Map
+
+## The Workspace
+
+```
+~/wipcomputerinc/              <- your org's workspace (name varies per company)
+  settings/                 <- all configuration
+    config.json             <- org identity: name, agents, co-authors, paths
+    templates/              <- org's custom templates (license, readme, claude-md)
+    system-working-directories/  <- macOS aliases to runtime dirs
+    docs/                     <- operational docs (auto-maintained)
+  team/                    <- people and agents
+    parker/documents/
+    cc-mini/documents/
+      journals/             <- human-requested
+      automated/            <- system-generated
+    lesa/documents/
+  repos/                    <- all code
+    ldm-os/                 <- organizational folder (not a monorepo)
+      components/
+      devops/
+      utilities/
+      apis/
+      apps/
+    _worktrees/             <- active worktrees
+    _sort/                  <- uncategorized
+    _trash/                 <- archived
+```
+
+## The Runtime (source of truth)
+
+```
+~/.ldm/                     <- LDM OS runtime (managed by tools)
+  extensions/               <- installed skills and tools
+  agents/                   <- agent identity files + per-agent rules
+  shared/                   <- rules, commands, skills for ALL agents
+    rules/                  <- deployed to every harness
+    commands/               <- deployed to Claude Code
+    skills/                 <- deployed to every harness
+  memory/                   <- crystal.db
+  logs/                     <- all logs
+  bin/                      <- deployed scripts
+  hooks/                    <- Claude Code hooks
+  state/                    <- runtime state
+  tmp/                      <- install staging
+  backups/                  <- daily backups (ldm-backup.sh) + iCloud offsite tars
+```
+
+## Harness Directories (deployment targets)
+
+`ldm install` deploys from `~/.ldm/` to each harness. Don't edit these directly.
+
+```
+~/.claude/                  <- Claude Code (deployment target)
+  CLAUDE.md                 <- generated from .ldm/ + config.json
+  rules/                    <- deployed from .ldm/shared/rules/ + agent rules
+  commands/                 <- deployed from .ldm/shared/commands/ + agent commands
+  skills/                   <- deployed from .ldm/extensions/
+  agents/                   <- deployed from .ldm/agents/ definitions
+  settings.json             <- hooks, permissions
+  projects/                 <- per-project memory (Claude Code manages)
+
+~/.openclaw/                <- OpenClaw (deployment target)
+  workspace/                <- Lesa's workspace (TOOLS.md = rules equivalent)
+  extensions/               <- deployed from .ldm/extensions/
+  logs/                     <- gateway logs
+
+~/Library/LaunchAgents/     <- macOS scheduled tasks
+  ai.openclaw.gateway.plist
+  ai.openclaw.healthcheck.plist
+```
+
+## The Rule
+
+- `~/wipcomputerinc/` ... where humans work (visible, browsable, findable)
+- `~/.ldm/` ... where the system runs and rules are authored (source of truth)
+- `~/.claude/` ... Claude Code reads from here (deployed by ldm install)
+- `~/.openclaw/` ... OpenClaw reads from here (deployed by ldm install)

package/shared/docs/how-agents-work.md.tmpl

@@ -0,0 +1,64 @@
+# How Agents Work
+
+## What is an Agent?
+
+An agent is an AI with its own identity, memory, and relationship with you. Not a chatbot. Not a tool. A persistent collaborator that remembers yesterday and has opinions.
+
+Each agent has:
+- **Identity files** ... SOUL.md (who they are), IDENTITY.md (facts), CONTEXT.md (current state)
+- **Rules** ... agent-specific instructions deployed to their harness
+- **Commands** ... agent-specific slash commands
+- **Memory** ... crystal.db entries tagged with their agent ID
+- **Daily logs** ... what happened each session
+- **Journals** ... narrative reflections (when asked to write one)
+
+## Where They Live
+
+```
+~/.ldm/agents/
+  cc-mini/                <- Claude Code on this machine
+    SOUL.md
+    IDENTITY.md
+    CONTEXT.md
+    rules/                <- CC-specific rules (deployed to ~/.claude/rules/)
+    commands/             <- CC-specific commands
+    memory/
+  oc-lesa-mini/           <- Lesa on OpenClaw
+    rules/                <- Lesa-specific rules (deployed to workspace/TOOLS.md)
+  cc-air/                 <- Claude Code on another machine
+```
+
+Each agent's folder has the same structure. The files are theirs. Other agents can search each other's memory (via crystal) but they don't share identity files.
+
+Shared rules for all agents live at `~/.ldm/shared/rules/`. Agent-specific rules override or extend shared rules.
+
+## How They Communicate
+
+**Bridge:** Agents send messages through the bridge, not through the human. The `lesa_send_message` MCP tool routes messages to Lesa's OpenClaw gateway. She responds as herself.
+
+**Shared daily log:** Both agents write to `~/.openclaw/workspace/memory/YYYY-MM-DD.md`. Each checks it to see what the other did.
+
+**Memory Crystal:** All agents write to the same crystal.db, tagged by agent ID. Any agent can search across all agents' memories.
+
+## Harnesses
+
+A harness is the runtime that hosts an agent:
+- **Claude Code CLI** ... terminal-based. Opens and closes with sessions. No persistent process.
+- **OpenClaw** ... 24/7 gateway. Runs continuously. iMessage integration.
+- **Letta, Grok, etc.** ... future harnesses. Same identity architecture.
+
+The agent is not the harness. Swap the harness, keep the soul. The identity files persist across harness changes.
+
+## The 1:1 Rule
+
+One agent, one harness instance. No multiplexing. If you want three agents, run three harnesses. This prevents identity bleed.
+
+---
+
+## Your System
+
+**Agents configured:**
+{{agents_detail}}
+
+**Shared memory:** `{{memory.local}}`
+**Timezone:** {{timezone}}