@geraldmaron/construct 1.1.1 → 1.2.1

package/lib/init.mjs

@@ -69,6 +69,14 @@ function main() {
     content: buildContextMarkdown(),
     generator: "construct/init",
   });
+  writeStampedIfMissing({
+    targetRoot: target,
+    created,
+    skipped,
+    filePath: path.join(target, ".cx", "brand-voice.json"),
+    content: `${JSON.stringify({ version: 1, formality: 3, toneOverride: {}, audienceLexicon: { prefer: [], avoid: [] } }, null, 2)}\n`,
+    generator: "construct/init",
+  });
   // `.cx/` already exists from the context writes above and is gitignored in full
   // (ADR-0027), so a keep file there could never be tracked; `.cx/inbox/` is the local
   // intake drop zone the watcher polls. Create the directories; write no dead keep file.

package/lib/install/desktop-binary-download.mjs

@@ -0,0 +1,85 @@
+/**
+ * lib/install/desktop-binary-download.mjs — downloads the Construct chat desktop binary.
+ *
+ * Fetches the platform-matching construct-chat binary from the latest GitHub
+ * release and writes it to ~/.construct/bin/. Called by `construct install --scope=user`.
+ * Network failures are non-fatal: returns { status: 'skipped', reason } so the
+ * rest of setup can proceed without the desktop binary.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const GITHUB_REPO = 'geraldmaron/construct';
+
+function assetName() {
+  const plat = process.platform;
+  const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
+  if (plat === 'win32') return 'construct-chat-windows-x64.exe';
+  if (plat === 'darwin') return `construct-chat-darwin-${arch}`;
+  return `construct-chat-linux-${arch}`;
+}
+
+function destBinaryName() {
+  return process.platform === 'win32' ? 'construct-chat.exe' : 'construct-chat';
+}
+
+async function fetchRelease(env) {
+  const headers = { 'User-Agent': 'construct-installer/1.0' };
+  if (env.GITHUB_TOKEN) headers['Authorization'] = `Bearer ${env.GITHUB_TOKEN}`;
+  const res = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, { headers });
+  if (!res.ok) throw new Error(`GitHub API ${res.status}: ${await res.text().then((t) => t.slice(0, 120))}`);
+  return res.json();
+}
+
+async function downloadAsset(url, dest, env) {
+  const headers = {
+    'User-Agent': 'construct-installer/1.0',
+    'Accept': 'application/octet-stream',
+  };
+  if (env.GITHUB_TOKEN) headers['Authorization'] = `Bearer ${env.GITHUB_TOKEN}`;
+  const res = await fetch(url, { headers, redirect: 'follow' });
+  if (!res.ok) throw new Error(`Download ${res.status}: ${url}`);
+  const buf = await res.arrayBuffer();
+  fs.writeFileSync(dest, Buffer.from(buf));
+}
+
+// Returns { status: 'downloaded'|'skipped'|'failed' }; 'skipped' and 'failed' are both non-fatal.
+export async function downloadDesktopBinary({ homeDir, env = process.env } = {}) {
+  const binDir = path.join(homeDir, '.construct', 'bin');
+  const dest = path.join(binDir, destBinaryName());
+  const name = assetName();
+
+  let release;
+  try {
+    release = await fetchRelease(env);
+  } catch (err) {
+    return { status: 'skipped', reason: `GitHub API unreachable: ${err.message}` };
+  }
+
+  const asset = release.assets?.find((a) => a.name === name);
+  if (!asset) {
+    return {
+      status: 'skipped',
+      reason: `No desktop binary in ${release.tag_name} for this platform (looked for ${name})`,
+    };
+  }
+
+  fs.mkdirSync(binDir, { recursive: true });
+
+  try {
+    await downloadAsset(asset.browser_download_url, dest, env);
+  } catch (err) {
+    return { status: 'failed', reason: err.message };
+  }
+
+  if (process.platform !== 'win32') {
+    try {
+      fs.chmodSync(dest, 0o755);
+    } catch {
+      /* best effort */
+    }
+  }
+
+  return { status: 'downloaded', dest, version: release.tag_name };
+}

