@geraldmaron/construct 1.0.23 → 1.1.0

package/lib/service-manager.mjs

@@ -1,8 +1,8 @@
 /**
  * lib/service-manager.mjs — start, stop, and describe Construct runtime services.
  *
- * Manages the dashboard process, local Postgres (Docker), memory server (cm),
- * and OpenCode. startServices() is the single entry point for `construct up` —
+ * Manages the dashboard process, memory server (cm), and OpenCode. 
+ * startServices() is the single entry point for `construct up` —
  * spawns whatever is available and returns a result per service.
  */
 import { spawn, spawnSync } from 'node:child_process';
@@ -14,37 +14,14 @@ import { fileURLToPath } from 'node:url';
 
 import { findAvailablePort } from './host-capabilities.mjs';
 import { getUserEnvPath, loadConstructEnv, parseEnvFile, writeEnvValues } from './env-config.mjs';
-import { detectDockerCompose } from './setup.mjs';
-import { stashConstructDb, restoreConstructDb } from './storage/postgres-backup.mjs';
 import { runPressureRelease } from './runtime-pressure.mjs';
-import {
-  pruneStashDir,
-  verifyTelemetryKeys,
-  isRemoteTelemetry,
-} from './services/local-postgres.mjs';
 import { resolveTraceBackend, telemetryProviderLabel } from './telemetry/client.mjs';
-import { postgresPort, postgresContainerName, memoryPort as derivedMemoryPort } from './home-namespace.mjs';
-
-const CONSTRUCT_PG_COMPOSE_DIR = 'services/postgres';
-const CONSTRUCT_PG_CONTAINER = postgresContainerName();
-const CONSTRUCT_PG_PORT = postgresPort();
-const CONSTRUCT_PG_HEALTH_RETRIES = 12;
-const CONSTRUCT_PG_HEALTH_INTERVAL_MS = 2000;
+import { memoryPort as derivedMemoryPort } from './home-namespace.mjs';
 
 const DASHBOARD_STATE_FILE = 'dashboard.json';
 
-// The caller's `rootDir` is the project (for compose/context/traces), but the
-// dashboard and doctor entrypoints ship with the install, not the project. They
-// must resolve against the install root — derived from this module's own
-// location — or `construct init` spawns `<project>/lib/server/index.mjs` and the
-// process dies with MODULE_NOT_FOUND while still advertising the URL.
-
 const INSTALL_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
 
-// pruneStashDir and verifyTelemetryKeys now live in lib/services/telemetry-backend.mjs.
-// Re-exported below at module bottom for tests that already import from here.
-
-
 function runtimeStateDir(homeDir = os.homedir()) {
   return path.join(homeDir, '.construct', 'runtime');
 }
