@geraldmaron/construct 1.2.0 → 1.2.1

package/lib/artifact-workflow.mjs

@@ -0,0 +1,252 @@
+/**
+ * lib/artifact-workflow.mjs — intent-to-artifact workflow planning.
+ *
+ * Planning describes specialist work and manifest ordering without reporting a
+ * planned role as executed.
+ */
+
+import { existsSync } from 'node:fs';
+import { loadProjectConfig } from './config/project-config.mjs';
+import {
+  BRAND_CAPABLE_FORMATS,
+  artifactTypes,
+  resolveArtifactType,
+  resolveArtifactWorkflowContract,
+} from './artifact-manifest.mjs';
+import { inferArtifactTypeFromPath } from './artifact-type-from-path.mjs';
+import { validateArtifactRelease } from './artifact-release-gate.mjs';
+import { exportMarkdown } from './document-export.mjs';
+
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function findRequestedTypes(input, { rootDir, cwd }) {
+  const text = String(input ?? '').toLowerCase();
+  const matches = [];
+  for (const type of artifactTypes({ rootDir, cwd }).sort((a, b) => b.length - a.length)) {
+    const entry = resolveArtifactType(type, { rootDir, cwd }).entry;
+    for (const candidate of [type, ...(entry?.aliases ?? [])]) {
+      if (new RegExp(`(?:^|[^a-z0-9])${escapeRegex(candidate.toLowerCase())}(?:$|[^a-z0-9])`, 'i').test(text)) {
+        matches.push(type);
+        break;
+      }
+    }
+  }
+  return [...new Set(matches)];
+}
+
+function inferFormat(input, requestedFormat) {
+  if (requestedFormat) return String(requestedFormat).toLowerCase();
+  const text = String(input ?? '').toLowerCase();
+  for (const format of ['pptx', 'docx', 'pdf', 'deck', 'html', 'doc', 'rtf', 'odt', 'epub', 'tex', 'txt', 'mdx', 'md']) {
+    if (new RegExp(`\\b${format}\\b`, 'i').test(text)) return format;
+  }
+  return null;
+}
+
+function inferBranding(input, requestedBranding) {
+  if (requestedBranding) return requestedBranding;
+  return /\b(?:unbranded|plain|without (?:the )?construct brand)\b/i.test(String(input ?? '')) ? 'plain' : 'construct';
+}
+
+function buildSteps({ contract, input, targetFormat, branding }) {
+  const text = String(input ?? '').toLowerCase();
+  const needsResearch = Boolean(contract.researchProfile) && /\b(?:research|source|evidence|validate claims)\b/.test(text);
+  const needsReview = /\b(?:review|critique|audit|feedback)\b/.test(text) || contract.requiredReviewers.length > 0;
+  const rewrite = /\b(?:rewrite|revise|edit|polish|improve)\b/.test(text);
+  const steps = [];
+  if (needsResearch) steps.push({ id: 'research', action: 'research', roles: [], required: false, reason: `research profile: ${contract.researchProfile}` });
+  if (needsReview) steps.push({ id: 'review', action: 'review', roles: contract.reviewerChain, required: contract.requiredReviewers.length > 0, reason: 'review occurs before any rewrite' });
+  steps.push({
+    id: rewrite ? 'rewrite' : 'author',
+    action: rewrite ? 'rewrite' : 'author',
+    roles: contract.authorChain,
+    required: true,
+    reason: rewrite ? 'requested revision after review' : 'manifest author chain',
+  });
+  if (contract.validation.releaseGate !== false) {
+    steps.push({ id: 'validate', action: 'validate', roles: [], required: true, reason: 'manifest validation policy' });
+  }
+  if (targetFormat && BRAND_CAPABLE_FORMATS.includes(targetFormat) && branding === 'construct') {
+    steps.push({ id: 'brand', action: 'brand', roles: [], required: true, reason: 'default Construct branding for brand-capable format' });
+  }
+  if (targetFormat) steps.push({ id: 'export', action: 'export', roles: [], required: true, format: targetFormat, reason: 'requested distribution format' });
+  return steps;
+}
+
+/**
+ * Build an artifact plan from an ordinary request. A missing or ambiguous
+ * class is a clarification result, never an implicit PRD route.
+ */
+export function planArtifactWorkflow(request = {}, { cwd = process.cwd(), rootDir } = {}) {
+  const input = request.input ?? request.request ?? '';
+  const sourcePath = request.sourcePath ?? request.filePath ?? '';
+  const project = request.projectConfig ?? loadProjectConfig(cwd).config;
+  const requested = request.artifactType ?? request.documentClass ?? null;
+  const pathType = sourcePath && existsSync(sourcePath) ? inferArtifactTypeFromPath(sourcePath, { rootDir: cwd }) : null;
+  const inferredTypes = requested ? [] : findRequestedTypes(input, { rootDir, cwd });
+  const candidates = requested ? [requested] : [...new Set([pathType, ...inferredTypes].filter(Boolean))];
+
+  if (candidates.length !== 1) {
+    return {
+      kind: 'artifact-workflow',
+      status: 'needs-classification',
+      plannedSteps: [],
+      executedSteps: [],
+      skippedSteps: [],
+      producedFiles: [],
+      validation: null,
+      appliedOverrides: [],
+      clarification: candidates.length > 1
+        ? `Request names multiple document classes (${candidates.join(', ')}). Specify one registered class.`
+        : 'Specify a registered document class, use a typed source path, or register the requested class in specialists/artifact-manifest.json.',
+    };
+  }
+
+  const resolution = resolveArtifactType(candidates[0], { rootDir, cwd });
+  if (resolution.status !== 'registered') {
+    return {
+      kind: 'artifact-workflow',
+      status: 'needs-classification',
+      plannedSteps: [],
+      executedSteps: [],
+      skippedSteps: [],
+      producedFiles: [],
+      validation: null,
+      appliedOverrides: [],
+      clarification: resolution.guidance,
+    };
+  }
+
+  const targetFormat = inferFormat(input, request.format ?? request.targetFormat);
+  const requestedBranding = inferBranding(input, request.branding);
+  const contract = resolveArtifactWorkflowContract(resolution.type, {
+    rootDir,
+    cwd,
+    projectConfig: project,
+    overrides: request.overrides,
+  });
+  const branding = request.branding ?? (requestedBranding === 'plain' ? 'plain' : (contract.outputs.branding ?? 'construct'));
+  const steps = buildSteps({ contract, input, targetFormat, branding });
+  const unavailableFormat = targetFormat && !contract.outputs.formats.includes(targetFormat);
+
+  return {
+    kind: 'artifact-workflow',
+    status: unavailableFormat ? 'needs-classification' : 'planned',
+    documentClass: contract.documentClass,
+    artifactType: contract.type,
+    sourcePath: sourcePath || null,
+    target: {
+      format: targetFormat,
+      audience: /\bcustomer(?:-facing)?\b/i.test(input) ? 'customer' : 'internal',
+      branding,
+      brandCapable: Boolean(targetFormat && BRAND_CAPABLE_FORMATS.includes(targetFormat)),
+    },
+    contract,
+    plannedSteps: steps,
+    executedSteps: [],
+    skippedSteps: [],
+    producedFiles: [],
+    validation: null,
+    appliedOverrides: contract.appliedOverrides,
+    clarification: unavailableFormat ? `${targetFormat} is not an output capability for ${contract.type}.` : null,
+  };
+}
+
+/**
+ * Produce a provenance-preserving workflow run report. Specialist authoring
+ * and review are never fabricated: Construct can plan them, but only reports
+ * them as executed when a host returns execution evidence (not available in
+ * the deterministic entry point). Validation/export are local operations and
+ * run only with the explicit durable-write approval mode.
+ */
+export function runArtifactWorkflow(request = {}, { cwd = process.cwd(), rootDir } = {}) {
+  const plan = planArtifactWorkflow(request, { cwd, rootDir });
+  const approvalMode = request.approvalMode ?? 'proposal-only';
+  const report = {
+    reportVersion: 1,
+    kind: 'artifact-workflow-run',
+    status: plan.status === 'planned' ? 'planned' : plan.status,
+    approval: {
+      mode: approvalMode,
+      durableWriteAllowed: approvalMode === 'allow-durable-write',
+    },
+    plan,
+    plannedSteps: plan.plannedSteps,
+    executedSteps: [],
+    skippedSteps: [],
+    producedFiles: [],
+    validation: null,
+    appliedOverrides: plan.appliedOverrides,
+  };
+  if (plan.status !== 'planned') return report;
+
+  const pendingReason = approvalMode === 'allow-durable-write'
+    ? 'specialist execution is host-owned; this local command has no specialist execution evidence'
+    : `approval mode '${approvalMode}' permits planning only`;
+  for (const step of plan.plannedSteps) {
+    if (['review', 'rewrite', 'author', 'research'].includes(step.action)) {
+      report.skippedSteps.push({ id: step.id, reason: pendingReason });
+    }
+  }
+  if (approvalMode !== 'allow-durable-write') {
+    for (const step of plan.plannedSteps) {
+      if (!['review', 'rewrite', 'author', 'research'].includes(step.action)) {
+        report.skippedSteps.push({ id: step.id, reason: pendingReason });
+      }
+    }
+    return report;
+  }
+
+  const sourcePath = plan.sourcePath;
+  for (const step of plan.plannedSteps) {
+    if (step.action === 'validate') {
+      if (!sourcePath) {
+        report.skippedSteps.push({ id: step.id, reason: 'validation needs sourcePath or filePath' });
+      } else {
+        const result = validateArtifactRelease({ filePath: sourcePath, type: plan.artifactType, cwd, rootDir });
+        report.validation = result;
+        report.executedSteps.push({ id: step.id, result: result.ok ? 'passed' : 'failed' });
+        if (!result.ok) {
+          report.status = 'validation-failed';
+          return report;
+        }
+      }
+    }
+    if (step.action === 'brand') {
+      // Branding is applied by the export operation. Keeping this pending until
+      // output exists avoids claiming a template was applied when no export ran.
+      report.skippedSteps.push({ id: step.id, reason: 'branding is evidenced by the export result' });
+    }
+    if (step.action === 'export') {
+      if (!sourcePath) {
+        report.skippedSteps.push({ id: step.id, reason: 'export needs sourcePath or filePath' });
+      } else {
+        const result = exportMarkdown({
+          inputPath: sourcePath,
+          outputPath: request.outputPath,
+          format: step.format,
+          artifactType: plan.artifactType,
+          branding: plan.target.branding,
+          cwd,
+          rootDir,
+        });
+        if (!result.ok) {
+          report.status = 'export-failed';
+          report.skippedSteps.push({ id: step.id, reason: result.message });
+          return report;
+        }
+        report.executedSteps.push({ id: step.id, result: 'produced', format: step.format });
+        report.producedFiles.push({ path: result.outputPath, format: step.format, branding: result.branding });
+        const brandStep = report.skippedSteps.findIndex((entry) => entry.id === 'brand');
+        if (brandStep >= 0 && result.branding?.applied === 'construct') {
+          report.skippedSteps.splice(brandStep, 1);
+          report.executedSteps.push({ id: 'brand', result: 'applied', mechanism: result.branding.mechanism });
+        }
+      }
+    }
+  }
+  report.status = report.executedSteps.length ? 'completed-local-steps' : 'planned';
+  return report;
+}

