@geraldmaron/construct 1.0.6 → 1.0.8

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/hooks/stop-notify.mjs

@@ -161,7 +161,11 @@ try {
   }
 } catch { /* non-critical */ }
 
-let costNote = '';
+// Pricing readout is intentionally suppressed in user-facing notifications.
+// The session-cost ledger is still written (lines below) so OTel + dashboard
+// consumers can pick the data up when the observability surfaces are wired.
+// Do not reintroduce a costNote variable here without a deliberate decision
+// about whether to surface pricing to the user.
 let totalCostUsd = 0;
 let turnsLogged = 0;
 try {
@@ -232,17 +236,14 @@ try {
 
   saveTranscriptCheckpoints(checkpointPath, checkpoints);
 
-  if (totalCostUsd > 0) {
-    const label = turnsLogged > 1 ? `${turnsLogged} turns` : 'this response';
-    costNote = `~$${totalCostUsd.toFixed(2)} ${label}`;
-  }
+  // totalCostUsd and turnsLogged stay as ledger-write accumulators only.
+  // Downstream telemetry consumers read the session-cost.jsonl ledger.
 } catch { /* non-critical */ }
 
 const parts = [];
 if (fileCount > 0) parts.push(`${fileCount} file${fileCount !== 1 ? 's' : ''} updated`);
 if (tsResult === 'pass') parts.push('TS OK');
 else if (tsResult !== 'unchecked') parts.push(`TS: ${tsResult}`);
-if (costNote) parts.push(costNote);
 
 const hasWarnings = warnings.length > 0;
 const title = hasWarnings ? 'Construct — Review needed' : 'Construct';

package/lib/host-capabilities.mjs

@@ -215,6 +215,10 @@ export function detectHostCapabilities() {
   ];
 }
 