@@ -118,17 +95,8 @@ export function buildRuntimeRecoverySummary({ rootDir, homeDir = os.homedir(), r
 }
 
 export function isManagedConstructPostgresUrl(databaseUrl = '') {
-  if (!databaseUrl) return false;
-  try {
-    const parsed = new URL(databaseUrl);
-    const host = parsed.hostname;
-    return (
-      parsed.port === String(CONSTRUCT_PG_PORT) &&
-      ['127.0.0.1', 'localhost', '::1'].includes(host)
-    ) || host === CONSTRUCT_PG_CONTAINER;
-  } catch {
-    return databaseUrl.includes(`:${CONSTRUCT_PG_PORT}/`);
-  }
+  // Construct no longer manages local Postgres containers.
+  return false;
 }
 
 function processExists(pid) {
@@ -191,10 +159,15 @@ async function isMemoryRunning(port) {
   return probeRuntimePort(port);
 }
 
-async function isOpenCodeRunning(port) {
+async function isBridgeRunning(port) {
   return probeRuntimeHttp(`http://127.0.0.1:${port}/`, { timeoutMs: 1000 });
 }
 
+async function isCopilotBridgeRunning(port) {
+  // Check if the port is reachable.
+  return probeRuntimePort(port);
+}
+
 function spawnDetached(command, args, homeDir, logFile, options = {}) {
   const logPath = path.join(runtimeStateDir(homeDir), logFile);
   fs.mkdirSync(path.dirname(logPath), { recursive: true });
@@ -296,11 +269,6 @@ export async function startDashboard({ rootDir, homeDir = os.homedir(), preferre
   });
   child.unref();
 
-  // Confirm the process actually bound the port before persisting state or
-  // advertising the URL. Without this the caller reports a dead PID/URL when the
-  // server crashes on boot — the readiness gate turns a silent failure into an
-  // honest, actionable one (the log tail names the cause).
-
   let ready = false;
   for (let i = 0; i < 30; i += 1) {
     if (await probeRuntimePort(port)) { ready = true; break; }
@@ -324,14 +292,10 @@ export async function startDashboard({ rootDir, homeDir = os.homedir(), preferre
   return { started: true, reused: false, ...state };
 }
 
-/**
- * Resolve runtime ports. Re-uses ports from config.env when the service is
- * already listening there (avoids port drift on repeated `construct up`).
- */
 export async function getRuntimePorts(homeDir = os.homedir(), {
   dashboardProbeFn = isDashboardRunning,
   memoryProbeFn = isMemoryRunning,
-  openCodeProbeFn = isOpenCodeRunning,
+  openCodeProbeFn = isBridgeRunning,
   findAvailablePortFn = findAvailablePort,
 } = {}) {
   const dashboard = readDashboardState(homeDir);
@@ -349,6 +313,7 @@ export async function getRuntimePorts(homeDir = os.homedir(), {
     dashboard: dashboard?.port ?? await resolvePort('DASHBOARD_PORT', 4242, dashboardProbeFn),
     memory: await resolvePort('MEMORY_PORT', derivedMemoryPort(), memoryProbeFn),
     bridge: await resolvePort('BRIDGE_PORT', 5173, openCodeProbeFn),
+    copilotBridge: await resolvePort('COPILOT_BRIDGE_PORT', 5174, probeRuntimePort),
   };
 }
 
@@ -363,122 +328,18 @@ export async function describeRuntimeSupport() {
   }
   return {
     tmux: commandExists('tmux'),
-    docker: commandExists('docker'),
     cm: commandExists('cm'),
     opencode: commandExists('opencode'),
+    gh: commandExists('gh'),
   };
 }
 
-// ── Construct Postgres management ──────────────────────────────────────────
-
-function constructPgComposePath(rootDir) {
-  return path.join(rootDir, CONSTRUCT_PG_COMPOSE_DIR, 'docker-compose.yml');
-}
-
-function isConstructPostgresRunning(spawnSyncFn = spawnSync) {
-  const result = spawnSyncFn('docker', ['inspect', '--format', '{{.State.Running}}', CONSTRUCT_PG_CONTAINER], {
-    encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
-  });
-  return result.stdout?.trim() === 'true';
-}
-
-function isConstructPostgresHealthy(spawnSyncFn = spawnSync) {
-  const result = spawnSyncFn('docker', ['exec', CONSTRUCT_PG_CONTAINER, 'pg_isready', '-U', 'construct'], {
-    encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
-  });
-  return result.status === 0;
-}
-
-async function waitForConstructPostgresHealthy({
-  spawnSyncFn = spawnSync,
-  maxRetries = CONSTRUCT_PG_HEALTH_RETRIES,
-  intervalMs = CONSTRUCT_PG_HEALTH_INTERVAL_MS,
-} = {}) {
-  for (let i = 0; i < maxRetries; i++) {
-    if (isConstructPostgresHealthy(spawnSyncFn)) return true;
-    await new Promise((r) => setTimeout(r, intervalMs));
-  }
-  return false;
-}
-
-function startConstructPostgres({ rootDir, homeDir = os.homedir(), spawnSyncFn = spawnSync, detectDockerComposeFn = detectDockerCompose } = {}) {
-  const composeRunner = detectDockerComposeFn({ autoStart: true });
-  if (!composeRunner) return { status: 'unavailable', note: 'Docker not available' };
-
-  const composeFile = constructPgComposePath(rootDir);
-  if (!fs.existsSync(composeFile)) return { status: 'unavailable', note: 'Postgres compose file not found — run construct init first' };
-
-  const args = [...composeRunner.argsPrefix, '-p', CONSTRUCT_PG_CONTAINER, '-f', composeFile, 'up', '-d'];
-  const r = spawnSyncFn(composeRunner.command, args, { stdio: 'pipe', encoding: 'utf8' });
-  if (r.status === 0) return { status: 'started' };
-  return { status: 'error', note: (r.stderr || '').trim().split('\n')[0] || 'compose up failed' };
-}
-
-function stopConstructPostgres({ rootDir, homeDir = os.homedir(), spawnSyncFn = spawnSync, detectDockerComposeFn = detectDockerCompose } = {}) {
-  const composeRunner = detectDockerComposeFn();
-  if (!composeRunner) return { status: 'skipped', note: 'Docker not available' };
-
-  const composeFile = constructPgComposePath(rootDir);
-  if (!fs.existsSync(composeFile)) return { status: 'skipped', note: 'no compose file' };
-
-  const args = [...composeRunner.argsPrefix, '-p', CONSTRUCT_PG_CONTAINER, '-f', composeFile, 'down'];
-  const r = spawnSyncFn(composeRunner.command, args, { stdio: 'pipe', encoding: 'utf8' });
-  if (r.status === 0) return { status: 'stopped' };
-  return { status: 'error', note: (r.stderr || '').trim().split('\n')[0] || 'compose down failed' };
-}
-
-function checkPgvectorEnabled(spawnSyncFn = spawnSync) {
-  const result = spawnSyncFn('docker', [
-    'exec', CONSTRUCT_PG_CONTAINER, 'psql', '-U', 'construct', '-d', 'construct',
-    '-tAc', "SELECT EXISTS(SELECT 1 FROM pg_extension WHERE extname = 'vector')",
-  ], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
-  return result.stdout?.trim() === 't';
-}
-
-/**
- * On macOS, when the Docker CLI is installed but the daemon is down,
- * launch Docker Desktop and poll `docker info` up to `timeoutMs` for
- * the daemon to come up. Opt-out via `CONSTRUCT_DISABLE_DOCKER_AUTOSTART=1`
- * so users who keep Docker off aren't forced into it. No-ops on Linux
- * (systemd needs sudo) and Windows (different launcher).
- */
-async function tryStartDockerDaemon({
-  env = process.env,
-  spawnSyncFn = spawnSync,
-  timeoutMs = 60_000,
-  pollMs = 1500,
-} = {}) {
-  if (env.CONSTRUCT_DISABLE_DOCKER_AUTOSTART === '1') return false;
-  if (process.platform !== 'darwin') return false;
-
-  // CLI must be present; without it, nothing to start.
-  if (spawnSyncFn('command -v docker', { stdio: 'ignore', shell: true }).status !== 0) return false;
-
-  // If the daemon is already up, no work needed.
-  if (spawnSyncFn('docker', ['info'], { stdio: 'ignore' }).status === 0) return true;
-
-  // Best-effort launch. `open -a Docker` returns immediately; the daemon
-  // takes 5-30s to come fully up so we poll.
-  spawnSyncFn('open', ['-a', 'Docker'], { stdio: 'ignore' });
-
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    await new Promise((r) => setTimeout(r, pollMs));
-    if (spawnSyncFn('docker', ['info'], { stdio: 'ignore' }).status === 0) return true;
-  }
-  return false;
-}
-
-// The optional services a user can pick from with `construct dev --select` /
-// `--only=`. Pressure Guard (cleanup) and Doctor (the L0 supervisor daemon)
-// are infrastructure, always on — they are intentionally not selectable.
-
 export const SELECTABLE_SERVICES = Object.freeze([
-  { key: 'postgres', label: 'Postgres', description: 'Managed pgvector container (or external DATABASE_URL).' },
   { key: 'dashboard', label: 'Dashboard', description: 'Local operations dashboard on http://127.0.0.1:4242.' },
   { key: 'telemetry', label: 'Telemetry', description: 'Trace export / local JSONL traces.' },
   { key: 'memory', label: 'Memory (cm)', description: 'Persistent memory service (cm).' },
   { key: 'opencode', label: 'OpenCode', description: 'OpenCode bridge server.' },
+  { key: 'copilot-bridge', label: 'Copilot Bridge', description: 'Host-native Copilot bridge proxy (requires gh auth).' },
 ]);
 
 export async function startServices({
@@ -488,38 +349,31 @@ export async function startServices({
   describeRuntimeSupportFn = describeRuntimeSupport,
   getRuntimePortsFn = getRuntimePorts,
   startDashboardFn = startDashboard,
-  detectDockerComposeFn = detectDockerCompose,
   loadConstructEnvFn = loadConstructEnv,
   spawnDetachedFn = spawnDetached,
-  verifyTelemetryKeysFn = verifyTelemetryKeys,
   memoryProbeFn = isMemoryRunning,
-  openCodeProbeFn = isOpenCodeRunning,
+  openCodeProbeFn = isBridgeRunning,
   runPressureReleaseFn = runPressureRelease,
-  tryStartDockerDaemonFn = tryStartDockerDaemon,
 } = {}) {
   const support = await describeRuntimeSupportFn();
   const ports = await getRuntimePortsFn(homeDir);
   const envPath = getUserEnvPath(homeDir);
 
-  // A null selection means "start everything" (the default). A Set restricts
-  // startup to the chosen optional services; always-on infrastructure ignores it.
-
   const wants = (key) => selected === null || selected.has(key);
 
-  // On macOS, auto-launch Docker Desktop when the CLI is present but the
-  // daemon is down. Polls up to 60s so downstream Postgres startup sees a working
-  // compose runner instead of "Docker not available".
-  await tryStartDockerDaemonFn({ env: { ...process.env, HOME: homeDir }, timeoutMs: 5000 });
-
   writeEnvValues(envPath, {
     DASHBOARD_PORT: String(ports.dashboard),
     MEMORY_PORT: String(ports.memory),
     BRIDGE_PORT: String(ports.bridge),
+    COPILOT_BRIDGE_PORT: String(ports.copilotBridge),
   });
 
-  // Construct Postgres — start if DATABASE_URL points to managed container
   const liveEnv = loadConstructEnvFn({ rootDir, homeDir });
   const results = [];
+  
+  // Set Ollama persistence for local inference performance
+  liveEnv.OLLAMA_KEEP_ALIVE = "-1";
+  
   const pressureReport = runPressureReleaseFn({ env: { ...liveEnv, HOME: homeDir } });
   if (pressureReport?.killed?.length) {
     results.push({
@@ -529,40 +383,6 @@ export async function startServices({
       note: `terminated ${pressureReport.killed.length} stale process(es)`,
     });
   }
-  const databaseUrl = liveEnv.DATABASE_URL || '';
-  const usesManagedPostgres = isManagedConstructPostgresUrl(databaseUrl);
-
-  if (wants('postgres') && usesManagedPostgres) {
-    if (!isConstructPostgresRunning()) {
-      const pgStart = startConstructPostgres({ rootDir, homeDir, spawnSyncFn: spawnSync, detectDockerComposeFn: detectDockerComposeFn });
-      if (pgStart.status === 'started') {
-        const healthy = await waitForConstructPostgresHealthy();
-        if (healthy) {
-          const pgvector = checkPgvectorEnabled();
-          results.push({
-            name: 'Postgres',
-            url: `postgresql://127.0.0.1:${CONSTRUCT_PG_PORT}/construct`,
-            status: pgvector ? 'started' : 'degraded',
-            note: pgvector ? 'pgvector enabled' : 'pgvector not installed — semantic search unavailable',
-          });
-        } else {
-          results.push({ name: 'Postgres', status: 'degraded', note: 'container started but health check timed out' });
-        }
-      } else {
-        results.push({ name: 'Postgres', status: 'error', note: pgStart.note });
-      }
-    } else {
-      const pgvector = checkPgvectorEnabled();
-      results.push({
-        name: 'Postgres',
-        url: `postgresql://127.0.0.1:${CONSTRUCT_PG_PORT}/construct`,
-        status: 'reused',
-        note: pgvector ? 'pgvector enabled' : 'pgvector not installed',
-      });
-    }
-  } else if (wants('postgres') && databaseUrl) {
-    results.push({ name: 'Postgres', url: databaseUrl, status: 'configured', note: 'external database' });
-  }
 
   // Dashboard
   if (wants('dashboard')) {
@@ -575,38 +395,38 @@ export async function startServices({
   const telemetryUrl = liveEnv.CONSTRUCT_TELEMETRY_URL ?? '';
   const traceBackend = resolveTraceBackend(liveEnv);
   if (wants('telemetry')) {
-  if (traceBackend === 'local') {
-    results.push({
-      name: 'Telemetry',
-      url: path.join(rootDir, '.cx', 'traces'),
-      status: 'configured',
-      note: 'local JSONL traces; remote export not configured',
-    });
-  } else if (traceBackend === 'none') {
-    results.push({
-      name: 'Telemetry',
-      url: path.join(rootDir, '.cx', 'traces'),
-      status: 'configured',
-      note: 'remote export disabled; local JSONL traces preserved',
-    });
-  } else if (traceBackend === 'otel') {
-    const endpoint = liveEnv.CONSTRUCT_OTEL_EXPORTER_OTLP_ENDPOINT || '';
-    results.push({
-      name: 'Telemetry',
-      url: endpoint || undefined,
-      status: endpoint ? 'configured' : 'unavailable',
-      note: endpoint ? `OTLP export (${telemetryProviderLabel(liveEnv)})` : 'CONSTRUCT_OTEL_EXPORTER_OTLP_ENDPOINT not set',
-    });
-  } else if (telemetryUrl && (isRemoteTelemetry(telemetryUrl) || traceBackend === 'langfuse' || traceBackend === 'http')) {
-    results.push({
-      name: 'Telemetry',
-      url: telemetryUrl,
-      status: 'configured',
-      note: `${telemetryProviderLabel(liveEnv)} export — ${telemetryUrl}`,
-    });
-  } else {
-    results.push({ name: 'Telemetry', status: 'unavailable', note: 'remote export requested but endpoint is not configured' });
-  }
+    if (traceBackend === 'local') {
+      results.push({
+        name: 'Telemetry',
+        url: path.join(rootDir, '.cx', 'traces'),
+        status: 'configured',
+        note: 'local JSONL traces; remote export not configured',
+      });
+    } else if (traceBackend === 'none') {
+      results.push({
+        name: 'Telemetry',
+        url: path.join(rootDir, '.cx', 'traces'),
+        status: 'configured',
+        note: 'remote export disabled; local JSONL traces preserved',
+      });
+    } else if (traceBackend === 'otel') {
+      const endpoint = liveEnv.CONSTRUCT_OTEL_EXPORTER_OTLP_ENDPOINT || '';
+      results.push({
+        name: 'Telemetry',
+        url: endpoint || undefined,
+        status: endpoint ? 'configured' : 'unavailable',
+        note: endpoint ? `OTLP export (${telemetryProviderLabel(liveEnv)})` : 'CONSTRUCT_OTEL_EXPORTER_OTLP_ENDPOINT not set',
+      });
+    } else if (telemetryUrl && (traceBackend === 'langfuse' || traceBackend === 'http')) {
+      results.push({
+        name: 'Telemetry',
+        url: telemetryUrl,
+        status: 'configured',
+        note: `${telemetryProviderLabel(liveEnv)} export — ${telemetryUrl}`,
+      });
+    } else {
+      results.push({ name: 'Telemetry', status: 'unavailable', note: 'remote export requested but endpoint is not configured' });
+    }
   }
 
   // Memory (cm)
@@ -631,6 +451,27 @@ export async function startServices({
     }
   }
 
+  // Copilot Bridge
+  if (wants('copilot-bridge') && support.gh) {
+    const { detectActiveSessions } = await import('./host-capabilities.mjs');
+    const sessions = detectActiveSessions();
+    if (sessions.includes('github-copilot')) {
+      if (await probeRuntimePort(ports.copilotBridge)) {
+        results.push({ name: 'Copilot Bridge', url: `http://127.0.0.1:${ports.copilotBridge}`, status: 'reused' });
+      } else {
+        const proxyPath = path.join(INSTALL_ROOT, 'lib', 'bridges', 'copilot-proxy.mjs');
+        if (fs.existsSync(proxyPath)) {
+          spawnDetachedFn('node', [proxyPath, '--port', String(ports.copilotBridge)], homeDir, 'copilot-bridge.log');
+          results.push({ name: 'Copilot Bridge', url: `http://127.0.0.1:${ports.copilotBridge}`, status: 'started' });
+        } else {
+          results.push({ name: 'Copilot Bridge', status: 'unavailable', note: 'copilot-proxy binary missing in lib/bridges/' });
+        }
+      }
+    } else {
+      results.push({ name: 'Copilot Bridge', status: 'unavailable', note: 'gh auth status shows no active GitHub session' });
+    }
+  }
+
   const doctor = startDoctor({ rootDir, homeDir });
   if (doctor.started) {
     results.push({ name: 'Doctor', status: 'started', note: `L0 daemon · logs: ${doctor.logPath}` });
@@ -650,9 +491,6 @@ export async function startServices({
   };
 }
 
-// Surface service probe failures into the role-framework event bus so cx-sre
-// can be invoked when a critical service is down. Non-blocking, best effort.
-
 async function emitServiceFailures(results) {
   if (process.env.CONSTRUCT_ROLES === 'off') return;
   const failed = results.filter((r) => r.status === 'error');
@@ -670,17 +508,9 @@ async function emitServiceFailures(results) {
   } catch { /* best effort */ }
 }
 
-// Exported for testing only
-export { verifyTelemetryKeys as _verifyTelemetryKeys, pruneStashDir as _pruneStashDir };
-
-/**
- * Kill every process listening on a given TCP port (best-effort, non-fatal).
- * Returns true if at least one PID was killed.
- */
 function killPortOwners(port, spawnSyncFn = spawnSync) {
   if (!port || !Number.isInteger(port) || port <= 0) return false;
   try {
-    // lsof works on macOS and Linux; -t returns just PIDs
     const result = spawnSyncFn('lsof', ['-t', `-i:${port}`], { encoding: 'utf8' });
     const pids = (result.stdout || '').trim().split(/\s+/).filter(Boolean).map(Number).filter((n) => n > 0);
     if (pids.length === 0) return false;
@@ -695,21 +525,10 @@ function killPortOwners(port, spawnSyncFn = spawnSync) {
 
 export async function stopServices({
   homeDir = os.homedir(),
-  rootDir,
   spawnSyncFn = spawnSync,
-  detectDockerComposeFn = detectDockerCompose,
 } = {}) {
   const results = [];
 
-  // Stash construct Postgres data before any container is stopped so data
-  // survives Docker restarts and machine reboots.
-  const constructDbStash = stashConstructDb({ homeDir, spawnSyncFn });
-
-  // Construct Postgres
-  const pgStop = stopConstructPostgres({ rootDir, homeDir, spawnSyncFn, detectDockerComposeFn });
-  results.push({ name: 'Postgres', status: pgStop.status });
-
-  // Doctor (L0 daemon)
   const doctor = stopDoctor(homeDir);
   if (doctor.stopped) {
     results.push({ name: 'Doctor', status: 'stopped', note: `pid ${doctor.pid}` });
@@ -717,7 +536,6 @@ export async function stopServices({
     results.push({ name: 'Doctor', status: 'cleaned', note: 'stale state file removed' });
   }
 
-  // Dashboard
   const dashboard = stopDashboard(homeDir);
   if (dashboard.stopped) {
     results.push({ name: 'Dashboard', status: 'stopped', note: `pid ${dashboard.pid}, port ${dashboard.port}` });
@@ -727,18 +545,20 @@ export async function stopServices({
     results.push({ name: 'Dashboard', status: 'not-running' });
   }
 
-  // Memory (cm) — find port from config.env or fall back to default
   const envPath = getUserEnvPath(homeDir);
   const envValues = parseEnvFile(envPath);
   const memoryPort = Number(envValues.MEMORY_PORT) || derivedMemoryPort();
   const cmKilled = killPortOwners(memoryPort, spawnSyncFn);
   results.push({ name: 'Memory (cm)', status: cmKilled ? 'stopped' : 'not-running' });
 
-  // OpenCode — find port from config.env or fall back to default
   const bridgePort = Number(envValues.BRIDGE_PORT) || 5173;
   const openCodeKilled = killPortOwners(bridgePort, spawnSyncFn);
   results.push({ name: 'OpenCode', status: openCodeKilled ? 'stopped' : 'not-running' });
 
+  const copilotBridgePort = Number(envValues.COPILOT_BRIDGE_PORT) || 5174;
+  const copilotBridgeKilled = killPortOwners(copilotBridgePort, spawnSyncFn);
+  results.push({ name: 'Copilot Bridge', status: copilotBridgeKilled ? 'stopped' : 'not-running' });
+
   const stopped = results.filter((r) => r.status === 'stopped' || r.status === 'cleaned').map((r) => r.name);
-  return { stopped, results, constructDbStash };
+  return { stopped, results };
 }