package/lib/install/legacy-global-cleanup.mjs

@@ -0,0 +1,189 @@
+/**
+ * Removes pre-project-scope Construct footprints from user-global tool config.
+ *
+ * Opt-in only: strips legacy ambient adapters/MCP/state that can slow unrelated
+ * Claude/Codex/OpenCode sessions, but never uninstalls a current global
+ * `construct` CLI package.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { removeTomlTables, tomlString } from '../codex-config.mjs';
+
+const CONSTRUCT_MCP_KEYS = ['memory', 'cass', 'construct-mcp'];
+
+function exists(p) {
+  try { fs.statSync(p); return true; } catch { return false; }
+}
+
+function rm(p, { dryRun, removed, label }) {
+  if (!exists(p)) return false;
+  removed.push(label || p);
+  if (!dryRun) fs.rmSync(p, { recursive: true, force: true });
+  return true;
+}
+
+function readJson(filePath) {
+  if (!exists(filePath)) return null;
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { return null; }
+}
+
+function writeJson(filePath, value, { dryRun, removed, label }) {
+  removed.push(label || filePath);
+  if (!dryRun) fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n', 'utf8');
+}
+
+function hasConstructText(value) {
+  return /construct|\.cx|\.construct/i.test(JSON.stringify(value ?? ''));
+}
+
+function stripClaudeSettings(homeDir, opts) {
+  const filePath = path.join(homeDir, '.claude', 'settings.json');
+  const settings = readJson(filePath);
+  if (!settings || typeof settings !== 'object') return;
+  let changed = false;
+
+  if (settings.hooks && hasConstructText(settings.hooks)) {
+    delete settings.hooks;
+    changed = true;
+  }
+
+  if (settings.mcpServers && typeof settings.mcpServers === 'object') {
+    for (const key of CONSTRUCT_MCP_KEYS) {
+      if (key in settings.mcpServers) {
+        delete settings.mcpServers[key];
+        changed = true;
+      }
+    }
+    if (Object.keys(settings.mcpServers).length === 0) delete settings.mcpServers;
+  }
+
+  if (changed) writeJson(filePath, settings, { ...opts, label: '~/.claude/settings.json Construct entries' });
+}
+
+function stripOpenCode(homeDir, opts) {
+  const filePath = path.join(homeDir, '.config', 'opencode', 'opencode.json');
+  const config = readJson(filePath);
+  if (!config || typeof config !== 'object') return;
+  let changed = false;
+
+  if (config.agent?.construct) {
+    delete config.agent.construct;
+    changed = true;
+    if (Object.keys(config.agent).length === 0) delete config.agent;
+  }
+
+  if (config.mcp && typeof config.mcp === 'object') {
+    for (const key of CONSTRUCT_MCP_KEYS) {
+      if (key in config.mcp) {
+        delete config.mcp[key];
+        changed = true;
+      }
+    }
+    if (Object.keys(config.mcp).length === 0) delete config.mcp;
+  }
+
+  if (Array.isArray(config.plugin)) {
+    const next = config.plugin.filter((entry) => !/construct/i.test(String(entry)));
+    if (next.length !== config.plugin.length) {
+      config.plugin = next;
+      changed = true;
+    }
+    if (config.plugin.length === 0) delete config.plugin;
+  }
+
+  if (changed) writeJson(filePath, config, { ...opts, label: '~/.config/opencode/opencode.json Construct entries' });
+}
+
+function stripVsCode(homeDir, opts) {
+  const userDir = path.join(homeDir, 'Library', 'Application Support', 'Code', 'User');
+  const mcpPath = path.join(userDir, 'mcp.json');
+  const mcp = readJson(mcpPath);
+  if (mcp?.servers && typeof mcp.servers === 'object') {
+    let changed = false;
+    for (const key of CONSTRUCT_MCP_KEYS) {
+      if (key in mcp.servers) {
+        delete mcp.servers[key];
+        changed = true;
+      }
+    }
+    if (changed) writeJson(mcpPath, mcp, { ...opts, label: 'VS Code mcp.json Construct servers' });
+  }
+
+  const settingsPath = path.join(userDir, 'settings.json');
+  const settings = readJson(settingsPath);
+  const copilotServers = settings?.['github.copilot.mcpServers'];
+  if (copilotServers && typeof copilotServers === 'object') {
+    let changed = false;
+    for (const key of CONSTRUCT_MCP_KEYS) {
+      if (key in copilotServers) {
+        delete copilotServers[key];
+        changed = true;
+      }
+    }
+    if (Object.keys(copilotServers).length === 0) delete settings['github.copilot.mcpServers'];
+    if (changed) writeJson(settingsPath, settings, { ...opts, label: 'VS Code settings.json Construct Copilot MCP servers' });
+  }
+}
+
+function stripCodex(homeDir, opts) {
+  const filePath = path.join(homeDir, '.codex', 'config.toml');
+  if (!exists(filePath)) return;
+  const existing = fs.readFileSync(filePath, 'utf8');
+  let next = existing
+    .replace(/\n?# BEGIN CONSTRUCT MCP SERVERS[\s\S]*?(?=\n# END CONSTRUCT MCP SERVERS\n)/g, '\n')
+    .replace(/\n# END CONSTRUCT MCP SERVERS\n?/g, '\n')
+    .replace(/\n?# BEGIN CONSTRUCT AGENTS[\s\S]*?(?=\n# END CONSTRUCT AGENTS\n)/g, '\n')
+    .replace(/\n# END CONSTRUCT AGENTS\n?/g, '\n');
+  const tables = [
+    ...CONSTRUCT_MCP_KEYS.flatMap((key) => [`mcp_servers.${key}`, `mcp_servers.${tomlString(key)}`]),
+    'agents.construct',
+    `agents.${tomlString('construct')}`,
+  ];
+  next = removeTomlTables(next, tables);
+  if (next.trimEnd() === existing.trimEnd()) return;
+  opts.removed.push('~/.codex/config.toml Construct tables');
+  if (!opts.dryRun) fs.writeFileSync(filePath, `${next.trimEnd()}\n`, 'utf8');
+}
+
+function rmConstructNamedChildren(dir, opts, labelPrefix) {
+  if (!exists(dir)) return;
+  for (const entry of fs.readdirSync(dir)) {
+    if (/construct/i.test(entry)) rm(path.join(dir, entry), { ...opts, label: `${labelPrefix}/${entry}` });
+  }
+}
+
+export function cleanupLegacyGlobalConstruct({ homeDir, dryRun = false } = {}) {
+  const removed = [];
+  const opts = { dryRun, removed };
+
+  rm(path.join(homeDir, '.construct'), { ...opts, label: '~/.construct' });
+  rm(path.join(homeDir, '.local', 'share', 'construct'), { ...opts, label: '~/.local/share/construct' });
+  rm(path.join(homeDir, 'Library', 'LaunchAgents', 'dev.construct.pressure-release.plist'), {
+    ...opts,
+    label: 'Construct pressure-release LaunchAgent',
+  });
+
+  rm(path.join(homeDir, '.github', 'prompts', 'construct.prompt.md'), { ...opts, label: '~/.github/prompts/construct.prompt.md' });
+  rm(path.join(homeDir, '.github', 'prompts', '.construct-manifest'), { ...opts, label: '~/.github/prompts/.construct-manifest' });
+  rm(path.join(homeDir, '.config', 'opencode', 'plugin', 'construct-fallback.js'), {
+    ...opts,
+    label: '~/.config/opencode/plugin/construct-fallback.js',
+  });
+
+  stripClaudeSettings(homeDir, opts);
+  stripOpenCode(homeDir, opts);
+  stripVsCode(homeDir, opts);
+  stripCodex(homeDir, opts);
+
+  rmConstructNamedChildren(path.join(homeDir, '.claude', 'projects'), opts, '~/.claude/projects');
+  rmConstructNamedChildren(path.join(homeDir, '.claude', 'plans'), opts, '~/.claude/plans');
+  rmConstructNamedChildren(path.join(homeDir, '.cursor', 'projects'), opts, '~/.cursor/projects');
+  rmConstructNamedChildren(path.join(homeDir, '.cursor', 'plans'), opts, '~/.cursor/plans');
+  rm(path.join(homeDir, '.gemini', 'history', 'construct'), { ...opts, label: '~/.gemini/history/construct' });
+  rm(path.join(homeDir, '.gemini', 'tmp', 'construct'), { ...opts, label: '~/.gemini/tmp/construct' });
+  rmConstructNamedChildren(path.join(homeDir, 'Library', 'Caches', 'claude-cli-nodejs'), opts, 'Claude cache');
+
+  return { removed, dryRun };
+}

package/lib/intake/constants.mjs

@@ -0,0 +1,29 @@
+/**
+ * lib/intake/constants.mjs — shared intake watcher depth constants and guidance.
+ */
+
+export const INTAKE_DEFAULT_MAX_DEPTH = 4;
+export const INTAKE_HARD_MAX_DEPTH = 16;
+
+export const INTAKE_DEPTH_GUIDANCE = [
+  { value: 0, label: 'Only this directory', detail: 'Scans files directly in the parent dir, ignores all subdirs.' },
+  { value: 1, label: 'One level deep', detail: 'Parent dir plus its immediate subdirs (e.g. parent/intake/file.md).' },
+  { value: 2, label: 'Two levels deep', detail: 'Parent and two subdirs. A reasonable default for organized intake roots.' },
+  { value: 4, label: 'Four levels (default)', detail: 'Catches most nested layouts without scanning huge trees.' },
+  { value: 8, label: 'Deep scan', detail: 'Useful for archives. Slower; skip if the parent contains build output.' },
+  { value: INTAKE_HARD_MAX_DEPTH, label: 'Unlimited (capped)', detail: `Walks up to ${INTAKE_HARD_MAX_DEPTH} levels — effectively unlimited. May be slow.` },
+];
+
+export function describeIntakeDepth(depth = INTAKE_DEFAULT_MAX_DEPTH) {
+  const n = Number(depth);
+  const value = !Number.isFinite(n) || n < 0
+    ? INTAKE_DEFAULT_MAX_DEPTH
+    : Math.min(Math.floor(n), INTAKE_HARD_MAX_DEPTH);
+  const exact = INTAKE_DEPTH_GUIDANCE.find((g) => g.value === value);
+  if (exact) return exact;
+  return {
+    value,
+    label: `Custom depth (${value})`,
+    detail: `Walks up to ${value} levels of subdirectories below each parent.`,
+  };
+}

