@geraldmaron/construct 1.0.21 → 1.0.24

package/lib/setup.mjs

@@ -2,15 +2,18 @@
 /**
  * lib/setup.mjs — Machine-scoped first-run setup wizard for Construct.
  *
- * Installs cm/cass, configures managed defaults, starts local Postgres
- * (consent-driven), pre-warms the embedding model, wires MCP integrations,
- * and writes ~/.construct/config.env. Invoked by `construct install` and
- * by lib/install/first-invocation.mjs when a TTY user is missing resources.
+ * Installs cm/cass, configures managed defaults, pre-warms the embedding model,
+ * wires MCP integrations, and writes ~/.construct/config.env. 
+ * Invoked by `construct install` and by lib/install/first-invocation.mjs 
+ * when a TTY user is missing resources.
  *
  * Project-scoped scaffolding (`.cx/`, AGENTS.md, plan.md, adapters) lives
  * in lib/init-unified.mjs — invoked by `construct init`. These two flows
  * are intentionally separate: install runs once per machine, init runs
  * once per repo.
+ *
+ * Construct now uses embedded LanceDB and Git-backed state, removing the
+ * dependency on local Docker-managed Postgres.
  */
 
 import fs from 'node:fs';
@@ -26,42 +29,38 @@ import {
   getDeploymentMode,
 } from './deployment-mode.mjs';
 import { getCanonicalOpenCodeConfigPath, readOpenCodeConfig, writeOpenCodeConfig } from './opencode-config.mjs';
-import { syncFileStateToSql } from './storage/sync.mjs';
-import { createSqlClient, closeSqlClient } from './storage/backend.mjs';
 import { getEmbeddingModelInfo, warmupEmbeddingModel } from './storage/embeddings-engine.mjs';
-import { restoreConstructDb } from './storage/postgres-backup.mjs';
 import { buildPressureGuardValues, installPressureGuardLaunchAgent, loadPressureGuardLaunchAgent } from './runtime-pressure.mjs';
 import { consentToInstall } from './setup-prompts.mjs';
 
 const ROOT_DIR = path.resolve(import.meta.dirname, '..');
 const HOME = os.homedir();
-const LOCAL_POSTGRES_PORT = '54329';
-const LOCAL_POSTGRES_USER = 'construct';
-const LOCAL_POSTGRES_PASSWORD = 'construct';
-const LOCAL_POSTGRES_DB = 'construct';
-const LOCAL_DATABASE_URL = `postgresql://${LOCAL_POSTGRES_USER}:${LOCAL_POSTGRES_PASSWORD}@127.0.0.1:${LOCAL_POSTGRES_PORT}/${LOCAL_POSTGRES_DB}`;
 
 function printHelp() {
   console.log(`Construct install — machine setup (once per machine)
 
 Usage:
-  construct install [--yes] [--no-docker] [--reconfigure]
+  construct install [--scope=project|user|both] [--yes] [--no-launch-agent] [--reconfigure]
 
 Flags:
-  --yes          accept detected defaults without prompting
-  --no-docker    skip local Postgres / Docker service setup
-  --reconfigure  re-prompt for service consent, ignoring cached answers
-
-What it does:
+  --scope=<s>       project | user | both (default: project — see ADR-0029)
+                      project: no-op + scope guidance; Construct's project artifacts
+                               are written by \`construct init\` inside a repo.
+                      user:    write machine-scope state (~/.construct/, MCP configs,
+                               ~/.claude/* via consent-gated sync).
+                      both:    print project guidance, then run user-scope install.
+  --yes             accept detected defaults without prompting
+  --no-launch-agent skip macOS LaunchAgent background service registration
+  --reconfigure     re-prompt for service consent, ignoring cached answers
+
+What --scope=user does:
   - creates ~/.construct/config.env
   - ensures OpenCode config exists
-  - configures managed defaults for local vector retrieval
-  - starts local Postgres with Docker when available
+  - configures managed defaults for local vector retrieval (LanceDB)
   - checks required runtime tools and installs cm and cass when available
   - wires Memory, GitHub, and telemetry configuration
-  - runs construct sync (which also regenerates AUTO docs regions)
+  - runs construct sync --global (which writes ~/.claude/* per consent)
   - runs construct doctor
-  - detects the project tech stack and writes .cx/project-profile.json
 
 For project setup (once per repo): construct init`);
 }
@@ -87,23 +86,20 @@ function findCommand(command) {
 }
 
 export function defaultVectorIndexPath(homeDir = HOME) {
-  return path.join(homeDir, '.construct', 'vector', 'index.json');
+  // LanceDB storage path
+  return path.join(homeDir, '.construct', 'vector', 'lancedb');
 }
 
