@way_marks/cli 0.7.0 → 0.9.0

package/dist/commands/init.js

@@ -40,7 +40,8 @@ const os = __importStar(require("os"));
 const readline = __importStar(require("readline"));
 const child_process_1 = require("child_process");
 const DEFAULT_CONFIG = {
-    version: '1',
+    version: '2',
+    platforms: ['claude'],
     policies: {
         allowedPaths: [
             './src/**',
@@ -170,6 +171,38 @@ function resolveServerBin() {
         return path.resolve(__dirname, '../../../server/dist/mcp/server.js');
     }
 }
+async function selectPlatforms() {
+    console.log('');
+    console.log('┌─ Platform Selection ──────────────────────────────────┐');
+    console.log('│ Which AI platform(s) will you use with Waymark?       │');
+    console.log('│                                                       │');
+    console.log('│ 1. Claude Desktop / Claude Code (RECOMMENDED) ✓       │');
+    console.log('│    → Best experience. Full Waymark features.          │');
+    console.log('│                                                       │');
+    console.log('│ 2. GitHub Copilot CLI (EXPERIMENTAL) ⚠               │');
+    console.log('│    → Terminal support. CLI-only (no VSCode).          │');
+    console.log('│                                                       │');
+    console.log('│ 3. Both (Claude + GitHub Copilot CLI)                 │');
+    console.log('│    → Setup for both. Easy to switch.                  │');
+    console.log('└───────────────────────────────────────────────────────┘');
+    console.log('');
+    while (true) {
+        const answer = await prompt('Enter choice (1-3) [default: 1]: ');
+        const choice = answer || '1';
+        if (choice === '1') {
+            return ['claude'];
+        }
+        else if (choice === '2') {
+            return ['copilot-cli'];
+        }
+        else if (choice === '3') {
+            return ['claude', 'copilot-cli'];
+        }
+        else {
+            console.log('Invalid choice. Please enter 1, 2, or 3.');
+        }
+    }
+}
 async function run() {
     const projectRoot = process.cwd();
     const projectName = kebabCase(path.basename(projectRoot));
@@ -183,6 +216,8 @@ async function run() {
     if (!hasPackageJson && !hasGit) {
         console.warn('Warning: No package.json or .git found. Continuing anyway.');
     }
+    // Step 1b — Select platforms (NEW in Phase 5)
+    const selectedPlatforms = await selectPlatforms();
     // Step 2 — Install @way_marks/server (skip if already resolvable or in monorepo)
     let serverBin;
     try {
@@ -208,38 +243,44 @@ async function run() {
             serverBin = resolveServerBin();
         }
     }
-    // Step 3 — Create waymark.config.json
+    // Step 3 — Create waymark.config.json with selected platforms
     const configPath = path.join(projectRoot, 'waymark.config.json');
+    const platformConfig = { ...DEFAULT_CONFIG, platforms: selectedPlatforms };
     if (fs.existsSync(configPath)) {
         const answer = await prompt('waymark.config.json exists. Overwrite? (y/N) ');
         if (answer.toLowerCase() !== 'y') {
             console.log('Keeping existing waymark.config.json');
         }
         else {
-            fs.writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2) + '\n');
-            console.log('✓ Created waymark.config.json');
+            fs.writeFileSync(configPath, JSON.stringify(platformConfig, null, 2) + '\n');
+            console.log('✓ Created waymark.config.json with platforms:', selectedPlatforms.join(', '));
         }
     }
     else {
-        fs.writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2) + '\n');
-        console.log('✓ Created waymark.config.json');
+        fs.writeFileSync(configPath, JSON.stringify(platformConfig, null, 2) + '\n');
+        console.log('✓ Created waymark.config.json with platforms:', selectedPlatforms.join(', '));
     }