package/lib/intake/daemon.mjs

@@ -15,6 +15,7 @@ import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 
 import { createDaemon, classifyPacket } from '../daemons/contract.mjs';
+import { memoryCapMbFor } from '../resources/process-budget.mjs';
 
 const KILLSWITCH_ENV = 'CONSTRUCT_INTAKE_DAEMON';
 
@@ -107,6 +108,7 @@ export function buildIntakeDaemon({ cwd = process.cwd(), intervalMs = 60_000, cl
     heartbeatPath: heartbeatPath(),
     maxRuntimeMs: 24 * 60 * 60 * 1000,
     maxIdleTicks: 6,
+    memoryCapMb: memoryCapMbFor('intake', cwd),
     async tick() {
       const files = listInboxFiles(cwd);
       if (files.length === 0) return { didWork: false };

package/lib/intake/git-queue.mjs

@@ -1,9 +1,8 @@
 /**
  * lib/intake/git-queue.mjs — Git-backed adapter for the IntakeQueue interface.
  *
- * This implementation replaces the PostgresIntakeQueue for team/enterprise
- * modes. It uses the filesystem and Git for state synchronization and
- * conflict resolution, removing the dependency on a central database server.
+ * Backs team/enterprise modes with the filesystem and Git for state
+ * synchronization and conflict resolution, with no central database server.
  *
  * Structure:
  * .cx/team-inbox/
@@ -111,7 +110,8 @@ export class GitIntakeQueue {
   async claim({ claimedBy }) {
     if (!claimedBy) throw new Error('claim: claimedBy is required');
     
-    // 1. Pull latest to minimize conflicts
+    // Pull latest to minimize conflicts
+
     try { execSync('git pull --rebase', { stdio: 'ignore' }); } catch (e) {}
 
     const pendingDir = path.join(this.inboxRoot, 'pending');
@@ -136,16 +136,17 @@ export class GitIntakeQueue {
       data.claimedAt = new Date().toISOString();
       fs.writeFileSync(claimedPath, JSON.stringify(data, null, 2));
 
-      // 2. Commit and Push
+      // Commit and push the claim so peers see it
+
       execSync(`git add .cx/team-inbox/pending/${fileName} .cx/team-inbox/claimed/${claimedBy}/${fileName}`, { stdio: 'ignore' });
       execSync(`git commit -m "Claim task ${data.id} by ${claimedBy}"`, { stdio: 'ignore' });
       execSync('git push', { stdio: 'ignore' });
 
       return data;
     } catch (err) {
-      // If push fails, someone else probably claimed it first or Git is out of sync.
-      // We should ideally rollback the local move, but for this first pass
-      // we'll let the next 'git pull --rebase' fix the state.
+      // A push failure means another worker claimed it first or Git is out of
+      // sync; the local move is left for the next 'git pull --rebase' to reconcile.
+
       console.error(`Failed to claim ${fileName}: ${err.message}`);
       return null;
     }

package/lib/intake/intake-config.mjs

@@ -1,136 +1,83 @@
 /**
- * lib/intake/intake-config.mjs — user-facing intake watcher config.
+ * lib/intake/intake-config.mjs — intake watcher config facade.
  *
- * Lets the user define which directories the inbox watcher scans and how
- * deep it descends through subdirectories. Persists to
- * `<rootDir>/.cx/intake-config.json` and merges with env-driven defaults so
- * CLI, dashboard, and process env all converge on the same answer.
- *
- * Schema:
- *   {
- *     parentDirs: string[]   // absolute or rootDir-relative
- *     maxDepth: number       // 0 = only the parent dir, no subdirs
- *     includeProjectInbox: boolean  // always include <rootDir>/.cx/inbox
- *     includeDocsIntake: boolean    // include <rootDir>/docs/intake when present
- *   }
- *
- * maxDepth guidance (surfaced verbatim in the dashboard):
- *   0 — only files directly inside the parent dir
- *   1 — parent dir + its immediate subdirs
- *   2 — two levels of subdirs (a common default for project intake roots)
- *   3+ — deep scans; use with care on large trees
+ * Reads and writes intake policy via construct.config.json intakePolicy.
+ * Legacy .cx/intake-config.json remains a warned compatibility fallback.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { isAbsolute, join, resolve } from 'node:path';
 import { shouldCreateCx } from '../project-detection.mjs';
-import { ensureCxDir } from '../project-init-shared.mjs';
-
-export const INTAKE_CONFIG_FILE = '.cx/intake-config.json';
-export const INTAKE_DEFAULT_MAX_DEPTH = 4;
-export const INTAKE_HARD_MAX_DEPTH = 16;
-
-export const INTAKE_DEPTH_GUIDANCE = [
-  { value: 0, label: 'Only this directory', detail: 'Scans files directly in the parent dir, ignores all subdirs.' },
-  { value: 1, label: 'One level deep', detail: 'Parent dir plus its immediate subdirs (e.g. parent/intake/file.md).' },
-  { value: 2, label: 'Two levels deep', detail: 'Parent and two subdirs. A reasonable default for organized intake roots.' },
-  { value: 4, label: 'Four levels (default)', detail: 'Catches most nested layouts without scanning huge trees.' },
-  { value: 8, label: 'Deep scan', detail: 'Useful for archives. Slower; skip if the parent contains build output.' },
-  { value: INTAKE_HARD_MAX_DEPTH, label: 'Unlimited (capped)', detail: `Walks up to ${INTAKE_HARD_MAX_DEPTH} levels — effectively unlimited. May be slow.` },
-];
+import {
+  loadIntakePolicy,
+  resolvedIntakeConfig,
+  saveIntakePolicy,
+  migrateLegacyIntakeConfig,
+  DEFAULT_INTAKE_POLICY,
+} from '../config/intake-policy.mjs';
+import {
+  INTAKE_DEFAULT_MAX_DEPTH,
+  INTAKE_HARD_MAX_DEPTH,
+  INTAKE_DEPTH_GUIDANCE,
+  describeIntakeDepth,
+} from './constants.mjs';
+import { INTAKE_CONFIG_FILE } from './legacy-paths.mjs';
+import { join } from 'node:path';
+
+export {
+  INTAKE_DEFAULT_MAX_DEPTH,
+  INTAKE_HARD_MAX_DEPTH,
+  INTAKE_DEPTH_GUIDANCE,
+  describeIntakeDepth,
+  INTAKE_CONFIG_FILE,
+  migrateLegacyIntakeConfig,
+  DEFAULT_INTAKE_POLICY,
+};
 
 export const DEFAULT_INTAKE_CONFIG = Object.freeze({
   parentDirs: [],
   maxDepth: INTAKE_DEFAULT_MAX_DEPTH,
   includeProjectInbox: true,
   includeDocsIntake: true,
-  includeArchetypeInbox: false,
+  includeArchetypeInbox: true,
+  includeRootInbox: true,
 });
 
 export function intakeConfigPath(rootDir) {
   return join(rootDir, INTAKE_CONFIG_FILE);
 }
 
-function clampDepth(value) {
-  const n = Number(value);
-  if (!Number.isFinite(n) || n < 0) return INTAKE_DEFAULT_MAX_DEPTH;
-  return Math.min(Math.floor(n), INTAKE_HARD_MAX_DEPTH);
-}
-
-function normalizeDir(dir, rootDir) {
-  if (typeof dir !== 'string') return null;
-  const trimmed = dir.trim();
-  if (!trimmed) return null;
-  return isAbsolute(trimmed) ? trimmed : resolve(rootDir, trimmed);
-}
-
-function parseEnvDirs(env) {
-  const raw = String(env?.CX_INBOX_DIRS ?? '').trim();
-  if (!raw) return [];
-  return raw.split(':').map((p) => p.trim()).filter(Boolean);
-}
-
 export function loadIntakeConfig(rootDir, env = process.env) {
-  const file = intakeConfigPath(rootDir);
-  let stored = {};
-  if (existsSync(file)) {
-    try { stored = JSON.parse(readFileSync(file, 'utf8')); } catch { stored = {}; }
+  const cfg = resolvedIntakeConfig(rootDir, env);
+  if (cfg.legacyWarning && process.stderr.isTTY) {
+    process.stderr.write(`[intake-config] ${cfg.legacyWarning}\n`);
   }
-
-  const parentDirs = []
-    .concat(Array.isArray(stored.parentDirs) ? stored.parentDirs : [])
-    .concat(parseEnvDirs(env))
-    .map((dir) => normalizeDir(dir, rootDir))
-    .filter(Boolean);
-
-  const seen = new Set();
-  const uniqueDirs = [];
-  for (const dir of parentDirs) {
-    if (seen.has(dir)) continue;
-    seen.add(dir);
-    uniqueDirs.push(dir);
-  }
-
-  const envDepth = env?.CX_INTAKE_MAX_DEPTH;
-  const maxDepth = clampDepth(envDepth ?? stored.maxDepth ?? DEFAULT_INTAKE_CONFIG.maxDepth);
-
-  return {
-    parentDirs: uniqueDirs,
-    maxDepth,
-    includeProjectInbox: stored.includeProjectInbox !== false,
-    includeDocsIntake: stored.includeDocsIntake !== false,
-    includeArchetypeInbox: stored.includeArchetypeInbox === true,
-  };
+  return cfg;
 }
 
 export function saveIntakeConfig(rootDir, patch = {}) {
   if (!shouldCreateCx(rootDir)) {
     throw new Error('Refusing to write intake config: directory is not an initialized construct project. Run `construct init` first.');
   }
-  const current = loadIntakeConfig(rootDir, {});
-  const next = {
-    parentDirs: Array.isArray(patch.parentDirs)
-      ? patch.parentDirs.map((dir) => normalizeDir(dir, rootDir)).filter(Boolean)
-      : current.parentDirs,
-    maxDepth: clampDepth(patch.maxDepth ?? current.maxDepth),
-    includeProjectInbox: patch.includeProjectInbox !== undefined ? Boolean(patch.includeProjectInbox) : current.includeProjectInbox,
-    includeDocsIntake: patch.includeDocsIntake !== undefined ? Boolean(patch.includeDocsIntake) : current.includeDocsIntake,
-    includeArchetypeInbox: patch.includeArchetypeInbox !== undefined ? Boolean(patch.includeArchetypeInbox) : current.includeArchetypeInbox,
-  };
 
-  const file = intakeConfigPath(rootDir);
-  ensureCxDir(rootDir);
-  writeFileSync(file, JSON.stringify(next, null, 2) + '\n');
-  return next;
+  const policyPatch = {};
+  if (patch.maxDepth !== undefined) policyPatch.maxDepth = patch.maxDepth;
+  if (patch.includeProjectInbox !== undefined) policyPatch.projectInbox = patch.includeProjectInbox;
+  if (patch.includeDocsIntake !== undefined) policyPatch.docsIntake = patch.includeDocsIntake;
+  if (patch.includeArchetypeInbox !== undefined || patch.includeRootInbox !== undefined) {
+    policyPatch.rootInbox = patch.includeRootInbox ?? patch.includeArchetypeInbox;
+  }
+  if (Array.isArray(patch.parentDirs)) policyPatch.additionalDirs = patch.parentDirs;
+
+  const { policy } = saveIntakePolicy(rootDir, policyPatch);
+  return policyToLegacyShape(policy);
 }
 
-export function describeIntakeDepth(depth = INTAKE_DEFAULT_MAX_DEPTH) {
-  const value = clampDepth(depth);
-  const exact = INTAKE_DEPTH_GUIDANCE.find((g) => g.value === value);
-  if (exact) return exact;
+function policyToLegacyShape(policy) {
   return {
-    value,
-    label: `Custom depth (${value})`,
-    detail: `Walks up to ${value} levels of subdirectories below each parent.`,
+    parentDirs: policy.additionalDirs,
+    maxDepth: policy.maxDepth,
+    includeProjectInbox: policy.zones.projectInbox,
+    includeDocsIntake: policy.zones.docsIntake,
+    includeArchetypeInbox: policy.zones.rootInbox,
+    includeRootInbox: policy.zones.rootInbox,
   };
 }

package/lib/intake/legacy-paths.mjs

@@ -0,0 +1,5 @@
+/**
+ * lib/intake/legacy-paths.mjs — legacy intake config file path constant.
+ */
+
+export const INTAKE_CONFIG_FILE = '.cx/intake-config.json';

package/lib/intake/queue.mjs

@@ -68,7 +68,8 @@ export function createIntakeQueue(rootDir, env = process.env, opts = {}) {
   const backend = opts.backend || resolveBackend(env);
   if (backend === 'filesystem') return new FilesystemIntakeQueue(rootDir);
   if (backend === 'git' || backend === 'postgres') {
-    // We treat 'postgres' as an alias for 'git' now to avoid breaking existing configs
+    // 'postgres' aliases to 'git' so existing configs keep resolving
+
     const project = opts.project ?? resolveProject(rootDir, env);
     return new GitIntakeQueue({ project, rootDir });
   }