@geraldmaron/construct 1.0.23 → 1.1.0

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,51 +29,37 @@ import {
   getDeploymentMode,
 } from './deployment-mode.mjs';
 import { getCanonicalOpenCodeConfigPath, readOpenCodeConfig, writeOpenCodeConfig } from './opencode-config.mjs';
-import { syncFileStateToSql } from './storage/sync.mjs';
-import { runMigrations } from './storage/migrations.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';
-import { postgresPort, postgresContainerName } from './home-namespace.mjs';
 
 const ROOT_DIR = path.resolve(import.meta.dirname, '..');
 const HOME = os.homedir();
-const LOCAL_POSTGRES_USER = 'construct';
-const LOCAL_POSTGRES_PASSWORD = 'construct';
-const LOCAL_POSTGRES_DB = 'construct';
-
-// The local DB URL's port is derived per home (construct-lb7b), so build it at
-// the call site from the active homeDir rather than a single module-level const.
-
-function localDatabaseUrl(env = process.env, home = HOME) {
-  return `postgresql://${LOCAL_POSTGRES_USER}:${LOCAL_POSTGRES_PASSWORD}@127.0.0.1:${postgresPort(env, home)}/${LOCAL_POSTGRES_DB}`;
-}
 
 function printHelp() {
   console.log(`Construct install — machine setup (once per machine)
 
 Usage:
-  construct install [--scope=project|user|both] [--yes] [--no-docker] [--no-launch-agent] [--reconfigure]
+  construct install [--scope=project|user|both] [--yes] [--no-launch-agent] [--reconfigure] [--with-docling]
 
 Flags:
   --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,
-                               local Postgres, ~/.claude/* via consent-gated sync).
+                               ~/.claude/* via consent-gated sync).
                       both:    print project guidance, then run user-scope install.
   --yes             accept detected defaults without prompting
-  --no-docker       skip local Postgres / Docker service setup
   --no-launch-agent skip macOS LaunchAgent background service registration
   --reconfigure     re-prompt for service consent, ignoring cached answers
+  --with-docling    eagerly provision the docling document-extraction venv now
+                      (heavy, ~10 min via uv; otherwise provisioned lazily on
+                      first document ingest)
 
 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 --global (which writes ~/.claude/* per consent)
@@ -100,23 +89,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);
   }
@@ -125,53 +111,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 });
-
-  // Container, port, and volume are derived per home so isolated HOMEs do not
-  // collide (construct-lb7b). The runtime (service-manager) derives the same
-  // values from the same home, so they match.
-
-  const container = postgresContainerName(process.env, homeDir);
-  const port = postgresPort(process.env, homeDir);
-  const volume = `${container}-data`;
-  const content = `services:
-  postgres:
-    image: pgvector/pgvector:pg16
-    container_name: ${container}
-    restart: unless-stopped
-    environment:
-      POSTGRES_USER: ${LOCAL_POSTGRES_USER}
-      POSTGRES_PASSWORD: ${LOCAL_POSTGRES_PASSWORD}
-      POSTGRES_DB: ${LOCAL_POSTGRES_DB}
-    ports:
-      - "127.0.0.1:${port}:5432"
-    volumes:
-      - ${volume}:/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:
-  ${volume}:
-`;
-  fs.writeFileSync(composePath, content, 'utf8');
-  return composePath;
-}
-
 function runQuiet(command, args, { env = process.env, spawn = spawnSync } = {}) {
   const result = spawn(command, args, {
     env,
@@ -180,26 +123,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;
@@ -233,8 +156,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) {
@@ -268,7 +189,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',
     };
   }
@@ -306,121 +227,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: localDatabaseUrl(env, homeDir),
-    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;
   }
 
@@ -431,7 +242,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');
   }
 }
 
@@ -446,25 +256,8 @@ 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.
-
-// Project-scoped git-hooks wiring lives in its own module and is owned by
-// `construct init`. Re-exported here for importers that reference it via
-// setup.mjs (e.g. tests/setup-git-hooks-path.test.mjs). `construct install`
-// must never mutate the cwd repo (ADR-0027 §3), so the install flow leaves
-// hooks wiring to init.
-
 export { ensureGitHooksPath } from './git-hooks-path.mjs';
 
-// $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 function ensureLibSymlink({ homeDir = HOME, rootDir = ROOT_DIR } = {}) {
   const target = path.join(homeDir, '.construct', 'lib');
   const source = path.join(rootDir, 'lib');
@@ -485,15 +278,10 @@ 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.`,
   };
 }
 
-// ADR-0029: install is explicitly scoped. Default is `project`, which writes
-// nothing and prints scope guidance — silent global writes are the failure mode
-// that ADR retires. `user` runs the machine-state body below; `both` prints the
-// project guidance and then runs user-scope.
-
 const VALID_SCOPES = new Set(['project', 'user', 'both']);
 const DEFAULT_SCOPE = 'project';
 
@@ -516,13 +304,11 @@ function printProjectScopeGuidance() {
   console.log('  construct install --scope=user');
   console.log('To do both project (guidance) and user-scope install:');
   console.log('  construct install --scope=both');
-  console.log('\nSee ADR-0029 (docs/adr/0029-install-scopes-and-hook-budgets.md) for the contract.');
 }
 
 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')) {
