@geraldmaron/construct 1.0.5 → 1.0.7

package/lib/embed/daemon.mjs

@@ -26,7 +26,7 @@
 
 import { existsSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 
 import { loadEmbedConfig } from './config.mjs';
 import { Scheduler } from './scheduler.mjs';
@@ -109,8 +109,44 @@ async function resolveLLMKey(varName, env) {
 
 // ─── Root dir resolution ─────────────────────────────────────────────────────
 
-function resolveRootDir(env = process.env) {
-  return (env.CX_DATA_DIR ?? '').trim() || homedir();
+// Cap upward search so a daemon launched from deep in the filesystem cannot
+// fan out to thousands of stat() calls in pathological layouts.
+
+const PROJECT_WALKUP_MAX = 10;
+
+/**
+ * Walk up from `startDir` looking for a directory that contains `.cx/context.md`.
+ * Returns the project root path, or null if nothing is found within the cap.
+ * Exported for unit tests.
+ */
+export function findProjectRoot(startDir, { maxLevels = PROJECT_WALKUP_MAX } = {}) {
+  if (!startDir || typeof startDir !== 'string') return null;
+  let current = startDir;
+  for (let i = 0; i <= maxLevels; i++) {
+    try {
+      if (existsSync(join(current, '.cx', 'context.md'))) return current;
+    } catch { /* skip unreadable dir */ }
+    const parent = dirname(current);
+    if (!parent || parent === current) return null;
+    current = parent;
+  }
+  return null;
+}
+
+/**
+ * Resolve the daemon's rootDir.
+ *
+ * Precedence:
+ *   1. `CX_DATA_DIR` env override (operator authority)
+ *   2. Project root discovered by walking up from `cwd` looking for `.cx/context.md`
+ *   3. `homedir()` fallback
+ */
+export function resolveRootDir(env = process.env, cwd = process.cwd()) {
+  const override = (env.CX_DATA_DIR ?? '').trim();
+  if (override) return override;
+  const projectRoot = findProjectRoot(cwd);
+  if (projectRoot) return projectRoot;
+  return homedir();
 }
 
 function resolveWorkspaceDir(env = process.env) {
@@ -708,7 +744,10 @@ this.#scheduler.register(
       async () => {
         const result = await this.#inboxWatcher.poll();
         if (result.processed.length) {
-          process.stderr.write(`[embed] Inbox: ingested ${result.processed.length} file(s) from [${result.dirs.join(', ')}]\n`);
+          const { getRebrand } = await import('../profiles/rebrand.mjs');
+          const { signalNoun } = getRebrand(this.#rootDir);
+          const noun = result.processed.length === 1 ? signalNoun : `${signalNoun}s`;
+          process.stderr.write(`[embed] Classified ${result.processed.length} ${noun} from [${result.dirs.join(', ')}]\n`);
           addObservation(this.#rootDir, {
             role: 'construct',
             category: 'insight',

package/lib/embed/docs-lifecycle.mjs

@@ -64,7 +64,7 @@ export function detectDocGaps(target, opts = {}) {
   const gaps = [];
 
   if (target.access === 'remote') {
-    // Remote-only targets: can't inspect filesystem, skip for now
+    // Remote-only targets have no local filesystem to inspect; gap detection requires the local docs tree.
     return gaps;
   }
 

package/lib/embed/inbox.mjs

@@ -29,6 +29,7 @@ import { addObservation } from '../observation-store.mjs';
 import { inferKnowledgeTarget, knowledgeDirForCategory } from '../knowledge/layout.mjs';
 import { docLaneDir, suggestDocsLaneForFile } from '../docs-routing.mjs';
 import { shouldCreateCx } from '../project-detection.mjs';
+import { ensureCxDir } from '../project-init-shared.mjs';
 import { prepareIntakeForIngestedFile } from '../intake/prepare.mjs';
 import { loadIntakeConfig, INTAKE_DEFAULT_MAX_DEPTH } from '../intake/intake-config.mjs';
 
@@ -90,6 +91,7 @@ function writeState(rootDir, state) {
   
   // Only create .cx directories if this is an initialized project
   if (shouldCreateCx(rootDir)) {
+    ensureCxDir(rootDir);
     mkdirSync(join(rootDir, '.cx', 'runtime'), { recursive: true });
     writeFileSync(p, JSON.stringify(state, null, 2) + '\n');
   }

package/lib/embed/scheduler.mjs

@@ -4,24 +4,30 @@
  * Lightweight alternative to a full cron library — runs tasks at fixed
  * intervals, tracks last-run times, and supports graceful shutdown.
  * Zero external deps.
+ *
+ * One-shot startup jobs MUST set `repeat: false`. With `repeat: true`
+ * (the default) and `intervalMs: 0`, the timer fires on every event-loop
+ * tick — the bug that filled embed-daemon.log to 34 GB before this option
+ * was added.
  */
 
 export class Scheduler {
-  #tasks = new Map();   // id → { fn, intervalMs, lastRun, timer, label }
+  #tasks = new Map();   // id → { fn, intervalMs, lastRun, timer, label, repeat }
   #running = false;
 
   /**
    * Register a task. Returns the task id.
    * @param {string} label       - Human-readable name for logging
-   * @param {number} intervalMs  - How often to run (ms)
+   * @param {number} intervalMs  - How often to run (ms); ignored when repeat is false
    * @param {Function} fn        - Async function to call; receives { label, lastRun }
    * @param {object} [opts]
    * @param {boolean} [opts.runImmediately=false] - Run once before first interval fires
    * @param {boolean} [opts.unref=false]           - Call timer.unref() so this task does not keep the event loop alive (use in tests)
+   * @param {boolean} [opts.repeat=true]           - When false, the task is one-shot: it runs once (immediately if runImmediately, otherwise after intervalMs) and never re-arms. Required for startup jobs that pass intervalMs: 0.
    */
-  register(label, intervalMs, fn, { runImmediately = false, unref = false } = {}) {
+  register(label, intervalMs, fn, { runImmediately = false, unref = false, repeat = true } = {}) {
     const id = `${label}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    const task = { label, intervalMs, fn, lastRun: null, timer: null, runImmediately, unref };
+    const task = { label, intervalMs, fn, lastRun: null, timer: null, runImmediately, unref, repeat };
     this.#tasks.set(id, task);
 
     if (this.#running) {
@@ -50,6 +56,7 @@ export class Scheduler {
     for (const task of this.#tasks.values()) {
       if (task.timer) {
         clearInterval(task.timer);
+        clearTimeout(task.timer);
         task.timer = null;
       }
     }
@@ -60,7 +67,10 @@ export class Scheduler {
    */
   unregister(id) {
     const task = this.#tasks.get(id);
-    if (task?.timer) clearInterval(task.timer);
+    if (task?.timer) {
+      clearInterval(task.timer);
+      clearTimeout(task.timer);
+    }
     this.#tasks.delete(id);
   }
 
@@ -74,6 +84,7 @@ export class Scheduler {
       intervalMs: t.intervalMs,
       lastRun: t.lastRun,
       active: Boolean(t.timer),
+      repeat: t.repeat,
     }));
   }
 
@@ -83,6 +94,23 @@ export class Scheduler {
         process.stderr.write(`[scheduler] ${task.label} error: ${err.message}\n`);
       });
     }
+
+    // One-shot jobs do not re-arm. When runImmediately is true, the task has
+    // already executed and no further scheduling is needed. When false, a
+    // single setTimeout fires once at intervalMs.
+    if (!task.repeat) {
+      if (!runImmediately) {
+        task.timer = setTimeout(() => {
+          task.timer = null;
+          this.#runTask(task).catch((err) => {
+            process.stderr.write(`[scheduler] ${task.label} error: ${err.message}\n`);
+          });
+        }, task.intervalMs);
+        if (task.unref && task.timer.unref) task.timer.unref();
+      }
+      return;
+    }
+
     task.timer = setInterval(() => {
       this.#runTask(task).catch((err) => {
         process.stderr.write(`[scheduler] ${task.label} error: ${err.message}\n`);

package/lib/evaluator-optimizer.mjs

@@ -95,9 +95,8 @@ export async function evaluateDocument({ content, docType, evaluatorFn = null })
     return await evaluatorFn({ content, docType, rubric });
   }
   
-  // Default: deterministic rubric-based evaluation
-  // In production, this would call an LLM evaluator
-  // For now, we use structural checks as a proxy
+  // Default path: deterministic structural-rubric evaluation.
+  // Consumers wanting LLM-graded evaluation supply `evaluatorFn` (handled above).
   
   const scores = [];
   const feedback = [];

package/lib/flavors/loader.mjs

@@ -130,7 +130,7 @@ export function validateFlavor(filePath) {
     errors.push(`${filePath}: applies_to must be a non-empty array`);
   }
   if (!Array.isArray(fm.profiles) || fm.profiles.length === 0) {
-    errors.push(`${filePath}: profiles must be a non-empty array (run scripts/migrate-flavors.mjs)`);
+    errors.push(`${filePath}: profiles must be a non-empty array; add a frontmatter line like \`profiles: [rnd]\``);
   }
   return errors;
 }

package/lib/hooks/comment-lint.mjs

@@ -40,8 +40,24 @@ const rootDir = path.resolve(fileURLToPath(import.meta.url), '..', '..', '..');
 const result = lintFile(filePath, { rootDir });
 if (!result.errors.length && !result.warnings.length) process.exit(0);
 
+// Artifact-prose violations are advisory at write-time (no-fabrication policy
+// enforces them at CI/release-gate time via CONSTRUCT_ARTIFACT_LINT_MODE=block).
+// Surface them on stderr but do not block the edit.
+const artifactOnly = (
+  result.errors.length === 0 &&
+  result.warnings.every((w) => w.kind === 'artifact')
+);
+
 const { output } = formatResults([result]);
 process.stderr.write(output);
+
+if (artifactOnly) {
+  process.stderr.write(
+    '\nArtifact-lint advisory (no-fabrication). The edit is not blocked, but these will fail the release gate. Fix before push.\n',
+  );
+  process.exit(0);
+}
+
 process.stderr.write(
   '\nComment policy blocked this edit. Remove the violations or set CONSTRUCT_SKIP_COMMENT_LINT=1.\n',
 );

package/lib/hooks/mcp-audit.mjs

@@ -10,6 +10,7 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 import { shouldCreateCx } from '../project-detection.mjs';
+import { ensureCxDir } from '../project-init-shared.mjs';
 
 let input = {};
 try { input = JSON.parse(readFileSync(0, 'utf8')); } catch { process.exit(0); }
@@ -47,7 +48,7 @@ if (audit[mcpServer].length > 200) audit[mcpServer] = audit[mcpServer].slice(-20
 
 try {
   if (shouldCreateCxDir) {
-    mkdirSync(join(cwd, '.cx'), { recursive: true });
+    ensureCxDir(cwd);
     writeFileSync(auditPath, JSON.stringify(audit, null, 2));
   }
 } catch { /* best effort */ }

package/lib/hooks/proactive-activation.mjs

@@ -239,20 +239,6 @@ export function onScheduleCheck() {
   return events;
 }
 
-/**
- * Get all pending activations for a specialist.
- */
-export function getPendingActivations(specialist) {
-  // In a full implementation, this would query a pending queue
-  // For now, return recent activation history
-  const state = getActivationState(specialist);
-  return {
-    pending: 0,
-    recent: state.activations.length,
-    total: state.totalActivations,
-  };
-}
-
 /**
  * Clear activation state (for testing or manual reset).
  */

package/lib/hooks/rule-verifier.mjs

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+/**
+ * lib/hooks/rule-verifier.mjs — Stop hook that audits the session for
+ * compliance with the construct rules the agent claimed to follow.
+ *
+ * Checks:
+ *   - Each commit / push was preceded by an approval signal scoped to that
+ *     branch + change.
+ *   - Edits to protected files (CLAUDE.md table) had user confirmation.
+ *   - Beads claims exist for any work that touched durable state.
+ *
+ * Approval detection is intent-based, not keyword-based. The verifier reads
+ * the conversational window before each consequential action and classifies
+ * the user's stance: APPROVED, REFUSED, INCONCLUSIVE. Direct affirmation,
+ * accepting a proposed plan that named the action, or "go ahead" all count
+ * as approval — no specific word is required.
+ *
+ * Output: { ok: 'pass' | 'fail' | 'inconclusive', findings[] } written to
+ * .cx/audit.jsonl. Inconclusive results surface as escalation questions to
+ * the user rather than silent passes or false-positive blocks.
+ *
+ * @p95ms 200
+ * @maxBlockingScope Stop
+ */
+
+import { readFileSync, existsSync, appendFileSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { logHookFailure } from './_lib/log.mjs';
+
+const AUDIT_REL = '.cx/audit.jsonl';
+
+function safeReadJsonLines(transcriptPath) {
+  try {
+    const raw = readFileSync(transcriptPath, 'utf8');
+    return raw.split('\n').map((line) => { try { return JSON.parse(line); } catch { return null; } }).filter(Boolean);
+  } catch { return []; }
+}
+
+function lastN(entries, count) {
+  return entries.slice(Math.max(0, entries.length - count));
+}
+
+/**
+ * Identify consequential actions in the transcript tail. Returns a list of
+ * { kind, branch, target, atIndex } items. Each one needs an approval signal
+ * within the window of conversation immediately preceding it.
+ *
+ * Detected actions:
+ *   - 'commit'        — git commit invocation
+ *   - 'push'          — git push invocation
+ *   - 'protected'     — edit to a CLAUDE.md-protected file
+ *   - 'durable-state' — bd close / claim against durable state
+ */
+export function findConsequentialActions(entries) {
+  const actions = [];
+  for (let i = 0; i < entries.length; i++) {
+    const e = entries[i];
+    const cmd = extractBashCommand(e);
+    if (cmd) {
+      if (/^git\s+commit\b/.test(cmd) && !/--dry-run/.test(cmd)) {
+        actions.push({ kind: 'commit', target: cmd.slice(0, 200), atIndex: i });
+      } else if (/^git\s+push\b/.test(cmd) && !/--dry-run/.test(cmd)) {
+        actions.push({ kind: 'push', target: cmd.slice(0, 200), atIndex: i });
+      } else if (/^gh\s+pr\s+(create|merge)\b/.test(cmd)) {
+        actions.push({ kind: 'pr-mutation', target: cmd.slice(0, 200), atIndex: i });
+      }
+    }
+    const editPath = extractEditPath(e);
+    if (editPath && /CLAUDE\.md|install\.sh|claude\/settings\.template\.json|agents\/registry\.json/.test(editPath)) {
+      actions.push({ kind: 'protected', target: editPath, atIndex: i });
+    }
+  }
+  return actions;
+}
+
+function extractBashCommand(entry) {
+  const toolUse = entry?.message?.content?.find?.((c) => c?.type === 'tool_use' && c?.name === 'Bash');
+  return toolUse?.input?.command || null;
+}
+
+function extractEditPath(entry) {
+  const toolUse = entry?.message?.content?.find?.((c) => c?.type === 'tool_use' && (c?.name === 'Edit' || c?.name === 'Write'));
+  return toolUse?.input?.file_path || null;
+}
+
+/**
+ * Classify a conversational window for approval intent. This is intentionally
+ * conservative — it does not require any keyword. If the window contains a
+ * user turn that directly addresses the action being taken (mentioning the
+ * branch, the file, or accepting a proposed plan), that counts as approval.
+ *
+ * The default classifier is deterministic: it scans for plausible approval
+ * tokens AND for the action target appearing earlier in the conversation.
+ * A pluggable classifier can replace this with an LLM-graded inference at
+ * runtime — register via setApprovalClassifier(fn).
+ *
+ * Returns: 'APPROVED' | 'REFUSED' | 'INCONCLUSIVE'.
+ */
+let _approvalClassifier = defaultApprovalClassifier;
+
+export function setApprovalClassifier(fn) {
+  _approvalClassifier = typeof fn === 'function' ? fn : defaultApprovalClassifier;
+}
+
+export function classifyApproval(window, action) {
+  return _approvalClassifier(window, action);
+}
+
+function defaultApprovalClassifier(window, action) {
+  if (!Array.isArray(window) || window.length === 0) return 'INCONCLUSIVE';
+
+  let assistantProposedAction = false;
+  let userResponded = false;
+  let userRefused = false;
+  let userAffirmed = false;
+
+  for (const entry of window) {
+    const role = entry?.message?.role || entry?.role;
+    const text = extractText(entry).toLowerCase();
+    if (!text) continue;
+
+    if (role === 'assistant') {
+      if (actionMentioned(text, action)) assistantProposedAction = true;
+    }
+    if (role === 'user') {
+      userResponded = true;
+      if (/\b(no|stop|don'?t|cancel|wait|abort|hold off|never mind)\b/.test(text)) userRefused = true;
+      if (/\b(yes|yep|yeah|go ahead|do it|proceed|ship it|approve|confirmed|sounds good|that works|lgtm|sgtm|ok|sure|please do|merge it|continue)\b/.test(text)) userAffirmed = true;
+      // Even without explicit affirmation words, accepting a named plan is approval.
+      if (assistantProposedAction && !userRefused && text.length > 0 && !/\?$/.test(text.trim())) {
+        userAffirmed = userAffirmed || /\b(thanks|great|perfect|sounds|works|good)\b/.test(text);
+      }
+    }
+  }
+
+  if (userRefused) return 'REFUSED';
+  if (userAffirmed && assistantProposedAction) return 'APPROVED';
+  if (userAffirmed) return 'APPROVED';
+  if (!userResponded) return 'INCONCLUSIVE';
+  return 'INCONCLUSIVE';
+}
+
+function extractText(entry) {
+  const msg = entry?.message;
+  if (!msg) return '';
+  if (typeof msg.content === 'string') return msg.content;
+  if (Array.isArray(msg.content)) {
+    return msg.content.map((c) => (typeof c === 'string' ? c : c?.text || '')).join(' ');
+  }
+  return '';
+}
+
+function actionMentioned(text, action) {
+  if (!text) return false;
+  if (action.kind === 'commit' || action.kind === 'push' || action.kind === 'pr-mutation') {
+    return /\b(commit|push|merge|ship|pr|pull request)\b/.test(text);
+  }
+  if (action.kind === 'protected') {
+    const fname = action.target.split('/').pop().toLowerCase();
+    return text.includes(fname.toLowerCase()) || text.includes(action.target.toLowerCase());
+  }
+  return false;
+}
+
+/**
+ * Verify a transcript against the rule set. Returns a structured audit
+ * result. Side-effect free; the runtime entry point below writes the result
+ * to .cx/audit.jsonl.
+ */
+export function verifyTranscript(entries, { windowSize = 20 } = {}) {
+  const findings = [];
+  const actions = findConsequentialActions(entries);
+
+  for (const action of actions) {
+    const window = lastN(entries.slice(0, action.atIndex), windowSize);
+    const verdict = classifyApproval(window, action);
+    findings.push({
+      action: action.kind,
+      target: action.target,
+      verdict,
+      atIndex: action.atIndex,
+    });
+  }
+
+  const failed = findings.some((f) => f.verdict === 'REFUSED');
+  const inconclusive = findings.some((f) => f.verdict === 'INCONCLUSIVE');
+  let ok;
+  if (failed) ok = 'fail';
+  else if (inconclusive) ok = 'inconclusive';
+  else ok = 'pass';
+
+  return { ok, findings, actionCount: actions.length };
+}
+
+function writeAudit(cwd, payload) {
+  const path = join(cwd, AUDIT_REL);
+  try { mkdirSync(dirname(path), { recursive: true }); } catch { /* ignore */ }
+  try { appendFileSync(path, JSON.stringify(payload) + '\n'); }
+  catch (err) { logHookFailure({ hook: 'rule-verifier', err, phase: 'append-audit' }); }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  let input = {};
+  try { input = JSON.parse(readFileSync(0, 'utf8')); }
+  catch (err) { logHookFailure({ hook: 'rule-verifier', err, phase: 'parse-stdin' }); process.exit(0); }
+
+  const cwd = input?.cwd || process.cwd();
+  const transcriptPath = input?.transcript_path;
+  if (!transcriptPath || !existsSync(transcriptPath)) process.exit(0);
+
+  const entries = safeReadJsonLines(transcriptPath);
+  const result = verifyTranscript(entries);
+  writeAudit(cwd, { ts: new Date().toISOString(), hook: 'rule-verifier', ...result });
+
+  if (result.ok === 'fail' && process.env.CONSTRUCT_RULE_VERIFIER === 'block') process.exit(2);
+  process.exit(0);
+}

package/lib/hooks/session-optimize.mjs

@@ -237,7 +237,8 @@ function main() {
     console.log(`  • ${agent.name}: avgScore=${agent.avgScore}, invocations=${agent.invocations}`);
   });
   
-  // Run optimization for each agent (serial for now)
+  // Sequential optimization keeps prompt-tuning deterministic and avoids
+  // colliding writes to per-agent prompt files.
   let optimizedCount = 0;
   let failedCount = 0;
   

package/lib/init-unified.mjs

@@ -615,87 +615,76 @@ function discoverProjectDirs(targetPath) {
   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' },
-];
+// Extra inbox-style directories the user can opt into. These are NOT
+// source-code, doc, or test directories: they're places where unsorted
+// signals tend to land (downloads, scratch notes, exported research). The
+// built-in `.cx/inbox/` and `docs/intake/` are always watched and not
+// listed here.
+//
+// Historically this list included `src/`, `docs/`, `tests/`, etc., and
+// `init --yes` auto-enabled every one that existed in the project. That
+// turned every code change, doc edit, and test file into a synthetic
+// "intake signal" and polluted the queue with hundreds of false positives.
+// Watching project artifact directories is opt-in only; an empty list is
+// the correct default.
+const INTAKE_DIR_PRESETS = [];
 
 async function askIntakeCollection(targetPath, skipInteractive) {
+  // Non-interactive default: empty parentDirs. The built-in zones
+  // (.cx/inbox/ and docs/intake/ when present) handle every well-defined
+  // signal path. Users who want to watch additional directories opt in
+  // explicitly via `construct intake config set --add-dir=<path>`.
   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 };
+    return null;
   }
-  
-  // Interactive mode
+
+  // Interactive mode: no presets to surface — the user must name the
+  // directory they want watched. Skipped entirely when the preset list
+  // is empty (the current default after the auto-include regression).
+  if (INTAKE_DIR_PRESETS.length === 0) {
+    return null;
+  }
+
   const existingDirs = discoverProjectDirs(targetPath);
   const presetOptions = INTAKE_DIR_PRESETS.map(p => ({
     label: p.label,
     value: p.value,
-    checked: existingDirs.includes(p.value),
+    checked: false,
     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('Intake watches `.cx/inbox/` and `docs/intake/` by default.');
+  console.log('Add extra directories ONLY if signals (customer notes, exports,');
+  console.log('PDFs, etc.) regularly land there. Do not select code or finished');
+  console.log('artifact directories like src/, docs/, or tests/.');
   console.log('');
-  
+
+  void existingDirs;
   const selected = await multiSelect({
-    title: 'Directories to Watch',
-    instructions: 'Press Enter to confirm your selection',
+    title: 'Additional Inbox Directories',
+    instructions: 'Press Enter to confirm your selection (or pick none)',
     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('No extra directories selected. The inbox watcher will scan');
+    console.log('.cx/inbox/ and docs/intake/ only. Add more later with:');
+    console.log('  construct intake config set --add-dir=<path>');
     console.log('');
     return null;
   }
-  
+
   console.log('');
-  console.log(`Watching ${selected.length} directory(ies):`);
+  console.log(`Watching ${selected.length} extra directory(ies):`);
   for (const d of selected) console.log(`  • ${d}/`);
   console.log('');
-  
+
   return { parentDirs: selected, maxDepth: 4 };
 }
 
@@ -949,18 +938,19 @@ async function main() {
     console.log('');
   }
   
-  // Intake collection — ask which directories to watch for context
+  // Intake collection — always write intake-config.json with safe defaults
+  // so the user can inspect what's watched and edit the file directly. Empty
+  // parentDirs is the correct default: the inbox watcher always scans
+  // .cx/inbox/ and docs/intake/ (when present); extra dirs are opt-in.
   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}`);
-    }
+
+  const intakeConfig = (await askIntakeCollection(target, skipInteractive)) ?? { parentDirs: [], maxDepth: 4 };
+  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