@geraldmaron/construct 1.2.1 → 1.2.3

package/lib/hooks/test-watch.mjs

@@ -15,10 +15,10 @@
  */
 
 import { readFileSync, existsSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { logHookFailure } from './_lib/log.mjs';
 import { emitRoleEvent } from '../roles/hook-emit.mjs';
+import { doctorRoot } from '../config/xdg.mjs';
 
 let input = {};
 try { input = JSON.parse(readFileSync(0, 'utf8')); }
@@ -44,7 +44,7 @@ emitRoleEvent({
   context: { command, exitCode, failedNames },
 });
 
-const flakeTrackerPath = join(homedir(), '.cx', 'test-watch-state.json');
+const flakeTrackerPath = join(doctorRoot(), 'test-watch-state.json');
 try {
   const state = existsSync(flakeTrackerPath) ? JSON.parse(readFileSync(flakeTrackerPath, 'utf8')) : {};
   const now = Date.now();

package/lib/host-disposition.mjs

@@ -2,7 +2,7 @@
  * lib/host-disposition.mjs — single source of truth for the disposition of
  * every artifact Construct creates in a host project (ADR-0027 §1).
  *
- * Scope model (see docs/concepts/project-scopes.md):
+ * Scope model (see docs/guides/concepts/project-scopes.md):
  *   templates/, docs/  — package/repo durable sources (committed)
  *   .construct/        — per-project launcher (ignored)
  *   .cx/               — per-project runtime: intake, oracle, observations, demos (ignored)

package/lib/ingest/provider-extract.mjs

@@ -24,6 +24,7 @@
 import { readFileSync, existsSync } from 'node:fs';
 import { extname, join } from 'node:path';
 import { homedir } from 'node:os';
+import { configDir } from '../config/xdg.mjs';
 
 import {
   AUDIO_VIDEO_EXTS,
@@ -75,7 +76,7 @@ function isAnthropic(provider, model) {
 function resolveKey(varName, env, allowAmbient) {
   if (env[varName] && typeof env[varName] === 'string' && env[varName].length > 0) return env[varName];
   if (!allowAmbient) return null;
-  for (const file of [join(homedir(), '.construct', 'config.env'), join(homedir(), '.env')]) {
+  for (const file of [join(configDir(), 'config.env'), join(homedir(), '.env')]) {
     try {
       if (!existsSync(file)) continue;
       const m = readFileSync(file, 'utf8').match(new RegExp(`^${varName}=["']?(.+?)["']?$`, 'm'));

package/lib/init/detect-existing-structure.mjs

@@ -12,13 +12,13 @@
  *
  * Heuristics intentionally err on the side of "skip" — a directory is treated
  * as a real lane only when it carries at least one markdown file. An empty
- * docs/meetings/ that an earlier init scaffolded does NOT register; that lets
+ * docs/notes/meetings/ that an earlier init scaffolded does NOT register; that lets
  * re-running init be a no-op rather than a contradictory "skip what we just
  * created" message.
  *
  * Issue #97 motivates this: `construct init` on an existing project with
  * `internal/meetings/`, a custom `ingest` script, and root-level `templates/`
- * created `docs/meetings/`, `.cx/inbox/`, and per-lane `templates/` folders
+ * created `docs/notes/meetings/`, `inbox/`, and per-lane `templates/` folders
  * that conflicted with the existing workflow.
  */
 

package/lib/init/doc-lanes.mjs

@@ -32,12 +32,6 @@ export const DOC_LANES = {
     description: 'User-facing release notes and version history entries.',
     templates: ['changelog-entry.md'],
   },
-  intake: {
-    title: 'Intake',
-    dir: 'intake',
-    description: 'Intake batch records that explain what arrived, why it matters, and how it should be ingested.',
-    templates: ['__intake-template__'],
-  },
   memos: {
     title: 'Memos',
     dir: 'memos',
@@ -88,11 +82,11 @@ export const DOC_LANES = {
   },
 };
 
-export const LANE_ORDER = ['adrs', 'briefs', 'changelogs', 'intake', 'memos', 'meetings', 'notes', 'onboarding', 'postmortems', 'prds', 'rfcs', 'runbooks'];
+export const LANE_ORDER = ['adrs', 'briefs', 'changelogs', 'memos', 'meetings', 'notes', 'onboarding', 'postmortems', 'prds', 'rfcs', 'runbooks'];
 
 export const DOC_PRESETS = {
-  lean: ['adrs', 'intake', 'memos', 'meetings', 'notes', 'prds'],
-  product: ['adrs', 'intake', 'memos', 'meetings', 'notes', 'prds', 'rfcs'],
+  lean: ['adrs', 'memos', 'meetings', 'notes', 'prds'],
+  product: ['adrs', 'memos', 'meetings', 'notes', 'prds', 'rfcs'],
   full: LANE_ORDER,
 };
 
@@ -107,7 +101,6 @@ export const LANE_ALIASES = {
   changelogs: 'changelogs',
   releases: 'changelogs',
   release: 'changelogs',
-  intake: 'intake',
   memo: 'memos',
   memos: 'memos',
   meeting: 'meetings',

package/lib/init-docs.mjs

@@ -3,8 +3,8 @@
  * lib/init-docs.mjs — stand up a documentation system for a project.
  *
  * Intentionally separate from `construct init`. Creates the docs surface only:
- * docs/README.md plus selected lane directories such as docs/adr/, docs/intake/,
- * docs/memos/, docs/notes/, docs/prds/, and docs/rfcs/ with starter templates
+ * docs/README.md plus selected lane directories such as docs/decisions/adr/, docs/intake/,
+ * docs/notes/memos/, docs/notes/, templates/docs/prds/, and templates/docs/rfcs/ with starter templates
  * copied into per-lane templates/ directories from Construct's template library.
  *
  * Usage:
@@ -290,15 +290,6 @@ function buildLaneReadme(laneKey) {
     const filename = index === 0 ? "_template.md" : templateName.replace(/\.md$/, ".template.md");
     return `- [${filename}](./templates/${filename})`;
   });
-  const usageSection = laneKey === "intake"
-    ? `
-## Intake flow
-
-- Drop source files into either [\`.cx/inbox/\`](../../.cx/inbox/) or this lane's directory when you want Construct to ingest them.
-- Run \`construct ingest ./docs/intake --sync\` or \`construct ingest ./.cx/inbox --sync\` to convert supported files into retrieval-ready markdown, or let the embed daemon watch those drop zones automatically.
-- Durable ingested knowledge lands under \`.cx/knowledge/internal/\` by default, which is where Construct's learning and search paths already operate.
-`
-    : "";
 
   return `<!--
 docs/${dirName}/README.md — lane guide for ${title}.
@@ -314,7 +305,6 @@ ${description}
 ## Starter templates
 
 ${templateLines.join("\n")}
-${usageSection}
 `;
 }
 
@@ -432,39 +422,6 @@ Promote durable decisions into ADRs, memos, or PRDs when needed.
 `;
 }
 
-function buildIntakeTemplate() {
-  return `<!--
-docs/intake/templates/_template.md — starter template for logging an intake batch.
-
-Use this when you want a durable record of what was dropped into intake and why.
-Raw source files belong in .cx/inbox/ until they are ingested.
--->
-
-# Intake Batch: {title}
-
-- **Date**: {YYYY-MM-DD}
-- **Owner**: {name}
-- **Source**: {vendor, teammate, export, upload}
-
-## What arrived
-
-<!-- Files, folders, or links dropped into .cx/inbox/. -->
-
-## Why it matters
-
-<!-- Why Construct should ingest this material. -->
-
-## Ingest plan
-
-- Run: \`construct ingest ./.cx/inbox --sync\`
-- Target: \`.cx/knowledge/internal/\` unless a different knowledge target is more appropriate
-
-## Notes
-
-<!-- Caveats, access concerns, or cleanup notes. -->
-`;
-}
-
 function titleCase(value) {
   return value
     .split(/[-_\s]+/)
@@ -532,7 +489,6 @@ function copyLaneTemplates(laneKey) {
     const content =
       templateName === "__notes-template__" ? buildNotesTemplate()
       : templateName === '__meeting-notes-template__' ? buildMeetingNotesTemplate()
-      : templateName === "__intake-template__" ? buildIntakeTemplate()
       : fs.readFileSync(path.join(TEMPLATE_DIR, templateName), "utf8");
     writeIfMissing(path.join(laneRoot, "templates", outputName), content);
   }
@@ -632,14 +588,16 @@ async function main() {
   if (withArchitecture) {
     writeIfMissing(path.join(docsDir, "architecture.md"), buildArchitectureDoc(projectName, allScaffoldedLaneKeys));
   }
-  if (lanesToScaffold.includes('intake')) {
-    const inboxDecision = shouldSkipProjectInbox(detection, { force: forceScaffold });
-    if (inboxDecision.skip) {
-      process.stdout.write(`[init:docs] skipping .cx/inbox/ — ${inboxDecision.reason}. Run with --force to scaffold anyway.\n`);
-      skipped.push('.cx/inbox/ (deferred to existing intake)');
-    } else {
-      fs.mkdirSync(path.join(target, '.cx', 'inbox'), { recursive: true });
-    }
+  const inboxDecision = shouldSkipProjectInbox(detection, { force: forceScaffold });
+  if (inboxDecision.skip) {
+    process.stdout.write(`[init:docs] skipping inbox/ — ${inboxDecision.reason}. Run with --force to scaffold anyway.\n`);
+    skipped.push('inbox/ (deferred to existing intake)');
+  } else {
+    // Single canonical drop zone (ADR-0045 §C): the project-root inbox/, with
+    // a gitignored .staging/ for atomic rename-in handoff. Independent of any
+    // docs lane.
+
+    fs.mkdirSync(path.join(target, 'inbox', '.staging'), { recursive: true });
   }
 
   for (const { laneKey, reason } of deferredLanes) {

package/lib/init-unified.mjs

@@ -175,10 +175,7 @@ function detectProjectType(targetPath) {
 function suggestLanes(targetPath, projectType) {
   const suggestions = [];
   const files = fs.readdirSync(targetPath);
-  
-  // Always suggest intake for collecting feedback
-  suggestions.push({ lane: 'intake', reason: 'Collect incoming requests and feedback', recommended: true });
-  
+
   // ADRs for any non-trivial project
   if (projectType.type !== 'docs') {
     suggestions.push({ lane: 'adrs', reason: 'Track architectural decisions', recommended: true });
@@ -365,33 +362,6 @@ Attendees: {{attendees}}
 - [ ] @owner: Task description (due: {{date}})`;
 }
 
-function buildIntakeTemplate() {
-  return `# Intake: {{source}}
-
-Received: {{date}}
-From: {{from}}
-Priority: {{priority}}
-
-## What arrived
-
-Brief description of what was received.
-
-## Why it matters
-
-Why this intake item is important to process.
-
-## How it should be ingested
-
-Processing instructions:
-- [ ] Step 1
-- [ ] Step 2
-- [ ] Step 3
-
-## Notes
-
-<!-- Caveats, access concerns, or cleanup notes. -->`;
-}
-
 function writeIfMissing(filePath, content) {
   if (fs.existsSync(filePath)) {
     skipped.push(path.relative(target, filePath));
@@ -418,8 +388,6 @@ function copyLaneTemplates(laneKey) {
       content = buildNotesTemplate();
     } else if (templateName === '__meeting-notes-template__') {
       content = buildMeetingNotesTemplate();
-    } else if (templateName === "__intake-template__") {
-      content = buildIntakeTemplate();
     } else {
       const templatePath = path.join(TEMPLATE_DIR, templateName);
       if (fs.existsSync(templatePath)) {
@@ -543,8 +511,8 @@ function discoverProjectDirs(targetPath) {
 // 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.
+// canonical `inbox/` at the project root is 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
@@ -555,10 +523,9 @@ function discoverProjectDirs(targetPath) {
 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>`.
+  // Non-interactive default: empty parentDirs. The canonical `inbox/` zone
+  // handles 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) {
     return null;
   }
@@ -583,7 +550,7 @@ async function askIntakeCollection(targetPath, skipInteractive) {
   console.log('  INTAKE COLLECTION');
   console.log('═══════════════════════════════════════════════════════════');
   console.log('');
-  console.log('Intake watches `.cx/inbox/` and `docs/intake/` by default.');
+  console.log('Intake watches `inbox/` at the project root.');
   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/.');
@@ -599,7 +566,7 @@ async function askIntakeCollection(targetPath, skipInteractive) {
   if (selected.length === 0) {
     console.log('');
     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('`inbox/` only. Add more later with:');
     console.log('  construct intake config set --add-dir=<path>');
     console.log('');
     return null;
@@ -866,37 +833,35 @@ async function main() {
 
 
   // Detect existing project content once; the result feeds three decisions
-  // below: skip .cx/inbox/ on custom intake, skip lane scaffolding for lanes
-  // already covered elsewhere, and skip per-lane templates/ when root
-  // templates/ already has them. --force bypasses every check.
+  // below: skip the inbox/ drop zone on custom intake, skip lane scaffolding
+  // for lanes already covered elsewhere, and skip per-lane templates/ when
+  // root templates/ already has them. --force bypasses every check.
 
   const { detectExistingContent, shouldSkipProjectInbox, shouldScaffoldLane, formatDeferralSummary } =
     await import('./init/detect-existing-structure.mjs');
   const detection = detectExistingContent(target);
   const inboxDecision = shouldSkipProjectInbox(detection, { force: forceScaffold });
 
-  if (inboxDecision.skip) {
-    console.log(`[init:intake] skipping .cx/inbox/ — ${inboxDecision.reason}. Run with --force to scaffold anyway.`);
-    skipped.push('.cx/inbox/ (deferred to existing intake)');
-  } else {
-    // `.cx/inbox/` is the local intake drop zone the watcher polls; under the gitignored
-    // `.cx/` tree the directory must exist on disk but needs no keep file.
-
-    fs.mkdirSync(path.join(target, ".cx", "inbox"), { recursive: true });
-    created.push(".cx/inbox/");
-  }
-
-  // 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.
+  // Single canonical drop zone (ADR-0045 §C): the visible project-root `inbox/`.
+  // Raw drops stay out of source via host-disposition IGNORED_PATTERNS
+  // (ADR-0027 §1). Machine/runtime intake state lives under the gitignored
+  // `.cx/intake/` tree, created lazily by the queue on first use — init no
+  // longer scaffolds the deprecated `.cx/inbox/` drop zone. Skipped when a
+  // 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 });
+    const rootInbox = path.join(target, 'inbox');
+    if (!fs.existsSync(rootInbox)) {
+      fs.mkdirSync(rootInbox, { recursive: true });
       created.push('inbox/');
     }
 
+    // Writers assemble files under `inbox/.staging/` and atomically rename them
+    // into `inbox/`; the gitignored staging dir keeps a half-written drop
+    // invisible to the watcher until it lands.
+
+    fs.mkdirSync(path.join(rootInbox, '.staging'), { recursive: true });
+
     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));
@@ -906,11 +871,10 @@ async function main() {
       }
     }
   } else {
+    console.log(`[init:intake] skipping inbox/ — ${inboxDecision.reason}. Run with --force to scaffold anyway.`);
     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
@@ -1075,28 +1039,18 @@ async function main() {
     console.warn(`⚠️  Could not inject agent-instruction block: ${err.message}`);
   }
 
-  // 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.
+  // Intake policy — write the single-zone model (ADR-0045 §C) so the user can
+  // inspect what's watched and edit it directly. The canonical `inbox/` at the
+  // project root is the only drop zone; empty parentDirs is correct — extra
+  // dirs are opt-in.
 
   const intakeConfig = (await askIntakeCollection(target, skipInteractive)) ?? { parentDirs: [], maxDepth: 4 };
 
-  if (inboxDecision.skip) intakeConfig.includeProjectInbox = false;
-
-  intakeConfig.includeRootInbox = !inboxDecision.skip;
-  intakeConfig.includeArchetypeInbox = intakeConfig.includeRootInbox;
-
   const { saveIntakePolicy } = await import('./config/intake-policy.mjs');
   try {
     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) {
@@ -1115,7 +1069,7 @@ async function main() {
   // Create documentation system if lanes specified
   if (lanes.length > 0) {
     // Filter out lanes that the project already covers elsewhere
-    // (issue #97: don't create docs/meetings/ when internal/meetings/
+    // (issue #97: don't create docs/notes/meetings/ when internal/meetings/
     // has 12 markdown files). --force bypasses the filter.
 
     const deferredLanes = [];
@@ -1210,7 +1164,7 @@ async function main() {
     const seed = await syncFileStateToSql(target, { env: process.env, project: projectName });
     if (seed?.status === 'ok' && (seed.documentsSynced || 0) > 0) {
       console.log(`\n🔍 Indexed existing project material: ${seed.documentsSynced} doc(s), ${seed.embeddingsSynced || 0} embeddings.`);
-      console.log(`   The agent can now compare new intake (.cx/inbox/, docs/intake/) against your existing PRDs, ADRs, and notes.`);
+      console.log(`   The agent can now compare new intake (inbox/) against your existing PRDs, ADRs, and notes.`);
     }
   } catch { /* silent — corpus seeding is best-effort, not a setup blocker */ }
   
@@ -1241,9 +1195,9 @@ async function main() {
     console.log(`${++step}. Edit plan.md`);
     console.log('   Add your current work and tasks');
     console.log('');
-    if (lanes.includes('intake')) {
+    if (created.includes('inbox/')) {
       console.log(`${++step}. Use Intake`);
-      console.log('   Drop files in .cx/inbox/ for processing');
+      console.log('   Drop files in inbox/ for processing');
       console.log('   Run: construct intake');
       console.log('');
     }

package/lib/init.mjs

@@ -77,12 +77,14 @@ function main() {
     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.
+  // Single canonical drop zone (ADR-0045 §C): the visible project-root `inbox/`,
+  // covered by the host .gitignore (ADR-0027 §1). Writers stage under the
+  // gitignored `inbox/.staging/` and atomically rename in; the watcher consumes
+  // only complete top-level files. Machine/runtime intake state lives under the
+  // gitignored `.cx/intake/`, created lazily by the queue.
 
-  fs.mkdirSync(path.join(target, ".cx", "inbox"), { recursive: true });
-  created.push(".cx/inbox/");
+  fs.mkdirSync(path.join(target, "inbox", ".staging"), { recursive: true });
+  created.push("inbox/");
 
   process.stdout.write(`\nConstruct init → ${target}\n\n`);
   if (created.length) {

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

@@ -2,7 +2,8 @@
  * 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`.
+ * release and writes it to the bin/ subdir of the XDG state dir. 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.
  */
@@ -10,6 +11,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { stateDir } from '../config/xdg.mjs';
+
 const GITHUB_REPO = 'geraldmaron/construct';
 
 function assetName() {
@@ -46,7 +49,7 @@ async function downloadAsset(url, dest, env) {
 
 // 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 binDir = path.join(stateDir(homeDir), 'bin');
   const dest = path.join(binDir, destBinaryName());
   const name = assetName();
 

package/lib/intake/daemon.mjs

@@ -1,10 +1,14 @@
 /**
  * lib/intake/daemon.mjs — Continuous intake daemon with safeguards.
  *
- * Polls `.cx/inbox/` for new files, classifies them via the existing intake
- * classifier, and writes packets to `.cx/intake/pending/`. Packets past their
- * TTL move to `.cx/intake/dead-letter/`; failed classification retries up to
- * the budget then dead-letters with the failure reason.
+ * Polls the canonical project-root `inbox/` for new files, classifies them via
+ * the existing intake classifier, and writes packets to `.cx/intake/pending/`.
+ * Packets past their TTL move to `.cx/intake/dead-letter/`; failed
+ * classification retries up to the budget then dead-letters with the reason.
+ *
+ * Atomic handoff (ADR-0045 §C): only complete top-level files are enqueued.
+ * Dotfiles and the `inbox/.staging/` assembly directory are skipped, so a file
+ * a writer is still staging is invisible until it is renamed into `inbox/`.
  *
  * Built on lib/daemons/contract.mjs — every safeguard (bounded lifetime,
  * idle shutdown, heartbeat, killswitch, single-writer lock) applies.
@@ -12,30 +16,49 @@
 
 import { readdirSync, statSync, readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from 'node:fs';
 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';
+import { stateDir } from '../config/xdg.mjs';
 
 const KILLSWITCH_ENV = 'CONSTRUCT_INTAKE_DAEMON';
 
-function inboxDir(cwd) { return join(cwd, '.cx', 'inbox'); }
+function inboxDir(cwd) { return join(cwd, 'inbox'); }
 function pendingDir(cwd) { return join(cwd, '.cx', 'intake', 'pending'); }
 function deadLetterDir(cwd) { return join(cwd, '.cx', 'intake', 'dead-letter'); }
-function heartbeatPath() { return join(homedir(), '.construct', 'intake-daemon.heartbeat'); }
+function heartbeatPath() { return join(stateDir(), 'intake-daemon.heartbeat'); }
 
 function ensureDir(dir) {
   try { mkdirSync(dir, { recursive: true }); } catch { /* ignore */ }
 }
 
+// A writer staging into `inbox/.staging/` and renaming into `inbox/` is the
+// atomic handoff. As a backstop for writers that drop in place, a file whose
+// size is still moving between two stats is mid-write — skip it this tick.
+
+function isSizeStable(full) {
+  try {
+    const a = statSync(full);
+    const b = statSync(full);
+    return a.size === b.size;
+  } catch {
+    return false;
+  }
+}
+
 function listInboxFiles(cwd) {
   const dir = inboxDir(cwd);
   if (!existsSync(dir)) return [];
   let entries;
   try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return []; }
+
+  // Only complete top-level files: dotfiles (and the `.staging/` assembly dir)
+  // are skipped, so a file a writer is still staging is invisible until rename.
+
   return entries
     .filter((e) => e.isFile() && !e.name.startsWith('.'))
-    .map((e) => join(dir, e.name));
+    .map((e) => join(dir, e.name))
+    .filter((full) => isSizeStable(full));
 }
 
 /**

package/lib/intake/intake-config.mjs

@@ -1,16 +1,14 @@
 /**
  * lib/intake/intake-config.mjs — intake watcher config facade.
  *
- * Reads and writes intake policy via construct.config.json intakePolicy.
- * Legacy .cx/intake-config.json remains a warned compatibility fallback.
+ * Reads and writes intake policy via construct.config.json intakePolicy, the
+ * only config source (single-zone model, ADR-0045 §C).
  */
 
 import { shouldCreateCx } from '../project-detection.mjs';
 import {
-  loadIntakePolicy,
   resolvedIntakeConfig,
   saveIntakePolicy,
-  migrateLegacyIntakeConfig,
   DEFAULT_INTAKE_POLICY,
 } from '../config/intake-policy.mjs';
 import {
@@ -19,38 +17,22 @@ import {
   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: true,
-  includeRootInbox: true,
 });
 
-export function intakeConfigPath(rootDir) {
-  return join(rootDir, INTAKE_CONFIG_FILE);
-}
-
 export function loadIntakeConfig(rootDir, env = process.env) {
-  const cfg = resolvedIntakeConfig(rootDir, env);
-  if (cfg.legacyWarning && process.stderr.isTTY) {
-    process.stderr.write(`[intake-config] ${cfg.legacyWarning}\n`);
-  }
-  return cfg;
+  return resolvedIntakeConfig(rootDir, env);
 }
 
 export function saveIntakeConfig(rootDir, patch = {}) {
@@ -60,24 +42,15 @@ export function saveIntakeConfig(rootDir, patch = {}) {
 
   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);
+  return policyToConfigShape(policy);
 }
 
-function policyToLegacyShape(policy) {
+function policyToConfigShape(policy) {
   return {
     parentDirs: policy.additionalDirs,
     maxDepth: policy.maxDepth,
-    includeProjectInbox: policy.zones.projectInbox,
-    includeDocsIntake: policy.zones.docsIntake,
-    includeArchetypeInbox: policy.zones.rootInbox,
-    includeRootInbox: policy.zones.rootInbox,
   };
 }