package/lib/auto-docs.mjs

@@ -368,7 +368,9 @@ function renderCommandPage(category, commands) {
       lines.push('**Subcommands**');
       lines.push('');
       for (const sub of cmd.subcommands) {
-        lines.push(`- \`${sub}\``);
+        const name = typeof sub === 'string' ? sub : sub.name;
+        const description = typeof sub === 'string' ? '' : (sub.desc || sub.description || '');
+        lines.push(`- \`${name}\`${description ? ` — ${description}` : ''}`);
       }
       lines.push('');
     }

package/lib/chat/present.mjs

@@ -225,6 +225,7 @@ export function sessionMetaToSsePayload({ session, layers, workingBranch, oracle
   return {
     type: 'session_meta',
     model: session?.model || null,
+    demoLabel: session?.demoGuide ? (session.demoTitle || 'scripted') : null,
     modelMode: session?.modelMode || 'pinned',
     sandbox: session?.sandbox || null,
     permissionMode: session?.permissionMode || null,

package/lib/cli-commands.mjs

@@ -330,12 +330,14 @@ export const CLI_COMMANDS = [
     category: 'Work',
     core: false,
     description: 'Export markdown to PDF, DOCX, HTML, and other Pandoc formats via Pandoc + Typst (optional system binaries; ADR-0024)',
-    usage: 'construct export <markdown-file> --to=<pdf|docx|deck|pptx|html|rtf|odt|epub|tex|txt|md|mdx> [--output=<path>] [--figures] [--detect]',
+    usage: 'construct export <markdown-file> --to=<pdf|docx|deck|pptx|html|rtf|odt|epub|tex|txt|md|mdx> [--output=<path>] [--figures|--no-figures] [--plain] [--detect]',
     strictFlags: true,
     options: [
       { flag: '--to=<format>', desc: 'pdf, docx, deck, pptx, html, rtf, odt, epub, tex, txt, md, mdx' },
       { flag: '--output=<path>', desc: 'Output path' },
       { flag: '--figures', desc: 'Render d2/mermaid via pandoc-ext/diagram filter' },
+      { flag: '--no-figures', desc: 'Skip diagram rendering' },
+      { flag: '--plain, --no-brand', desc: 'Explicitly opt out of Construct branding for a brand-capable output' },
       { flag: '--detect', desc: 'Report binary availability (JSON)' },
     ],
   },
@@ -658,10 +660,11 @@ export const CLI_COMMANDS = [
     emoji: '📋',
     category: 'Work',
     core: false,
-    description: 'Validate typed document artifacts against the release gate',
-    usage: 'construct artifact validate <path> --type=<doc-type> [--json]',
+    description: 'Plan or locally execute manifest-backed artifact workflows with execution provenance',
+    usage: 'construct artifact <validate|workflow> ...',
     subcommands: [
       { name: 'validate', desc: 'Run manifest structure, citation, and reviewer checks' },
+      { name: 'workflow', desc: 'Return a truthful plan/run report; --apply only runs local validation/export after approval' },
     ],
   },
   {
@@ -772,6 +775,20 @@ export const CLI_COMMANDS = [
     description: 'Deployment mode configuration',
     usage: 'construct config <get|set>',
   },
+  {
+    name: 'sources',
+    emoji: '🔗',
+    category: 'Advanced',
+    core: false,
+    description: 'Manage typed integration source targets in construct.config.json',
+    usage: 'construct sources list|add|remove|validate',
+    subcommands: [
+      { name: 'list', desc: 'Show config targets, legacy env merge, and effective set' },
+      { name: 'add <provider> <id> <selector-json>', desc: 'Add a typed target (github, jira, linear, slack)' },
+      { name: 'remove <id>', desc: 'Remove a config target by id' },
+      { name: 'validate', desc: 'Validate sources.targets in construct.config.json' },
+    ],
+  },
   {
     name: 'uninstall',
     emoji: '🧹',

package/lib/cli-service-inventory.mjs

@@ -0,0 +1,42 @@
+/**
+ * lib/cli-service-inventory.mjs — auditable public CLI/catalog/docs inventory.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { CLI_COMMANDS } from './cli-commands.mjs';
+
+function slugify(category) {
+  return category.toLowerCase().replace(/&/g, 'and').replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+}
+
+function handlerNames(rootDir) {
+  const source = fs.readFileSync(path.join(rootDir, 'bin', 'construct'), 'utf8');
+  const names = new Set();
+  for (const match of source.matchAll(/\n {2,3}\[\s*'([^']+)'\s*,/g)) names.add(match[1]);
+  return names;
+}
+
+/**
+ * The catalog is the public-service source of truth. This projection joins it
+ * to runtime dispatch and the generated reference pages so drift is observable
+ * without treating internal handlers as public services.
+ */
+export function buildCliServiceInventory({ rootDir = process.cwd() } = {}) {
+  const handlers = handlerNames(rootDir);
+  return CLI_COMMANDS.filter((spec) => !spec.internal).map((spec) => {
+    const page = path.join(rootDir, 'docs', 'reference', 'cli', `${slugify(spec.category)}.md`);
+    const pageText = fs.existsSync(page) ? fs.readFileSync(page, 'utf8') : '';
+    return {
+      name: spec.name,
+      category: spec.category,
+      runnable: handlers.has(spec.name),
+      documented: pageText.includes(`## construct ${spec.name}`),
+      usage: spec.usage,
+      subcommands: (spec.subcommands ?? []).map((sub) => ({
+        name: typeof sub === 'string' ? sub : sub.name,
+        documented: typeof sub === 'string' ? true : Boolean(sub.desc || sub.description),
+      })),
+    };
+  });
+}

package/lib/config/intake-policy.mjs

@@ -0,0 +1,209 @@
+/**
+ * lib/config/intake-policy.mjs — project-scoped intake watcher policy.
+ *
+ * Resolves watch zones, scan depth, and additional directories from
+ * construct.config.json intakePolicy, with warned fallback to legacy
+ * .cx/intake-config.json and env overrides.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+import { loadProjectConfig, writeProjectConfig, findProjectConfigPath, PROJECT_CONFIG_FILENAME } from './project-config.mjs';
+import {
+  INTAKE_DEFAULT_MAX_DEPTH,
+  INTAKE_HARD_MAX_DEPTH,
+  INTAKE_DEPTH_GUIDANCE,
+  describeIntakeDepth,
+} from '../intake/constants.mjs';
+import { INTAKE_CONFIG_FILE } from '../intake/legacy-paths.mjs';
+
+export { INTAKE_DEFAULT_MAX_DEPTH, INTAKE_HARD_MAX_DEPTH, INTAKE_DEPTH_GUIDANCE, describeIntakeDepth };
+
+export const DEFAULT_INTAKE_POLICY = Object.freeze({
+  maxDepth: INTAKE_DEFAULT_MAX_DEPTH,
+  zones: Object.freeze({
+    rootInbox: true,
+    projectInbox: true,
+    docsIntake: true,
+  }),
+  additionalDirs: [],
+});
+
+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);
+}
+
+function readLegacyIntakeConfig(rootDir) {
+  const file = join(rootDir, INTAKE_CONFIG_FILE);
+  if (!existsSync(file)) return null;
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function intakePolicyFromProjectConfig(config) {
+  const raw = config?.intakePolicy ?? {};
+  const zones = raw.zones ?? {};
+  return {
+    maxDepth: clampDepth(raw.maxDepth ?? DEFAULT_INTAKE_POLICY.maxDepth),
+    zones: {
+      rootInbox: zones.rootInbox !== false,
+      projectInbox: zones.projectInbox !== false,
+      docsIntake: zones.docsIntake !== false,
+    },
+    additionalDirs: Array.isArray(raw.additionalDirs)
+      ? raw.additionalDirs.map((d) => String(d).trim()).filter(Boolean)
+      : [],
+  };
+}
+
+export function legacyIntakeToPolicy(stored = {}) {
+  return {
+    maxDepth: clampDepth(stored.maxDepth ?? INTAKE_DEFAULT_MAX_DEPTH),
+    zones: {
+      rootInbox: stored.includeArchetypeInbox === true || stored.includeRootInbox === true,
+      projectInbox: stored.includeProjectInbox !== false,
+      docsIntake: stored.includeDocsIntake !== false,
+    },
+    additionalDirs: Array.isArray(stored.parentDirs) ? stored.parentDirs : [],
+  };
+}
+
+export function policyToLegacyIntakeShape(policy) {
+  return {
+    parentDirs: policy.additionalDirs,
+    maxDepth: policy.maxDepth,
+    includeProjectInbox: policy.zones.projectInbox,
+    includeDocsIntake: policy.zones.docsIntake,
+    includeArchetypeInbox: policy.zones.rootInbox,
+    includeRootInbox: policy.zones.rootInbox,
+  };
+}
+
+export function loadIntakePolicy(rootDir, env = process.env) {
+  const { config, path: configPath, raw } = loadProjectConfig(rootDir, env);
+  const legacy = readLegacyIntakeConfig(rootDir);
+  let policy;
+  let source = 'default';
+  let legacyWarning = null;
+
+  if (configPath && raw?.intakePolicy) {
+    policy = intakePolicyFromProjectConfig(config);
+    source = 'project-config';
+  } else if (legacy) {
+    policy = legacyIntakeToPolicy(legacy);
+    source = 'legacy-intake-config';
+    legacyWarning = `Using deprecated ${INTAKE_CONFIG_FILE}; migrate with \`construct intake config migrate\``;
+  } else {
+    policy = structuredClone(DEFAULT_INTAKE_POLICY);
+    source = 'default';
+  }
+
+  const envDirs = parseEnvDirs(env).map((dir) => normalizeDir(dir, rootDir)).filter(Boolean);
+  const additionalDirs = []
+    .concat(policy.additionalDirs.map((dir) => normalizeDir(dir, rootDir)).filter(Boolean))
+    .concat(envDirs);
+
+  const seen = new Set();
+  const uniqueDirs = [];
+  for (const dir of additionalDirs) {
+    if (seen.has(dir)) continue;
+    seen.add(dir);
+    uniqueDirs.push(dir);
+  }
+
+  const envDepth = env?.CX_INTAKE_MAX_DEPTH;
+  const maxDepth = clampDepth(envDepth ?? policy.maxDepth);
+
+  return {
+    maxDepth,
+    zones: { ...policy.zones },
+    additionalDirs: uniqueDirs,
+    source,
+    legacyWarning,
+  };
+}
+
+export function resolvedIntakeConfig(rootDir, env = process.env) {
+  const policy = loadIntakePolicy(rootDir, env);
+  return {
+    parentDirs: policy.additionalDirs,
+    maxDepth: policy.maxDepth,
+    includeProjectInbox: policy.zones.projectInbox,
+    includeDocsIntake: policy.zones.docsIntake,
+    includeArchetypeInbox: policy.zones.rootInbox,
+    includeRootInbox: policy.zones.rootInbox,
+    source: policy.source,
+    legacyWarning: policy.legacyWarning,
+  };
+}
+
+export function saveIntakePolicy(rootDir, patch = {}, options = {}) {
+  const configPath = findProjectConfigPath(rootDir) ?? join(rootDir, PROJECT_CONFIG_FILENAME);
+  const { config } = loadProjectConfig(rootDir, {});
+  const current = intakePolicyFromProjectConfig(config.intakePolicy ? config : { intakePolicy: DEFAULT_INTAKE_POLICY });
+
+  const nextZones = { ...current.zones, ...(patch.zones ?? {}) };
+  const next = {
+    maxDepth: clampDepth(patch.maxDepth ?? current.maxDepth),
+    zones: {
+      rootInbox: patch.rootInbox !== undefined ? Boolean(patch.rootInbox) : (patch.zones?.rootInbox ?? nextZones.rootInbox),
+      projectInbox: patch.projectInbox !== undefined ? Boolean(patch.projectInbox) : (patch.zones?.projectInbox ?? nextZones.projectInbox),
+      docsIntake: patch.docsIntake !== undefined ? Boolean(patch.docsIntake) : (patch.zones?.docsIntake ?? nextZones.docsIntake),
+    },
+    additionalDirs: Array.isArray(patch.additionalDirs)
+      ? patch.additionalDirs.map((dir) => normalizeDir(dir, rootDir)).filter(Boolean)
+      : current.additionalDirs,
+  };
+
+  if (patch.addDir) {
+    const dir = normalizeDir(patch.addDir, rootDir);
+    if (dir && !next.additionalDirs.includes(dir)) {
+      next.additionalDirs = [...next.additionalDirs, dir];
+    }
+  }
+  if (patch.removeDir) {
+    const dir = normalizeDir(patch.removeDir, rootDir);
+    next.additionalDirs = next.additionalDirs.filter((d) => d !== dir);
+  }
+
+  const updated = {
+    ...config,
+    version: config.version ?? 1,
+    intakePolicy: next,
+  };
+
+  if (options.dryRun) {
+    return { policy: next, configPath, dryRun: true };
+  }
+
+  writeProjectConfig(configPath, updated);
+  return { policy: next, configPath };
+}
+
+export function migrateLegacyIntakeConfig(rootDir) {
+  const legacy = readLegacyIntakeConfig(rootDir);
+  if (!legacy) {
+    return { migrated: false, reason: 'no legacy file' };
+  }
+  const policy = legacyIntakeToPolicy(legacy);
+  saveIntakePolicy(rootDir, policy);
+  return { migrated: true, policy };
+}

package/lib/config/project-config.mjs

@@ -15,6 +15,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { CONFIG_SCHEMA_VERSION, DEFAULT_PROJECT_CONFIG, validateProjectConfig, FIELD_RULES } from './schema.mjs';
+import { validateSourceTargets } from './source-targets.mjs';
 
 export const PROJECT_CONFIG_FILENAME = 'construct.config.json';
 
@@ -85,13 +86,17 @@ export function loadProjectConfig(cwd = process.cwd(), env = process.env) {
     };
   }
   const validation = validateProjectConfig(raw);
-  if (!validation.valid) {
+  const targetErrors = raw?.sources?.targets !== undefined
+    ? validateSourceTargets(raw.sources.targets)
+    : [];
+  const allErrors = [...(validation.errors ?? []), ...targetErrors];
+  if (!validation.valid || targetErrors.length) {
     return {
       path: configPath,
       raw,
       config: structuredClone(DEFAULT_PROJECT_CONFIG),
       source: 'invalid',
-      errors: validation.errors,
+      errors: allErrors,
     };
   }
   const merged = deepMerge(structuredClone(DEFAULT_PROJECT_CONFIG), raw);
@@ -161,6 +166,10 @@ export function writeProjectConfig(filePath, config, options = {}) {
   let validation = { valid: true, errors: [] };
   if (validate) {
     validation = validateProjectConfig(config);
+    if (config?.sources?.targets !== undefined) {
+      validation.errors = [...(validation.errors ?? []), ...validateSourceTargets(config.sources.targets)];
+      validation.valid = validation.errors.length === 0;
+    }
   }
   
   // Combine all errors (handle case where validation.errors is undefined)

package/lib/config/schema.mjs

@@ -5,7 +5,8 @@
  * AJV/zod to keep Construct dependency-free at startup — the loader runs
  * before npm install completes in some bootstrap paths.
  *
- * Schema v1 covers: alias, deployment, providers, autoEmbed, ingest, telemetry.
+ * Schema v1 covers: alias, deployment, providers, sources, intakePolicy,
+ * autoEmbed, ingest, telemetry.
  * Tier model selection lives in `specialists/registry.json` only — this config
  * file is intentionally not a second edit surface for model assignments.
  * Later phases (6, 7b) extend it with `resources` and `costs` blocks
@@ -47,6 +48,22 @@ export const DEFAULT_PROJECT_CONFIG = Object.freeze({
     tenantId: null,
   }),
   providers: Object.freeze({}),
+  sources: Object.freeze({
+    targets: [],
+  }),
+  intakePolicy: Object.freeze({
+    maxDepth: 4,
+    zones: Object.freeze({
+      rootInbox: true,
+      projectInbox: true,
+      docsIntake: true,
+    }),
+    additionalDirs: [],
+  }),
+  artifactWorkflow: Object.freeze({
+    defaults: Object.freeze({}),
+    types: Object.freeze({}),
+  }),
   profile: DEFAULT_PROFILE_ID,
   autoEmbed: false,
   ingest: Object.freeze({
@@ -121,6 +138,38 @@ export const FIELD_RULES = {
     },
   },
   providers: { type: 'object', required: false },
+  sources: {
+    type: 'object',
+    required: false,
+    fields: {
+      targets: { type: 'array' },
+    },
+  },
+  intakePolicy: {
+    type: 'object',
+    required: false,
+    fields: {
+      maxDepth: { type: 'number' },
+      additionalDirs: { type: 'array' },
+      zones: {
+        type: 'object',
+        required: false,
+        fields: {
+          rootInbox: { type: 'boolean' },
+          projectInbox: { type: 'boolean' },
+          docsIntake: { type: 'boolean' },
+        },
+      },
+    },
+  },
+  artifactWorkflow: {
+    type: 'object',
+    required: false,
+    fields: {
+      defaults: { type: 'object', required: false },
+      types: { type: 'object', required: false },
+    },
+  },
   profile: { type: 'string', required: false, maxLength: 40 },
   autoEmbed: { type: 'boolean', required: false },
   ingest: {