+export function formatHostCapabilitiesJson(hosts = detectHostCapabilities()) {
+  return JSON.stringify(hosts, null, 2) + '\n';
+}
+
 export function printHostCapabilities(hosts = detectHostCapabilities()) {
   console.log("Construct orchestration host capabilities:");
   for (const host of hosts) {
@@ -229,5 +233,10 @@ export function printHostCapabilities(hosts = detectHostCapabilities()) {
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) {
-  printHostCapabilities();
+  const args = new Set(process.argv.slice(2));
+  if (args.has('--json')) {
+    process.stdout.write(formatHostCapabilitiesJson());
+  } else {
+    printHostCapabilities();
+  }
 }

package/lib/hygiene/scan.mjs

@@ -0,0 +1,141 @@
+/**
+ * lib/hygiene/scan.mjs — Lightweight doc hygiene candidate scanner.
+ *
+ * Selects up to N (default 25) documents for hygiene review each run using:
+ * 1. lifecycle/approved tag + last_verified_at older than 30 days
+ * 2. lifecycle/draft tag + last_verified_at older than 7 days
+ * 3. Any document without a last_verified_at field
+ *
+ * Sorted oldest-first. Results are beads-item candidates — actual creation
+ * is handled by the scheduler job handler.
+ *
+ * Wired into the `doc-hygiene-scan` scheduler job (lib/scheduler/index.mjs).
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const APPROVED_STALE_DAYS = 30;
+const DRAFT_STALE_DAYS = 7;
+const DEFAULT_BATCH = 25;
+
+/**
+ * Read YAML frontmatter from a markdown file. Returns {} on failure.
+ */
+function readFrontmatter(filePath) {
+  let text = '';
+  try { text = fs.readFileSync(filePath, 'utf8'); } catch { return {}; }
+  const m = text.match(/^---\n([\s\S]*?)\n---/);
+  if (!m) return {};
+  const fm = {};
+  for (const line of m[1].split('\n')) {
+    const kv = line.match(/^(\w[\w_-]*):\s*(.+)$/);
+    if (kv) fm[kv[1].replace(/-/g, '_')] = kv[2].trim().replace(/^["']|["']$/g, '');
+  }
+  return fm;
+}
+
+/**
+ * Walk a directory and return all .md / .mdx files.
+ */
+function walkMarkdown(dir, results = []) {
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return results; }
+  for (const e of entries) {
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) walkMarkdown(p, results);
+    else if (e.name.endsWith('.md') || e.name.endsWith('.mdx')) results.push(p);
+  }
+  return results;
+}
+
+/**
+ * Return the N oldest hygiene candidates from the given scopes.
+ *
+ * @param {object} opts
+ * @param {string} opts.cwd       — project root
+ * @param {string[]} [opts.scopes] — directories to scan relative to cwd
+ * @param {number} [opts.limit]   — max candidates (default 25)
+ * @returns {Array<{path, rel, verdict, lastVerifiedAt, ageDays, tags}>}
+ */
+export function findHygieneCandidates({ cwd = process.cwd(), scopes = ['docs/prd', 'docs/adr', 'docs/rfc', '.cx/knowledge'], limit = DEFAULT_BATCH } = {}) {
+  const now = Date.now();
+  const candidates = [];
+
+  for (const scope of scopes) {
+    const dir = path.join(cwd, scope);
+    if (!fs.existsSync(dir)) continue;
+    for (const filePath of walkMarkdown(dir)) {
+      const fm = readFrontmatter(filePath);
+      // Handle both inline YAML arrays `[a, b]` and comma-separated strings.
+    const rawTags = fm.tags ? String(fm.tags).replace(/^\s*\[|\]\s*$/g, '') : '';
+    const tags = rawTags ? rawTags.split(',').map((t) => t.trim().replace(/^["']|["']$/g, '')) : [];
+      const lva = fm.last_verified_at || null;
+      const ageDays = lva ? Math.floor((now - new Date(lva).getTime()) / 86400000) : null;
+
+      const lifecycle = tags.find((t) => t.startsWith('lifecycle/')) || null;
+
+      let include = false;
+      let reason = '';
+
+      if (!lva) {
+        include = true;
+        reason = 'no last_verified_at';
+      } else if (lifecycle === 'lifecycle/approved' && ageDays > APPROVED_STALE_DAYS) {
+        include = true;
+        reason = `approved and stale (${ageDays}d > ${APPROVED_STALE_DAYS}d)`;
+      } else if (lifecycle === 'lifecycle/draft' && ageDays > DRAFT_STALE_DAYS) {
+        include = true;
+        reason = `draft and stale (${ageDays}d > ${DRAFT_STALE_DAYS}d)`;
+      }
+
+      if (include) {
+        candidates.push({
+          path: filePath,
+          rel: path.relative(cwd, filePath),
+          reason,
+          lastVerifiedAt: lva,
+          ageDays,
+          tags,
+        });
+      }
+    }
+  }
+
+  // Sort: no last_verified_at first (oldest-first by path), then by age descending.
+  candidates.sort((a, b) => {
+    if (!a.lastVerifiedAt && !b.lastVerifiedAt) return a.rel.localeCompare(b.rel);
+    if (!a.lastVerifiedAt) return -1;
+    if (!b.lastVerifiedAt) return 1;
+    return (b.ageDays || 0) - (a.ageDays || 0);
+  });
+
+  return candidates.slice(0, limit);
+}
+
+/**
+ * Stamp last_verified_at into a document's frontmatter.
+ * If no frontmatter exists, prepends one.
+ */
+export function stampVerified(filePath, { date = new Date().toISOString().slice(0, 10) } = {}) {
+  let text = '';
+  try { text = fs.readFileSync(filePath, 'utf8'); } catch {
+    throw new Error(`stampVerified: cannot read ${filePath}`);
+  }
+
+  const fmMatch = text.match(/^(---\n)([\s\S]*?)(\n---)/);
+  if (fmMatch) {
+    const fmBody = fmMatch[2];
+    if (fmBody.includes('last_verified_at:')) {
+      // Update existing field.
+      const updated = fmBody.replace(/^last_verified_at:.+$/m, `last_verified_at: ${date}`);
+      fs.writeFileSync(filePath, `${fmMatch[1]}${updated}${fmMatch[3]}${text.slice(fmMatch[0].length)}`);
+    } else {
+      // Append field inside frontmatter.
+      fs.writeFileSync(filePath, `${fmMatch[1]}${fmBody}\nlast_verified_at: ${date}${fmMatch[3]}${text.slice(fmMatch[0].length)}`);
+    }
+  } else {
+    // No frontmatter — prepend one.
+    fs.writeFileSync(filePath, `---\nlast_verified_at: ${date}\n---\n${text}`);
+  }
+}

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 };
 }
 
@@ -902,6 +891,24 @@ async function main() {
     if (!claudePre && fs.existsSync(path.join(target, '.claude', 'settings.json'))) {
       created.push('.claude/ (agents + settings)');
     }
+
+    // Also sync home-level adapters for all 6 host surfaces (Copilot, OpenCode,
+    // Codex, VS Code, Cursor, plus Claude home) so the user's environment is
+    // fully wired after init. Project-local Claude adapters were written above.
+    const syncScript = path.join(ROOT_DIR, 'scripts', 'sync-specialists.mjs');
+    if (fs.existsSync(syncScript)) {
+      const { spawnSync } = await import('node:child_process');
+      const homeResult = spawnSync(process.execPath, [syncScript], {
+        cwd: target,
+        stdio: 'pipe',
+        env: { ...process.env, CONSTRUCT_PROJECT_ROOT: target },
+        timeout: 120000,
+      });
+      if (homeResult.status !== 0) {
+        const errMsg = homeResult.stderr.toString().substring(0, 200);
+        console.warn(`⚠️  Home adapter sync had issues (exit ${homeResult.status}): ${errMsg}`);
+      }
+    }
   } catch (err) {
     console.warn(`⚠️  Adapter staging failed: ${err.message}`);
   }
@@ -949,18 +956,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

package/lib/install/stage-project.mjs

@@ -3,11 +3,11 @@
  *
  * Same work as `bin/construct-postinstall.mjs` but callable from both the
  * npm postinstall hook and `construct init`. Stages `.construct/{run.mjs,
- * bootstrap.sh, bootstrap.ps1, version}` and runs `sync-agents.mjs --project`
+ * bootstrap.sh, bootstrap.ps1, version}` and runs `sync-specialists.mjs --project`
  * to materialise `.claude/agents/` and `.claude/settings.json` from the
  * bundled registry. Idempotent — re-runs overwrite the launcher files but
  * leave existing `.construct/version` and project state untouched beyond
- * what `sync-agents.mjs --project` writes itself.
+ * what `sync-specialists.mjs --project` writes itself.
  */
 
 import { spawnSync } from 'node:child_process';
@@ -20,13 +20,13 @@ export function stageProjectAdapters({ projectRoot, packageRoot, pkgVersion, log
   const emit = typeof log === 'function' ? log : () => {};
 
   const templateDir = path.join(packageRoot, 'templates', 'distribution');
-  const syncScript = path.join(packageRoot, 'scripts', 'sync-agents.mjs');
+  const syncScript = path.join(packageRoot, 'scripts', 'sync-specialists.mjs');
 
   ensureProjectLauncher({ projectRoot, templateDir, pkgVersion });
   emit(`staged .construct/ launcher in ${projectRoot}`);
 
   if (!existsSync(syncScript)) {
-    emit(`sync-agents.mjs not found at ${syncScript}; skipping adapter sync`);
+    emit(`sync-specialists.mjs not found at ${syncScript}; skipping adapter sync`);
     return { staged: true, synced: false };
   }