-export async function buildManagedSetupValues({ homeDir = HOME, env = process.env, databaseUrl = '' } = {}) {
+export async function buildManagedSetupValues({ homeDir = HOME, env = process.env } = {}) {
   const modelInfo = await getEmbeddingModelInfo({ env });
 
   const values = {
     CONSTRUCT_TRACE_BACKEND: env.CONSTRUCT_TRACE_BACKEND || 'local',
-    CONSTRUCT_VECTOR_INDEX_PATH: env.CONSTRUCT_VECTOR_INDEX_PATH || defaultVectorIndexPath(homeDir),
+    CONSTRUCT_LANCEDB_PATH: env.CONSTRUCT_LANCEDB_PATH || defaultVectorIndexPath(homeDir),
     CONSTRUCT_VECTOR_MODEL: env.CONSTRUCT_VECTOR_MODEL || modelInfo.model,
     ...buildPressureGuardValues({ env }),
   };
-  // Deployment mode is persisted in construct.config.json — setup never writes
-  // CONSTRUCT_DEPLOYMENT_MODE to ~/.construct/config.env. The env var is
-  // reserved for ephemeral runtime overrides (CI/scripts via `export …`).
-  // Forwarding it here pinned the env value and silently masked any JSON
-  // setter that ran later.
+  
   if (env[DEPLOYMENT_MODE_ENV_KEY] && getDeploymentMode(env) !== DEFAULT_DEPLOYMENT_MODE) {
     values[DEPLOYMENT_MODE_ENV_KEY] = getDeploymentMode(env);
   }
@@ -112,45 +108,10 @@ export async function buildManagedSetupValues({ homeDir = HOME, env = process.en
   if (env.CONSTRUCT_TELEMETRY_PUBLIC_KEY) values.CONSTRUCT_TELEMETRY_PUBLIC_KEY = env.CONSTRUCT_TELEMETRY_PUBLIC_KEY;
   if (env.CONSTRUCT_TELEMETRY_SECRET_KEY) values.CONSTRUCT_TELEMETRY_SECRET_KEY = env.CONSTRUCT_TELEMETRY_SECRET_KEY;
 
-  const resolvedDatabaseUrl = databaseUrl || env.DATABASE_URL || '';
-  if (resolvedDatabaseUrl) values.DATABASE_URL = resolvedDatabaseUrl;
-  if (env.CONSTRUCT_VECTOR_URL) values.CONSTRUCT_VECTOR_URL = env.CONSTRUCT_VECTOR_URL;
+  if (env.DATABASE_URL) values.DATABASE_URL = env.DATABASE_URL;
   return values;
 }
 
-export function localPostgresComposePath(homeDir = HOME) {
-  return path.join(homeDir, '.construct', 'services', 'postgres', 'docker-compose.yml');
-}
-
-export function writeLocalPostgresCompose(homeDir = HOME) {
-  const composePath = localPostgresComposePath(homeDir);
-  fs.mkdirSync(path.dirname(composePath), { recursive: true });
-  const content = `services:
-  postgres:
-    image: pgvector/pgvector:pg16
-    container_name: construct-postgres
-    restart: unless-stopped
-    environment:
-      POSTGRES_USER: ${LOCAL_POSTGRES_USER}
-      POSTGRES_PASSWORD: ${LOCAL_POSTGRES_PASSWORD}
-      POSTGRES_DB: ${LOCAL_POSTGRES_DB}
-    ports:
-      - "127.0.0.1:${LOCAL_POSTGRES_PORT}:5432"
-    volumes:
-      - construct-postgres-data:/var/lib/postgresql/data
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U ${LOCAL_POSTGRES_USER} -d ${LOCAL_POSTGRES_DB}"]
-      interval: 5s
-      timeout: 5s
-      retries: 20
-
-volumes:
-  construct-postgres-data:
-`;
-  fs.writeFileSync(composePath, content, 'utf8');
-  return composePath;
-}
-
 function runQuiet(command, args, { env = process.env, spawn = spawnSync } = {}) {
   const result = spawn(command, args, {
     env,
@@ -159,26 +120,6 @@ function runQuiet(command, args, { env = process.env, spawn = spawnSync } = {})
   return result;
 }
 
-async function runAsyncQuiet(command, args, { env = process.env, spawn = spawn } = {}) {
-  return new Promise((resolve) => {
-    const timeout = setTimeout(() => {
-      resolve({ status: -1, signal: 'SIGTERM' }); // treat timeout as error
-    }, 5000);
-    const child = spawn(command, args, {
-      env,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    let stdout = '';
-    let stderr = '';
-    child.stdout.on('data', (data) => { stdout += data.toString(); });
-    child.stderr.on('data', (data) => { stderr += data.toString(); });
-    child.on('close', (code, signal) => {
-      clearTimeout(timeout);
-      resolve({ status: code || 0, signal, stdout, stderr });
-    });
-  });
-}
-
 export function commandExists(command, { env = process.env, spawn = spawnSync } = {}) {
   const checker = process.platform === 'win32' ? 'where' : 'which';
   return runQuiet(checker, [command], { env, spawn }).status === 0;
@@ -212,8 +153,6 @@ export function ensureCmInstalled({ env = process.env, spawn = spawnSync } = {})
   };
 }
 
-// Version 0.3.0 has a known issue where the FTS-rebuild loop can OOM on large corpora and fail to converge.
-// Version 0.4.0 resolves this. Below this version, we fail closed to avoid the problem.
 const CASS_MIN_VERSION = '0.4.0';
 
 function parseSemver(s) {
@@ -247,7 +186,7 @@ export function ensureCassInstalled({ env = process.env, spawn = spawnSync } = {
     }
     return {
       status: 'outdated',
-      message: `cass ${version || 'unknown'} is older than required ${CASS_MIN_VERSION}. Older versions hit a frankensqlite FTS-rebuild OOM loop on large session corpora (upstream #168, #186, #110, #155).`,
+      message: `cass ${version || 'unknown'} is older than required ${CASS_MIN_VERSION}.`,
       installCommand: 'brew upgrade dicklesworthstone/tap/cass || brew install dicklesworthstone/tap/cass',
     };
   }
@@ -285,121 +224,11 @@ export function ensureCassInstalled({ env = process.env, spawn = spawnSync } = {
   };
 }
 
-/**
- * Platform-aware install hint shown when Docker isn't on PATH. Mirrors
- * what `supabase start` / `prisma init` print: don't auto-install, but
- * point at the canonical option for the user's OS so they have a one-line
- * command to copy.
- */
-export function dockerInstallHint(platform = process.platform) {
-  if (platform === 'darwin') {
-    return 'Install Docker Desktop (https://www.docker.com/products/docker-desktop) or a lighter alternative like OrbStack (`brew install orbstack`) or Colima (`brew install colima && colima start`).';
-  }
-  if (platform === 'win32') {
-    return 'Install Docker Desktop for Windows (https://www.docker.com/products/docker-desktop).';
-  }
-  return 'Install Docker Engine (https://docs.docker.com/engine/install/) — your distribution likely has a `docker` package (apt/dnf/pacman).';
-}
-
-export function detectDockerCompose({ env = process.env, spawn = spawnSync } = {}) {
-  // Use a timeout wrapper so we don't block forever if Docker daemon is hung/missing
-  const timeoutWrap = (fn) => {
-    let timedOut = false;
-    const timer = setTimeout(() => { timedOut = true; }, 5000);
-    try {
-      const result = fn();
-      clearTimeout(timer);
-      return timedOut ? null : result;
-    } catch {
-      clearTimeout(timer);
-      return null;
-    }
-  };
-
-  const docker = timeoutWrap(() => runQuiet('docker', ['info'], { env, spawn }));
-  if (!docker || docker.status !== 0) return null;
-  const compose = timeoutWrap(() => runQuiet('docker', ['compose', 'version'], { env, spawn }));
-  if (compose && compose.status === 0) return { command: 'docker', argsPrefix: ['compose'] };
-  const dockerCompose = timeoutWrap(() => runQuiet('docker-compose', ['version'], { env, spawn }));
-  if (dockerCompose && dockerCompose.status === 0) return { command: 'docker-compose', argsPrefix: [] };
-  return null;
-}
-
-// Duplicated from service-manager.spawnDetached to avoid the import cycle
-// setup ↔ service-manager (service-manager already imports detectDockerCompose
-// from setup, so the reverse path can't exist).
-
-function spawnDetachedForSetup(command, args, homeDir, logFile, options = {}) {
-  const logDir = path.join(homeDir, '.construct', 'runtime');
-  fs.mkdirSync(logDir, { recursive: true });
-  const logPath = path.join(logDir, logFile);
-  const fd = fs.openSync(logPath, 'a');
-  const child = spawn(command, args, {
-    detached: true,
-    stdio: ['ignore', fd, fd],
-    cwd: options.cwd,
-    env: options.env,
-  });
-  child.unref();
-  return { child, logPath };
-}
-
-export function startManagedPostgres({ homeDir = HOME, env = process.env, spawn = spawnSync } = {}) {
-  const composeRunner = detectDockerCompose({ env, spawn });
-  if (!composeRunner) {
-    return {
-      status: 'skipped',
-      databaseUrl: env.DATABASE_URL || '',
-      message: 'Docker is not available; using existing DATABASE_URL if configured.',
-    };
-  }
-
-  const composePath = writeLocalPostgresCompose(homeDir);
-  const result = runQuiet(
-    composeRunner.command,
-    [...composeRunner.argsPrefix, '-f', composePath, 'up', '-d', 'postgres'],
-    { env, spawn },
-  );
-
-  if (result.status !== 0) {
-    return {
-      status: 'degraded',
-      databaseUrl: env.DATABASE_URL || '',
-      composePath,
-      message: (result.stderr || result.stdout || 'Docker compose failed').trim(),
-    };
-  }
-
-  return {
-    status: 'ok',
-    databaseUrl: LOCAL_DATABASE_URL,
-    composePath,
-    message: 'Managed local Postgres is running.',
-  };
-}
-
-async function waitForSqlReady(env, { attempts = 20, delayMs = 500 } = {}) {
-  for (let attempt = 0; attempt < attempts; attempt += 1) {
-    const client = createSqlClient(env);
-    try {
-      await client`select 1 as ok`;
-      await closeSqlClient(client);
-      return true;
-    } catch {
-      await closeSqlClient(client).catch(() => {});
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
-    }
-  }
-  return false;
-}
-
 function warnIfGlobalCommandIsUnavailable() {
   const globalConstruct = findCommand('construct');
   if (!globalConstruct) {
     console.log('\nInstall warning: `construct` is not on PATH yet.');
     console.log('  From this checkout, run: npm install -g .');
-    console.log('  Without cloning, run: npm install -g github:geraldmaron/construct');
-    console.log('  Do not use `npm install -g construct`; that npm name belongs to another project.');
     return;
   }
 
@@ -410,7 +239,6 @@ function warnIfGlobalCommandIsUnavailable() {
   if (version.status !== 0 || !/^construct v\d+\./.test(version.stdout.trim())) {
     console.log(`\nInstall warning: PATH resolves \`construct\` to ${globalConstruct}, but it does not look like this CLI.`);
     console.log('  Reinstall from this checkout with: npm install -g .');
-    console.log('  Or install from GitHub with: npm install -g github:geraldmaron/construct');
   }
 }
 
@@ -425,61 +253,7 @@ function ensureOpenCodeConfig() {
   return getCanonicalOpenCodeConfigPath();
 }
 
-// Wire core.hooksPath to .beads/hooks so the tracked hook scripts (ECC
-// secret-scan, Construct policy gates, BEADS dispatcher) actually fire on
-// git commit/push. Without this, .beads/hooks/* are inert — present in the
-// repo but never executed by git. Idempotent: leaves a user-set value alone
-// rather than clobbering it.
-
-export function ensureGitHooksPath({ cwd = process.cwd() } = {}) {
-  const hooksDir = path.join(cwd, '.beads', 'hooks');
-  if (!fs.existsSync(path.join(hooksDir, 'pre-commit'))) {
-    return { status: 'skipped', reason: 'no .beads/hooks/pre-commit in this directory' };
-  }
-  const inGit = spawnSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd, stdio: 'pipe', encoding: 'utf8' });
-  if (inGit.status !== 0) {
-    return { status: 'skipped', reason: 'not a git working tree' };
-  }
-  const current = spawnSync('git', ['config', '--get', 'core.hooksPath'], { cwd, stdio: 'pipe', encoding: 'utf8' });
-  const currentValue = current.status === 0 ? (current.stdout || '').trim() : '';
-  const desired = '.beads/hooks';
-  if (currentValue === desired) {
-    return { status: 'ok', message: 'core.hooksPath already wired to .beads/hooks' };
-  }
-
-  // Treat the git default (`.git/hooks` or an absolute path to it) as
-  // equivalent to unset. A user who has accepted the default has not made an
-  // active choice that justifies "leave alone" semantics; without this branch
-  // an install that happens to land while `.git/hooks` is already in play
-  // leaves policy gates inactive permanently.
-  const isGitDefault =
-    !currentValue ||
-    currentValue === '.git/hooks' ||
-    currentValue === path.join(cwd, '.git', 'hooks') ||
-    currentValue.replace(/\/+$/, '').endsWith(`${path.sep}.git${path.sep}hooks`);
-  if (!isGitDefault) {
-    return {
-      status: 'warning',
-      message: `core.hooksPath is set to '${currentValue}'. Leaving alone. Set to '.beads/hooks' to activate Construct policy gates.`,
-    };
-  }
-  const result = spawnSync('git', ['config', 'core.hooksPath', desired], { cwd, stdio: 'pipe', encoding: 'utf8' });
-  if (result.status !== 0) {
-    return {
-      status: 'error',
-      message: `failed to set core.hooksPath: ${(result.stderr || '').trim() || 'unknown error'}`,
-    };
-  }
-  return {
-    status: 'set',
-    message: `core.hooksPath set to .beads/hooks (activates pre-commit secret-scan + Construct policy gates + beads dispatcher)`,
-  };
-}
-
-// $HOME/.construct/lib/hooks/* is the resolution path for Claude Code
-// Stop-hook commands. Absent symlink → every Stop hook fails silently,
-// including stop-notify (dashboard cost feed). Idempotent: matching
-// symlink left alone, stale symlink replaced, real dir refused.
+export { ensureGitHooksPath } from './git-hooks-path.mjs';
 
 export function ensureLibSymlink({ homeDir = HOME, rootDir = ROOT_DIR } = {}) {
   const target = path.join(homeDir, '.construct', 'lib');
@@ -501,14 +275,37 @@ export function ensureLibSymlink({ homeDir = HOME, rootDir = ROOT_DIR } = {}) {
   return {
     status: 'conflict',
     target,
-    message: `${target} exists and is not a symlink — leaving alone. Move or remove it, then re-run \`construct install\` to wire the hooks.`,
+    message: `${target} exists and is not a symlink — leaving alone.`,
   };
 }
 
+const VALID_SCOPES = new Set(['project', 'user', 'both']);
+const DEFAULT_SCOPE = 'project';
+
+function parseScopeFlag(args) {
+  for (const a of args) {
+    if (a === '--scope') return { invalid: '--scope requires a value (project|user|both)' };
+    if (!a.startsWith('--scope=')) continue;
+    const v = a.slice('--scope='.length);
+    if (!VALID_SCOPES.has(v)) return { invalid: `--scope=${v} is not one of project|user|both` };
+    return { scope: v };
+  }
+  return { scope: DEFAULT_SCOPE };
+}
+
+function printProjectScopeGuidance() {
+  console.log('Construct install — scope: project (no-op)');
+  console.log('────────────────────────────────────────');
+  console.log('Project artifacts are written by `construct init` inside a repo.');
+  console.log('To install machine-scope state on this user account:');
+  console.log('  construct install --scope=user');
+  console.log('To do both project (guidance) and user-scope install:');
+  console.log('  construct install --scope=both');
+}
+
 export async function runSetup({ rootDir = ROOT_DIR, args = [], homeDir = HOME } = {}) {
   const argSet = new Set(args);
   const isYes = argSet.has('--yes');
-  const skipDocker = argSet.has('--no-docker');
   const reconfigure = argSet.has('--reconfigure');
 
   if (argSet.has('--help') || argSet.has('-h')) {
@@ -516,19 +313,39 @@ export async function runSetup({ rootDir = ROOT_DIR, args = [], homeDir = HOME }
     return;
   }
 
-  // Reject unknown flags loudly so a typo (e.g. --reconfig) fails fast with the
-  // help text instead of silently running defaults.
-
-  const KNOWN_FLAGS = new Set(['--yes', '--no-docker', '--reconfigure', '--help', '-h']);
-  const unknownFlags = args.filter((a) => a.startsWith('-') && !KNOWN_FLAGS.has(a));
+  const KNOWN_FLAGS = new Set(['--yes', '--no-launch-agent', '--reconfigure', '--help', '-h']);
+  const unknownFlags = args.filter((a) => {
+    if (!a.startsWith('-')) return false;
+    if (a.startsWith('--scope=') || a === '--scope') return false;
+    return !KNOWN_FLAGS.has(a);
+  });
   if (unknownFlags.length) {
     console.error(`Unknown flag(s): ${unknownFlags.join(', ')}`);
     printHelp();
     throw new Error(`Unknown setup flag(s): ${unknownFlags.join(', ')}`);
   }
 
+  const scopeResult = parseScopeFlag(args);
+  if (scopeResult.invalid) {
+    console.error(scopeResult.invalid);
+    printHelp();
+    throw new Error(`Invalid setup scope: ${scopeResult.invalid}`);
+  }
+  const scope = scopeResult.scope;
+
+  if (scope === 'project') {
+    printProjectScopeGuidance();
+    return;
+  }
+
+  if (scope === 'both') {
+    printProjectScopeGuidance();
+    console.log('');
+  }
+
   console.log('Construct setup');
   console.log('────────────────');
+  console.log(`Scope: ${scope}`);
 
   const envPath = ensureUserConfig(homeDir);
   const opencodePath = ensureOpenCodeConfig();
@@ -538,68 +355,25 @@ export async function runSetup({ rootDir = ROOT_DIR, args = [], homeDir = HOME }
   console.log(`OpenCode config: ${opencodePath}`);
   if (libLink.status === 'created' || libLink.status === 'replaced') {
     console.log(`Hook lib link: ${libLink.target} → ${libLink.source} (${libLink.status})`);
-  } else if (libLink.status === 'kept') {
-    console.log(`Hook lib link: ${libLink.target} already in place`);
-  } else if (libLink.status === 'conflict') {
-    console.log(`Hook lib link: ${libLink.message}`);
   }
   warnIfGlobalCommandIsUnavailable();
 
   const cmInstall = ensureCmInstalled({ env: process.env });
-  if (cmInstall.status === 'installed') {
-    console.log('Memory CLI: installed cm via Homebrew');
-  } else if (cmInstall.status === 'available') {
-    console.log('Memory CLI: cm available');
+  if (cmInstall.status === 'installed' || cmInstall.status === 'available') {
+    console.log(`Memory CLI: ${cmInstall.message}`);
   } else {
     console.log(`Memory CLI: ${cmInstall.message}`);
     if (cmInstall.installCommand) console.log(`  Install with: ${cmInstall.installCommand}`);
   }
 
   const cassInstall = ensureCassInstalled({ env: process.env });
-  if (cassInstall.status === 'installed') {
+  if (cassInstall.status === 'installed' || cassInstall.status === 'available') {
     console.log(`Session search: ${cassInstall.message}`);
-  } else if (cassInstall.status === 'available') {
-    console.log('Session search: cass available');
   } else {
     console.log(`Session search: ${cassInstall.message}`);
     if (cassInstall.installCommand) console.log(`  Install with: ${cassInstall.installCommand}`);
   }
 
-  // Local Postgres — consent-driven. Interactive default-yes; --yes accepts
-  // without prompting. Skipped when --no-docker, when DATABASE_URL is already
-  // set (caller has an external DB), or when user declines.
-
-  const dockerRunner = detectDockerCompose();
-  const dockerAvailable = !skipDocker && Boolean(dockerRunner);
-  let serviceResult = {
-    status: 'skipped',
-    databaseUrl: process.env.DATABASE_URL || '',
-    message: skipDocker ? 'Docker service setup skipped by flag.' : 'Docker not detected — skipping local Postgres.',
-  };
-
-  if (dockerAvailable) {
-    const pgConsent = await consentToInstall({
-      name: 'postgres',
-      isYes,
-      force: reconfigure,
-      alreadyConfigured: Boolean(process.env.DATABASE_URL),
-      alreadyConfiguredNote: 'DATABASE_URL already set — using external database.',
-      envPath,
-    });
-    if (pgConsent.decision) {
-      writeLocalPostgresCompose(homeDir);
-      serviceResult = startManagedPostgres({ homeDir, env: process.env });
-      console.log(`Postgres: ${serviceResult.status === 'ok' ? 'started locally' : serviceResult.message}`);
-    } else {
-      console.log(`Postgres: skipped (${pgConsent.note})`);
-    }
-  } else if (skipDocker) {
-    console.log('Postgres: skipped (--no-docker)');
-  } else {
-    console.log('Postgres: skipped (Docker not detected — local Postgres unavailable)');
-    console.log(`  ${dockerInstallHint()}`);
-  }
-
   const telemetryResult = process.env.CONSTRUCT_TELEMETRY_URL
     ? { status: 'configured', note: `remote export configured (${process.env.CONSTRUCT_TELEMETRY_URL})` }
     : { status: 'local', note: 'local JSONL traces in .cx/traces; remote export optional' };
@@ -607,13 +381,6 @@ export async function runSetup({ rootDir = ROOT_DIR, args = [], homeDir = HOME }
 
   fs.mkdirSync(path.dirname(defaultVectorIndexPath(homeDir)), { recursive: true });
 
-  // Pre-warm the embedding model so the first agent query doesn't stall on
-  // a one-time ONNX download. Same pattern as `supabase start` pre-pulling
-  // images and `playwright install` pre-fetching browsers — make the wait
-  // visible during setup, not during user-facing work. Best-effort: a
-  // download failure here degrades gracefully via the engine's hash fallback
-  // and is non-fatal to setup.
-
   try {
     const warm = await warmupEmbeddingModel({ env: process.env });
     if (warm.degraded) {
@@ -625,12 +392,7 @@ export async function runSetup({ rootDir = ROOT_DIR, args = [], homeDir = HOME }
     console.log(`Embeddings: warmup skipped (${err?.message || 'unknown error'}) — model will load on first use`);
   }
 
-  // Cheapest provider selection — opt-out by default. When user consents,
-  // evaluate all configured providers, pick the lowest-cost model per tier,
-  // and write to config.env. On subsequent runs the preference is persisted
-  // so the prompt is skipped.
-
-  const { isCheapestProviderEnabled, selectCheapestForAllTiers, setCheapestProviderPreference, formatCheapestProviderMessage } =
+  const { isCheapestProviderEnabled, selectCheapestForAllTiers, setCheapestProviderPreference } =
     await import('./model-cheapest-provider.mjs');
   const cheapestAlreadyEnabled = isCheapestProviderEnabled(envPath, { env: process.env });
   if (!cheapestAlreadyEnabled) {
@@ -657,166 +419,54 @@ export async function runSetup({ rootDir = ROOT_DIR, args = [], homeDir = HOME }
             const label = selections[tier]?.providerLabel || '';
             console.log(`  ${tier.padEnd(11)} ${model} (${label})`);
           }
-        } else {
-          console.log('\nCheapest provider: no configured providers found — nothing to apply.');
         }
         setCheapestProviderPreference(envPath, true);
       } catch (err) {
         console.log(`Cheapest provider: skipped (${err?.message || 'unknown error'})`);
       }
-    } else {
-      console.log(`Cheapest provider: skipped (${cheapestConsent.note})`);
     }
-  } else {
-    console.log('Cheapest provider: already enabled — skipping prompt.');
   }
 
-  const hooksResult = ensureGitHooksPath({ cwd: process.cwd() });
-  if (hooksResult.status === 'set') console.log(`Git hooks: ${hooksResult.message}`);
-  else if (hooksResult.status === 'ok') console.log('Git hooks: wired');
-  else if (hooksResult.status === 'warning') console.log(`Git hooks: ${hooksResult.message}`);
-  else if (hooksResult.status === 'error') console.log(`Git hooks: ${hooksResult.message}`);
-
-  // Ensure workspace directory with docs lanes exists
   ensureWorkspace(homeDir);
 
   const managedValues = await buildManagedSetupValues({
     homeDir,
     env: process.env,
-    databaseUrl: serviceResult.databaseUrl,
   });
   writeEnvValues(envPath, managedValues);
+  
   let pressureGuardAgent = null;
   let pressureGuardLoad = null;
-  if (process.platform === 'darwin') {
-    pressureGuardAgent = installPressureGuardLaunchAgent({
-      homeDir,
-      rootDir,
-      intervalSeconds: Number(managedValues.CONSTRUCT_PRESSURE_GUARD_INTERVAL_SECONDS || 300),
-      nodePath: process.execPath,
+  if (process.platform === 'darwin' && !argSet.has('--no-launch-agent')) {
+    const laConsent = await consentToInstall({
+      name: 'launchagent',
+      question: 'Install background pressure-release service (macOS LaunchAgent)?',
+      isYes,
+      force: reconfigure,
+      alreadyConfigured: fs.existsSync(path.join(homeDir, 'Library', 'LaunchAgents', 'dev.construct.pressure-release.plist')),
+      alreadyConfiguredNote: 'Background pressure-release service already installed.',
+      envPath,
     });
-    pressureGuardLoad = loadPressureGuardLaunchAgent({ plistPath: pressureGuardAgent.plistPath });
-  }
-
-  if (isYes) {
-    console.log('\nManaged setup:');
-    console.log(`  Deployment mode: ${getDeploymentMode(process.env) || DEFAULT_DEPLOYMENT_MODE} (set in construct.config.json — runtime env override available via ${DEPLOYMENT_MODE_ENV_KEY})`);
-    console.log(`  Vector index: ${managedValues.CONSTRUCT_VECTOR_INDEX_PATH}`);
-    console.log(`  Vector model: ${managedValues.CONSTRUCT_VECTOR_MODEL}`);
-    console.log(`  Trace backend: ${managedValues.CONSTRUCT_TRACE_BACKEND}`);
-    if (managedValues.CONSTRUCT_TELEMETRY_URL) console.log(`  Trace URL: ${managedValues.CONSTRUCT_TELEMETRY_URL}`);
-    console.log(`  Pressure guard: every ${managedValues.CONSTRUCT_PRESSURE_GUARD_INTERVAL_SECONDS}s, swap threshold ${managedValues.CONSTRUCT_PRESSURE_GUARD_SWAP_GB} GiB`);
-    if (serviceResult.status === 'ok') {
-      console.log(`  Postgres: ${serviceResult.databaseUrl}`);
-      console.log(`  Compose file: ${serviceResult.composePath}`);
-    } else {
-      console.log(`  Postgres: ${serviceResult.message}`);
-    }
-    if (pressureGuardAgent?.plistPath) {
-      console.log(`  LaunchAgent: ${pressureGuardAgent.plistPath}`);
-      console.log(`  LaunchAgent load: ${pressureGuardLoad?.loaded ? 'active' : pressureGuardLoad?.reason || 'pending manual load'}`);
-    }
-
-    const sqlClient = createSqlClient({ ...process.env, ...managedValues });
-    if (sqlClient) {
-      let readyClient = null;
-      let sqlClientClosed = false;
-      try {
-        if (serviceResult.status === 'ok') {
-          await closeSqlClient(sqlClient);
-          sqlClientClosed = true;
-          await waitForSqlReady({ ...process.env, ...managedValues });
-        }
-        readyClient = createSqlClient({ ...process.env, ...managedValues });
-        const migration = await import('node:fs/promises').then((fs) => fs.readFile(new URL('../db/schema/001_init.sql', import.meta.url), 'utf8'));
-        await readyClient.unsafe(migration);
-        console.log('\nPostgres schema initialized.');
-
-        // Restore data from the most recent stash (if any) before syncing.
-        if (serviceResult.status === 'ok') {
-          const restore = restoreConstructDb({ homeDir });
-          if (restore.status === 'restored') {
-            console.log(`Construct DB restored from stash: ${restore.stashPath}`);
-          } else if (restore.status === 'no-stash') {
-            console.log('No stash found — starting with empty construct DB.');
-          } else if (restore.status !== 'no-stash') {
-            console.log(`Construct DB restore: ${restore.status}`);
-          }
-        }
-
-        const syncResult = await syncFileStateToSql(rootDir, { env: { ...process.env, ...managedValues }, project: 'construct' });
-        console.log(`Hybrid storage sync: ${syncResult.status}`);
-        if (syncResult.embeddingModel) console.log(`Embedding model: ${syncResult.embeddingModel}`);
-
-        // When setup runs inside a downstream project (cwd is not the
-        // Construct package itself), seed the vector index from the
-        // project's existing docs / AGENTS / plan so the agent has
-        // context to compare new intake against from day one. No-op
-        // when there's nothing project-like in cwd.
-
-        const projectCwd = process.cwd();
-        const isDownstreamProject = projectCwd !== rootDir && (
-          fs.existsSync(path.join(projectCwd, 'docs')) ||
-          fs.existsSync(path.join(projectCwd, 'AGENTS.md')) ||
-          fs.existsSync(path.join(projectCwd, 'package.json'))
-        );
-        if (isDownstreamProject) {
-          try {
-            const projectName = path.basename(projectCwd);
-            const projectSync = await syncFileStateToSql(projectCwd, {
-              env: { ...process.env, ...managedValues },
-              project: projectName,
-            });
-            console.log(`Project corpus indexed: ${projectName} (${projectSync.documentsSynced || 0} docs, ${projectSync.embeddingsSynced || 0} embeddings) — agent can now compare new intake against existing material.`);
-          } catch (err) {
-            console.log(`Project corpus index skipped: ${err?.message || 'unknown error'} — run \`construct ingest\` later to seed manually.`);
-          }
-        }
-      } catch (error) {
-        console.log(`Hybrid storage init failed: ${error?.message || 'unknown error'}`);
-      } finally {
-        await closeSqlClient(readyClient).catch(() => {});
-        if (!sqlClientClosed) await closeSqlClient(sqlClient);
-      }
+    if (laConsent.decision) {
+      pressureGuardAgent = installPressureGuardLaunchAgent({
+        homeDir,
+        rootDir,
+        intervalSeconds: Number(managedValues.CONSTRUCT_PRESSURE_GUARD_INTERVAL_SECONDS || 300),
+        nodePath: process.execPath,
+      });
+      pressureGuardLoad = loadPressureGuardLaunchAgent({ plistPath: pressureGuardAgent.plistPath });
     }
   }
 
   if (isYes) {
     runConstruct(['mcp', 'add', 'memory', '--auto'], { optional: true });
     runConstruct(['mcp', 'add', 'github', '--auto'], { optional: true });
-  } else {
-    console.log('\nManaged defaults written:');
-    console.log(`  Deployment mode: ${getDeploymentMode(process.env) || DEFAULT_DEPLOYMENT_MODE} (set in construct.config.json — runtime env override available via ${DEPLOYMENT_MODE_ENV_KEY})`);
-    console.log(`  Vector index: ${managedValues.CONSTRUCT_VECTOR_INDEX_PATH}`);
-    console.log(`  Trace backend: ${managedValues.CONSTRUCT_TRACE_BACKEND}${managedValues.CONSTRUCT_TELEMETRY_URL ? ` (${managedValues.CONSTRUCT_TELEMETRY_URL})` : ''}`);
-    console.log(`  Pressure guard: swap ${managedValues.CONSTRUCT_PRESSURE_GUARD_SWAP_GB} GiB, opencode max ${managedValues.CONSTRUCT_PRESSURE_GUARD_MAX_OPENCODE}`);
-    console.log('\nFor unattended setup, including local Postgres when Docker is running:');
-    console.log('  construct install --yes');
   }
 
-  // Install is machine setup: the global front-door agent must land on every
-  // user-scope surface (opencode/claude/codex/copilot) or a fresh machine fails
-  // cross-surface parity. Plain sync writes global hooks + project tier but not
-  // the front-door agent — `--global` is what populates it, so run both.
-
-  runConstruct(['sync']);
+  runConstruct(['sync', '--quiet']);
   runConstruct(['sync', '--global']);
   runConstruct(['doctor']);
 
-  // Profile the CWD so per-host skill filtering layers downstream have
-  // a cached, host-agnostic signal to work from. Non-fatal on failure.
-  try {
-    const { detectProjectProfile, writeProfile } = await import('./project-profile.mjs');
-    const profile = detectProjectProfile(process.cwd());
-    if (profile.tags.length > 0) {
-      const profilePath = writeProfile(profile, process.cwd());
-      console.log(`\nProject profile: ${profile.tags.join(', ')}`);
-      console.log(`  Saved to ${profilePath}`);
-      console.log(`  Run \`construct skills scope\` to see which installed skills apply to this project.`);
-    }
-  } catch { /* best effort */ }
-
-  // ── Summary panel ────────────────────────────────────────────────────────
   const setupTs = new Date().toISOString().slice(0, 19).replace(/[:.]/g, '-');
   const setupLogPath = path.join(HOME, '.cx', `setup-${setupTs}.log`);
   try {
@@ -826,42 +476,21 @@ export async function runSetup({ rootDir = ROOT_DIR, args = [], homeDir = HOME }
       `Config: ${getUserEnvPath(HOME)}`,
       `OpenCode: ${getCanonicalOpenCodeConfigPath(HOME)}`,
     ];
-    if (managedValues?.DATABASE_URL) {
-      logLines.push(`Database: ${managedValues.DATABASE_URL.replace(/:\/\/[^@]+@/, '://<credentials>@')}`);
-    }
     fs.writeFileSync(setupLogPath, logLines.join('\n') + '\n');
   } catch { /* best effort */ }
 
   console.log('\n────────────────────────────────────');
   console.log('Setup complete.');
 
-  // Local-service summary — surfaces running local services. Same pattern
-  // as `supabase start`, which prints all local URLs + keys after spin-up.
-
-  const hasLocalPostgres = serviceResult?.status === 'ok' && serviceResult?.databaseUrl?.includes('127.0.0.1');
-  const vectorBackend = hasLocalPostgres
-    ? { label: 'Postgres + pgvector', detail: `${serviceResult.databaseUrl} (384d embeddings, ${managedValues.CONSTRUCT_VECTOR_MODEL})` }
-    : { label: 'JSON fallback', detail: `${managedValues.CONSTRUCT_VECTOR_INDEX_PATH} (${managedValues.CONSTRUCT_VECTOR_MODEL})` };
-
   console.log('\nLocal services:');
   console.log('  Traces:      local JSONL (.cx/traces)');
-  if (process.env.CONSTRUCT_TELEMETRY_URL) console.log(`  Telemetry:   remote export (${process.env.CONSTRUCT_TELEMETRY_URL})`);
-  else console.log('  Telemetry:   remote export not configured');
-  if (hasLocalPostgres) {
-    console.log(`  Postgres:    ${serviceResult.databaseUrl}`);
-  } else if (process.env.DATABASE_URL) {
-    console.log(`  Postgres:    external (${process.env.DATABASE_URL.replace(/:\/\/[^@]+@/, '://<credentials>@')})`);
-  } else {
-    console.log(`  Postgres:    not running — vector retrieval will use JSON fallback`);
-  }
-  console.log(`  Vector:      ${vectorBackend.label}`);
-  console.log(`    ${vectorBackend.detail}`);
+  console.log(`  Vector:      LanceDB (embedded)`);
+  console.log(`    ${managedValues.CONSTRUCT_LANCEDB_PATH}`);
   console.log('  Credentials are saved to ~/.construct/config.env for later reference.');
 
   console.log('\nNext steps:');
   console.log('  construct provider add github     # Connect GitHub repository data');
   console.log('  construct doctor                  # Verify all systems');
-  console.log('  construct evals retrieval         # Baseline retrieval quality');
   console.log(`\nSetup log: ${setupLogPath}`);
 }
 
@@ -872,17 +501,12 @@ function ensureUserConfig(homeDir = HOME) {
   return envPath;
 }
 
-/**
- * Create ~/.construct/workspace/ with the standard docs lane structure.
- * Fallback target for embed output that isn't repo-specific.
- */
 export function ensureWorkspace(homeDir = HOME) {
   const wsPath = path.join(homeDir, '.construct', 'workspace');
   const docsPath = path.join(wsPath, 'docs');
   for (const lane of WORKSPACE_DOCS_LANES) {
     fs.mkdirSync(path.join(docsPath, lane), { recursive: true });
   }
-  // Ensure top-level workspace files exist
   const snapshotPath = path.join(wsPath, 'snapshot.md');
   if (!fs.existsSync(snapshotPath)) fs.writeFileSync(snapshotPath, '# Snapshot\n\nNo snapshot yet.\n');
   const roadmapPath = path.join(wsPath, 'roadmap.md');