@geraldmaron/construct 1.2.0 → 1.2.1

package/lib/embed/demand-fetch.mjs

@@ -19,6 +19,11 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { loadConstructEnv } from '../env-config.mjs';
 import { addObservation } from '../observation-store.mjs';
+import { loadProjectConfig } from '../config/project-config.mjs';
+import {
+  resolveEffectiveSourceTargetsFromConfig,
+  resolveKnownSourcesFromTargets,
+} from '../config/source-targets.mjs';
 
 // ─── Self-query detection ────────────────────────────────────────────────────
 
@@ -62,7 +67,13 @@ function isSelfQuery(query) {
  * @param {object} env
  * @returns {{ id: string, provider: string, ref: string, display: string }[]}
  */
-export function resolveKnownSources(env = process.env) {
+export function resolveKnownSources(env = process.env, cwd = process.cwd()) {
+  const { config } = loadProjectConfig(cwd, env);
+  const targets = resolveEffectiveSourceTargetsFromConfig(config, env);
+  if (targets.length > 0) {
+    return resolveKnownSourcesFromTargets(targets);
+  }
+
   const sources = [];
 
   // GitHub repos
@@ -112,8 +123,8 @@ export function resolveKnownSources(env = process.env) {
  * @param {object} env
  * @returns {{ provider: string, ref: string, display: string } | null}
  */
-export function matchSourceFromQuery(query, env = process.env) {
-  const sources = resolveKnownSources(env);
+export function matchSourceFromQuery(query, env = process.env, cwd = process.cwd()) {
+  const sources = resolveKnownSources(env, cwd);
   const q = query.toLowerCase();
 
   // Exact or substring match — longest id wins
@@ -138,13 +149,12 @@ export function matchSourceFromQuery(query, env = process.env) {
  * @param {object} [opts.env]        - Env override
  * @returns {Promise<DemandFetchResult>}
  */
-export async function demandFetch({ query, rootDir, env } = {}) {
+export async function demandFetch({ query, rootDir, env, cwd } = {}) {
   const resolvedEnv = env ?? loadConstructEnv();
   const root = rootDir ?? (resolvedEnv.CX_DATA_DIR?.trim() || homedir());
+  const projectRoot = cwd ?? root;
 
-  // Provider match takes priority: if the query names a configured repo/project,
-  // always fetch from that provider — even if isSelfQuery() also fires.
-  const match = matchSourceFromQuery(query, resolvedEnv);
+  const match = matchSourceFromQuery(query, resolvedEnv, projectRoot);
 
   // Self-referential queries about Construct itself → route to knowledge_search,
   // but only when no external provider source was matched.
@@ -168,8 +178,7 @@ export async function demandFetch({ query, rootDir, env } = {}) {
   }
 
   if (!match) {
-    // No specific source match and not a self-query — fetch from all configured providers
-    return demandFetchAll({ query, rootDir: root, env: resolvedEnv });
+    return demandFetchAll({ query, rootDir: root, env: resolvedEnv, cwd: projectRoot });
   }
 
   // Dynamically import provider registry to avoid loading all providers at module init
@@ -188,7 +197,7 @@ export async function demandFetch({ query, rootDir, env } = {}) {
   }
 
   // Build read calls for the matched source and execute them
-  const readCalls = buildReadCalls(match, resolvedEnv);
+  const readCalls = buildReadCalls(match, resolvedEnv, projectRoot);
   if (!readCalls.length) {
     return {
       ok: false,
@@ -281,23 +290,32 @@ export async function demandFetch({ query, rootDir, env } = {}) {
  * @param {object} [opts.env]      - Resolved env
  * @returns {Promise<DemandFetchResult>}
  */
-async function demandFetchAll({ query, rootDir, env } = {}) {
+async function demandFetchAll({ query, rootDir, env, cwd } = {}) {
   const { ProviderRegistry } = await import('./providers/registry.mjs');
   const registry = await ProviderRegistry.fromEnv(env);
-  const providerNames = registry.names();
+  const projectRoot = cwd ?? rootDir ?? process.cwd();
+  const { config } = loadProjectConfig(projectRoot, env);
+  const targets = resolveEffectiveSourceTargetsFromConfig(config, env);
+  const scoped = targets.length > 0;
+
+  const providerNames = scoped
+    ? [...new Set(targets.map((t) => t.provider))].filter((name) => registry.get(name))
+    : registry.names();
 
   if (!providerNames.length) {
     return {
       ok: false,
       reason: 'no_providers',
-      message: 'No provider credentials configured in config.env',
+      message: scoped
+        ? 'No provider credentials configured for the declared source targets'
+        : 'No provider credentials configured in config.env',
       items: [],
     };
   }
 
   const allItems = [];
   const errors = [];
-  const sources = resolveKnownSources(env);
+  const sources = resolveKnownSources(env, projectRoot);
 
   // Group known sources by provider so we can batch-fetch per-provider
   const byProvider = new Map();
@@ -306,11 +324,16 @@ async function demandFetchAll({ query, rootDir, env } = {}) {
     byProvider.get(src.provider).push(src);
   }
 
-  // Also include providers that have no explicit sources (Jira, Linear default fetch)
   for (const name of providerNames) {
     if (!byProvider.has(name)) byProvider.set(name, []);
   }
 
+  if (scoped) {
+    for (const key of [...byProvider.keys()]) {
+      if (!providerNames.includes(key)) byProvider.delete(key);
+    }
+  }
+
   for (const [providerName, provSources] of byProvider) {
     const provider = registry.get(providerName);
     if (!provider) continue;
@@ -318,10 +341,12 @@ async function demandFetchAll({ query, rootDir, env } = {}) {
     // Build read calls — one set per known source, or a default if none listed
     const matchList = provSources.length > 0
       ? provSources
-      : [{ provider: providerName, ref: null, display: providerName }];
+      : (scoped ? [] : [{ provider: providerName, ref: null, display: providerName }]);
+
+    if (!matchList.length) continue;
 
     for (const src of matchList) {
-      const readCalls = buildReadCalls(src, env);
+      const readCalls = buildReadCalls(src, env, projectRoot);
       if (!readCalls.length) continue;
       for (const { ref, opts, display } of readCalls) {
         try {
@@ -384,7 +409,7 @@ async function demandFetchAll({ query, rootDir, env } = {}) {
  * @param {object} env
  * @returns {{ ref: string, opts: object, display: string }[]}
  */
-function buildReadCalls(match, env) {
+function buildReadCalls(match, env, cwd = process.cwd()) {
   if (match.provider === 'github') {
     const opts = { repos: [match.ref], limit: 25 };
     return [
@@ -397,7 +422,13 @@ function buildReadCalls(match, env) {
     ];
   }
   if (match.provider === 'jira') {
-    const projects = (env.JIRA_PROJECTS ?? '').split(',').map(p => p.trim()).filter(Boolean);
+    const { config } = loadProjectConfig(cwd, env);
+    const targets = resolveEffectiveSourceTargetsFromConfig(config, env)
+      .filter((t) => t.provider === 'jira')
+      .map((t) => t.selector.project);
+    const projects = targets.length
+      ? targets
+      : (env.JIRA_PROJECTS ?? '').split(',').map((p) => p.trim()).filter(Boolean);
     const recencyDays = parseInt(env.JIRA_FETCH_RECENCY_DAYS, 10) || 30;
 
     let jql;

package/lib/embed/inbox.mjs

@@ -148,6 +148,12 @@ export function resolveInboxDirs(rootDir, env = process.env) {
   const config = loadIntakeConfig(rootDir, env);
   const dirs = [];
 
+  if (config.includeRootInbox ?? config.includeArchetypeInbox) {
+    const rootInbox = join(rootDir, ARCHETYPE_INBOX_SUBDIR);
+    mkdirSync(rootInbox, { recursive: true });
+    dirs.push(rootInbox);
+  }
+
   if (config.includeProjectInbox) {
     const projectInbox = join(rootDir, DEFAULT_INBOX_SUBDIR);
     mkdirSync(projectInbox, { recursive: true });
@@ -159,16 +165,6 @@ export function resolveInboxDirs(rootDir, env = process.env) {
     if (existsSync(docsIntake)) dirs.push(docsIntake);
   }
 
-  // Archetype inbox is a profile-driven drop zone for raw source files
-  // (capabilities.intake.inbox). Off by default; init flips it on when the
-  // active profile declares the capability so non-archetype projects keep
-  // their pre-Piece-C behavior.
-
-  if (config.includeArchetypeInbox) {
-    const archetypeInbox = join(rootDir, ARCHETYPE_INBOX_SUBDIR);
-    if (existsSync(archetypeInbox)) dirs.push(archetypeInbox);
-  }
-
   for (const candidate of config.parentDirs) {
     if (!candidate) continue;
     if (!existsSync(candidate)) continue;

package/lib/embed/worker.mjs

@@ -28,8 +28,9 @@ if (configPath) {
 } else {
   const { ProviderRegistry } = await import('./providers/registry.mjs');
   const { EMPTY_CONFIG } = await import('./config.mjs');
+  const { resolveAutoEmbedSources } = await import('./auto-sources.mjs');
   const registry = await ProviderRegistry.fromEnv(env);
-  const sources = registry.autoSources(env);
+  const sources = resolveAutoEmbedSources({ cwd: process.cwd(), env, registry });
   daemonOpts.registry = registry;
   daemonOpts.config = {
     ...EMPTY_CONFIG,

package/lib/embedded-contract/index.mjs

@@ -13,6 +13,7 @@ import { recommendPlan as recommendPlanCore } from './triage.mjs';
 import { invokeWorkflow as invokeWorkflowCore } from './workflow-invoke.mjs';
 import { buildCapabilityContract } from './capability.mjs';
 import { resolveExecution as resolveExecutionCore } from './execution.mjs';
+import { planArtifactWorkflow as planArtifactWorkflowCore, runArtifactWorkflow as runArtifactWorkflowCore } from '../artifact-workflow.mjs';
 
 export { CONTRACT_VERSION, MIN_CLIENT_CONTRACT_VERSION, isClientCompatible } from './contract-version.mjs';
 export { APPROVAL_MODES } from './audit.mjs';
@@ -85,3 +86,13 @@ export function describeCapabilities({ env, cwd, rootDir } = {}) {
 export function resolveExecution(request = {}, { env, cwd, registryPath } = {}) {
   return wrapContractResult(resolveExecutionCore(request, { env, cwd, registryPath }), { surface: 'sdk', env, cwd });
 }
+
+/** Plan a manifest-backed artifact workflow without executing specialists. */
+export function planArtifactWorkflow(request = {}, { env, cwd, rootDir } = {}) {
+  return wrapContractResult(planArtifactWorkflowCore(request, { cwd, rootDir }), { surface: 'sdk', env, cwd });
+}
+
+/** Run only locally observable artifact steps and return truthful provenance. */
+export function runArtifactWorkflow(request = {}, { env, cwd, rootDir } = {}) {
+  return wrapContractResult(runArtifactWorkflowCore(request, { cwd, rootDir }), { surface: 'sdk', env, cwd });
+}

package/lib/export-branding.mjs

@@ -0,0 +1,32 @@
+/**
+ * lib/export-branding.mjs — one honest branding contract for distribution exports.
+ */
+
+import { BRAND_CAPABLE_FORMATS, PLAIN_OUTPUT_FORMATS } from './artifact-manifest.mjs';
+
+export const EXPORT_BRANDING_CAPABILITIES = Object.freeze({
+  pdf: { capable: true, mechanism: 'typst-template', asset: 'construct-pdf.typ' },
+  html: { capable: true, mechanism: 'pandoc-template', asset: 'construct-web.html' },
+  deck: { capable: true, mechanism: 'pandoc-template', asset: 'construct-deck.html' },
+  pptx: { capable: true, mechanism: 'native-pptx', asset: 'pptxgenjs' },
+  docx: { capable: true, mechanism: 'reference-doc', asset: 'construct-reference.docx' },
+  doc: { capable: true, mechanism: 'docx-reference-via-libreoffice', asset: 'construct-reference.docx' },
+  rtf: { capable: true, mechanism: 'pandoc-writer', asset: null },
+  odt: { capable: true, mechanism: 'pandoc-writer', asset: null },
+  epub: { capable: true, mechanism: 'pandoc-writer', asset: null },
+  tex: { capable: true, mechanism: 'pandoc-writer', asset: null },
+  txt: { capable: false, mechanism: 'plain-source', asset: null },
+  md: { capable: false, mechanism: 'plain-source', asset: null },
+  mdx: { capable: false, mechanism: 'plain-source', asset: null },
+});
+
+export function resolveExportBranding(format, requested = 'construct') {
+  const capability = EXPORT_BRANDING_CAPABILITIES[format];
+  if (!capability) return { requested, applied: 'none', capable: false, reason: 'unsupported format' };
+  if (!BRAND_CAPABLE_FORMATS.includes(format) || PLAIN_OUTPUT_FORMATS.includes(format)) {
+    return { requested, applied: 'none', capable: false, reason: 'format has no styling surface' };
+  }
+  if (requested === 'plain') return { requested, applied: 'plain', capable: true, mechanism: capability.mechanism, reason: 'explicit opt-out' };
+  return { requested: 'construct', applied: 'construct', capable: true, mechanism: capability.mechanism, asset: capability.asset, reason: 'default policy' };
+}
+

package/lib/hooks/session-start.mjs

@@ -265,28 +265,31 @@ const selfKnowledgeNote = '\nSelf-knowledge: call `knowledge_search` for any Con
 let sourcesNote = '';
 let embedStatusNote = '';
 try {
-  const repos = (process.env.GITHUB_REPOS ?? '').split(',').map(r => r.trim()).filter(Boolean);
-  const jiraConfigured = !!(process.env.JIRA_BASE_URL);
-  const linearConfigured = !!(process.env.LINEAR_API_KEY);
-  const hasSources = repos.length > 0 || jiraConfigured || linearConfigured;
+  const { loadProjectConfig } = await import('../config/project-config.mjs');
+  const { resolveEffectiveSourceTargetsFromConfig } = await import('../config/source-targets.mjs');
+  const { config } = loadProjectConfig(process.cwd(), process.env);
+  const targets = resolveEffectiveSourceTargetsFromConfig(config, process.env);
+  const repos = targets.filter((t) => t.provider === 'github').map((t) => t.selector.repo);
+  const jiraTargets = targets.filter((t) => t.provider === 'jira');
+  const linearTargets = targets.filter((t) => t.provider === 'linear');
+  const slackTargets = targets.filter((t) => t.provider === 'slack');
+  const hasSources = targets.length > 0;
   if (hasSources) {
     const parts = [];
     if (repos.length > 0) parts.push(`GitHub repos: ${repos.join(', ')}`);
-    if (jiraConfigured) parts.push('Jira: configured');
-    if (linearConfigured) parts.push('Linear: configured');
-    // Surface which sources are wired so `provider_fetch` is the obvious
-    // tool for questions about them. The "fetch first, don't answer from
-    // memory" policy lives in the persona.
+    if (jiraTargets.length > 0) parts.push(`Jira projects: ${jiraTargets.map((t) => t.selector.project).join(', ')}`);
+    if (linearTargets.length > 0) parts.push(`Linear teams: ${linearTargets.map((t) => t.selector.team).join(', ')}`);
+    if (slackTargets.length > 0) parts.push(`Slack channels: ${slackTargets.map((t) => t.selector.channel).join(', ')}`);
     sourcesNote = '\nProvider sources wired: ' + parts.join(' · ') +
       '. Use `provider_fetch` for any question about them.\n';
   }
+} catch { /* best effort */ }
 
-  // Embed daemon status — surface as a one-liner so operator always knows state
+try {
   const { resolveEmbedStatus, autoStartEmbedIfNeeded } = await import('../embed/cli.mjs');
   const embedStatus = resolveEmbedStatus(process.env);
   if (embedStatus.level !== 'none') {
     embedStatusNote = `\n## Embed daemon\n${embedStatus.label} · ${embedStatus.detail}\n`;
-    // Auto-start if CX_AUTO_EMBED=1 and daemon is stopped
     if (embedStatus.level === 'stopped' && process.env.CX_AUTO_EMBED === '1') {
       const result = await autoStartEmbedIfNeeded(process.env);
       if (result.started) {

package/lib/init-unified.mjs

@@ -886,21 +886,18 @@ async function main() {
     created.push(".cx/inbox/");
   }
 
-  // Intake-archetype scaffolding. When the active profile declares
-  // capabilities.intake.inbox, scaffold a project-root inbox/ drop zone and seed
-  // the dedup manifest. The whole inbox/ is ignored via host-disposition
-  // IGNORED_PATTERNS (ADR-0027 §1), so raw drops never enter source and no local
-  // keep-file is needed. Existing-structure detection already opted out of
-  // clobbering a user's pipeline above.
-
-  if (intakeCap?.inbox && !inboxDecision.skip) {
+  // Universal project-root inbox/ drop zone. Raw drops stay out of source via
+  // host-disposition IGNORED_PATTERNS (ADR-0027 §1). Skipped when custom intake
+  // pipeline already owns the project root.
+
+  if (!inboxDecision.skip) {
     const projectInbox = path.join(target, 'inbox');
     if (!fs.existsSync(projectInbox)) {
       fs.mkdirSync(projectInbox, { recursive: true });
       created.push('inbox/');
     }
 
-    if (intakeCap.dedup === 'sha256') {
+    if (intakeCap?.dedup === 'sha256') {
       const { saveManifest, loadManifest, MANIFEST_REL_PATH } = await import('./intake/manifest.mjs');
       const manifestExists = fs.existsSync(path.join(target, MANIFEST_REL_PATH));
       if (!manifestExists) {
@@ -908,8 +905,12 @@ async function main() {
         created.push(MANIFEST_REL_PATH);
       }
     }
+  } else {
+    skipped.push('inbox/ (deferred to existing intake)');
   }
 
+  // Legacy archetype block removed — root inbox/ is universal (construct-1arm).
+
   // Gitignore every Construct-generated artifact whose disposition is `ignored`
   // (ADR-0027 §1): the six adapter dirs, the `.construct/` launcher, `.cx/`
   // runtime state, and the generated config files all carry machine-specific
@@ -1080,26 +1081,26 @@ async function main() {
   // .cx/inbox/ and docs/intake/ (when present); extra dirs are opt-in.
 
   const intakeConfig = (await askIntakeCollection(target, skipInteractive)) ?? { parentDirs: [], maxDepth: 4 };
-  // When a custom intake surface was detected, default includeProjectInbox
-  // to false so the watcher does not double-claim with the user's existing
-  // pipeline. User can opt in later via `construct config intake.includeProjectInbox=true`.
 
   if (inboxDecision.skip) intakeConfig.includeProjectInbox = false;
 
-  // Archetype: flip includeArchetypeInbox on so resolveInboxDirs picks up
-  // the project-root inbox/ drop zone alongside .cx/inbox/. Mirrors the
-  // existing includeProjectInbox / includeDocsIntake toggles rather than
-  // polluting parentDirs (which is reserved for user-explicit dirs).
+  intakeConfig.includeRootInbox = !inboxDecision.skip;
+  intakeConfig.includeArchetypeInbox = intakeConfig.includeRootInbox;
 
-  if (intakeCap?.inbox) {
-    intakeConfig.includeArchetypeInbox = true;
-  }
-  const { saveIntakeConfig } = await import('./intake/intake-config.mjs');
+  const { saveIntakePolicy } = await import('./config/intake-policy.mjs');
   try {
-    saveIntakeConfig(target, intakeConfig);
-    created.push('.cx/intake-config.json');
+    saveIntakePolicy(target, {
+      maxDepth: intakeConfig.maxDepth,
+      additionalDirs: intakeConfig.parentDirs ?? [],
+      zones: {
+        rootInbox: intakeConfig.includeRootInbox !== false,
+        projectInbox: intakeConfig.includeProjectInbox !== false,
+        docsIntake: intakeConfig.includeDocsIntake !== false,
+      },
+    });
+    created.push('construct.config.json (intakePolicy)');
   } catch (err) {
-    console.warn(`⚠️  Could not write intake config: ${err.message}`);
+    console.warn(`⚠️  Could not write intake policy: ${err.message}`);
   }
   
   // Ask about documentation system

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/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';