@wipcomputer/wip-ldm-os 0.4.82-alpha.1 → 0.4.84

package/README.md

@@ -96,6 +96,8 @@ The OS connects your AIs. Add-ons are what they actually use. Each one is a full
 
 **OpenClaw**
 - Open-source agent runtime. Run AI agents 24/7 with identity, memory, and tool access. The existence proof for LDM OS.
+- WIP contributions accepted upstream: `before_message_write` plugin hook (#18197), Codex app-server final chat events (#70815 -> maintainer PR #71293), memory-core seed cache streaming/yield (#73067 -> maintainer PR #73118), and fallback vector top-K streaming (#73069 -> maintainer PR #73100).
+- Submitted / superseded: symlink plugin discovery fix (#45744; bug confirmed, superseded by #69971, not landed as submitted).
 - [Read more about OpenClaw](https://github.com/openclaw/openclaw)
 
 [See all skills](docs/skills/README.md)

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

package/bin/ldm.js

@@ -1935,6 +1935,36 @@ async function cmdInstallCatalog() {
     console.log(`  + Migrated ${migrated} registry entries to v2 format (source info added)`);
   }
 
+  // Aggregate the bin ownership manifest BEFORE seedLocalCatalog,
+  // deployBridge, deployScripts, and the heal walk run. If two
+  // declarers claim the same file in ~/.ldm/bin/ we cannot safely
+  // decide ownership, so install must abort before catalog.json,
+  // bridge files, or any ~/.ldm/bin/ shim is written. See
+  // ai/product/plans-prds/current/2026-04-28--cc-mini--ldm-bin-ownership-manifest-design.md
+  const { aggregateBinManifest, healBinManifest } = await import('../lib/bin-manifest.mjs');
+  const ldmCliRoot = join(__dirname, '..');
+  const binManifestRegistry = readJSON(REGISTRY_PATH) || { extensions: {} };
+  const manifest = aggregateBinManifest({
+    ldmCliRoot,
+    extensionsRoot: LDM_EXTENSIONS,
+    binDir: join(LDM_ROOT, 'bin'),
+    registry: binManifestRegistry,
+  });
+  if (manifest.conflicts.length > 0) {
+    console.log('');
+    console.log('  x bin manifest conflict ... aborting before seedLocalCatalog/deployBridge/deployScripts run:');
+    for (const c of manifest.conflicts) {
+      console.log(`    "${c.name}" claimed by ${c.declarers.length} declarers:`);
+      for (const d of c.declarers) {
+        console.log(`        ${d.declarer}: ${d.sourcePath.replace(HOME, '~')}`);
+      }
+    }
+    console.log('');
+    console.log('  Resolve ownership in the package manifests, then re-run.');
+    installLog(`ldm install aborted: ${manifest.conflicts.length} bin manifest conflict(s)`);
+    process.exit(1);
+  }
+
   // Seed local catalog if missing (#262)
   if (seedLocalCatalog()) {
     console.log(`  + catalog.json seeded to ~/.ldm/catalog.json`);
@@ -1950,6 +1980,24 @@ async function cmdInstallCatalog() {
   deployDocs();
   deployRules();
 
+  // Manifest-driven self-heal. deployScripts() above wrote LDM CLI's own
+  // *.sh files; this pass covers the rest of the manifest (LDM CLI files
+  // deployed elsewhere, e.g. process-monitor.sh, plus extension-owned
+  // shims like crystal-capture.sh). Read-only entries that already match
+  // the manifest are no-ops.
+  if (manifest.entries.length > 0) {
+    const heal = healBinManifest(manifest.entries, { heal: !DRY_RUN });
+    for (const e of heal.healed) {
+      console.log(`  + Restored ${e.name} from ${e.sourcePath.replace(HOME, '~')} (declarer: ${e.declarer})`);
+    }
+    for (const f of heal.failed) {
+      console.log(`  ! ${f.entry.name}: ${f.reason} (declarer: ${f.entry.declarer})`);
+    }
+    if (heal.ok.length > 0 && heal.healed.length === 0 && heal.failed.length === 0) {
+      console.log(`  + bin manifest: ${heal.ok.length} entr${heal.ok.length === 1 ? 'y' : 'ies'} verified`);
+    }
+  }
+
   // Check backup configuration
   checkBackupHealth();
 
@@ -2947,6 +2995,98 @@ async function cmdDoctor() {
     }
   }
 
+  // 3c. Cron target health (parallel to crystal doctor's checkCaptureShim)
+  //
+  // When an extension wires a shim into ~/.ldm/bin/ via cron, the cron
+  // line is sticky: it keeps firing even if the shim file goes missing
+  // for any reason. crystal doctor catches this for crystal-capture.sh,
+  // but any cron line referencing ~/.ldm/bin/<file> is at the same risk
+  // class. Walk the crontab and surface broken bin-targeted entries
+  // explicitly. Read-only by default; --fix restores known shims from
+  // their extension dist when the canonical source is present on disk.
+  {
+    const ldmBinPrefix = join(LDM_ROOT, 'bin') + '/';
+    let crontab = '';
+    try {
+      crontab = execSync('crontab -l 2>/dev/null', { encoding: 'utf-8' });
+    } catch {}
+    function expandTilde(p) {
+      return p.startsWith('~') ? join(HOME, p.slice(1)) : p;
+    }
+    function extractCronTarget(line) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith('*')) return null;
+      const tokens = trimmed.split(/\s+/);
+      if (tokens.length < 6) return null;
+      const expanded = expandTilde(tokens[5]);
+      return expanded.startsWith(ldmBinPrefix) ? expanded : null;
+    }
+    const cronTargets = new Map();    // path → ['missing'|'not executable']
+    const seenTargets = new Set();    // every bin-targeted path we found
+    for (const line of crontab.split('\n')) {
+      const expanded = extractCronTarget(line);
+      if (!expanded) continue;
+      seenTargets.add(expanded);
+      if (cronTargets.has(expanded)) continue;
+      const problems = [];
+      if (!existsSync(expanded)) {
+        problems.push('missing');
+      } else if ((statSync(expanded).mode & 0o111) === 0) {
+        problems.push('not executable');
+      }
+      if (problems.length > 0) cronTargets.set(expanded, problems);
+    }
+    if (cronTargets.size > 0) {
+      // Manifest-driven lookup. Aggregates LDM CLI's wipLdmOs.binFiles
+      // and every registered extension's openclaw.plugin.json#binFiles.
+      // If aggregation reports a conflict, the lookup stays empty and
+      // each broken target becomes "owner unknown" until the conflict
+      // is resolved at the package-manifest layer.
+      const { aggregateBinManifest } = await import('../lib/bin-manifest.mjs');
+      const drManifest = aggregateBinManifest({
+        ldmCliRoot: join(__dirname, '..'),
+        extensionsRoot: LDM_EXTENSIONS,
+        binDir: join(LDM_ROOT, 'bin'),
+        registry: readJSON(REGISTRY_PATH) || { extensions: {} },
+      });
+      const knownSources = {};
+      const declarers = {};
+      if (drManifest.conflicts.length === 0) {
+        for (const e of drManifest.entries) {
+          knownSources[e.name] = e.sourcePath;
+          declarers[e.name] = e.declarer;
+        }
+      } else {
+        console.log(`  ! bin manifest conflict: ${drManifest.conflicts.length}; restore disabled until resolved`);
+      }
+      let healed = 0;
+      for (const [path, problems] of cronTargets) {
+        const detail = problems.join(', ');
+        console.log(`  ! cron target ${detail}: ${path}`);
+        const base = basename(path);
+        const src = knownSources[base];
+        if (FIX_FLAG && src && existsSync(src)) {
+          try {
+            mkdirSync(dirname(path), { recursive: true });
+            cpSync(src, path);
+            chmodSync(path, 0o755);
+            console.log(`  + Restored ${base} from ${src.replace(HOME, '~')}`);
+            healed++;
+          } catch (e) {
+            console.log(`    Restore failed: ${e.message}`);
+          }
+        } else if (src) {
+          console.log(`    Run: ldm doctor --fix to restore from ${src.replace(HOME, '~')}`);
+        } else {
+          console.log(`    Owner unknown; consult the extension that registered this cron entry`);
+        }
+      }
+      issues += cronTargets.size - healed;
+    } else if (seenTargets.size > 0) {
+      console.log(`  + Cron targets under ~/.ldm/bin/: ${seenTargets.size} entr${seenTargets.size === 1 ? 'y' : 'ies'}, all exist and executable`);
+    }
+  }
+
   // 4. Check sacred locations
   const sacred = [
     { path: join(LDM_ROOT, 'memory'), label: 'memory/' },

package/docs/skills/README.md

@@ -31,6 +31,8 @@ Your AIs are only as powerful as what you give them. Here's everything available
 
 **OpenClaw**
 - Open-source agent runtime. Run AI agents 24/7 with identity, memory, and tool access. The existence proof for LDM OS.
+- WIP contributions accepted upstream: `before_message_write` plugin hook (#18197), Codex app-server final chat events (#70815 -> maintainer PR #71293), memory-core seed cache streaming/yield (#73067 -> maintainer PR #73118), and fallback vector top-K streaming (#73069 -> maintainer PR #73100).
+- Submitted / superseded: symlink plugin discovery fix (#45744; bug confirmed, superseded by #69971, not landed as submitted).
 - [Read more about OpenClaw](https://github.com/openclaw/openclaw)
 
 ## Identity

package/docs/universal-installer/README.md

@@ -68,7 +68,7 @@ If I say yes, run: ldm install --dry-run
 Show me exactly what will change. Don't install anything until I say "install".
 ```
 
-See [TECHNICAL.md](TECHNICAL.md) for sensors/actuators, the interface table, and real examples.
+See [SPEC.md](SPEC.md) for the architecture layers, the **eight interfaces** (CLI, Module, MCP local stdio, Remote MCP, OpenClaw Plugin, Skill, Claude Code Hook, Claude Code Plugin), the install spec URL convention, track flags (alpha/beta), and the `agent.txt` distinction. See [TECHNICAL.md](TECHNICAL.md) for sensors/actuators, the interface table, and real examples.
 
 ---
 

package/docs/universal-installer/SPEC.md

@@ -4,7 +4,29 @@ Every tool is a sensor, an actuator, or both. Every tool should be accessible th
 
 This is the spec.
 
-## The Six Interfaces
+## Architecture Layers
+
+Five layers. Each one does one job. Together they let any AI safely consume any product.
+
+| Layer | What it is | Where it lives |
+|-------|-----------|----------------|
+| **Interface** | What a product exposes (CLI, MCP, Skill, etc.). Eight kinds, listed below in canonical order. | The product repo. |
+| **Installer** | Detects a product's interfaces and installs them all. `ldm install`. Stable, alpha, and beta tracks via flags. | `wip-ldm-os` (`bin/ldm.js`). |
+| **Catalog** | Slug→source resolver (npm package, repo, registry/CLI matches, status) **plus** the trust surface: provenance, version pinning, permission scopes, audits, install/update/revocation. Stays human-readable and browseable as a fallback discovery surface; not the primary steering wheel. | `catalog.json` at the LDM OS root. |
+| **Install Spec** | Agent-readable install runbook published at `wip.computer/install/<slug>.txt`. Track-neutral. Teaches an AI to safely check, explain, dry-run, install, update, and pair the product. | `https://wip.computer/install/<slug>.txt`. See [Install Spec](#install-spec). |
+| **Stacks** | Multi-product bundles. One install brings up several products and their MCP servers. | `catalog.json.stacks`. |
+
+Use the install spec URL to learn the safe install flow; use catalog to resolve the slug; use `ldm install` with stable/alpha/beta track flags; installer detects and installs the product's declared interfaces; stacks install bundles.
+
+### Primary flow
+
+The user's path is **outcome → agent resolves services → install specs / catalog / auth → bespoke artifact**. Not "browse a plugin store and pick one." The catalog stays browseable for the times a user wants to look around, but it is no longer the steering wheel. The steering wheel is the user's stated outcome and the agent's composition.
+
+**Personal context** (goals, preferences, prior experiments, constraints) does not come from this spec. It comes from **Memory Crystal**, a sibling LDM OS component. The universal-installer spec describes how *services* expose themselves; Memory Crystal describes how the *agent* knows you. Both feed the bespoke composition.
+
+## The Eight Interfaces
+
+The canonical order is fixed: CLI (1), Module (2), MCP Server local stdio (3), Remote MCP (4), OpenClaw Plugin (5), Skill (6), Claude Code Hook (7), Claude Code Plugin (8). Local and Remote MCP sit next to each other because they are sibling transports of the same protocol. Claude Code Plugin sits last because it bundles the others.
 
 ### 1. CLI
 
@@ -45,15 +67,15 @@ An importable ES module. The programmatic interface. Other tools compose with it
 }
 ```
 
-### 3. MCP Server
+### 3. MCP Server (local stdio)
 
-A JSON-RPC server implementing the Model Context Protocol. Any MCP-compatible agent can use it.
+A JSON-RPC server implementing the Model Context Protocol over stdio. Spawned as a child process by the agent (Claude Code, Cursor, OpenClaw). For the HTTP/SSE sibling, see [#4 Remote MCP](#4-remote-mcp).
 
 **Convention:** `mcp-server.mjs` (or `.js`, `.ts`) at the repo root. Uses `@modelcontextprotocol/sdk`.
 
 **Detection:** One of `mcp-server.mjs`, `mcp-server.js`, `mcp-server.ts`, `dist/mcp-server.js` exists.
 
-**Install:** Add to `.mcp.json`:
+**Install:** Add to `.mcp.json` with `command` + `args`:
 
 ```json
 {
@@ -64,7 +86,51 @@ A JSON-RPC server implementing the Model Context Protocol. Any MCP-compatible ag
 }
 ```
 
-### 4. OpenClaw Plugin
+### 4. Remote MCP
+
+The HTTP/SSE (or streamable HTTP) sibling of #3. Hosted at an HTTPS endpoint, not spawned locally. The transport that lights up Claude Desktop connectors, web, and mobile clients.
+
+**Contract:** Remote MCP endpoint is **declared by package/catalog metadata** and **registered by `ldm install`**. No filesystem-sniffing fallback.
+
+**Convention:** `mcp.remote` field in `package.json`:
+
+```json
+{
+  "mcp": {
+    "remote": {
+      "url": "https://example.com/mcp",
+      "transport": "streamable-http",
+      "auth": "oauth"
+    }
+  }
+}
+```
+
+`url` may be a placeholder (`"https://__DEPLOYED_URL__"`) when the repo ships the server code and the URL is supplied by the catalog at install time.
+
+**Detection:** `package.json.mcp.remote.url` is a string.
+
+**Install:** Add to `.mcp.json` as a remote entry (`url` + `transport` instead of `command` + `args`). Print a one-line Claude Desktop hint so the user can also add it under Connectors. Implementation tracked in [bugs/installer/](../../ai/product/bugs/installer/2026-04-28--cc-mini--installer-remote-mcp-install.md).
+
+```json
+{
+  "tool-name": {
+    "url": "https://example.com/mcp",
+    "transport": "streamable-http"
+  }
+}
+```
+
+**How it differs from #3:** sibling transport, not a flag on #3.
+
+| | #3 Local stdio | #4 Remote |
+|---|---|---|
+| Transport | stdio (child process) | HTTPS + SSE or streamable HTTP |
+| Process model | Per-session spawn | Long-running, multi-tenant |
+| Auth | Trust the local process | OAuth or shared secret |
+| Surfaces | Claude Code, Cursor, OpenClaw | Claude Desktop, web, mobile |
+
+### 5. OpenClaw Plugin
 
 A plugin for OpenClaw agents. Lifecycle hooks, tool registration, settings.
 
@@ -74,12 +140,14 @@ A plugin for OpenClaw agents. Lifecycle hooks, tool registration, settings.
 
 **Install:** Copy to `~/.openclaw/extensions/<name>/`, run `npm install --omit=dev`.
 
-### 5. Skill (SKILL.md)
+### 6. Skill (SKILL.md)
 
 A markdown file that teaches agents when and how to use the tool. The instruction interface. Follows the [Agent Skills Spec](https://agentskills.io/specification).
 
 **Convention:** `SKILL.md` at the repo root. YAML frontmatter with name, description. Optional `references/` directory for context files.
 
+**Platform variants:** Codex CLI reads `AGENTS.md` instead of `SKILL.md`, with the same role and the same content shape. Treat `AGENTS.md` as the Codex-flavored filename for this same interface, not a separate interface. A repo may ship both (or symlink one to the other) so it works in Codex and SKILL.md-aware agents.
+
 **Detection:** `SKILL.md` exists.
 
 **Install:** `SKILL.md` deployed to `~/.openclaw/skills/<name>/`. If `references/` exists, deployed alongside SKILL.md and to `settings/docs/skills/<name>/` in the workspace.
@@ -113,7 +181,7 @@ metadata:
 ---
 ```
 
-### 6. Claude Code Hook
+### 7. Claude Code Hook
 
 A hook that runs during Claude Code's tool lifecycle (PreToolUse, Stop, etc.).
 
@@ -138,6 +206,58 @@ A hook that runs during Claude Code's tool lifecycle (PreToolUse, Stop, etc.).
 }
 ```
 
+### 8. Claude Code Plugin
+
+A distributable plugin for Claude Code. Bundles skills, agents, hooks, MCP servers, and LSP servers into one installable package. Shareable via marketplaces.
+
+**Convention:** `.claude-plugin/plugin.json` at the repo root.
+
+**Detection:** `.claude-plugin/plugin.json` exists.
+
+**Install:** Registered with Claude Code via `/plugin install` or marketplace.
+
+```
+your-plugin/
+├── .claude-plugin/
+│   └── plugin.json   # manifest (name, version, description)
+├── skills/           # SKILL.md files
+├── agents/           # subagent definitions
+├── hooks/
+│   └── hooks.json    # event handlers
+├── .mcp.json         # MCP server configs
+└── .lsp.json         # LSP server configs
+```
+
+```json
+{
+  "name": "your-plugin",
+  "version": "1.0.0",
+  "description": "What it does",
+  "author": { "name": "Your Name" }
+}
+```
+
+### Out of scope by design
+
+**Disposable, agent-generated artifacts** (custom dashboards, ephemeral scripts, one-off automations, the 300-line cardio tracker someone vibe-codes in an hour) are out of scope for this spec. They are products of an agent, not Universal Interface products. The eight interfaces describe what the agent has to *compose with*. The composition output is not itself a numbered interface and never will be.
+
+### Worked example (compact sketch)
+
+User says: *"Help me track my resting heart rate over the next 8 weeks. Goal: 50 → 45 bpm. Zone 2 cardio + 1 HIIT/week."*
+
+The agent:
+
+1. Reads personal context from Memory Crystal (RHR baseline, prior experiments, units preference).
+2. Resolves the treadmill via catalog → install spec URL → declared Remote MCP (#4) for workout data.
+3. Pulls calendar/time semantics for the 8-week window.
+4. Composes a disposable dashboard (~300 lines).
+
+The dashboard is **not** a Universal Interface product. It is the agent's output, assembled from agent-native sensors and actuators. Full version of this example is tracked separately ... see [bugs/installer/2026-04-28--cc-mini--installer-cardio-tracker-worked-example.md](../../ai/product/bugs/installer/2026-04-28--cc-mini--installer-cardio-tracker-worked-example.md).
+
+### Future considerations
+
+*LSP as a standalone interface (#9).* LSP servers are currently surfaced via Claude Code Plugin bundles (#8) ... `.lsp.json` is part of the plugin shape. If a product ships a standalone LSP server outside a CC Plugin, we will add it as a numbered interface. Not added today because no WIP product ships one yet, and the spec should describe interfaces we install and use, not interfaces software could theoretically have.
+
 ## Architecture
 
 Every repo that follows this spec has the same basic structure:
@@ -153,9 +273,9 @@ your-tool/
   ai/                  development process (plans, todos, notes)
 ```
 
-Not every tool needs all six interfaces. Build the ones that make sense.
+Not every tool needs all eight interfaces. Build the ones that make sense.
 
-The minimum viable agent-native tool has two interfaces: **Module** (importable) and **Skill** (agent instructions). Add CLI for humans. Add MCP for agents that speak MCP. Add OpenClaw/CC Hook for specific platforms.
+The minimum viable agent-native tool has two interfaces: **Module** (importable) and **Skill** (agent instructions). Add CLI for humans. Add local MCP (#3) for agents that speak MCP over stdio. Add Remote MCP (#4) when you want Claude Desktop / web / mobile to reach the same server. Add OpenClaw Plugin / CC Hook / CC Plugin for specific platforms.
 
 ## The `ai/` Folder
 
@@ -175,20 +295,73 @@ The `ai/` folder is the development process. It is not part of the published pro
 
 **Public/private split:** If a repo is public, the `ai/` folder should not ship. The recommended pattern is to maintain a private working repo (with `ai/`) and a public repo (everything except `ai/`). The public repo has everything an LLM or human needs to understand and use the tool. The `ai/` folder is operational context for the team building it.
 
-## The Reference Installer
+## The Installer
 
-`ldm install` is the primary installer (part of LDM OS). `wip-install` is the standalone fallback. Both scan a repo, detect which interfaces exist, and install them all. One command.
+`ldm install` is the primary installer (part of LDM OS). `wip-install` is the standalone fallback. Both scan a repo or slug, detect which interfaces exist, and install them all. One command.
 
 ```bash
-ldm install /path/to/repo           # local (via LDM OS)
-ldm install org/repo                # from GitHub
-ldm install org/repo --dry-run      # detect only
-wip-install /path/to/repo           # standalone fallback (bootstraps LDM OS if needed)
-wip-install --json /path/to/repo    # JSON output
+ldm install /path/to/repo               # local (via LDM OS)
+ldm install org/repo                    # from GitHub
+ldm install <slug>                      # from catalog (stable, default)
+ldm install --alpha <slug>              # alpha (validation track)
+ldm install --beta <slug>               # beta (validation track)
+ldm install <slug> --dry-run            # detect only, no changes
+wip-install /path/to/repo               # standalone fallback (bootstraps LDM OS if needed)
+wip-install --json /path/to/repo        # JSON output
 ```
 
+Tracks select the npm dist-tag (or git ref) the installer pulls from. The same install spec URL covers all three; the AI follows the spec, the user (or releasing agent) picks the track via flag.
+
 For toolbox repos (with a `tools/` directory containing sub-tools), the installer enters toolbox mode and installs each sub-tool.
 
+## Install Spec
+
+An **install spec** is an agent-readable install runbook published at a stable URL:
+
+```
+https://wip.computer/install/<slug>.txt
+```
+
+The contract is the URL and the behavior, not the file origin. An install spec can be generated from `SKILL.md`, mirrored from it, or live alongside it. What matters is that any AI can fetch it, read it, and walk a user through a safe install.
+
+### Behavior contract
+
+The spec teaches an AI to:
+
+1. **Check** whether the product is already installed and at what version.
+2. **Explain** what the product is, what it installs, and what changes for this AI and the user's other AIs.
+3. **Dry-run** so the user sees what will change before anything is touched.
+4. **Install** only after explicit user consent.
+5. **Update** an existing install (skip steps the user already did).
+6. **Pair** any post-install steps (passkey, device pairing, gateway start, etc.) with explicit consent at each step.
+
+### Tracks
+
+One install spec covers all release tracks. The user picks via flag:
+
+| Track | Flag | Audience |
+|-------|------|----------|
+| Stable | (default) `ldm install <slug>` | End users. Owner-dogfooded. |
+| Beta | `ldm install --beta <slug>` | Validation; agents may install. |
+| Alpha | `ldm install --alpha <slug>` | Validation; agents may install. |
+
+The spec text itself is track-neutral. Tracks are an installer concern, not a copy concern.
+
+### Install spec vs `agent.txt`
+
+These are related, not the same. Both are agent-readable. They sit at different scopes:
+
+- **`agent.txt`** ... site- or product-level entrypoint for agents. "What can agents do here? What routes exist? What policies apply?" Lives at the root of a site or product (e.g. `wip.computer/agent.txt`).
+- **`install/<slug>.txt`** ... per-product install runbook. "How should an agent safely check, explain, dry-run, install, update, and pair this product?" Lives under `wip.computer/install/`.
+
+`agent.txt` can point agents at install specs. An install spec does not replace `agent.txt`.
+
+### Worked example: Codex Remote Control
+
+Install spec: [`https://wip.computer/install/wip-codex-remote-control.txt`](https://wip.computer/install/wip-codex-remote-control.txt).
+
+The user pastes one prompt into Codex (or any AI). The AI fetches the install spec, checks installed state, explains the product, runs `ldm install --dry-run wip-codex-remote-control`, and only installs (and starts the daemon, and pairs the phone) after the user says yes at each step. Tracks are selected by flag against the same URL.
+
 ## Examples
 
 ### AI DevOps Toolbox (this repo)