@geraldmaron/construct 1.0.2 → 1.0.3

package/.env.example

@@ -46,7 +46,7 @@ OPENROUTER_TITLE=Your App Name
 # The installer can auto-configure local memory or let you skip/manualize it.
 
 # ─── Hybrid Retrieval Backend ─────────────────────────────────────────────────
-# `construct setup --yes` writes managed defaults automatically. When Docker is
+# `construct init --yes` writes managed defaults automatically. When Docker is
 # available, it starts a localhost-only Postgres container on 127.0.0.1:54329.
 #
 # Shared Postgres store for team-ready state/querying

package/bin/construct

@@ -130,7 +130,7 @@ function usage() {
 
 /** Show interactive context-aware menu when construct is run without arguments. */
 async function showInteractiveMenu() {
-  const { loadProjectConfig } = await import('./lib/config/project-config.mjs');
+  const { loadProjectConfig } = await import('../lib/config/project-config.mjs');
   const { existsSync } = await import('node:fs');
   const { join } = await import('node:path');
   
@@ -142,7 +142,7 @@ async function showInteractiveMenu() {
   println('');
   
   if (isConstructProject) {
-    const projectName = process.env.CX_PROJECT_NAME || require('path').basename(projectRoot);
+    const projectName = process.env.CX_PROJECT_NAME || path.basename(projectRoot);
     println(`${COLORS.dim}Project:${COLORS.reset} ${projectName}`);
     println('');
   }
@@ -160,7 +160,7 @@ async function showInteractiveMenu() {
   
   // Show context-aware suggestions
   if (isConstructProject) {
-    const { readDashboardState } = await import('./lib/service-manager.mjs');
+    const { readDashboardState } = await import('../lib/service-manager.mjs');
     const dashboard = readDashboardState(HOME);
     
     if (!dashboard) {
@@ -288,12 +288,12 @@ async function cmdDoctor() {
     for (const varName of vars) {
       const sources = [];
 
-      // 1. process.env
+      // process.env
       if (process.env[varName]) {
         sources.push(`process.env (${process.env[varName].slice(0, 8)}…)`);
       }
 
-      // 2. .env files
+      // .env files
       for (const envPath of [join(process.cwd(), '.env'), join(homedir(), '.env'), join(homedir(), '.construct', 'config.env')]) {
         if (fs.existsSync(envPath)) {
           try {
@@ -304,7 +304,7 @@ async function cmdDoctor() {
         }
       }
 
-      // 3. Shell rc files
+      // Shell rc files
       const shellFiles = [join(homedir(), '.zshrc'), join(homedir(), '.bashrc'), join(homedir(), '.bash_profile'), join(homedir(), '.profile')];
       for (const rcPath of shellFiles) {
         if (!fs.existsSync(rcPath)) continue;
@@ -904,9 +904,9 @@ async function cmdUp() {
   if (embedConfigExists && autoEmbed) {
     try {
       const { runEmbedCli } = await import('../lib/embed/cli.mjs');
-      await runEmbedCli(['start']);
-    } catch {
-      // best effort
+      await runEmbedCli(['start'], { rootDir: ROOT_DIR });
+    } catch (err) {
+      warn(`embed start failed: ${err.message} — check ~/.cx/runtime/embed-daemon.log`);
     }
   }
 
@@ -1789,8 +1789,8 @@ async function cmdIntakeConfig(args) {
 async function cmdIntakeMetrics() {
   try {
     const { computeIntakeMetrics, pendingAge } = await import('../lib/embed/intake-metrics.mjs');
-    const metrics = computeIntakeMetrics({ rootDir: cwd });
-    const age = pendingAge({ rootDir: cwd });
+    const metrics = computeIntakeMetrics({ rootDir: process.cwd() });
+    const age = pendingAge({ rootDir: process.cwd() });
 
     println(`${COLORS.bold}Intake pipeline metrics:${COLORS.reset}`);
     println('');
@@ -2449,6 +2449,44 @@ async function cmdModels(args) {
     await cmdSync([]);
     return;
   }
+  if (args.includes('--cheapest')) {
+    const { selectCheapestProvider, rankConfiguredProvidersByCost, formatCheapestProviderMessage, isCheapestProviderEnabled } =
+      await import('../lib/model-cheapest-provider.mjs');
+    const cheapestTier = args.find((arg) => arg.startsWith('--tier='))?.split('=')[1] ?? 'standard';
+    const verbose = args.includes('--verbose');
+    const enabled = isCheapestProviderEnabled(envPath, { env: process.env });
+    const result = await selectCheapestProvider(cheapestTier, { env: process.env });
+    const msg = formatCheapestProviderMessage(result, { showRanking: verbose });
+    println(msg);
+    if (enabled) println('\nCheapest provider mode: enabled');
+    return;
+  }
+  if (args.includes('--apply-cheapest')) {
+    const { selectCheapestForAllTiers, setCheapestProviderPreference } =
+      await import('../lib/model-cheapest-provider.mjs');
+    const allTiers = args.includes('--all-tiers') || !args.find((arg) => arg.startsWith('--tier='));
+    const tierArg = args.find((arg) => arg.startsWith('--tier='))?.split('=')[1];
+    const tiers = allTiers ? ['reasoning', 'standard', 'fast'] : (tierArg ? [tierArg] : ['standard']);
+    const selections = {};
+    for (const currentTier of tiers) {
+      const { selectCheapestProvider } = await import('../lib/model-cheapest-provider.mjs');
+      const result = await selectCheapestProvider(currentTier, { env: process.env });
+      if (result.modelId) selections[currentTier] = result.modelId;
+    }
+    if (Object.keys(selections).length === 0) {
+      errorln('No configured providers found. Set API keys or install Ollama first.');
+      process.exit(1);
+    }
+    applyToEnv(envPath, selections);
+    println('Applying cheapest models:');
+    for (const [tier, model] of Object.entries(selections)) {
+      println(`  ${tier.padEnd(11)} ${model}`);
+    }
+    println('Written to ~/.construct/config.env. Running construct sync...');
+    setCheapestProviderPreference(envPath, true);
+    await cmdSync([]);
+    return;
+  }
   const registry = JSON.parse(fs.readFileSync(path.join(ROOT_DIR, 'agents', 'registry.json'), 'utf8'));
   const result = readCurrentModels(envPath, registry.models ?? {});
   const nothingSelected = ['reasoning', 'standard', 'fast'].every((t) => !result[t]);

package/bin/construct-postinstall.mjs

@@ -6,7 +6,7 @@
  * and runs `npm install`, npm fetches Construct into the project's
  * `node_modules/` and then runs this script. Its job: regenerate the project's
  * `.claude/agents/` and `.claude/settings.json` from the bundled registry so
- * the project clone is fully runnable without a manual `construct setup`.
+ * the project clone is fully runnable without a manual `construct init`.
  *
  * The script is a no-op in three cases:
  *

package/lib/bootstrap/resources.mjs

@@ -15,7 +15,7 @@
  *   downloadSize  approximate install size in bytes (informational)
  *
  * The registry is consulted by:
- *   - `construct setup`         walks every resource, asks consent, installs
+ *   - `construct init`         walks every resource, asks consent, installs
  *   - `construct doctor --bootstrap`  re-probes every resource verbosely
  *   - lazy-install paths in hooks (consult the cached consent silently)
  *
@@ -114,7 +114,7 @@ export function formatProbe(probe) {
     ? `\n     fallback: ${probe.fallback}`
     : '';
   const install = !probe.present && probe.installable
-    ? `\n     installable via construct setup`
+    ? `\n     installable via construct init`
     : '';
   return `  ${status}  ${probe.displayName}${v}${loc}${detail}${fallback}${install}`;
 }

package/lib/document-ingest.mjs

@@ -77,7 +77,7 @@ function renderMarkdown({ sourcePath, extractedAt, title, extractionMethod, char
   return lines.join('\n');
 }
 
-function collectInputFiles(inputPath) {
+function collectInputFiles(inputPath, { maxDepth = 10 } = {}) {
   const resolvedPath = resolve(inputPath);
   if (!existsSync(resolvedPath)) throw new Error(`Input path not found: ${resolvedPath}`);
 
@@ -90,13 +90,14 @@ function collectInputFiles(inputPath) {
   if (!stat.isDirectory()) return [];
 
   const files = [];
-  const stack = [resolvedPath];
+  const stack = [{ path: resolvedPath, depth: 0 }];
   while (stack.length > 0) {
-    const current = stack.pop();
+    const { path: current, depth } = stack.pop();
+    if (depth >= maxDepth) continue;
     for (const entry of readdirSync(current, { withFileTypes: true })) {
       const full = join(current, entry.name);
       if (entry.isDirectory()) {
-        stack.push(full);
+        stack.push({ path: full, depth: depth + 1 });
         continue;
       }
       if (entry.isFile() && isExtractableDocumentPath(full)) files.push(full);
@@ -135,7 +136,7 @@ export async function ingestDocuments(inputPaths, {
     throw new Error('--out can only be used with a single input path');
   }
 
-  const files = inputPaths.flatMap((inputPath) => collectInputFiles(isAbsolute(inputPath) ? inputPath : resolve(cwd, inputPath)));
+  const files = inputPaths.flatMap((inputPath) => collectInputFiles(isAbsolute(inputPath) ? inputPath : resolve(cwd, inputPath), { maxDepth: 10 }));
   if (files.length === 0) {
     throw new Error('No supported document files found');
   }

package/lib/embed/cli.mjs

@@ -174,7 +174,7 @@ function parseArgs(args) {
 // Subcommand: start
 // ---------------------------------------------------------------------------
 
-async function cmdEmbedStart(args, { homeDir = os.homedir(), rootDir } = {}) {
+async function cmdEmbedStart(args, { homeDir = os.homedir(), rootDir, _workerPath, _livenessCheckMs = 400 } = {}) {
   const existing = readRunningState(homeDir);
   if (existing) {
     process.stdout.write(`embed daemon already running (pid ${existing.pid})\n`);
@@ -188,7 +188,11 @@ async function cmdEmbedStart(args, { homeDir = os.homedir(), rootDir } = {}) {
       ? path.join(os.homedir(), '.construct', 'embed.yaml')
       : null;
 
-  const workerPath = path.join(rootDir, 'lib', 'embed', 'worker.mjs');
+  const workerPath = _workerPath ?? path.join(rootDir, 'lib', 'embed', 'worker.mjs');
+  if (!fs.existsSync(workerPath)) {
+    throw new Error(`embed worker not found at ${workerPath}`);
+  }
+
   const workerArgs = configPath ? [workerPath, '--config', configPath] : [workerPath];
   const log = logPath(homeDir);
   fs.mkdirSync(path.dirname(log), { recursive: true });
@@ -199,9 +203,18 @@ async function cmdEmbedStart(args, { homeDir = os.homedir(), rootDir } = {}) {
     stdio: ['ignore', fd, fd],
     env: { ...process.env },
   });
+  fs.closeSync(fd);
   child.unref();
 
   writeState({ pid: child.pid, configPath: configPath ?? 'auto', startedAt: new Date().toISOString() }, homeDir);
+
+  // Brief liveness check — detects immediate crashes (e.g. missing module, bad config path)
+  await new Promise(r => setTimeout(r, _livenessCheckMs));
+  if (!processExists(child.pid)) {
+    clearState(homeDir);
+    throw new Error(`embed worker (pid ${child.pid}) exited immediately — check ${log}`);
+  }
+
   process.stdout.write(`embed daemon started (pid ${child.pid})\n`);
   process.stdout.write(`config: ${configPath ?? 'auto-discover from config.env'}\n`);
   process.stdout.write(`log:    ${log}\n`);
@@ -299,7 +312,7 @@ export async function runEmbedCli(args, opts = {}) {
   const rootDir = opts.rootDir ?? new URL('../..', import.meta.url).pathname;
 
   switch (sub) {
-    case 'start':       return cmdEmbedStart(subArgs, { homeDir, rootDir });
+    case 'start':       return cmdEmbedStart(subArgs, { homeDir, rootDir, _workerPath: opts._workerPath, _livenessCheckMs: opts._livenessCheckMs });
     case 'stop':        return cmdEmbedStop(subArgs, { homeDir });
     case 'status':      return cmdEmbedStatus(subArgs, { homeDir });
     case 'snapshot':    return cmdEmbedSnapshot(subArgs, { homeDir });

package/lib/embed/customer-profiles.mjs

@@ -3,7 +3,7 @@
  *
  * Maintains durable customer/account memory in ~/.cx/product-intel/customer-profiles/.
  * Profiles are additive — history is preserved unless explicitly deleted.
- * Used by intake triage to link signals to customers and detect account-level patterns.
+ * Links signals to customers and detects account-level patterns during intake triage.
  *
  * Storage:
  *   ~/.cx/product-intel/customer-profiles/<customer-id>.md

package/lib/embed/daemon.mjs

@@ -58,8 +58,8 @@ function logCatch(source, err) {
 
 /**
  * Resolve an LLM API key from multiple sources: env → config.env → ~/.env → shell rc.
- * Used by the telemetry-generation probe so it can find keys stored via 1Password
- * op:// refs in .zshrc or other shell config files.
+ * Supports 1Password op:// refs in .zshrc or other shell config files for the
+ * telemetry-generation probe.
  */
 async function resolveLLMKey(varName, env) {
   if (env[varName] && typeof env[varName] === 'string' && env[varName].length > 0) return env[varName];
@@ -575,7 +575,8 @@ this.#scheduler.register(
         const ok = result.results.filter(r => r.success).length;
         const total = result.results.length;
         process.stderr.write(`[embed] Telemetry setup: ${ok}/${total} resources configured\n`);
-      } else if (!result.ok) {
+      } else if (!result.ok && !result.error?.includes('required')) {
+        // Suppress the "keys required" message — normal for solo mode without telemetry configured.
         process.stderr.write(`[embed] Telemetry setup skipped: ${result.error}\n`);
       } else if (result.results?.some(r => !r.success)) {
         const failures = result.results.filter(r => !r.success);
@@ -840,21 +841,23 @@ this.#scheduler.register(
               meta: { gaps: result.gaps.length, conflicts: result.conflicts?.length || 0, recommendations: result.recommendations?.length || 0, autoFixed, queued },
             });
           }
-          emitTraceEvent({
-            rootDir: this.#rootDir,
-            eventType: 'lifecycle.completed',
-            traceId: this.#daemonTraceId,
-            spanId: newSpanId(),
-            env: this.#env,
-            metadata: {
-              gaps: result.gaps.length,
-              conflicts: result.conflicts?.length || 0,
-              recommendations: result.recommendations?.length || 0,
-              autoFixed,
-              queued,
-              targets: result.targets,
-            },
-          }).catch(() => {});
+          try {
+            emitTraceEvent({
+              rootDir: this.#rootDir,
+              eventType: 'lifecycle.completed',
+              traceId: this.#daemonTraceId,
+              spanId: newSpanId(),
+              env: this.#env,
+              metadata: {
+                gaps: result.gaps.length,
+                conflicts: result.conflicts?.length || 0,
+                recommendations: result.recommendations?.length || 0,
+                autoFixed,
+                queued,
+                targets: result.targets,
+              },
+            });
+          } catch { /* observability must not break the caller */ }
         } catch (err) {
           process.stderr.write(`[embed] Docs lifecycle error: ${err.message}\n`);
         }
@@ -1114,18 +1117,20 @@ this.#scheduler.register(
 
     this.#status = 'running';
     this.#daemonTraceId = newTraceId();
-    emitTraceEvent({
-      rootDir: this.#rootDir,
-      eventType: 'daemon.started',
-      traceId: this.#daemonTraceId,
-      spanId: newSpanId(),
-      env: this.#env,
-      metadata: {
-        pid: process.pid,
-        configSnapshotIntervalMs: this.#config.snapshot.intervalMs,
-        version: process.env.CONSTRUCT_VERSION || '0.0.0',
-      },
-    }).catch(() => {});
+    try {
+      emitTraceEvent({
+        rootDir: this.#rootDir,
+        eventType: 'daemon.started',
+        traceId: this.#daemonTraceId,
+        spanId: newSpanId(),
+        env: this.#env,
+        metadata: {
+          pid: process.pid,
+          configSnapshotIntervalMs: this.#config.snapshot.intervalMs,
+          version: process.env.CONSTRUCT_VERSION || '0.0.0',
+        },
+      });
+    } catch { /* observability must not break the caller */ }
     process.stderr.write(`[embed] Daemon started. Snapshot interval: ${this.#config.snapshot.intervalMs}ms\n`);
   }
 
@@ -1134,14 +1139,16 @@ this.#scheduler.register(
     this.#inboxLiveWatcher = null;
     this.#scheduler?.stop();
     this.#status = 'stopped';
-    emitTraceEvent({
-      rootDir: this.#rootDir,
-      eventType: 'daemon.stopped',
-      traceId: this.#daemonTraceId,
-      spanId: newSpanId(),
-      env: this.#env,
-      metadata: { pid: process.pid, uptimeMs: process.uptime() * 1000 },
-    }).catch(() => {});
+    try {
+      emitTraceEvent({
+        rootDir: this.#rootDir,
+        eventType: 'daemon.stopped',
+        traceId: this.#daemonTraceId,
+        spanId: newSpanId(),
+        env: this.#env,
+        metadata: { pid: process.pid, uptimeMs: process.uptime() * 1000 },
+      });
+    } catch { /* observability must not break the caller */ }
     process.stderr.write('[embed] Daemon stopped.\n');
   }
 
@@ -1182,10 +1189,10 @@ this.#scheduler.register(
      try {
        // Query strategy/PRDs/RFCs from knowledge base
        
-       const strategyDocs = searchObservations(this.#rootDir, 'PRD RFC strategy', {
-         category: 'knowledge',
-         limit: 50,
-       });
+        const strategyDocs = searchObservations(this.#rootDir, 'PRD RFC strategy', {
+          category: 'insight',
+          limit: 50,
+        });
        
        // Query existing Jira tickets via Atlassian provider
        

package/lib/embed/inbox.mjs

@@ -36,6 +36,7 @@ const STATE_FILE = '.cx/runtime/inbox-state.json';
 const DEFAULT_INBOX_SUBDIR = '.cx/inbox';
 const DOCS_INTAKE_SUBDIR = 'docs/intake';
 const MAX_FILE_SIZE_BYTES = 50 * 1024 * 1024; // 50 MB hard cap
+const STALE_STATE_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
 
 function nextAvailablePath(targetPath) {
   if (!existsSync(targetPath)) return targetPath;
@@ -50,6 +51,28 @@ function nextAvailablePath(targetPath) {
   }
 }
 
+// ─── Stale state pruning ─────────────────────────────────────────────────────
+
+/**
+ * Remove state entries for source files absent from disk for more than 7 days.
+ * Returns the count of removed entries.
+ */
+function pruneStaleState(rootDir, state) {
+  const cutoffMs = Date.now() - STALE_STATE_AGE_MS;
+  let removed = 0;
+  for (const key of Object.keys(state)) {
+    const entry = state[key];
+    if (!existsSync(key) && entry.processedAt) {
+      const processedMs = new Date(entry.processedAt).getTime();
+      if (processedMs < cutoffMs) {
+        delete state[key];
+        removed++;
+      }
+    }
+  }
+  return removed;
+}
+
 // ─── State helpers ────────────────────────────────────────────────────────────
 
 function statePath(rootDir) {
@@ -327,6 +350,13 @@ export class InboxWatcher {
       }
     }
 
+    // Prune stale state entries: remove entries for source files absent from disk
+    // for more than 7 days (covers moved/renamed files that linger in state).
+    const staleRemoved = pruneStaleState(this.#rootDir, state);
+    if (staleRemoved > 0) {
+      process.stderr.write(`[inbox] pruned ${staleRemoved} stale state entries\n`);
+    }
+
     if (processed.length || errors.length) {
       writeState(this.#rootDir, state);
     }

package/lib/embed/recommendation-store.mjs

@@ -191,7 +191,7 @@ export function dismissRecommendation(dedupKey, { reason = 'manually dismissed',
 }
 
 /**
- * Supersede a recommendation (mark as replaced by a newer one).
+ * Supersede a recommendation (mark as superseded by a newer one).
  *
  * @param {string} dedupKey - Existing recommendation to supersede
  * @param {string} supersedingId - ID of the recommendation that replaces it

package/lib/evaluator-optimizer.mjs

@@ -26,8 +26,6 @@
  *   }
  */
 
-import { getTemplate } from './templates.mjs';
-
 const DEFAULT_THRESHOLD = 0.7;
 const DEFAULT_MAX_ITERATIONS = 3;
 

package/lib/features.mjs

@@ -287,6 +287,17 @@ function buildFeatures(overrides = {}) {
       if (platforms.length > 0) {
         return { status: 'configured', message: `Configured in ${platforms.join(', ')}` };
       }
+      // If every host explicitly marks this MCP as unsupported, it is delivered
+      // through the built-in construct-mcp stdio server — not a standalone tool.
+      const hostSupportEntries = Object.values(mcp.hostSupport ?? {});
+      const allUnsupported = hostSupportEntries.length > 0 &&
+        hostSupportEntries.every((s) => {
+          const mode = typeof s === 'string' ? s : (s?.mode ?? 'managed');
+          return mode === 'unsupported';
+        });
+      if (allUnsupported) {
+        return { status: 'configured', message: 'Available via construct-mcp (built-in)' };
+      }
       return { status: 'unavailable', message: 'Not configured in any host' };
     },
   }));

package/lib/health-check.mjs

@@ -2,10 +2,8 @@
 /**
  * lib/health-check.mjs — reusable prerequisite and health checks.
  *
- * Used by:
- * - `construct dev` (auto-checks before starting services)
- * - `construct doctor` (comprehensive system audit)
- * - `construct init` (pre-init validation)
+ * Prerequisite and health check runners for `construct dev`, `construct doctor`,
+ * and `construct init`.
  */
 
 import { spawnSync } from 'node:child_process';

package/lib/init-unified.mjs

@@ -591,6 +591,108 @@ async function askDocumentationQuestions() {
   return { lanes: selectedLanes, withArchitecture, withReadme };
 }
 
+// Intake collection — suggest directories to watch for context
+function discoverProjectDirs(targetPath) {
+  const dirs = [];
+  let entries;
+  try { entries = fs.readdirSync(targetPath, { withFileTypes: true }); } catch { return dirs; }
+  
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const name = entry.name;
+    // Skip hidden dirs, node_modules, build artifacts
+    if (name.startsWith('.')) continue;
+    if (name === 'node_modules') continue;
+    if (name === 'dist' || name === 'build' || name === '.next' || name === '.out') continue;
+    dirs.push(name);
+  }
+  return dirs.sort();
+}
+
+const INTAKE_DIR_PRESETS = [
+  { value: 'src', label: 'src/', reason: 'Source code — most projects put code here' },
+  { value: 'lib', label: 'lib/', reason: 'Library code' },
+  { value: 'packages', label: 'packages/', reason: 'Monorepo packages' },
+  { value: 'services', label: 'services/', reason: 'Microservices or backend services' },
+  { value: 'apps', label: 'apps/', reason: 'Monorepo apps' },
+  { value: 'docs', label: 'docs/', reason: 'Documentation source' },
+  { value: 'tests', label: 'tests/', reason: 'Test files' },
+  { value: 'spec', label: 'spec/', reason: 'Specifications' },
+  { value: 'infra', label: 'infra/', reason: 'Infrastructure code (Terraform, etc.)' },
+  { value: 'config', label: 'config/', reason: 'Configuration files' },
+  { value: 'scripts', label: 'scripts/', reason: 'Build/ops scripts' },
+  { value: 'tools', label: 'tools/', reason: 'Internal tooling' },
+];
+
+async function askIntakeCollection(targetPath, skipInteractive) {
+  if (skipInteractive) {
+    // Non-interactive: auto-detect and suggest based on what exists
+    const existingDirs = discoverProjectDirs(targetPath);
+    const selected = INTAKE_DIR_PRESETS
+      .filter(preset => existingDirs.includes(preset.value))
+      .map(p => p.value);
+    
+    if (selected.length === 0) return null;
+    
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('  INTAKE COLLECTION');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('');
+    console.log(`Auto-detected ${selected.length} directory(ies) to watch for context:`);
+    for (const d of selected) console.log(`  • ${d}/`);
+    console.log('');
+    console.log('The inbox watcher will scan these directories for new files');
+    console.log('and route them through R&D triage automatically.');
+    console.log('');
+    
+    return { parentDirs: selected, maxDepth: 4 };
+  }
+  
+  // Interactive mode
+  const existingDirs = discoverProjectDirs(targetPath);
+  const presetOptions = INTAKE_DIR_PRESETS.map(p => ({
+    label: p.label,
+    value: p.value,
+    checked: existingDirs.includes(p.value),
+    description: p.reason,
+  }));
+  
+  console.log('');
+  console.log('═══════════════════════════════════════════════════════════');
+  console.log('  INTAKE COLLECTION');
+  console.log('═══════════════════════════════════════════════════════════');
+  console.log('');
+  console.log('Intake watches directories for new files and routes them');
+  console.log('through R&D triage. Select which directories to watch.');
+  console.log('(directories already found in your project are pre-checked)');
+  console.log('');
+  
+  const selected = await multiSelect({
+    title: 'Directories to Watch',
+    instructions: 'Press Enter to confirm your selection',
+    options: presetOptions,
+  });
+  
+  if (selected.length === 0) {
+    console.log('');
+    console.log('No directories selected. The inbox watcher will only scan');
+    console.log('.cx/inbox/ and docs/intake/ (built-in zones).');
+    console.log('');
+    console.log('You can always add more later with:');
+    console.log('  construct intake config set --add-dir=src');
+    console.log('');
+    return null;
+  }
+  
+  console.log('');
+  console.log(`Watching ${selected.length} directory(ies):`);
+  for (const d of selected) console.log(`  • ${d}/`);
+  console.log('');
+  
+  return { parentDirs: selected, maxDepth: 4 };
+}
+
 function buildProjectReadme(projectName) {
   return `# ${projectName}
 
@@ -824,6 +926,20 @@ async function main() {
     console.log('');
   }
   
+  // Intake collection — ask which directories to watch for context
+  console.log('[TRACE init:intake-ask]');
+  
+  const intakeConfig = await askIntakeCollection(target, skipInteractive);
+  if (intakeConfig) {
+    const { saveIntakeConfig } = await import('./intake/intake-config.mjs');
+    try {
+      saveIntakeConfig(target, intakeConfig);
+      created.push('.cx/intake-config.json');
+    } catch (err) {
+      console.warn(`⚠️  Could not write intake config: ${err.message}`);
+    }
+  }
+  
   // Ask about documentation system
   console.log('[TRACE init:docs-ask]');
   
@@ -895,7 +1011,7 @@ async function main() {
   // can compare new intake against established PRDs/RFCs/ADRs from day
   // one. Best-effort: skipped silently when Postgres + embedding model
   // aren't ready yet (DATABASE_URL unset, no ONNX cache). User can re-run
-  // `construct ingest` or `construct setup` later to seed manually.
+  // `construct ingest` or `construct init` later to seed manually.
 
   try {
     const { syncFileStateToSql } = await import('./storage/sync.mjs');
@@ -950,10 +1066,10 @@ async function main() {
     if (verbose) console.log('\nStarting services...');
     try {
       const { startServices } = await import('./service-manager.mjs');
-      const { os } = await import('node:os');
+      const { homedir } = await import('node:os');
       const { detectDockerCompose } = await import('./setup.mjs');
       
-      const homeDir = os.homedir();
+      const homeDir = homedir();
       const composeRunner = detectDockerCompose();
       
       const { results } = await startServices({