-    // Step 4 — Create/append CLAUDE.md
-    const claudeMdPath = path.join(projectRoot, 'CLAUDE.md');
-    const claudeMdContent = generateClaudeMd(projectName, defaultPort);
-    if (fs.existsSync(claudeMdPath)) {
-        const existing = fs.readFileSync(claudeMdPath, 'utf8');
-        if (existing.includes(WAYMARK_MARKER)) {
-            console.log('✓ CLAUDE.md already has Waymark section');
+    // Step 4 — Create/append CLAUDE.md (only if Claude selected)
+    if (selectedPlatforms.includes('claude')) {
+        const claudeMdPath = path.join(projectRoot, 'CLAUDE.md');
+        const claudeMdContent = generateClaudeMd(projectName, defaultPort);
+        if (fs.existsSync(claudeMdPath)) {
+            const existing = fs.readFileSync(claudeMdPath, 'utf8');
+            if (existing.includes(WAYMARK_MARKER)) {
+                console.log('✓ CLAUDE.md already has Waymark section');
+            }
+            else {
+                fs.appendFileSync(claudeMdPath, `\n${WAYMARK_MARKER}\n${claudeMdContent}`);
+                console.log('✓ Appended Waymark section to CLAUDE.md');
+            }
         }
         else {
-            fs.appendFileSync(claudeMdPath, `\n${WAYMARK_MARKER}\n${claudeMdContent}`);
-            console.log('✓ Appended Waymark section to CLAUDE.md');
+            fs.writeFileSync(claudeMdPath, `${WAYMARK_MARKER}\n${claudeMdContent}`);
+            console.log('✓ Created CLAUDE.md — Claude Code will now use Waymark automatically');
         }
     }
     else {
-        fs.writeFileSync(claudeMdPath, `${WAYMARK_MARKER}\n${claudeMdContent}`);
-        console.log('✓ Created CLAUDE.md — Claude Code will now use Waymark automatically');
+        console.log('⊘ Skipping CLAUDE.md (Claude not selected)');
     }
     // Step 5 — Update .gitignore
     const gitignorePath = path.join(projectRoot, '.gitignore');
@@ -256,47 +297,66 @@ async function run() {
     else {
         console.log('✓ .gitignore already up to date');
     }
-    // Step 6 — Register MCP in both Claude configs
-    const nodeBin = process.execPath;
-    const mcpEntry = {
-        command: nodeBin,
-        args: [serverBin, '--project-root', projectRoot, '--db-path', dbPath]
-    };
-    // Claude Desktop config — add/update this project's entry only
-    const desktopConfigPath = getClaudeDesktopConfigPath();
-    try {
-        const desktopDir = path.dirname(desktopConfigPath);
-        if (!fs.existsSync(desktopDir))
-            fs.mkdirSync(desktopDir, { recursive: true });
-        const desktopConfig = fs.existsSync(desktopConfigPath)
-            ? JSON.parse(fs.readFileSync(desktopConfigPath, 'utf8'))
-            : { mcpServers: {} };
-        if (!desktopConfig.mcpServers)
-            desktopConfig.mcpServers = {};
-        desktopConfig.mcpServers[mcpKey] = mcpEntry;
-        fs.writeFileSync(desktopConfigPath, JSON.stringify(desktopConfig, null, 2) + '\n');
-        console.log(`✓ Registered MCP server "${mcpKey}" in Claude Desktop config`);
-    }
-    catch (err) {
-        console.warn(`Warning: Could not update Claude Desktop config: ${err.message}`);
+    // Step 6 — Register MCP in both Claude configs (only if Claude selected)
+    if (selectedPlatforms.includes('claude')) {
+        const nodeBin = process.execPath;
+        const mcpEntry = {
+            command: nodeBin,
+            args: [serverBin, '--project-root', projectRoot, '--db-path', dbPath]
+        };
+        // Claude Desktop config — add/update this project's entry only
+        const desktopConfigPath = getClaudeDesktopConfigPath();
+        try {
+            const desktopDir = path.dirname(desktopConfigPath);
+            if (!fs.existsSync(desktopDir))
+                fs.mkdirSync(desktopDir, { recursive: true });
+            const desktopConfig = fs.existsSync(desktopConfigPath)
+                ? JSON.parse(fs.readFileSync(desktopConfigPath, 'utf8'))
+                : { mcpServers: {} };
+            if (!desktopConfig.mcpServers)
+                desktopConfig.mcpServers = {};
+            desktopConfig.mcpServers[mcpKey] = mcpEntry;
+            fs.writeFileSync(desktopConfigPath, JSON.stringify(desktopConfig, null, 2) + '\n');
+            console.log(`✓ Registered MCP server "${mcpKey}" in Claude Desktop config`);
+        }
+        catch (err) {
+            console.warn(`Warning: Could not update Claude Desktop config: ${err.message}`);
+        }
+        // .mcp.json (Claude Code project-level)
+        const mcpJsonPath = path.join(projectRoot, '.mcp.json');
+        try {
+            const mcpJson = fs.existsSync(mcpJsonPath)
+                ? JSON.parse(fs.readFileSync(mcpJsonPath, 'utf8'))
+                : { mcpServers: {} };
+            if (!mcpJson.mcpServers)
+                mcpJson.mcpServers = {};
+            mcpJson.mcpServers[mcpKey] = { type: 'stdio', ...mcpEntry, cwd: projectRoot };
+            fs.writeFileSync(mcpJsonPath, JSON.stringify(mcpJson, null, 2) + '\n');
+            console.log(`✓ Created/updated .mcp.json for Claude Code`);
+        }
+        catch (err) {
+            console.warn(`Warning: Could not update .mcp.json: ${err.message}`);
+        }
     }
-    // .mcp.json (Claude Code project-level)
-    const mcpJsonPath = path.join(projectRoot, '.mcp.json');
-    try {
-        const mcpJson = fs.existsSync(mcpJsonPath)
-            ? JSON.parse(fs.readFileSync(mcpJsonPath, 'utf8'))
-            : { mcpServers: {} };
-        if (!mcpJson.mcpServers)
-            mcpJson.mcpServers = {};
-        mcpJson.mcpServers[mcpKey] = { type: 'stdio', ...mcpEntry, cwd: projectRoot };
-        fs.writeFileSync(mcpJsonPath, JSON.stringify(mcpJson, null, 2) + '\n');
-        console.log(`✓ Created/updated .mcp.json for Claude Code`);
+    else {
+        console.log('⊘ Skipping MCP registration (Claude not selected)');
     }
-    catch (err) {
-        console.warn(`Warning: Could not update .mcp.json: ${err.message}`);
+    // Step 6b — Show Copilot CLI instructions (if Copilot CLI selected)
+    if (selectedPlatforms.includes('copilot-cli')) {
+        console.log('');
+        console.log('📋 GitHub Copilot CLI Setup');
+        console.log('─'.repeat(50));
+        console.log('⚠️  Copilot CLI support requires manual setup.');
+        console.log('See COPILOT_CLI.md for step-by-step instructions.');
+        console.log('');
+        console.log('Quick start:');
+        console.log('1. Find copilot binary: which copilot');
+        console.log('2. Run: npx @way_marks/cli init-copilot-wrapper');
+        console.log('3. Test: copilot --version');
+        console.log('');
     }
-    // Step 7 — Success summary
-    const col = 43;
+    // Step 7 — Success summary (updated for platform selection)
+    const col = 50;
     const pad = (s) => s + ' '.repeat(Math.max(0, col - 2 - s.length));
     console.log('');
     console.log('┌' + '─'.repeat(col) + '┐');
@@ -304,22 +364,35 @@ async function run() {
     console.log(`│ ${pad('')} │`);
     console.log(`│ ${pad(`Project: ${projectName}`)} │`);
     console.log(`│ ${pad('Database: .waymark/waymark.db')} │`);
-    console.log(`│ ${pad(`MCP key: ${mcpKey}`)} │`);
+    console.log(`│ ${pad(`Platforms: ${selectedPlatforms.join(', ')}`)} │`);
     console.log(`│ ${pad('')} │`);
     console.log(`│ ${pad('Files created:')} │`);
-    console.log(`│ ${pad('  waymark.config.json')} │`);
-    console.log(`│ ${pad('  CLAUDE.md')} │`);
+    console.log(`│ ${pad('  waymark.config.json (with platforms)')} │`);
+    if (selectedPlatforms.includes('claude')) {
+        console.log(`│ ${pad('  CLAUDE.md')} │`);
+    }
+    if (selectedPlatforms.includes('copilot-cli')) {
+        console.log(`│ ${pad('  (see COPILOT_CLI.md setup)')} │`);
+    }
     console.log(`│ ${pad('  .waymark/ (gitignored)')} │`);
     console.log(`│ ${pad('')} │`);
-    console.log(`│ ${pad('Next steps:')} │`);
-    console.log(`│ ${pad('1. Run: npx @way_marks/cli start')} │`);
-    console.log(`│ ${pad('2. Restart Claude Code')} │`);
-    console.log(`│ ${pad('3. Open this project in Claude')} │`);
-    console.log(`│ ${pad('4. Dashboard: http://localhost:3001')} │`);
-    console.log(`│ ${pad('   (port may differ if 3001 is taken)')} │`);
+    if (selectedPlatforms.includes('claude')) {
+        console.log(`│ ${pad('Next steps (Claude):')} │`);
+        console.log(`│ ${pad('1. Run: npx @way_marks/cli start')} │`);
+        console.log(`│ ${pad('2. Restart Claude Code')} │`);
+        console.log(`│ ${pad('3. Open project in Claude')} │`);
+        console.log(`│ ${pad('4. Dashboard: http://localhost:3001')} │`);
+    }
+    if (selectedPlatforms.includes('copilot-cli')) {
+        if (selectedPlatforms.includes('claude')) {
+            console.log(`│ ${pad('')} │`);
+        }
+        console.log(`│ ${pad('Next steps (Copilot CLI):')} │`);
+        console.log(`│ ${pad('1. See COPILOT_CLI.md for wrapper setup')} │`);
+    }
     console.log(`│ ${pad('')} │`);
-    console.log(`│ ${pad('Waymark is now always-on in this')} │`);
-    console.log(`│ ${pad('project. Claude will use Waymark')} │`);
-    console.log(`│ ${pad('tools automatically via CLAUDE.md')} │`);
+    console.log(`│ ${pad('For more info:')} │`);
+    console.log(`│ ${pad('  README.md — Feature overview')} │`);
+    console.log(`│ ${pad('  README_PLATFORMS.md — Platform support')} │`);
     console.log('└' + '─'.repeat(col) + '┘');
 }

package/dist/commands/list.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * waymark list — List all registered Waymark projects
+ *
+ * Shows project name, port, status, uptime, and user.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const registry_1 = require("../registry");
+function run() {
+    (0, registry_1.cleanupStaleEntries)();
+    const projects = (0, registry_1.listProjects)();
+    if (projects.length === 0) {
+        console.log('No Waymark projects registered.');
+        console.log('Run: waymark init && waymark start');
+        return;
+    }
+    // Format output
+    console.log('\n📋 Waymark Projects');
+    console.log('═══════════════════════════════════════════════════════════════\n');
+    for (const p of projects) {
+        const statusEmoji = p.status === 'running' ? '🟢' : p.status === 'paused' ? '⏸️ ' : '🔴';
+        const started = new Date(p.startedAt);
+        const uptime = p.status === 'running'
+            ? Math.floor((Date.now() - started.getTime()) / 1000)
+            : 0;
+        const uptimeStr = uptime > 3600
+            ? `${Math.floor(uptime / 3600)}h ${Math.floor((uptime % 3600) / 60)}m`
+            : `${Math.floor(uptime / 60)}m`;
+        console.log(`${statusEmoji} ${p.projectName}`);
+        console.log(`   ID:     ${p.id}`);
+        console.log(`   Port:   http://localhost:${p.port}`);
+        console.log(`   Status: ${p.status}${p.status === 'running' ? ` (${uptimeStr})` : ''}`);
+        console.log(`   User:   ${p.user}@${p.hostname}`);
+        console.log(`   Path:   ${p.projectRoot}`);
+        console.log('');
+    }
+    const running = projects.filter(p => p.status === 'running').length;
+    const paused = projects.filter(p => p.status === 'paused').length;
+    const stopped = projects.filter(p => p.status === 'stopped').length;
+    console.log(`Summary: ${running} running, ${paused} paused, ${stopped} stopped`);
+    console.log('═══════════════════════════════════════════════════════════════\n');
+    if (running === 0) {
+        console.log('💡 Tip: Run "waymark open PROJECT_NAME" to start a project');
+    }
+}

package/dist/commands/open.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * waymark open — Open a project dashboard in browser
+ *
+ * Usage: waymark open PROJECT_NAME
+ *
+ * If the project is not running, starts it first.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const child_process_1 = require("child_process");
+const registry_1 = require("../registry");
+function openBrowser(url) {
+    try {
+        const cmd = process.platform === 'darwin' ? 'open'
+            : process.platform === 'win32' ? 'start'
+                : 'xdg-open';
+        (0, child_process_1.execSync)(`${cmd} ${url}`, { stdio: 'ignore' });
+    }
+    catch {
+        console.log(`Open this URL in your browser: ${url}`);
+    }
+}
+function run() {
+    const projectName = process.argv[3];
+    if (!projectName) {
+        console.error('Usage: waymark open PROJECT_NAME');
+        console.error('');
+        console.error('Example:');
+        console.error('  waymark open my-app');
+        console.error('');
+        console.error('Registered projects:');
+        (0, registry_1.cleanupStaleEntries)();
+        const projects = (0, registry_1.listProjects)('running');
+        if (projects.length > 0) {
+            projects.forEach(p => {
+                console.error(`  - ${p.id} (port ${p.port})`);
+            });
+        }
+        else {
+            console.error('  (none running — run: waymark start)');
+        }
+        process.exit(1);
+    }
+    (0, registry_1.cleanupStaleEntries)();
+    const project = (0, registry_1.getProject)(projectName);
+    if (!project) {
+        console.error(`Project not found: ${projectName}`);
+        console.error('');
+        console.error('Available projects:');
+        const all = (0, registry_1.listProjects)();
+        if (all.length > 0) {
+            all.forEach(p => {
+                const status = p.status === 'running' ? '🟢' : '🔴';
+                console.error(`  ${status} ${p.id} (port ${p.port})`);
+            });
+        }
+        else {
+            console.error('  (none registered)');
+        }
+        process.exit(1);
+    }
+    if (project.status !== 'running') {
+        console.log(`Project "${projectName}" is ${project.status}. Starting...`);
+        // Try to start it by running `waymark start` in its directory
+        const cwd = process.cwd();
+        try {
+            process.chdir(project.projectRoot);
+            (0, child_process_1.execSync)('npx @way_marks/cli start', { stdio: 'inherit' });
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    }
+    const url = `http://localhost:${project.port}`;
+    console.log(`Opening dashboard: ${url}`);
+    openBrowser(url);
+}

package/dist/commands/pause.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * waymark pause — Pause a project (keep port allocation, but mark as paused)
+ *
+ * Usage: waymark pause [PROJECT_NAME]
+ *
+ * If PROJECT_NAME is omitted, pauses the current project.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const registry_1 = require("../registry");
+function run() {
+    const projectName = process.argv[3];
+    const projectRoot = process.cwd();
+    const configPath = path.join(projectRoot, '.waymark', 'config.json');
+    if (!fs.existsSync(configPath)) {
+        console.error('No .waymark/config.json found. Run: waymark init');
+        process.exit(1);
+    }
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    const name = projectName || config.projectName || path.basename(projectRoot);
+    try {
+        const project = (0, registry_1.getProject)(name);
+        if (!project) {
+            console.error(`Project not found: ${name}`);
+            console.error('Hint: Use "waymark list" to see registered projects');
+            process.exit(1);
+        }
+        if (project.status === 'paused') {
+            console.log(`Project "${name}" is already paused.`);
+            process.exit(0);
+        }
+        (0, registry_1.updateProjectStatus)(name, 'paused');
+        console.log(`✓ Paused project: ${name}`);
+        console.log(`  Port allocated: ${project.port} (reserved for this project)`);
+        console.log(`  Resume with: waymark resume ${name}`);
+    }
+    catch (err) {
+        console.error(`Failed to pause project: ${err.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/resume.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * waymark resume — Resume a paused project
+ *
+ * Usage: waymark resume [PROJECT_NAME]
+ *
+ * If PROJECT_NAME is omitted, resumes the current project.
+ * The project keeps its previously allocated port.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const registry_1 = require("../registry");
+function run() {
+    const projectName = process.argv[3];
+    const projectRoot = process.cwd();
+    const configPath = path.join(projectRoot, '.waymark', 'config.json');
+    if (!fs.existsSync(configPath)) {
+        console.error('No .waymark/config.json found. Run: waymark init');
+        process.exit(1);
+    }
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    const name = projectName || config.projectName || path.basename(projectRoot);
+    try {
+        const project = (0, registry_1.getProject)(name);
+        if (!project) {
+            console.error(`Project not found: ${name}`);
+            console.error('Hint: Use "waymark list" to see registered projects');
+            process.exit(1);
+        }
+        if (project.status !== 'paused') {
+            console.error(`Project "${name}" is not paused (current status: ${project.status})`);
+            process.exit(1);
+        }
+        (0, registry_1.updateProjectStatus)(name, 'running');
+        console.log(`✓ Resumed project: ${name}`);
+        console.log(`  Dashboard: http://localhost:${project.port}`);
+    }
+    catch (err) {
+        console.error(`Failed to resume project: ${err.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/start.js

@@ -38,6 +38,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const net = __importStar(require("net"));
 const child_process_1 = require("child_process");
+const registry_1 = require("../registry");
 function resolveServerBin(name) {
     const file = name === 'mcp' ? 'mcp/server.js' : 'api/server.js';
     try {
@@ -76,20 +77,27 @@ function kebabCase(str) {
         .replace(/^-|-$/g, '');
 }
 function findAvailablePort(preferred) {
-    return new Promise((resolve) => {
-        const server = net.createServer();
-        server.listen(preferred, () => {
-            const port = server.address().port;
-            server.close(() => resolve(port));
-        });
-        server.on('error', () => {
-            if (preferred >= 3010) {
-                console.error('No available ports found between 3001-3010. Stop other Waymark projects first.');
-                process.exit(1);
-            }
-            resolve(findAvailablePort(preferred + 1));
+    // Try registry first (Phase 2+)
+    try {
+        return Promise.resolve((0, registry_1.findAvailablePort)(preferred));
+    }
+    catch {
+        // Fallback: old logic (Phase 1 compatibility)
+        return new Promise((resolve) => {
+            const server = net.createServer();
+            server.listen(preferred, () => {
+                const port = server.address().port;
+                server.close(() => resolve(port));
+            });
+            server.on('error', () => {
+                if (preferred >= 4000) {
+                    console.error('No available ports found between 3001-4000. Stop other Waymark projects first.');
+                    process.exit(1);
+                }
+                resolve(findAvailablePort(preferred + 1));
+            });
         });
-    });
+    }
 }
 async function run() {
     const projectRoot = process.cwd();
@@ -157,6 +165,25 @@ async function run() {
         port,
         startedAt: new Date().toISOString()
     }, null, 2) + '\n');
+    // Register in global registry (Phase 2+)
+    try {
+        (0, registry_1.registerProject)({
+            id: projectName,
+            projectRoot,
+            projectName,
+            port,
+            mcp_pid: mcpProc.pid,
+            api_pid: apiProc.pid,
+            status: 'running',
+            startedAt: new Date().toISOString(),
+            hostname: require('os').hostname(),
+            user: process.env.USER || 'unknown',
+        });
+    }
+    catch (err) {
+        console.warn('Warning: failed to register in global registry:', err instanceof Error ? err.message : String(err));
+        // Continue anyway — registry is optional (backward compat)
+    }
     // Open browser after short delay for server startup
     setTimeout(() => {
         openBrowser(`http://localhost:${port}`);

package/dist/commands/stop.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.run = run;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const registry_1 = require("../registry");
 function tryKill(pid) {
     try {
         process.kill(pid, 'SIGTERM');
@@ -66,6 +67,17 @@ function run() {
         fs.unlinkSync(pidFile);
     }
     catch { /* already gone */ }
+    // Unregister from global registry and release port (Phase 2+ & Phase 4)
+    try {
+        const project = (0, registry_1.findProjectByPath)(process.cwd());
+        if (project) {
+            (0, registry_1.releasePort)(project.id); // Phase 4: Release port for reuse
+            (0, registry_1.unregisterProject)(project.id);
+        }
+    }
+    catch (err) {
+        // ignore — registry cleanup is optional
+    }
     if (killedApi || killedMcp) {
         console.log('Waymark stopped.');
     }

package/dist/index.js

@@ -11,20 +11,36 @@ switch (command) {
     case 'stop':
         require('./commands/stop').run();
         break;
+    case 'pause':
+        require('./commands/pause').run();
+        break;
+    case 'resume':
+        require('./commands/resume').run();
+        break;
     case 'status':
         require('./commands/status').run();
         break;
     case 'logs':
         require('./commands/logs').run();
         break;
+    case 'list':
+        require('./commands/list').run();
+        break;
+    case 'open':
+        require('./commands/open').run();
+        break;
     default:
-        console.log('Usage: npx @way_marks/cli <init|start|stop|status|logs>');
+        console.log('Usage: npx @way_marks/cli <init|start|stop|pause|resume|status|logs|list|open>');
         console.log('');
         console.log('Commands:');
         console.log('  init    Set up Waymark in the current project');
         console.log('  start   Start the Waymark dashboard and MCP server');
         console.log('  stop    Stop the running Waymark servers');
+        console.log('  pause   Pause a project (keep port allocated)');
+        console.log('  resume  Resume a paused project');
         console.log('  status  Show current Waymark status and pending count');
         console.log('  logs    Show recent action log');
+        console.log('  list    List all registered Waymark projects');
+        console.log('  open    Open a project dashboard or start it');
         process.exit(command ? 1 : 0);
 }

package/dist/registry.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * Waymark Project Registry
+ *
+ * Central registry for managing active Waymark projects.
+ * Stored at ~/.waymark/registry.json
+ *
+ * This enables:
+ * - `waymark list` — enumerate all active projects
+ * - `waymark open PROJECT` — quickly switch between projects
+ * - Port broker — central allocation system (Phase 2 future)
+ * - Project lifecycle tracking
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRegistry = getRegistry;
+exports.registerProject = registerProject;
+exports.unregisterProject = unregisterProject;
+exports.updateProjectStatus = updateProjectStatus;
+exports.releasePort = releasePort;
+exports.getProject = getProject;
+exports.findProjectByPath = findProjectByPath;
+exports.listProjects = listProjects;
+exports.findAvailablePort = findAvailablePort;
+exports.cleanupStaleEntries = cleanupStaleEntries;
+exports.garbageCollectRegistry = garbageCollectRegistry;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const REGISTRY_DIR = path.join(os.homedir(), '.waymark');
+const REGISTRY_PATH = path.join(REGISTRY_DIR, 'registry.json');
+/**
+ * Ensure registry directory and file exist
+ */
+function ensureRegistry() {
+    if (!fs.existsSync(REGISTRY_DIR)) {
+        fs.mkdirSync(REGISTRY_DIR, { recursive: true });
+    }
+    if (!fs.existsSync(REGISTRY_PATH)) {
+        const empty = {
+            version: 1,
+            projects: {},
+            releasedPorts: [],
+            lastUpdated: new Date().toISOString(),
+        };
+        fs.writeFileSync(REGISTRY_PATH, JSON.stringify(empty, null, 2) + '\n');
+        return empty;
+    }
+    try {
+        const reg = JSON.parse(fs.readFileSync(REGISTRY_PATH, 'utf8'));
+        // Ensure releasedPorts exists for Phase 4
+        if (!reg.releasedPorts) {
+            reg.releasedPorts = [];
+        }
+        return reg;
+    }
+    catch (err) {
+        throw new Error(`Failed to read registry: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Get the current registry
+ */
+function getRegistry() {
+    return ensureRegistry();
+}
+/**
+ * Register a project (called on `waymark start`)
+ */
+function registerProject(entry) {
+    const registry = ensureRegistry();
+    entry.startedAt = entry.startedAt || new Date().toISOString();
+    entry.status = entry.status || 'running';
+    entry.hostname = entry.hostname || os.hostname();
+    entry.user = entry.user || process.env.USER || 'unknown';
+    registry.projects[entry.id] = entry;
+    registry.lastUpdated = new Date().toISOString();
+    fs.writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2) + '\n');
+}
+/**
+ * Unregister a project (called on `waymark stop`)
+ */
+function unregisterProject(id) {
+    const registry = ensureRegistry();
+    delete registry.projects[id];
+    registry.lastUpdated = new Date().toISOString();
+    fs.writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2) + '\n');
+}
+/**
+ * Update project status
+ */
+function updateProjectStatus(id, status) {
+    const registry = ensureRegistry();
+    const entry = registry.projects[id];
+    if (!entry) {
+        throw new Error(`Project not found: ${id}`);
+    }
+    entry.status = status;
+    if (status === 'stopped') {
+        entry.stoppedAt = new Date().toISOString();
+    }
+    else if (status === 'paused') {
+        entry.pausedAt = new Date().toISOString();
+    }
+    registry.lastUpdated = new Date().toISOString();
+    fs.writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2) + '\n');
+}
+/**
+ * Phase 4: Release a port when project stops (enables reuse)
+ */
+function releasePort(projectId) {
+    const registry = ensureRegistry();
+    const entry = registry.projects[projectId];
+    if (!entry) {
+        return; // Project not found, nothing to do
+    }
+    // Add port to released queue for reuse
+    if (!registry.releasedPorts) {
+        registry.releasedPorts = [];
+    }
+    registry.releasedPorts.push(entry.port);
+    registry.lastUpdated = new Date().toISOString();
+    fs.writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2) + '\n');
+}
+/**
+ * Get a project by ID
+ */
+function getProject(id) {
+    const registry = ensureRegistry();
+    return registry.projects[id] || null;
+}
+/**
+ * Find a project by directory path
+ */
+function findProjectByPath(projectRoot) {
+    const registry = ensureRegistry();
+    const normalized = path.resolve(projectRoot);
+    for (const entry of Object.values(registry.projects)) {
+        if (path.resolve(entry.projectRoot) === normalized) {
+            return entry;
+        }
+    }
+    return null;
+}
+/**
+ * List all projects
+ */
+function listProjects(filter) {
+    const registry = ensureRegistry();
+    const entries = Object.values(registry.projects);
+    if (filter) {
+        return entries.filter(e => e.status === filter);
+    }
+    return entries;
+}
+/**
+ * Find available port in the 3001-4000 range
+ * (Phase 2 future: will be replaced by central port broker)
+ */
+function findAvailablePort(preferred = 3001) {
+    const registry = ensureRegistry();
+    const usedPorts = new Set(Object.values(registry.projects)
+        .filter(p => p.status === 'running')
+        .map(p => p.port));
+    // Phase 4: Check if we have a released port to reuse first
+    if (registry.releasedPorts && registry.releasedPorts.length > 0) {
+        const releasedPort = registry.releasedPorts.shift();
+        if (releasedPort && !usedPorts.has(releasedPort)) {
+            // Save updated registry with shifted port
+            registry.lastUpdated = new Date().toISOString();
+            fs.writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2) + '\n');
+            return releasedPort;
+        }
+    }
+    // Check if preferred is available
+    if (!usedPorts.has(preferred)) {
+        return preferred;
+    }
+    // Find next available
+    for (let port = 3001; port <= 4000; port++) {
+        if (!usedPorts.has(port)) {
+            return port;
+        }
+    }
+    throw new Error('No available ports in range 3001-4000');
+}
+/**
+ * Clean up stale entries (processes that are dead but not unregistered)
+ * Called periodically by waymark list/status commands
+ */
+function cleanupStaleEntries() {
+    const registry = ensureRegistry();
+    let changed = false;
+    for (const [id, entry] of Object.entries(registry.projects)) {
+        if (entry.status === 'running' && entry.mcp_pid) {
+            try {
+                process.kill(entry.mcp_pid, 0); // Check if process exists
+            }
+            catch {
+                // Process is dead — mark as stopped
+                entry.status = 'stopped';
+                entry.stoppedAt = new Date().toISOString();
+                changed = true;
+            }
+        }
+    }
+    if (changed) {
+        registry.lastUpdated = new Date().toISOString();
+        fs.writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2) + '\n');
+    }
+}
+/**
+ * Phase 4: Garbage collect stale entries (cleanup old stopped projects)
+ * Removes entries older than daysOld that are marked as stopped
+ */
+function garbageCollectRegistry(daysOld = 7) {
+    const registry = ensureRegistry();
+    const cutoffTime = new Date();
+    cutoffTime.setDate(cutoffTime.getDate() - daysOld);
+    let removed = 0;
+    const idsToRemove = [];
+    for (const [id, entry] of Object.entries(registry.projects)) {
+        if (entry.status === 'stopped' && entry.stoppedAt) {
+            const stoppedTime = new Date(entry.stoppedAt);
+            if (stoppedTime < cutoffTime) {
+                idsToRemove.push(id);
+            }
+        }
+    }
+    for (const id of idsToRemove) {
+        delete registry.projects[id];
+        removed++;
+    }
+    if (removed > 0) {
+        // Clean up released ports queue (keep only last 20)
+        if (registry.releasedPorts && registry.releasedPorts.length > 20) {
+            registry.releasedPorts = registry.releasedPorts.slice(-20);
+        }
+        registry.lastUpdated = new Date().toISOString();
+        fs.writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2) + '\n');
+    }
+    return removed;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@way_marks/cli",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Control what AI agents can do in your codebase",
   "author": "Waymark <hello@waymarks.dev>",
   "license": "MIT",