cognova 0.2.19 → 0.2.21

package/dist/cli/index.js

@@ -155,7 +155,7 @@ var require_src = __commonJS({
 });
 
 // src/commands/init.ts
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 import { join as join9 } from "path";
 import crypto3 from "crypto";
 
@@ -1791,9 +1791,13 @@ import { cpSync as cpSync2, mkdirSync as mkdirSync3, existsSync as existsSync5,
 import { join as join6 } from "path";
 
 // src/templates/claude-md.ts
+import { platform } from "os";
 function generateClaudeMd(config) {
   const { personality, vault, database, appUrl, installDir } = config;
   const p = personality;
+  const plat = platform();
+  const serviceManager = plat === "darwin" ? "launchd" : plat === "linux" ? "systemd" : null;
+  const platformName = plat === "darwin" ? "macOS" : plat === "linux" ? "Linux" : plat === "win32" ? "Windows" : "this system";
   return `# ${p.agentName}
 
 You are ${p.agentName}, ${p.userName}'s personal knowledge management assistant running through **Cognova**. You operate directly on ${p.userName}'s machine via the Claude Agent SDK \u2014 you are not sandboxed.
@@ -1802,7 +1806,7 @@ You are ${p.agentName}, ${p.userName}'s personal knowledge management assistant
 
 You are a Claude-powered agent embedded in a Cognova installation. ${p.userName} has granted you full system access: file system, shell, local services, and the Cognova API. You can read and write files, execute commands, manage processes, and interact with all Cognova features.
 
-You run as a persistent service managed by PM2. Your conversations are streamed to ${p.userName} through the Cognova web dashboard.
+${serviceManager ? `You run as a persistent system service managed by **${serviceManager}** on ${platformName}.` : `You run on ${platformName}.`} Your conversations are streamed to ${p.userName} through the Cognova web dashboard.
 
 ## Identity
 
@@ -1821,7 +1825,7 @@ You run as a persistent service managed by PM2. Your conversations are streamed
 | Vault | ${vault.path} (PARA method) |
 | Database | ${database.type === "local" ? "Local PostgreSQL (Docker)" : "Remote PostgreSQL"} |
 | Skills | ~/.claude/skills/ |
-| Process Manager | PM2 \u2014 \`pm2 status\`, \`pm2 logs cognova\` |
+| Service Manager | ${serviceManager ? `${serviceManager} (${platformName})` : platformName} \u2014 \`cognova status\`, \`cognova logs\` |
 
 ## Skills
 
@@ -1890,6 +1894,7 @@ Memory is your most important tool. You are stateless between sessions \u2014 wi
 **CRITICAL \u2014 Zero tolerance for leaked secrets:**
 - NEVER store passwords, tokens, API keys, or credentials in memory, notes, conversation, or any file
 - NEVER write secrets to files \u2014 use \`/secret set KEY\` or the Cognova settings UI instead
+- ALWAYS store sensitive information using the secrets tool, which encrypts data.
 - NEVER embed API keys, tokens, or credentials in SKILL.md files or Python scripts when creating or modifying skills \u2014 always use \`get_secret()\` from \`_lib/api.py\`
 - If ${p.userName} shares a credential in chat, warn them and store it via \`/secret set KEY\` immediately
 - When you need a token for an integration, check with \`/secret list\` and \`/secret get KEY\` before asking ${p.userName}
@@ -1898,8 +1903,8 @@ Memory is your most important tool. You are stateless between sessions \u2014 wi
 
 ### Troubleshooting
 - Use \`/environment status\` or \`/environment health\` to diagnose issues
-- Check logs: \`pm2 logs cognova --lines 50\`
-- Restart: \`pm2 restart cognova\`
+- Check logs: \`cognova logs\`
+- Restart: \`cognova restart\`
 
 ### Onboarding
 On first session (when no memories exist), ask ${p.userName} about themselves before doing anything else. Store each fact as a memory and write a \`## User Profile\` section at the end of this CLAUDE.md with a brief summary. This ensures core user context is always loaded, even if memory retrieval fails.
@@ -1909,6 +1914,7 @@ On first session (when no memories exist), ask ${p.userName} about themselves be
 - You MAY create new skills in ~/.claude/skills/
 - You MAY update existing skills when you find improvements
 - Always inform ${p.userName} when modifying your own configuration
+- AVOID mofifying core system files. If an issue is found in Cognova, validate it thoroughly and then suggest to the user to report it to the github repo.
 
 ## Vault Structure
 
@@ -2117,117 +2123,256 @@ function mergeSettings(existing, generated) {
 }
 
 // src/lib/process-manager.ts
+import { execSync as execSync4 } from "child_process";
+
+// src/lib/daemon.ts
 import { execSync as execSync3 } from "child_process";
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir2, platform as platform2 } from "os";
 import { join as join7 } from "path";
-
-// src/templates/pm2-ecosystem.ts
-function generatePm2Ecosystem(config) {
-  return `const { readFileSync } = require('fs')
-const { join } = require('path')
-
-// Load .env file into env vars for PM2
-function loadEnv(dir) {
-  try {
-    const content = readFileSync(join(dir, '.env'), 'utf-8')
-    const env = {}
-    for (const line of content.split('\\n')) {
-      const trimmed = line.trim()
-      if (!trimmed || trimmed.startsWith('#')) continue
-      const eq = trimmed.indexOf('=')
-      if (eq === -1) continue
-      env[trimmed.slice(0, eq)] = trimmed.slice(eq + 1)
-    }
-    return env
-  } catch { return {} }
-}
-
-const dotenv = loadEnv('${config.installDir}')
-
-module.exports = {
-  apps: [{
-    name: 'cognova',
-    script: '.output/server/index.mjs',
-    cwd: '${config.installDir}',
-    // Use 'node' interpreter when NVM is detected to avoid path parsing issues
-    interpreter: 'node',
-    node_args: '--max-old-space-size=4096',
-    env: {
-      ...dotenv,
-      NODE_ENV: 'production',
-      PORT: 3000,
-      COGNOVA_PROJECT_DIR: '${config.installDir}'
-    },
-    // Restart on crash
-    autorestart: true,
-    max_restarts: 10,
-    restart_delay: 5000,
-    // Logging
-    log_date_format: 'YYYY-MM-DD HH:mm:ss',
-    error_file: '${config.installDir}/logs/error.log',
-    out_file: '${config.installDir}/logs/out.log',
-    merge_logs: true
-  }]
+function getDaemonInfo(installDir) {
+  const plat = platform2();
+  const serviceName = "com.cognova";
+  if (plat === "darwin") {
+    return {
+      platform: "macos",
+      serviceName,
+      configPath: join7(homedir2(), "Library", "LaunchAgents", `${serviceName}.plist`),
+      logsDir: join7(installDir, "logs")
+    };
+  }
+  if (plat === "linux") {
+    return {
+      platform: "linux",
+      serviceName: "cognova",
+      configPath: join7(homedir2(), ".config", "systemd", "user", "cognova.service"),
+      logsDir: join7(installDir, "logs")
+    };
+  }
+  return {
+    platform: "unsupported",
+    serviceName: "cognova",
+    configPath: "",
+    logsDir: ""
+  };
 }
+function generateLaunchdPlist(config) {
+  const nodePath = execSync3("which node", { encoding: "utf-8" }).trim();
+  const serverPath = join7(config.installDir, ".output", "server", "index.mjs");
+  const logsDir = join7(config.installDir, "logs");
+  const envPath = join7(config.installDir, ".env");
+  let envVars = "";
+  if (existsSync6(envPath)) {
+    const envContent = readFileSync5(envPath, "utf-8");
+    const envLines = envContent.split("\n").filter((line) => line.trim() && !line.startsWith("#"));
+    envVars = envLines.map((line) => {
+      const [key, ...valueParts] = line.split("=");
+      const value = valueParts.join("=").replace(/^["']|["']$/g, "");
+      return `    <key>${key}</key>
+    <string>${value}</string>`;
+    }).join("\n");
+  }
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.cognova</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${serverPath}</string>
+  </array>
+
+  <key>WorkingDirectory</key>
+  <string>${config.installDir}</string>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+${envVars}
+  </dict>
+
+  <key>RunAtLoad</key>
+  <true/>
+
+  <key>KeepAlive</key>
+  <true/>
+
+  <key>StandardOutPath</key>
+  <string>${logsDir}/stdout.log</string>
+
+  <key>StandardErrorPath</key>
+  <string>${logsDir}/stderr.log</string>
+</dict>
+</plist>
 `;
 }
-
-// src/lib/process-manager.ts
-async function setupAndStart(config) {
+function generateSystemdUnit(config) {
+  const nodePath = execSync3("which node", { encoding: "utf-8" }).trim();
+  const serverPath = join7(config.installDir, ".output", "server", "index.mjs");
+  const logsDir = join7(config.installDir, "logs");
+  const envPath = join7(config.installDir, ".env");
+  return `[Unit]
+Description=Cognova Personal Knowledge Assistant
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory=${config.installDir}
+ExecStart=${nodePath} ${serverPath}
+Restart=always
+RestartSec=10
+StandardOutput=append:${logsDir}/stdout.log
+StandardError=append:${logsDir}/stderr.log
+Environment=NODE_ENV=production
+EnvironmentFile=${envPath}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function installDaemon(config) {
+  const info = getDaemonInfo(config.installDir);
+  if (info.platform === "unsupported") {
+    throw new Error("Daemon installation not supported on this platform");
+  }
+  if (!existsSync6(info.logsDir)) {
+    mkdirSync4(info.logsDir, { recursive: true });
+  }
+  const configDir = join7(info.configPath, "..");
+  if (!existsSync6(configDir)) {
+    mkdirSync4(configDir, { recursive: true });
+  }
+  const configContent = info.platform === "macos" ? generateLaunchdPlist(config) : generateSystemdUnit(config);
+  writeFileSync4(info.configPath, configContent, "utf-8");
+  if (info.platform === "linux") {
+    execSync3("systemctl --user daemon-reload", { stdio: "ignore" });
+  }
+}
+function startDaemon(installDir) {
+  const info = getDaemonInfo(installDir);
+  if (info.platform === "unsupported") {
+    throw new Error("Daemon control not supported on this platform");
+  }
+  if (info.platform === "macos") {
+    execSync3(`launchctl load ${info.configPath}`, { stdio: "inherit" });
+  } else {
+    execSync3("systemctl --user start cognova", { stdio: "inherit" });
+    execSync3("systemctl --user enable cognova", { stdio: "inherit" });
+  }
+}
+function stopDaemon(installDir) {
+  const info = getDaemonInfo(installDir);
+  if (info.platform === "unsupported") {
+    throw new Error("Daemon control not supported on this platform");
+  }
+  if (info.platform === "macos") {
+    execSync3(`launchctl unload ${info.configPath}`, { stdio: "inherit" });
+  } else {
+    execSync3("systemctl --user stop cognova", { stdio: "inherit" });
+  }
+}
+function restartDaemon(installDir) {
+  const info = getDaemonInfo(installDir);
+  if (info.platform === "unsupported") {
+    throw new Error("Daemon control not supported on this platform");
+  }
+  if (info.platform === "macos") {
+    try {
+      execSync3(`launchctl unload ${info.configPath}`, { stdio: "ignore" });
+    } catch {
+    }
+    execSync3(`launchctl load ${info.configPath}`, { stdio: "inherit" });
+  } else {
+    execSync3("systemctl --user restart cognova", { stdio: "inherit" });
+  }
+}
+function getDaemonStatus(installDir) {
+  const info = getDaemonInfo(installDir);
+  if (info.platform === "unsupported") {
+    return "unknown";
+  }
   try {
-    execSync3("pm2 --version", { stdio: "pipe" });
-  } catch {
-    const install = await Re({
-      message: "PM2 not found. Install it globally?",
-      initialValue: true
-    });
-    if (Ct(install)) process.exit(0);
-    if (install) {
-      const s2 = bt2();
-      s2.start("Installing PM2");
-      const cmd = process.platform === "linux" ? "sudo npm install -g pm2" : "npm install -g pm2";
-      execSync3(cmd, { stdio: "inherit" });
-      s2.stop("PM2 installed");
+    if (info.platform === "macos") {
+      const output = execSync3("launchctl list", { encoding: "utf-8" });
+      return output.includes("com.cognova") ? "running" : "stopped";
     } else {
-      R2.warn("Skipping PM2. Start manually with: node .output/server/index.mjs");
-      return;
+      const output = execSync3("systemctl --user is-active cognova", { encoding: "utf-8" });
+      return output.trim() === "active" ? "running" : "stopped";
     }
+  } catch {
+    return "stopped";
+  }
+}
+function getLogsPath(installDir) {
+  const logsDir = join7(installDir, "logs");
+  return {
+    stdout: join7(logsDir, "stdout.log"),
+    stderr: join7(logsDir, "stderr.log")
+  };
+}
+
+// src/lib/process-manager.ts
+async function setupAndStart(config) {
+  const info = getDaemonInfo(config.installDir);
+  if (info.platform === "unsupported") {
+    R2.warn("Native daemon management not supported on this platform");
+    R2.info("Start manually with: node .output/server/index.mjs");
+    return;
   }
-  const logsDir = join7(config.installDir, "logs");
-  if (!existsSync6(logsDir))
-    mkdirSync4(logsDir, { recursive: true });
-  const ecosystem = generatePm2Ecosystem(config);
-  writeFileSync4(join7(config.installDir, "ecosystem.config.cjs"), ecosystem);
   const s = bt2();
-  s.start("Starting Cognova with PM2");
+  s.start("Building application");
   try {
-    execSync3("pm2 start ecosystem.config.cjs", {
-      cwd: config.installDir,
-      stdio: "pipe"
-    });
+    execSync4("pnpm build", { cwd: config.installDir, stdio: "pipe" });
+    s.stop("Application built");
+  } catch (err) {
+    s.stop("Build failed");
+    R2.error(`Build error: ${err}`);
+    throw err;
+  }
+  s.start(`Installing ${info.platform === "macos" ? "launchd" : "systemd"} service`);
+  try {
+    installDaemon(config);
+    s.stop(`Service configuration installed`);
+  } catch (err) {
+    s.stop("Service installation failed");
+    R2.error(`Installation error: ${err}`);
+    throw err;
+  }
+  s.start("Starting Cognova");
+  try {
+    startDaemon(config.installDir);
     s.stop("Cognova is running");
+    if (info.platform === "macos") {
+      R2.info("Service: ~/Library/LaunchAgents/com.cognova.plist");
+      R2.info("Auto-start: Enabled (will start on login)");
+    } else {
+      R2.info("Service: ~/.config/systemd/user/cognova.service");
+      R2.info("Auto-start: Enabled (will start on login)");
+    }
   } catch (err) {
     s.stop("Failed to start");
-    const errMsg = String(err);
-    if (errMsg.includes("nvm") && errMsg.includes("not found")) {
-      R2.error("PM2 + NVM compatibility issue detected");
-      R2.info("Try: pm2 delete cognova && pm2 start ecosystem.config.cjs");
-      R2.info(`Working directory: ${config.installDir}`);
+    R2.error(`Start error: ${err}`);
+    if (info.platform === "macos") {
+      R2.info("Troubleshoot: launchctl list | grep cognova");
+      R2.info(`View logs: tail -f ${info.logsDir}/stderr.log`);
     } else {
-      R2.error(`PM2 error: ${err}`);
+      R2.info("Troubleshoot: systemctl --user status cognova");
+      R2.info(`View logs: journalctl --user -u cognova -f`);
     }
     throw err;
   }
 }
 
 // src/lib/health.ts
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 async function waitForHealth(url, maxWaitSeconds = 30) {
   const s = bt2();
   s.start("Waiting for app to become healthy");
   for (let i = 0; i < maxWaitSeconds; i++) {
     try {
-      const result = execSync4(`curl -sf ${url}/api/health`, { encoding: "utf-8", timeout: 3e3 });
+      const result = execSync5(`curl -sf ${url}/api/health`, { encoding: "utf-8", timeout: 3e3 });
       const data = JSON.parse(result);
       if (data.status === "ok") {
         s.stop("App is healthy");
@@ -2238,19 +2383,19 @@ async function waitForHealth(url, maxWaitSeconds = 30) {
     await new Promise((resolve) => setTimeout(resolve, 1e3));
   }
   s.stop("App did not become healthy in time");
-  R2.warn(`Check logs: pm2 logs cognova`);
+  R2.warn("Check logs: cognova logs");
   return false;
 }
 
 // src/lib/progress.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, unlinkSync } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2 } from "fs";
 import { join as join8 } from "path";
 var PROGRESS_FILE = join8(process.env.HOME || "~", ".cognova-setup.json");
 function loadProgress() {
   try {
     if (!existsSync7(PROGRESS_FILE))
       return null;
-    const content = readFileSync5(PROGRESS_FILE, "utf-8");
+    const content = readFileSync6(PROGRESS_FILE, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -2267,7 +2412,7 @@ function saveProgress(progress) {
 function clearProgress() {
   try {
     if (existsSync7(PROGRESS_FILE))
-      unlinkSync(PROGRESS_FILE);
+      unlinkSync2(PROGRESS_FILE);
   } catch {
   }
 }
@@ -2545,7 +2690,7 @@ async function init() {
         "Dependency installation",
         async () => {
           s.start("Installing dependencies");
-          execSync5("pnpm install", { cwd: resolvedInstallDir, stdio: "pipe" });
+          execSync6("pnpm install", { cwd: resolvedInstallDir, stdio: "pipe" });
           s.stop("Dependencies installed");
         },
         { canSkip: false }
@@ -2563,23 +2708,23 @@ async function init() {
     R2.info("Dependencies already installed");
   }
   R2.step(import_picocolors6.default.bold("Launch"));
-  if (!progress.completedSteps.includes("pm2")) {
+  if (!progress.completedSteps.includes("daemon")) {
     try {
       await withRetry(
-        "PM2 setup and start",
+        "Service setup and start",
         () => setupAndStart(config),
         { canSkip: false }
       );
-      progress.completedSteps.push("pm2");
+      progress.completedSteps.push("daemon");
       saveProgress(progress);
     } catch (err) {
       if (err instanceof SkipError) {
-        R2.error("PM2 setup is required and cannot be skipped");
+        R2.error("Service setup is required and cannot be skipped");
       }
       process.exit(1);
     }
   } else {
-    R2.info("PM2 already configured");
+    R2.info("Service already configured");
   }
   if (!progress.completedSteps.includes("health")) {
     try {
@@ -2593,7 +2738,7 @@ async function init() {
     } catch (err) {
       if (err instanceof SkipError) {
         R2.warn("Health check skipped - app may not be fully started");
-        R2.info("Check status with: pm2 status");
+        R2.info("Check status with: cognova status");
       } else {
         process.exit(1);
       }
@@ -2611,15 +2756,14 @@ async function init() {
     `  ${import_picocolors6.default.cyan("Agent:")}          ${personality.agentName}`,
     "",
     `  ${import_picocolors6.default.dim("Manage:")}`,
-    `    cognova start     Start the app`,
-    `    cognova stop      Stop the app`,
-    `    cognova restart   Restart the app`,
+    `    cognova start     Start the service`,
+    `    cognova stop      Stop the service`,
+    `    cognova restart   Restart the service`,
+    `    cognova status    Check service status`,
+    `    cognova logs      View logs`,
     `    cognova update    Update to latest version`,
     `    cognova doctor    Check health`,
     `    cognova reset     Re-generate configs`,
-    "",
-    `    pm2 logs cognova  View logs`,
-    `    pm2 monit              Monitor resources`,
     ""
   ].join("\n"));
   Le(`${personality.agentName} is ready. Open ${import_picocolors6.default.underline(config.appUrl)} to get started.`);
@@ -2627,40 +2771,81 @@ async function init() {
 }
 
 // src/commands/start.ts
-import { execSync as execSync6 } from "child_process";
 import { existsSync as existsSync8 } from "fs";
-import { join as join10 } from "path";
+import { execSync as execSync7 } from "child_process";
 async function start() {
   const installDir = findInstallDir();
-  const ecosystem = join10(installDir, "ecosystem.config.cjs");
-  if (!existsSync8(ecosystem)) {
-    console.error("No ecosystem.config.cjs found. Run `cognova init` first.");
+  const info = getDaemonInfo(installDir);
+  if (!existsSync8(info.configPath)) {
+    console.error(`No ${info.platform === "macos" ? "launchd plist" : "systemd unit"} found. Run \`cognova init\` first.`);
+    process.exit(1);
+  }
+  try {
+    startDaemon(installDir);
+    console.log("Cognova started.");
+  } catch (err) {
+    console.error("Failed to start:", err);
     process.exit(1);
   }
-  execSync6("pm2 start ecosystem.config.cjs", { cwd: installDir, stdio: "inherit" });
-  console.log("Cognova started.");
 }
 async function stop() {
   try {
-    execSync6("pm2 stop cognova", { stdio: "inherit" });
+    const installDir = findInstallDir();
+    stopDaemon(installDir);
     console.log("Cognova stopped.");
   } catch {
     console.error("Failed to stop. Is Cognova running?");
+    process.exit(1);
   }
 }
 async function restart() {
   try {
-    execSync6("pm2 restart cognova", { stdio: "inherit" });
+    const installDir = findInstallDir();
+    restartDaemon(installDir);
     console.log("Cognova restarted.");
   } catch {
     console.error("Failed to restart. Is Cognova running?");
+    process.exit(1);
+  }
+}
+async function status() {
+  try {
+    const installDir = findInstallDir();
+    const daemonStatus = getDaemonStatus(installDir);
+    const info = getDaemonInfo(installDir);
+    console.log(`Status: ${daemonStatus}`);
+    if (daemonStatus === "running") {
+      console.log(`Platform: ${info.platform}`);
+      console.log(`Config: ${info.configPath}`);
+    } else {
+      console.log("Cognova is not running. Start with: cognova start");
+    }
+  } catch (err) {
+    console.error("Failed to check status:", err);
+    process.exit(1);
+  }
+}
+async function logs() {
+  try {
+    const installDir = findInstallDir();
+    const info = getDaemonInfo(installDir);
+    const logPaths = getLogsPath(installDir);
+    console.log("Showing stderr log (Ctrl+C to exit)...\n");
+    if (info.platform === "macos") {
+      execSync7(`tail -f ${logPaths.stderr}`, { stdio: "inherit" });
+    } else {
+      execSync7("journalctl --user -u cognova -f", { stdio: "inherit" });
+    }
+  } catch (err) {
+    console.error("Failed to show logs:", err);
+    process.exit(1);
   }
 }
 
 // src/commands/update.ts
-import { execSync as execSync7 } from "child_process";
+import { execSync as execSync8 } from "child_process";
 import { existsSync as existsSync9, cpSync as cpSync3, rmSync } from "fs";
-import { join as join11 } from "path";
+import { join as join10 } from "path";
 var import_picocolors7 = __toESM(require_picocolors(), 1);
 var BACKUP_ITEMS = [
   "app",
@@ -2675,22 +2860,22 @@ var BACKUP_ITEMS = [
   "pnpm-lock.yaml"
 ];
 function createBackup(installDir) {
-  const backupDir = join11(installDir, ".update-backup");
+  const backupDir = join10(installDir, ".update-backup");
   if (existsSync9(backupDir))
     rmSync(backupDir, { recursive: true });
   for (const item of BACKUP_ITEMS) {
-    const src = join11(installDir, item);
+    const src = join10(installDir, item);
     if (!existsSync9(src)) continue;
-    const dest = join11(backupDir, item);
+    const dest = join10(backupDir, item);
     cpSync3(src, dest, { recursive: true });
   }
   return backupDir;
 }
 function restoreBackup(installDir, backupDir) {
   for (const item of BACKUP_ITEMS) {
-    const src = join11(backupDir, item);
+    const src = join10(backupDir, item);
     if (!existsSync9(src)) continue;
-    const dest = join11(installDir, item);
+    const dest = join10(installDir, item);
     if (existsSync9(dest))
       rmSync(dest, { recursive: true });
     cpSync3(src, dest, { recursive: true });
@@ -2712,7 +2897,7 @@ async function update() {
   s.start("Checking for updates");
   let latestVersion;
   try {
-    latestVersion = execSync7("npm view cognova version", { encoding: "utf-8" }).trim();
+    latestVersion = execSync8("npm view cognova version", { encoding: "utf-8" }).trim();
   } catch {
     s.stop("Could not check npm registry");
     R2.warn("Unable to check for updates. Rebuilding current version.");
@@ -2730,10 +2915,10 @@ async function update() {
   let updateFailed = false;
   try {
     s.start("Downloading latest version");
-    const tmpDir = execSync7("mktemp -d", { encoding: "utf-8" }).trim();
+    const tmpDir = execSync8("mktemp -d", { encoding: "utf-8" }).trim();
     try {
-      execSync7(`npm pack cognova@${latestVersion} --pack-destination ${tmpDir}`, { stdio: "pipe" });
-      execSync7(`tar -xzf ${tmpDir}/cognova-${latestVersion}.tgz -C ${tmpDir}`, { stdio: "pipe" });
+      execSync8(`npm pack cognova@${latestVersion} --pack-destination ${tmpDir}`, { stdio: "pipe" });
+      execSync8(`tar -xzf ${tmpDir}/cognova-${latestVersion}.tgz -C ${tmpDir}`, { stdio: "pipe" });
       copyAppSource(`${tmpDir}/package`, installDir);
       s.stop("Source files updated");
     } finally {
@@ -2745,10 +2930,10 @@ async function update() {
     const dotenv = loadEnvFile(installDir);
     const envWithDotenv = { ...process.env, ...dotenv };
     s.start("Installing dependencies");
-    execSync7("pnpm install", { cwd: installDir, stdio: "pipe" });
+    execSync8("pnpm install", { cwd: installDir, stdio: "pipe" });
     s.stop("Dependencies installed");
     s.start("Running database migrations");
-    execSync7("pnpm db:migrate", { cwd: installDir, stdio: "pipe", env: envWithDotenv });
+    execSync8("pnpm db:migrate", { cwd: installDir, stdio: "pipe", env: envWithDotenv });
     s.stop("Migrations complete");
   } catch (err) {
     updateFailed = true;
@@ -2764,7 +2949,7 @@ async function update() {
     rollbackSpinner.start("Restoring previous version");
     try {
       restoreBackup(installDir, backupDir);
-      execSync7("pnpm install", { cwd: installDir, stdio: "pipe" });
+      execSync8("pnpm install", { cwd: installDir, stdio: "pipe" });
       rollbackSpinner.stop("Previous version restored");
       R2.info("Your previous installation has been restored.");
     } catch (rollbackErr) {
@@ -2785,19 +2970,19 @@ async function update() {
   }
   s.start("Restarting application");
   try {
-    execSync7("pm2 restart cognova", { stdio: "pipe" });
+    restartDaemon(installDir);
     s.stop("Application restarted");
   } catch {
-    s.stop("PM2 restart failed \u2014 start manually with `cognova start`");
+    s.stop("Restart failed \u2014 start manually with `cognova start`");
   }
   R2.info(`Run ${import_picocolors7.default.cyan("cognova reset")} to regenerate CLAUDE.md or settings.json.`);
   Le(`Updated to v${latestVersion}`);
 }
 
 // src/commands/doctor.ts
-import { execSync as execSync8 } from "child_process";
+import { execSync as execSync9 } from "child_process";
 import { existsSync as existsSync10 } from "fs";
-import { join as join12 } from "path";
+import { join as join11 } from "path";
 var import_picocolors8 = __toESM(require_picocolors(), 1);
 async function doctor() {
   We(import_picocolors8.default.bgCyan(import_picocolors8.default.black(" Cognova Doctor ")));
@@ -2810,61 +2995,61 @@ async function doctor() {
   const checks = [
     {
       name: ".env file",
-      check: () => existsSync10(join12(installDir, ".env")),
+      check: () => existsSync10(join11(installDir, ".env")),
       fixDescription: 'Run "cognova reset" to regenerate'
     },
     {
       name: "node_modules",
-      check: () => existsSync10(join12(installDir, "node_modules")),
+      check: () => existsSync10(join11(installDir, "node_modules")),
       fix: async () => {
         const s = bt2();
         s.start("Installing dependencies");
-        execSync8("pnpm install", { cwd: installDir, stdio: "inherit" });
+        execSync9("pnpm install", { cwd: installDir, stdio: "inherit" });
         s.stop("Dependencies installed");
       },
       fixDescription: "Install dependencies"
     },
     {
       name: "Build output",
-      check: () => existsSync10(join12(installDir, ".output", "server", "index.mjs")),
+      check: () => existsSync10(join11(installDir, ".output", "server", "index.mjs")),
       fix: async () => {
         const s = bt2();
         s.start("Building application");
-        execSync8("pnpm build", { cwd: installDir, stdio: "inherit" });
+        execSync9("pnpm build", { cwd: installDir, stdio: "inherit" });
         s.stop("Build complete");
       },
       fixDescription: "Build the application"
     },
     {
       name: "~/.claude/CLAUDE.md",
-      check: () => existsSync10(join12(claudeDir, "CLAUDE.md")),
+      check: () => existsSync10(join11(claudeDir, "CLAUDE.md")),
       fixDescription: 'Run "cognova reset --claude" to reinstall'
     },
     {
       name: "~/.claude/skills/",
-      check: () => existsSync10(join12(claudeDir, "skills")),
+      check: () => existsSync10(join11(claudeDir, "skills")),
       fixDescription: 'Run "cognova reset --claude" to reinstall'
     },
     {
       name: "~/.claude/hooks/",
-      check: () => existsSync10(join12(claudeDir, "hooks")),
+      check: () => existsSync10(join11(claudeDir, "hooks")),
       fixDescription: 'Run "cognova reset --claude" to reinstall'
     },
     {
       name: "~/.claude/rules/",
-      check: () => existsSync10(join12(claudeDir, "rules")),
+      check: () => existsSync10(join11(claudeDir, "rules")),
       fixDescription: 'Run "cognova reset --claude" to reinstall'
     },
     {
       name: "~/.claude/settings.json",
-      check: () => existsSync10(join12(claudeDir, "settings.json")),
+      check: () => existsSync10(join11(claudeDir, "settings.json")),
       fixDescription: 'Run "cognova reset --claude" to reinstall'
     },
     {
       name: "Claude Code CLI",
       check: () => {
         try {
-          execSync8("claude --version", { stdio: "pipe" });
+          execSync9("claude --version", { stdio: "pipe" });
           return true;
         } catch {
           return false;
@@ -2876,7 +3061,7 @@ async function doctor() {
       name: "Python 3",
       check: () => {
         try {
-          execSync8("python3 --version", { stdio: "pipe" });
+          execSync9("python3 --version", { stdio: "pipe" });
           return true;
         } catch {
           return false;
@@ -2888,7 +3073,7 @@ async function doctor() {
       name: "Docker daemon",
       check: () => {
         try {
-          execSync8("docker info", { stdio: "pipe" });
+          execSync9("docker info", { stdio: "pipe" });
           return true;
         } catch {
           return false;
@@ -2899,10 +3084,10 @@ async function doctor() {
         s.start("Starting Docker daemon");
         try {
           if (process.platform === "darwin") {
-            execSync8("open -a Docker", { stdio: "pipe" });
+            execSync9("open -a Docker", { stdio: "pipe" });
             R2.info("Docker Desktop is starting - this may take a moment");
           } else if (process.platform === "linux") {
-            execSync8("sudo systemctl start docker", { stdio: "inherit" });
+            execSync9("sudo systemctl start docker", { stdio: "inherit" });
           }
           s.stop("Docker daemon start command issued");
         } catch (err) {
@@ -2913,36 +3098,34 @@ async function doctor() {
       fixDescription: "Start Docker daemon"
     },
     {
-      name: "PM2 process",
+      name: "Service status",
       check: () => {
         try {
-          const out = execSync8("pm2 jlist", { encoding: "utf-8" });
-          const procs = JSON.parse(out);
-          return procs.some(
-            (proc) => proc.name === "cognova" && proc.pm2_env?.status === "online"
-          );
+          const status2 = getDaemonStatus(installDir);
+          return status2 === "running";
         } catch {
           return false;
         }
       },
       fix: async () => {
+        const info = getDaemonInfo(installDir);
         const s = bt2();
-        s.start("Starting PM2 process");
+        s.start(`Starting ${info.platform === "macos" ? "launchd" : "systemd"} service`);
         try {
-          execSync8("pm2 start ecosystem.config.cjs", { cwd: installDir, stdio: "inherit" });
-          s.stop("PM2 process started");
+          startDaemon(installDir);
+          s.stop("Service started");
         } catch (err) {
-          s.stop("Failed to start PM2");
+          s.stop("Failed to start service");
           throw err;
         }
       },
-      fixDescription: "Start the PM2 process"
+      fixDescription: 'Start the service with "cognova start"'
     },
     {
       name: "App health endpoint",
       check: () => {
         try {
-          const result = execSync8("curl -sf http://localhost:3000/api/health", { encoding: "utf-8" });
+          const result = execSync9("curl -sf http://localhost:3000/api/health", { encoding: "utf-8" });
           const data = JSON.parse(result);
           return data.status === "ok";
         } catch {
@@ -2954,7 +3137,7 @@ async function doctor() {
       name: "Database connection",
       check: () => {
         try {
-          const result = execSync8("curl -sf http://localhost:3000/api/health", { encoding: "utf-8" });
+          const result = execSync9("curl -sf http://localhost:3000/api/health", { encoding: "utf-8" });
           const data = JSON.parse(result);
           return data.database?.available === true;
         } catch {
@@ -2974,7 +3157,7 @@ async function doctor() {
       check: () => {
         if (!metadata) return "unknown";
         try {
-          const latest = execSync8("npm view cognova version", { encoding: "utf-8" }).trim();
+          const latest = execSync9("npm view cognova version", { encoding: "utf-8" }).trim();
           return latest === metadata.version ? true : `outdated (${metadata.version} \u2192 ${latest})`;
         } catch {
           return "could not check";
@@ -3102,9 +3285,11 @@ var HELP_TEXT = `
 
   Commands:
     init      Interactive setup wizard
-    start     Start Cognova (PM2)
+    start     Start Cognova
     stop      Stop Cognova
     restart   Restart Cognova
+    status    Check service status
+    logs      View application logs
     update    Update to latest version
     doctor    Check health of all components
     reset     Re-generate configuration files
@@ -3127,14 +3312,14 @@ var COMMAND_HELP = {
     5. Configures database (local Docker or remote PostgreSQL)
     6. Sets network access mode
     7. Creates admin credentials
-    8. Installs dependencies, builds, and starts with PM2
+    8. Installs dependencies, builds, and starts as system service
 
   Usage: cognova init
 `,
   start: `
   cognova start \u2014 Start Cognova
 
-  Starts the application using PM2 process manager.
+  Starts the application as a system service (launchd on macOS, systemd on Linux).
   Requires a prior 'cognova init' to have been run.
 
   Usage: cognova start
@@ -3142,22 +3327,37 @@ var COMMAND_HELP = {
   stop: `
   cognova stop \u2014 Stop Cognova
 
-  Stops the PM2 process. Data and configuration are preserved.
+  Stops the service. Data and configuration are preserved.
 
   Usage: cognova stop
 `,
   restart: `
   cognova restart \u2014 Restart Cognova
 
-  Restarts the PM2 process. Useful after manual config changes.
+  Restarts the service. Useful after manual config changes.
 
   Usage: cognova restart
+`,
+  status: `
+  cognova status \u2014 Check service status
+
+  Shows whether Cognova is running and service configuration details.
+
+  Usage: cognova status
+`,
+  logs: `
+  cognova logs \u2014 View application logs
+
+  Streams application logs in real-time (stderr).
+  Press Ctrl+C to exit.
+
+  Usage: cognova logs
 `,
   update: `
   cognova update \u2014 Update to latest version
 
   Checks npm registry for a newer version, downloads and installs it.
-  Preserves: .env, .api-token, ecosystem.config.cjs, logs/
+  Preserves: .env, .api-token, service config, logs/
   Runs database migrations and rebuilds automatically.
   Creates a backup before updating so failed updates can be rolled back.
 
@@ -3170,7 +3370,7 @@ var COMMAND_HELP = {
     - Configuration files (.env, Claude config)
     - Dependencies (Node, Python, Claude Code CLI)
     - Build output
-    - PM2 process status
+    - Service status (launchd/systemd)
     - App health endpoint
     - Database connection
     - Vault directory
@@ -3209,6 +3409,8 @@ var commands = {
   start,
   stop,
   restart,
+  status,
+  logs,
   update,
   doctor,
   reset