@@ -530,10 +316,8 @@ 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', '--no-launch-agent', '--reconfigure', '--help', '-h']);
+  const KNOWN_FLAGS = new Set(['--yes', '--no-launch-agent', '--reconfigure', '--with-docling', '--help', '-h']);
+  const withDocling = argSet.has('--with-docling');
   const unknownFlags = args.filter((a) => {
     if (!a.startsWith('-')) return false;
     if (a.startsWith('--scope=') || a === '--scope') return false;
@@ -575,68 +359,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' };
@@ -644,13 +385,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) {
@@ -662,12 +396,22 @@ 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.
+  // Docling (document/PDF extraction) provisions a pinned Python venv via uv,
+  // which is heavy (~10 min) and only needed for document ingest — so it stays
+  // lazy by default and is provisioned eagerly only when the user opts in with
+  // --with-docling. First document ingest still auto-provisions if skipped.
+  if (withDocling) {
+    try {
+      const { ensureDoclingVenv } = await import('./runtime/uv-bootstrap.mjs');
+      console.log('Docling: provisioning Python venv (uv) — this can take several minutes…');
+      const docling = await ensureDoclingVenv();
+      console.log(`Docling: ready (${docling.fresh ? 'provisioned' : 'already present'} at ${docling.venvDir})`);
+    } catch (err) {
+      console.log(`Docling: provisioning skipped (${err?.message || 'unknown error'}) — will provision on first document ingest`);
+    }
+  }
 
-  const { isCheapestProviderEnabled, selectCheapestForAllTiers, setCheapestProviderPreference, formatCheapestProviderMessage } =
+  const { isCheapestProviderEnabled, selectCheapestForAllTiers, setCheapestProviderPreference } =
     await import('./model-cheapest-provider.mjs');
   const cheapestAlreadyEnabled = isCheapestProviderEnabled(envPath, { env: process.env });
   if (!cheapestAlreadyEnabled) {
@@ -694,29 +438,22 @@ 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.');
   }
 
-  // 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' && !argSet.has('--no-launch-agent')) {
@@ -737,110 +474,18 @@ export async function runSetup({ rootDir = ROOT_DIR, args = [], homeDir = HOME }
         nodePath: process.execPath,
       });
       pressureGuardLoad = loadPressureGuardLaunchAgent({ plistPath: pressureGuardAgent.plistPath });
-    } else {
-      console.log(`LaunchAgent: skipped (${laConsent.note})`);
-    }
-  } else if (argSet.has('--no-launch-agent')) {
-    console.log('LaunchAgent: skipped (--no-launch-agent)');
-  }
-
-  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'}`);
-    }
-  }
-
-  // Schema init runs whenever postgres is reachable — pgvector tables must exist before any
-  // retrieval call. Idempotent via construct_schema_migrations hash tracking.
-
-  if (serviceResult.status === 'ok') {
-    try {
-      await waitForSqlReady({ ...process.env, ...managedValues });
-      const readyClient = createSqlClient({ ...process.env, ...managedValues });
-      if (readyClient) {
-        try {
-          const { applied } = await runMigrations(readyClient);
-          if (applied.length) console.log(`Postgres schema: applied ${applied.length} migration(s) — ${applied.join(', ')}`);
-          else console.log('Postgres schema: up to date');
-        } finally {
-          await closeSqlClient(readyClient).catch(() => {});
-        }
-      }
-    } catch (error) {
-      console.log(`Postgres schema init failed: ${error?.message || 'unknown error'}`);
-    }
-  }
-
-  if (isYes && serviceResult.status === 'ok') {
-    const sqlClient = createSqlClient({ ...process.env, ...managedValues });
-    if (sqlClient) {
-      try {
-        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 {
-          console.log(`Construct DB restore: ${restore.status}`);
-        }
-
-        // Index Construct's own package docs (rootDir, machine-scoped) into the
-        // shared hybrid store. Seeding a downstream project's corpus is project
-        // state and belongs to `construct init` / `construct ingest`, never to
-        // machine install (ADR-0027 §3): install reads no cwd.
-
-        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}`);
-      } catch (error) {
-        console.log(`Hybrid storage sync failed: ${error?.message || 'unknown error'}`);
-      } finally {
-        await closeSqlClient(sqlClient).catch(() => {});
-      }
     }
   }
 
   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. Both `sync` and `sync --global` are kept to preserve
-  // every write across the project-detected and forced-global paths; in a
-  // non-project install cwd both resolve to the same global branch and would
-  // print the "Synced … to global scope" summary twice. The first call runs
-  // --quiet so the canonical summary prints exactly once from `sync --global`,
-  // with no change to what either writes.
-
   runConstruct(['sync', '--quiet']);
   runConstruct(['sync', '--global']);
   runConstruct(['doctor']);
 
-  // ── Summary panel ────────────────────────────────────────────────────────
   const setupTs = new Date().toISOString().slice(0, 19).replace(/[:.]/g, '-');
   const setupLogPath = path.join(HOME, '.cx', `setup-${setupTs}.log`);
   try {
@@ -850,42 +495,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}`);
 }
 
@@ -896,17 +520,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');