@sudosandwich/limps 0.2.0 → 0.3.0

package/README.md

@@ -1,28 +1,214 @@
-# MCP Planning Server
+# limps
 
-MCP server for managing planning documents, agent coordination, and task tracking.
+**L**ocal **I**ntelligent **M**CP **P**lanning **S**erver - AI agent plan management and coordination.
+
+[![npm](https://img.shields.io/npm/v/@sudosandwich/limps)](https://www.npmjs.com/package/@sudosandwich/limps)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+![Tests](https://img.shields.io/badge/Tests-692%20passing-brightgreen)
+![Coverage](https://img.shields.io/badge/Coverage-%3E70%25-brightgreen)
+
+![limps in action](.github/assets/limps-in-action.gif)
+
+*Claude Desktop accessing the planning MCP, talking to Runi project docs*
+
+## The Problem limps Solves
+
+**Context drift between LLM providers** — Each AI assistant (Claude, ChatGPT, Cursor, GitHub Copilot, etc.) maintains its own separate context. Without a shared source of truth, planning documents, task status, and decisions get fragmented across different conversations and sessions.
+
+limps solves this by providing a **standardized MCP interface** that any MCP-compatible tool can access. Your planning documents, tasks, and decisions live in one place, accessible to:
+
+- **Claude Desktop** — Full access to search, read, update, create documents, claim tasks, and more
+- **Cursor** — Integrated planning and task management via MCP tools
+- **GitHub Copilot** — When MCP support is enabled
+- **Any MCP-compatible tool** — Standard protocol means universal access
+
+### Deployment Options
+
+- **Local (Default)** — Run limps locally for secure, private access
+- **Deployed** — You can deploy the MCP server for global access, but **research AUTH** to protect your endpoint and documents
+
+## Used In Production
+
+limps is actively used to build [runi](https://github.com/paulbreuler/runi) - managing planning documents, agent coordination, and task tracking across the development lifecycle.
+
+### How runi Uses limps
+
+The [runi](https://github.com/paulbreuler/runi) project uses a separate git repository ([runi-planning-docs](https://github.com/paulbreuler/runi-planning-docs)) for version-controlled planning documents. Custom Cursor commands in `.cursor/commands/` integrate with limps tools:
+
+
+
+**Core Commands:**
+
+| Command | Description | MCP Tools Used |
+|---------|-------------|----------------|
+| `/create-feature-plan` | Generate TDD plan with docs and agent files | `create_plan`, `create_doc`, `list_docs` |
+| `/list-feature-plans` | List all plans with clickable file paths | `list_docs`, `process_doc` |
+| `/run-agent` | Start work on next agent task | `process_doc`, `claim_task` |
+| `/close-feature-agent` | Verify completion, sync status | `process_doc`, `update_doc`, `release_task` |
+| `/update-feature-plan` | Regenerate agents from updated plan | `process_doc`, `create_doc`, `process_docs` |
+| `/plan-list-agents` | Show all agents with status | `list_docs`, `process_docs` |
+
+**Example: `/create-feature-plan` using MCP tools:**
+
+```typescript
+// 1. Find next plan number
+const plans = await list_docs({ path: 'plans/', pattern: '*' });
+const nextNum = Math.max(...plans.map(p => parseInt(p.name))) + 1;
+
+// 2. Create plan structure
+await create_plan({ name: `${nextNum}-my-feature`, description: '...' });
+
+// 3. Create planning documents
+await create_doc({ path: `plans/${nextNum}-my-feature/plan.md`, content: '...' });
+await create_doc({ path: `plans/${nextNum}-my-feature/interfaces.md`, content: '...' });
+```
+
+**Example: `/run-agent` using process_doc:**
+
+```typescript
+// Extract next GAP feature from plan
+const nextGap = await process_doc({
+  path: `plans/${planName}/plan.md`,
+  code: `
+    const features = extractFeatures(doc.content);
+    const gaps = features.filter(f => f.status === 'GAP');
+    return gaps.sort((a, b) => a.priority - b.priority)[0];
+  `,
+});
+```
+
+**Project Structure:**
+
+```
+runi/                          # Main codebase
+├── .cursor/commands/          # Cursor slash commands
+│   ├── create-feature-plan.md
+│   ├── list-feature-plans.md
+│   ├── run-agent.md
+│   ├── close-feature-agent.md
+│   └── update-feature-plan.md
+└── .claude/commands/          # Claude Code commands
+    └── pr.md
+
+runi-planning-docs/            # Separate git repo for plans
+├── plans/
+│   ├── 0004-datagrid/        # Feature plan
+│   │   ├── plan.md           # Full specifications
+│   │   ├── interfaces.md     # Interface contracts
+│   │   ├── README.md         # Status index
+│   │   ├── gotchas.md        # Discovered issues
+│   │   └── agents/           # Agent task files
+│   └── ...
+└── decisions/                 # Decision log
+```
 
 ## Installation
 
 ### Global Install (Recommended)
 
 ```bash
-npm install -g mcp-planning-server
+npm install -g @sudosandwich/limps
+```
+
+### Quick Setup
+
+```bash
+limps init my-project --docs-path ~/Documents/my-project
+```
+
+This creates a config and outputs the Cursor/Claude Desktop configuration snippets with full paths.
+
+## CLI Commands
+
+limps provides a full CLI for managing projects and viewing plans without needing an MCP client.
+
+```bash
+limps --help              # Show all commands
+limps <command> --help    # Show command help
 ```
 
+### Project Management
+
+| Command | Description |
+|---------|-------------|
+| `limps init <name>` | Initialize a new project |
+| `limps serve` | Start the MCP server |
+
+### Plan Commands
+
+| Command | Description |
+|---------|-------------|
+| `limps list-plans` | List all plans with status |
+| `limps list-agents <plan>` | List agents in a plan |
+| `limps next-task <plan>` | Get the highest-priority available task |
+| `limps status <plan>` | Show plan status summary |
+
+### Configuration
+
+| Command | Description |
+|---------|-------------|
+| `limps config list` | Show all registered projects |
+| `limps config use <name>` | Switch to a different project |
+| `limps config show` | Display resolved configuration |
+| `limps config path` | Print the config file path |
+| `limps config add <name> <path>` | Register an existing config |
+| `limps config remove <name>` | Unregister a project |
+| `limps config set <path>` | Set current from config path |
+| `limps config discover` | Find configs in default locations |
+
+### Multi-Project Workflow
+
+```bash
+# Register multiple projects
+limps init project-a --docs-path ~/Documents/project-a
+limps init project-b --docs-path ~/Documents/project-b
+
+# Switch between projects
+limps config use project-a
+limps list-plans
+
+limps config use project-b
+limps list-plans
+
+# Use environment variable
+LIMPS_PROJECT=project-a limps list-plans
+```
+
+### Example: Git-based Document Versioning
+
+Point limps at a git repository to version control your planning documents:
+
+```bash
+# Create a dedicated docs repo
+mkdir ~/Documents/GitHub/my-planning-docs
+cd ~/Documents/GitHub/my-planning-docs
+git init
+
+# Initialize limps with your docs repo
+limps init my-project --docs-path ~/Documents/GitHub/my-planning-docs
+```
+
+This approach gives you:
+- **Version history** for all plans and decisions
+- **Branching** for experimental planning
+- **Collaboration** via pull requests
+- **Backup** through remote repositories
+
+### Manual Configuration
+
 The server automatically finds configuration at OS-specific locations:
 
 | OS | Config Location |
 |----|-----------------|
-| macOS | `~/Library/Application Support/mcp-planning-server/config.json` |
-| Linux | `~/.config/mcp-planning-server/config.json` |
-| Windows | `%APPDATA%\mcp-planning-server\config.json` |
+| macOS | `~/Library/Application Support/limps/config.json` |
+| Linux | `~/.config/limps/config.json` |
+| Windows | `%APPDATA%\limps\config.json` |
 
 ### From Source
 
 ```bash
-git clone https://github.com/yourusername/mcp-planning-server.git
-cd mcp-planning-server
+git clone https://github.com/paulbreuler/limps.git
+cd limps
 npm install
 npm run build
 ```
@@ -36,8 +222,8 @@ Create a `config.json` at the OS-specific location or specify a path:
   "plansPath": "~/Documents/my-plans",
   "docsPaths": ["~/Documents/my-plans"],
   "fileExtensions": [".md"],
-  "dataPath": "~/Library/Application Support/mcp-planning-server/data",
-  "coordinationPath": "~/Library/Application Support/mcp-planning-server/coordination.json",
+  "dataPath": "~/Library/Application Support/limps/data",
+  "coordinationPath": "~/Library/Application Support/limps/coordination.json",
   "heartbeatTimeout": 300000,
   "debounceDelay": 200,
   "maxHandoffIterations": 3
@@ -45,7 +231,7 @@ Create a `config.json` at the OS-specific location or specify a path:
 ```
 
 **Config priority:**
-1. CLI: `mcp-planning-server --config /path/to/config.json`
+1. CLI: `limps --config /path/to/config.json`
 2. Environment: `MCP_PLANNING_CONFIG=/path/to/config.json`
 3. OS-specific default location
 
@@ -61,8 +247,8 @@ Add to Cursor settings (`Cmd+Shift+P` → "Preferences: Open User Settings (JSON
 ```json
 {
   "mcp.servers": {
-    "mcp-planning-server": {
-      "command": "mcp-planning-server"
+    "limps": {
+      "command": "limps"
     }
   }
 }
@@ -72,47 +258,101 @@ With explicit config:
 ```json
 {
   "mcp.servers": {
-    "mcp-planning-server": {
-      "command": "mcp-planning-server",
+    "limps": {
+      "command": "limps",
       "args": ["--config", "/path/to/config.json"]
     }
   }
 }
 ```
 
-From source:
+## Claude Desktop Setup
+
+Claude Desktop runs in a macOS sandbox and cannot access global npm binaries. Use `npx` instead.
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
 ```json
 {
-  "mcp.servers": {
-    "mcp-planning-server": {
-      "command": "node",
-      "args": ["/path/to/mcp-planning-server/dist/index.js"],
-      "cwd": "/path/to/mcp-planning-server"
+  "mcpServers": {
+    "limps": {
+      "command": "npx",
+      "args": ["-y", "@sudosandwich/limps", "--config", "/path/to/config.json"]
     }
   }
 }
 ```
 
+> **Note:** Run `limps init my-project` first to generate the config, then copy the full path into the config above.
+
 ## Features
 
-### Document Management (14 Tools)
+### MCP Tools (16 Tools)
+
+#### Document Operations
 
 | Tool | Description |
 |------|-------------|
-| `read_doc` | Read full document content |
+| `process_doc` | Process a document with JavaScript code (read, filter, transform, extract) |
+| `process_docs` | Process multiple documents with JavaScript for cross-document analysis |
 | `create_doc` | Create new documents |
 | `update_doc` | Update with optimistic concurrency |
 | `delete_doc` | Delete documents |
 | `list_docs` | List files and directories |
 | `search_docs` | Full-text search (SQLite FTS5) |
-| `rlm_query` | JavaScript filter/transform on documents |
-| `rlm_multi_query` | Cross-document analysis with globs |
-| `create_plan` | Create feature plans with structure |
-| `update_task_status` | Update task status (GAP → WIP → PASS) |
+| `open_document_in_cursor` | Open files in Cursor editor |
+
+#### Plan Management
+
+| Tool | Description |
+|------|-------------|
+| `create_plan` | Create feature plans with directory structure and agent files |
+| `list_plans` | List all plans with status, workType, and overview |
+| `list_agents` | List agents for a plan with status, persona, and file counts |
+| `get_plan_status` | Get plan progress with completion %, blocked/WIP agents |
+
+#### Task Coordination
+
+| Tool | Description |
+|------|-------------|
+| `get_next_task` | Get highest-priority task with detailed score breakdown |
 | `claim_task` | Claim tasks with file locks |
 | `release_task` | Release tasks and locks |
-| `get_next_task` | Get highest-priority available task |
-| `open_document_in_cursor` | Open files in Cursor editor |
+| `update_task_status` | Update task status (GAP → WIP → PASS/BLOCKED) |
+
+#### Task Scoring Algorithm
+
+When using `get_next_task` with a `planId`, returns a detailed score breakdown:
+
+| Score Component | Max Points | Description |
+|----------------|------------|-------------|
+| Dependency Score | 40 | All dependencies satisfied = 40, otherwise 0 |
+| Priority Score | 30 | Based on agent number (lower = higher priority) |
+| Workload Score | 30 | Based on file count (fewer files = higher score) |
+| **Total** | **100** | Sum of all components |
+
+Example response:
+```json
+{
+  "taskId": "0001-feature#002",
+  "title": "Implement API endpoints",
+  "totalScore": 85,
+  "dependencyScore": 40,
+  "priorityScore": 24,
+  "workloadScore": 21,
+  "reasons": ["All 2 dependencies satisfied", "Agent #2 priority: 24/30", "3 files to modify: 21/30"],
+  "otherAvailableTasks": 3
+}
+```
+
+### RLM (Recursive Language Model) Support
+
+Implements the [RLM pattern from MIT CSAIL](https://arxiv.org/abs/2512.24601) for programmatic document examination and recursive processing:
+
+- **Sandbox execution** - Secure JavaScript via QuickJS
+- **Recursive sub-calls** - Depth-limited processing
+- **Parallel execution** - Cross-document analysis
+- **Document extractors** - Markdown, YAML, Gherkin parsing
 
 ### Resources (Progressive Disclosure)
 
@@ -147,10 +387,16 @@ GitHub Actions automatically builds, tests, and creates releases with changelogs
 
 ## Architecture
 
-- **SQLite + FTS5** — Full-text search with auto-updates
-- **File Watching** — Real-time indexing (Chokidar)
-- **Multi-Agent Coordination** — File-based with heartbeats
-- **RLM Sandbox** — Secure JavaScript execution (QuickJS)
+![TypeScript](https://img.shields.io/badge/TypeScript-strict-blue)
+![React](https://img.shields.io/badge/React-19-61dafb)
+![Ink](https://img.shields.io/badge/Ink-6-green)
+![SQLite](https://img.shields.io/badge/SQLite-FTS5-003B57)
+![Zod](https://img.shields.io/badge/Zod-4-3068b7)
+
+- Full-text search with auto-indexing
+- Real-time file watching (Chokidar)
+- Multi-agent coordination with heartbeats
+- RLM sandbox (QuickJS)
 
 ### Principles
 
@@ -165,6 +411,7 @@ GitHub Actions automatically builds, tests, and creates releases with changelogs
 The server is designed for planning documents but the core is generic:
 
 **Configuration-only:**
+
 ```json
 {
   "plansPath": "./your-docs",
@@ -174,6 +421,7 @@ The server is designed for planning documents but the core is generic:
 ```
 
 **For different domains** (wikis, knowledge bases):
+
 - Replace/remove planning-specific tools
 - Customize document extractors in `src/rlm/extractors.ts`
 - Modify coordination patterns or remove if single-agent

package/dist/cli/config-cmd.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Config subcommand handlers for limps CLI.
+ * Provides commands to manage the project registry and view configuration.
+ */
+/**
+ * List all registered projects.
+ *
+ * @returns Formatted list of projects
+ */
+export declare function configList(): string;
+/**
+ * Switch to a different project.
+ *
+ * @param name - Project name to switch to
+ * @returns Success message
+ * @throws Error if project not found
+ */
+export declare function configUse(name: string): string;
+/**
+ * Show the resolved configuration values.
+ *
+ * @param resolveConfigPathFn - Function to resolve config path (injected to avoid circular deps)
+ * @returns Formatted configuration
+ */
+export declare function configShow(resolveConfigPathFn: () => string): string;
+/**
+ * Print the resolved config file path.
+ *
+ * @param resolveConfigPathFn - Function to resolve config path (injected to avoid circular deps)
+ * @returns The config path
+ */
+export declare function configPath(resolveConfigPathFn: () => string): string;
+/**
+ * Add/register an existing config file to the registry.
+ *
+ * @param name - Project name to use
+ * @param configFilePath - Path to the config file
+ * @returns Success message
+ * @throws Error if config file doesn't exist
+ */
+export declare function configAdd(name: string, configFilePath: string): string;
+/**
+ * Remove a project from the registry.
+ * Does not delete any files.
+ *
+ * @param name - Project name to remove
+ * @returns Success message
+ * @throws Error if project not found
+ */
+export declare function configRemove(name: string): string;
+/**
+ * Set the current project from an existing config file path.
+ * Auto-derives the project name from the parent directory.
+ * Registers the project if not already registered.
+ *
+ * @param configFilePath - Path to the config file
+ * @returns Success message
+ * @throws Error if config file doesn't exist or is invalid
+ */
+export declare function configSet(configFilePath: string): string;
+/**
+ * Discover and register config files from default OS locations.
+ * Scans the OS-specific application support directories for config.json files.
+ *
+ * @returns Summary of discovered projects
+ */
+export declare function configDiscover(): string;
+//# sourceMappingURL=config-cmd.d.ts.map

package/dist/cli/config-cmd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-cmd.d.ts","sourceRoot":"","sources":["../../src/cli/config-cmd.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAaH;;;;GAIG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAmBnC;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG9C;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,mBAAmB,EAAE,MAAM,MAAM,GAAG,MAAM,CAiCpE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,mBAAmB,EAAE,MAAM,MAAM,GAAG,MAAM,CAEpE;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,CAkBtE;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGjD;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAmCxD;AAID;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAmDvC"}

package/dist/cli/config-cmd.js

@@ -0,0 +1,206 @@
+/**
+ * Config subcommand handlers for limps CLI.
+ * Provides commands to manage the project registry and view configuration.
+ */
+import { existsSync, readdirSync } from 'fs';
+import { resolve, dirname, basename } from 'path';
+import { registerProject, unregisterProject, setCurrentProject, listProjects, loadRegistry, } from './registry.js';
+import { loadConfig } from '../config.js';
+/**
+ * List all registered projects.
+ *
+ * @returns Formatted list of projects
+ */
+export function configList() {
+    const projects = listProjects();
+    if (projects.length === 0) {
+        return 'No projects registered. Run `limps init <name>` to create one.';
+    }
+    const lines = [];
+    lines.push('CURRENT  NAME                 PATH');
+    lines.push('-------  -------------------  ----');
+    for (const project of projects) {
+        const current = project.current ? '*' : ' ';
+        const name = project.name.padEnd(19);
+        const exists = existsSync(project.configPath) ? '' : ' (missing)';
+        lines.push(`   ${current}     ${name}  ${project.configPath}${exists}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Switch to a different project.
+ *
+ * @param name - Project name to switch to
+ * @returns Success message
+ * @throws Error if project not found
+ */
+export function configUse(name) {
+    setCurrentProject(name);
+    return `Switched to project "${name}"`;
+}
+/**
+ * Show the resolved configuration values.
+ *
+ * @param resolveConfigPathFn - Function to resolve config path (injected to avoid circular deps)
+ * @returns Formatted configuration
+ */
+export function configShow(resolveConfigPathFn) {
+    const configPath = resolveConfigPathFn();
+    if (!existsSync(configPath)) {
+        return `Config file not found: ${configPath}\n\nRun \`limps init <name>\` to create a project.`;
+    }
+    const config = loadConfig(configPath);
+    const lines = [];
+    lines.push(`Config file: ${configPath}`);
+    lines.push('');
+    lines.push('Configuration:');
+    lines.push(`  plansPath:          ${config.plansPath}`);
+    lines.push(`  dataPath:           ${config.dataPath}`);
+    lines.push(`  coordinationPath:   ${config.coordinationPath}`);
+    if (config.docsPaths && config.docsPaths.length > 0) {
+        lines.push(`  docsPaths:`);
+        for (const p of config.docsPaths) {
+            lines.push(`    - ${p}`);
+        }
+    }
+    if (config.fileExtensions) {
+        lines.push(`  fileExtensions:     ${config.fileExtensions.join(', ')}`);
+    }
+    lines.push(`  heartbeatTimeout:   ${config.heartbeatTimeout}ms`);
+    lines.push(`  debounceDelay:      ${config.debounceDelay}ms`);
+    lines.push(`  maxHandoffIterations: ${config.maxHandoffIterations}`);
+    return lines.join('\n');
+}
+/**
+ * Print the resolved config file path.
+ *
+ * @param resolveConfigPathFn - Function to resolve config path (injected to avoid circular deps)
+ * @returns The config path
+ */
+export function configPath(resolveConfigPathFn) {
+    return resolveConfigPathFn();
+}
+/**
+ * Add/register an existing config file to the registry.
+ *
+ * @param name - Project name to use
+ * @param configFilePath - Path to the config file
+ * @returns Success message
+ * @throws Error if config file doesn't exist
+ */
+export function configAdd(name, configFilePath) {
+    const absolutePath = resolve(configFilePath);
+    if (!existsSync(absolutePath)) {
+        throw new Error(`Config file not found: ${absolutePath}`);
+    }
+    // Validate it's a valid config file
+    try {
+        loadConfig(absolutePath);
+    }
+    catch (error) {
+        throw new Error(`Invalid config file: ${error instanceof Error ? error.message : 'unknown error'}`);
+    }
+    registerProject(name, absolutePath);
+    return `Registered project "${name}" with config: ${absolutePath}`;
+}
+/**
+ * Remove a project from the registry.
+ * Does not delete any files.
+ *
+ * @param name - Project name to remove
+ * @returns Success message
+ * @throws Error if project not found
+ */
+export function configRemove(name) {
+    unregisterProject(name);
+    return `Removed project "${name}" from registry (files not deleted)`;
+}
+/**
+ * Set the current project from an existing config file path.
+ * Auto-derives the project name from the parent directory.
+ * Registers the project if not already registered.
+ *
+ * @param configFilePath - Path to the config file
+ * @returns Success message
+ * @throws Error if config file doesn't exist or is invalid
+ */
+export function configSet(configFilePath) {
+    const absolutePath = resolve(configFilePath);
+    if (!existsSync(absolutePath)) {
+        throw new Error(`Config file not found: ${absolutePath}`);
+    }
+    // Validate it's a valid config file
+    try {
+        loadConfig(absolutePath);
+    }
+    catch (error) {
+        throw new Error(`Invalid config file: ${error instanceof Error ? error.message : 'unknown error'}`);
+    }
+    // Derive project name from parent directory
+    const projectName = basename(dirname(absolutePath));
+    // Check if already registered with this path
+    const registry = loadRegistry();
+    const existingEntry = Object.entries(registry.projects).find(([, project]) => project.configPath === absolutePath);
+    if (existingEntry) {
+        // Already registered, just set as current
+        setCurrentProject(existingEntry[0]);
+        return `Switched to project "${existingEntry[0]}"`;
+    }
+    // Register and set as current
+    registerProject(projectName, absolutePath);
+    setCurrentProject(projectName);
+    return `Registered and switched to project "${projectName}"`;
+}
+import { getOSBasePath } from '../utils/os-paths.js';
+/**
+ * Discover and register config files from default OS locations.
+ * Scans the OS-specific application support directories for config.json files.
+ *
+ * @returns Summary of discovered projects
+ */
+export function configDiscover() {
+    // Get the parent directory of where limps stores its config
+    // This respects any mocking of getOSBasePath for testing
+    const limpsBasePath = getOSBasePath('limps');
+    const searchDir = dirname(limpsBasePath);
+    const registry = loadRegistry();
+    const registeredPaths = new Set(Object.values(registry.projects).map((p) => p.configPath));
+    const discovered = [];
+    if (!existsSync(searchDir)) {
+        return 'No new projects discovered.';
+    }
+    try {
+        const entries = readdirSync(searchDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const configPath = `${searchDir}/${entry.name}/config.json`;
+            // Skip if already registered or doesn't exist
+            if (registeredPaths.has(configPath) || !existsSync(configPath))
+                continue;
+            // Validate it's a valid limps config
+            try {
+                loadConfig(configPath);
+                registerProject(entry.name, configPath);
+                discovered.push({ name: entry.name, path: configPath });
+            }
+            catch {
+                // Not a valid limps config, skip
+            }
+        }
+    }
+    catch {
+        // Can't read directory, skip
+    }
+    if (discovered.length === 0) {
+        return 'No new projects discovered.';
+    }
+    const lines = [`Discovered ${discovered.length} project(s):`, ''];
+    for (const { name, path } of discovered) {
+        lines.push(`  ${name}: ${path}`);
+    }
+    lines.push('');
+    lines.push('Run `limps config use <name>` to switch to a project.');
+    return lines.join('\n');
+}
+//# sourceMappingURL=config-cmd.js.map