@geraldmaron/construct 1.2.1 → 1.2.3

package/lib/project-root.mjs

@@ -4,12 +4,12 @@
  * Writers that own per-project state (contract violations, audit reads, agent
  * dispatches, intent verifications) call `resolveProjectScope()` to decide
  * which `<project>/.cx/<file>.jsonl` to write to. When no project is
- * detected, the call returns `null` and writers fall back to the legacy
- * user-scope path (`~/.cx/<file>.jsonl`) so existing standalone hook
+ * detected, the call returns `null` and writers fall back to the global
+ * user-scope path (`<doctorRoot>/<file>.jsonl`) so existing standalone hook
  * invocations don't lose data.
  *
  * Writers that own cross-project telemetry (skill calls, role-pending,
- * session cost) keep using `~/.cx/` but tag each entry with the
+ * session cost) keep using the global doctor root but tag each entry with the
  * `projectId` from `resolveProjectId()` so a reader can attribute the
  * entry to a specific project later.
  *
@@ -24,6 +24,8 @@ import path from 'node:path';
 import os from 'node:os';
 import { createHash } from 'node:crypto';
 
+import { doctorRoot } from './config/xdg.mjs';
+
 const HOME = os.homedir();
 const MARKERS = ['.cx', '.construct'];
 const cache = new Map();   // cwd → { projectRoot, projectId, scope } | null
@@ -84,13 +86,13 @@ export function resolveProjectScope(cwd = process.cwd()) {
 
 /**
  * For project-scoped writers: returns the `<project>/.cx/<basename>` path
- * when cwd is inside a Construct project, otherwise the legacy
- * `~/.cx/<basename>` path. Callers pass just the file basename; this helper
- * resolves the directory side. ensureDir=true creates the parent dir.
+ * when cwd is inside a Construct project, otherwise the global
+ * `<doctorRoot>/<basename>` path. Callers pass just the file basename; this
+ * helper resolves the directory side. ensureDir=true creates the parent dir.
  */
 export function resolveProjectScopedPath(basename, { cwd, ensureDir = true } = {}) {
   const scope = resolveProjectScope(cwd ?? process.cwd());
-  const dir = scope ? scope.cxDir : path.join(HOME, '.cx');
+  const dir = scope ? scope.cxDir : doctorRoot();
   if (ensureDir && !fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
   return path.join(dir, basename);
 }

package/lib/provider-capabilities.js

@@ -18,9 +18,10 @@
  */
 import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
 
-const CAPABILITY_CACHE_PATH = join(homedir(), '.cx', 'provider-capabilities.json');
+import { doctorRoot } from './config/xdg.mjs';
+
+const CAPABILITY_CACHE_PATH = join(doctorRoot(), 'provider-capabilities.json');
 const CAPABILITY_CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24h
 
 const ADAPTERS = {
@@ -110,7 +111,7 @@ function readCapabilityCache() {
 
 function writeCapabilityCache(capabilities) {
   try {
-    mkdirSync(join(homedir(), '.cx'), { recursive: true });
+    mkdirSync(doctorRoot(), { recursive: true });
     writeFileSync(CAPABILITY_CACHE_PATH, JSON.stringify({
       fetchedAt: Date.now(),
       capabilities,

package/lib/providers/auth-manager.mjs

@@ -11,10 +11,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { homedir } from 'node:os';
+import { configDir } from '../config/xdg.mjs';
 
 function authDir() {
   const home = process.env.HOME || homedir();
-  const dir = path.join(home, '.construct', 'auth');
+  const dir = path.join(configDir(home), 'auth');
   try { fs.mkdirSync(dir, { recursive: true, mode: 0o700 }); } catch { /* ignore */ }
   return dir;
 }

package/lib/providers/copilot-auth.mjs

@@ -11,7 +11,7 @@
  * its token is rejected by the exchange endpoint.
  *
  * Credentials persist to two places: Construct's own store
- * (~/.construct/auth/github-copilot.json) and the de-facto standard
+ * (github-copilot.json under the XDG config dir auth/) and the de-facto standard
  * ~/.config/github-copilot/apps.json that other tools read and write, so a login
  * here is reusable elsewhere and an existing login is reused here. The access
  * token is refreshed from the refresh token when it expires; the session token
@@ -22,6 +22,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { configDir } from '../config/xdg.mjs';
 
 const CLIENT_ID = 'Iv1.b507a08c87ecfe98';
 const DEVICE_CODE_URL = 'https://github.com/login/device/code';
@@ -53,7 +54,7 @@ function homeDir() {
 }
 
 function constructStorePath() {
-  return path.join(homeDir(), '.construct', 'auth', 'github-copilot.json');
+  return path.join(configDir(homeDir()), 'auth', 'github-copilot.json');
 }
 
 function appsStorePath() {

package/lib/providers/creds.mjs

@@ -1,7 +1,7 @@
 /**
  * lib/providers/creds.mjs — credential management for provider integrations.
  *
- * Reads and writes provider credentials stored in `~/.construct/config.env`.
+ * Reads and writes provider credentials stored in the user config.env (XDG config dir).
  * Each provider block is delimited by comment markers so the file can be
  * parsed without a full ini/dotenv library and can also be sourced by a shell.
  *
@@ -24,11 +24,12 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { configDir } from '../config/xdg.mjs';
 
 const CONFIG_FILE = 'config.env';
 
 function constructDir() {
-  return path.join(os.homedir(), '.construct');
+  return configDir();
 }
 
 export function credsFilePath() {

package/lib/providers/registry.mjs

@@ -4,7 +4,7 @@
  * Resolution order (last-write wins):
  *
  *   1. Built-in factories under `lib/providers/<id>/index.mjs` (loaded lazily).
- *   2. Operator overrides at `~/.construct/providers.json`:
+ *   2. Operator overrides at `providers.json` in the XDG config dir:
  *        { "providers": [{ "id": "...", "package": "...", "options": {} }] }
  *   3. Project overrides at `<projectRoot>/.cx/providers.json` (same shape).
  *
@@ -21,11 +21,11 @@
  */
 
 import { readFileSync, existsSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join, isAbsolute, resolve, dirname } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { assertProviderContract } from './contract.mjs';
 import { getBreaker } from './circuit-breaker.mjs';
+import { configDir } from '../config/xdg.mjs';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 
@@ -92,7 +92,7 @@ async function instantiate(mod, options) {
 
 function gatherOverrides(rootDir) {
   const out = [];
-  const userConfig = readJsonIfExists(join(homedir(), '.construct', 'providers.json'));
+  const userConfig = readJsonIfExists(join(configDir(), 'providers.json'));
   if (userConfig?.providers) out.push(...userConfig.providers);
   const projectConfig = readJsonIfExists(join(rootDir, '.cx', 'providers.json'));
   if (projectConfig?.providers) out.push(...projectConfig.providers);

package/lib/providers/secret-resolver.mjs

@@ -3,7 +3,7 @@
  *
  * Resolves a canonical environment variable (for example ANTHROPIC_API_KEY) by
  * walking the same sources the rest of Construct trusts, in priority order:
- * process env, ~/.construct/config.env, ~/.env, the project .env, then shell rc
+ * process env, the XDG config dir config.env, ~/.env, the project .env, then shell rc
  * files (.zshrc/.bashrc/.bash_profile/.profile). When the value carries a
  * 1Password reference — a bare `op://vault/item/field` or the shell form
  * `$(op read 'op://...')` — it is resolved through the `op` CLI and cached for
@@ -22,6 +22,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { discoverAlternateRawForVar } from './credential-sources.mjs';
+import { configDir } from '../config/xdg.mjs';
 
 // The 1Password desktop integration prompts for biometric unlock on the first
 // read after the vault locks, and that interactive round-trip routinely takes
@@ -111,7 +112,7 @@ function readShellRcVar(varName, home) {
 function rawCandidate(varName, { env, cwd, home }) {
   const direct = env?.[varName];
   if (typeof direct === 'string' && direct.length > 0) return direct;
-  const files = [path.join(home, '.construct', 'config.env'), path.join(home, '.env'), path.join(cwd, '.env')];
+  const files = [path.join(configDir(home), 'config.env'), path.join(home, '.env'), path.join(cwd, '.env')];
   for (const file of files) {
     const value = readDotenvVar(file, varName);
     if (value) return value;

package/lib/read-tracker-store.mjs

@@ -9,6 +9,7 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { doctorRoot } from './config/xdg.mjs';
 
 const SESSION_IDLE_RESET_MS = 2 * 60 * 60 * 1000;
 const REPEATED_READ_WARNING_THRESHOLD = 5;
@@ -20,7 +21,7 @@ const EFFICIENCY_LARGE_READ_LIMIT = 400;
 
 export function readTrackerPaths(env = process.env) {
   const home = env.CX_HOME_OVERRIDE || env.HOME || homedir();
-  const cxDir = join(home, '.cx');
+  const cxDir = doctorRoot(home);
   return {
     cxDir,
     efficiencyStore: join(cxDir, 'session-efficiency.json'),

package/lib/reconcile/mcp-entry-reconcile.mjs

@@ -21,7 +21,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { homeDir } from '../paths.mjs';
+import { homeDir, constructDir } from '../paths.mjs';
 import {
   getCodexConfigPath,
   buildCodexMcpEntry,
@@ -34,7 +34,7 @@ function escapeRegExp(value) {
 }
 
 function registryMcpServers() {
-  const installed = path.join(homeDir(), '.construct', 'specialists', 'registry.json');
+  const installed = path.join(constructDir(), 'specialists', 'registry.json');
   const bundled = fileURLToPath(new URL('../../specialists/registry.json', import.meta.url));
   for (const src of [installed, bundled]) {
     try {

package/lib/reflect.mjs

@@ -13,9 +13,10 @@ import { loadConstructEnv } from './env-config.mjs';
 import { KNOWLEDGE_ROOT, KNOWLEDGE_SUBDIRS, inferKnowledgeTarget } from './knowledge/layout.mjs';
 import { extractSessionObservation } from './reflect/extractor.mjs';
 import { readContextState, contextSummaryLine } from './context-state.mjs';
+import { configDir } from './config/xdg.mjs';
 
 const HOME = process.env.HOME || process.env.USERPROFILE;
-const USER_ENV_PATH = join(HOME, '.construct', 'config.env');
+const USER_ENV_PATH = join(configDir(HOME), 'config.env');
 
 /**
  * Main reflect command handler.

package/lib/registry/generate-docs.mjs

@@ -1,7 +1,7 @@
 /**
  * lib/registry/generate-docs.mjs — generate reference docs from registry/capabilities.json.
  *
- * Writes docs/reference/capabilities.md so the human-readable capability matrix
+ * Writes docs/guides/reference/capabilities.md so the human-readable capability matrix
  * cannot drift from the machine-readable registry.
  */
 
@@ -62,7 +62,7 @@ export function generateCapabilitiesDoc({ rootDir = REPO_ROOT, write = true } =
   }
 
   const content = `${lines.join('\n')}\n`;
-  const out = path.join(rootDir, 'docs', 'reference', 'capabilities.md');
+  const out = path.join(rootDir, 'docs', 'guides', 'reference', 'capabilities.md');
   if (!write) return { out, content, drift: fs.existsSync(out) ? fs.readFileSync(out, 'utf8') !== content : true };
   fs.mkdirSync(path.dirname(out), { recursive: true });
   fs.writeFileSync(out, content);

package/lib/roles/approval-surface.mjs

@@ -3,7 +3,7 @@
  *
  * When a persona-tagged session hits an action that lands in the fence's
  * `approvalRequired` bucket (commit, push, out-of-fence edit, etc.), this
- * module appends a marker to ~/.cx/approval-pending.jsonl and emits an SSE
+ * module appends a marker to <doctorRoot>/approval-pending.jsonl and emits an SSE
  * toast through the embed notification bus. The user sees a dashboard toast
  * instead of having to grep stderr.
  *
@@ -12,13 +12,14 @@
  */
 
 import { existsSync, appendFileSync, mkdirSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 
-const PENDING_PATH = join(homedir(), '.cx', 'approval-pending.jsonl');
+import { doctorRoot } from '../config/xdg.mjs';
+
+const PENDING_PATH = join(doctorRoot(), 'approval-pending.jsonl');
 
 function ensureDir() {
-  const dir = join(homedir(), '.cx');
+  const dir = doctorRoot();
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 }
 

package/lib/roles/event-bus.mjs

@@ -14,7 +14,6 @@
 
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync, appendFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { resolveProjectScopedPath } from '../project-root.mjs';
 

package/lib/roles/gateway.mjs

@@ -11,15 +11,19 @@
  */
 
 import { existsSync, readFileSync, appendFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { homedir, tmpdir } from 'node:os';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 import { emit, _paths } from './event-bus.mjs';
 import { route as routeEvent } from './router.mjs';
 import { runBd } from '../beads-client.mjs';
+import { doctorRoot } from '../config/xdg.mjs';
+
+// CONSTRUCT_ROLES_ROOT still wins for the roles event ecosystem's test
+// isolation; the literal fallback follows the global doctor root instead of ~/.cx.
 
 function rootDir() {
-  return process.env.CONSTRUCT_ROLES_ROOT || join(homedir(), '.cx');
+  return process.env.CONSTRUCT_ROLES_ROOT || doctorRoot();
 }
 function pendingPath() {
   return join(rootDir(), 'role-pending.jsonl');

package/lib/rules-delivery.mjs

@@ -10,7 +10,7 @@
  * carry the `construct-` prefix and are swept when their rule stops matching, so
  * user-authored .mdc files are never touched (ADR-0027 ownership contract).
  * Claude/Codex/OpenCode have no per-rule glob mechanism; for them rules remain
- * reference-delivered (cited by path in prose) — see docs/concepts/rules-delivery.md.
+ * reference-delivered (cited by path in prose) — see docs/guides/concepts/rules-delivery.md.
  */
 import fs from 'node:fs';
 import path from 'node:path';

package/lib/runtime-env.mjs

@@ -1,7 +1,7 @@
 /**
  * lib/runtime-env.mjs — Construct runtime environment with credential bootstrap.
  *
- * prepareConstructEnv merges ~/.construct/config.env into the process environment.
+ * prepareConstructEnv merges ~/.config/construct/config.env into the process environment.
  * Credential auto-link from 1Password runs only when autoLink:true (setup-credentials).
  */
 

package/lib/runtime-pressure.mjs

@@ -10,6 +10,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 
+import { stateDir } from './config/xdg.mjs';
+
 const DEFAULTS = Object.freeze({
   enabled: '1',
   intervalSeconds: '300',
@@ -115,7 +117,7 @@ function summarizeTermination(entries) {
 
 function warningStatePath(env = process.env) {
   const homeDir = env.HOME || os.homedir();
-  return path.join(homeDir, '.construct', 'runtime', 'process-pressure-warnings.json');
+  return path.join(stateDir(homeDir), 'runtime', 'process-pressure-warnings.json');
 }
 
 function readWarningState(env = process.env) {
@@ -374,9 +376,9 @@ ${programArgs.map((arg) => `      <string>${plistEscape(arg)}</string>`).join('\
     <key>StartInterval</key>
     <integer>${intervalSeconds}</integer>
     <key>StandardOutPath</key>
-    <string>${plistEscape(path.join(homeDir, '.construct', 'runtime', 'pressure-release.log'))}</string>
+    <string>${plistEscape(path.join(stateDir(homeDir), 'runtime', 'pressure-release.log'))}</string>
     <key>StandardErrorPath</key>
-    <string>${plistEscape(path.join(homeDir, '.construct', 'runtime', 'pressure-release.log'))}</string>
+    <string>${plistEscape(path.join(stateDir(homeDir), 'runtime', 'pressure-release.log'))}</string>
   </dict>
 </plist>
 `;

package/lib/sandbox.mjs

@@ -18,11 +18,12 @@
  * lives under `~/.cx/sandboxes/<id>/` so they survive across CLI sessions.
  */
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 
-const ROOT = path.join(os.homedir(), '.cx', 'sandboxes');
+import { doctorRoot } from './config/xdg.mjs';
+
+const ROOT = path.join(doctorRoot(), 'sandboxes');
 
 function ensureRoot() {
   fs.mkdirSync(ROOT, { recursive: true });

package/lib/scheduler/solo.mjs

@@ -20,6 +20,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 
+import { doctorRoot } from '../config/xdg.mjs';
+
 // ---------------------------------------------------------------------------
 // Cron parsing helpers — minimal support for standard 5-field cron
 // ---------------------------------------------------------------------------
@@ -82,9 +84,9 @@ function writeLaunchdPlist(id, schedule, cwd) {
 ${calendarEntries}
     </dict>
     <key>StandardOutPath</key>
-    <string>${path.join(os.homedir(), '.cx', 'scheduler', 'logs', `${id}.stdout.log`)}</string>
+    <string>${path.join(doctorRoot(), 'scheduler', 'logs', `${id}.stdout.log`)}</string>
     <key>StandardErrorPath</key>
-    <string>${path.join(os.homedir(), '.cx', 'scheduler', 'logs', `${id}.stderr.log`)}</string>
+    <string>${path.join(doctorRoot(), 'scheduler', 'logs', `${id}.stderr.log`)}</string>
     <key>RunAtLoad</key>
     <false/>
 </dict>
@@ -120,8 +122,8 @@ Description=Construct job: ${id}
 Type=oneshot
 WorkingDirectory=${cwd}
 ExecStart=${constructBin} scheduler run ${id}
-StandardOutput=append:${path.join(os.homedir(), '.cx', 'scheduler', 'logs', `${id}.stdout.log`)}
-StandardError=append:${path.join(os.homedir(), '.cx', 'scheduler', 'logs', `${id}.stderr.log`)}
+StandardOutput=append:${path.join(doctorRoot(), 'scheduler', 'logs', `${id}.stdout.log`)}
+StandardError=append:${path.join(doctorRoot(), 'scheduler', 'logs', `${id}.stderr.log`)}
 `;
 
   fs.mkdirSync(unitDir, { recursive: true });

package/lib/server/auth.mjs

@@ -2,7 +2,7 @@
  * lib/server/auth.mjs — Dashboard authentication middleware.
  *
  * Token-based auth for the Construct dashboard. A single shared bearer token
- * is stored at ~/.construct/config.env under CONSTRUCT_DASHBOARD_TOKEN. If no
+ * is stored at config.env in the XDG config dir under CONSTRUCT_DASHBOARD_TOKEN. If no
  * token is configured the dashboard runs open (localhost-only by design). The
  * browser receives a short-lived session cookie on successful token exchange so
  * subsequent requests don't need to re-send the Authorization header.
@@ -16,9 +16,10 @@ import { randomBytes, timingSafeEqual } from 'crypto';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import { configDir } from '../config/xdg.mjs';
 
 const HOME = homedir();
-const CONFIG_ENV = join(HOME, '.construct', 'config.env');
+const CONFIG_ENV = join(configDir(HOME), 'config.env');
 const SESSION_COOKIE = 'cx_session';
 const SESSION_TTL_MS = 8 * 60 * 60 * 1000; // 8 hours
 const SUPPORTED_OAUTH_PROVIDERS = new Set(['github', 'google']);
@@ -46,7 +47,7 @@ export function getDashboardToken() {
 }
 
 export function setDashboardToken(token) {
-  mkdirSync(join(HOME, '.construct'), { recursive: true });
+  mkdirSync(configDir(HOME), { recursive: true });
   const env = existsSync(CONFIG_ENV) ? readFileSync(CONFIG_ENV, 'utf8') : '';
   const lines = env.split('\n').filter(l => !l.startsWith('CONSTRUCT_DASHBOARD_TOKEN='));
   lines.push(`CONSTRUCT_DASHBOARD_TOKEN=${token}`);

package/lib/server/index.mjs

@@ -20,6 +20,7 @@ import { generateArtifact, listArtifacts } from '../embed/artifact.mjs';
 import { ApprovalQueue } from '../embed/approval-queue.mjs';
 import { resolveEmbedStatus } from '../embed/cli.mjs';
 import { loadConstructEnv, prepareConstructEnv } from '../runtime-env.mjs';
+import { configDir, doctorRoot } from '../config/xdg.mjs';
 import {
   isAuthConfigured, isAuthenticated, rejectUnauthorized,
   validateToken, createSession, sessionCookieHeader, clearSessionCookieHeader,
@@ -71,15 +72,15 @@ function assertSafeBind() {
 
 const STATIC_DIR = join(__dirname, 'static');
 const REGISTRY_FILE = join(ROOT_DIR, 'specialists', 'registry.json');
-const FEATURES_FILE = join(HOME, '.construct', 'features.json');
+const FEATURES_FILE = join(configDir(HOME), 'features.json');
 const WORKFLOW_FILE = join(ROOT_DIR, 'plan.md');
 const SKILLS_DIR = join(ROOT_DIR, 'skills');
 const COMMANDS_DIR = join(ROOT_DIR, 'commands');
-const SNAPSHOTS_FILE = join(HOME, '.cx', 'snapshots.jsonl');
-const APPROVAL_QUEUE_FILE = join(HOME, '.cx', 'approval-queue.jsonl');
-const CONFIG_ENV_FILE = join(HOME, '.construct', 'config.env');
-const EMBED_YAML_FILE = join(HOME, '.construct', 'embed.yaml');
-const CREDENTIAL_AUDIT_FILE = join(HOME, '.cx', 'credential-audit.jsonl');
+const SNAPSHOTS_FILE = join(doctorRoot(), 'snapshots.jsonl');
+const APPROVAL_QUEUE_FILE = join(doctorRoot(), 'approval-queue.jsonl');
+const CONFIG_ENV_FILE = join(configDir(HOME), 'config.env');
+const EMBED_YAML_FILE = join(configDir(HOME), 'embed.yaml');
+const CREDENTIAL_AUDIT_FILE = join(doctorRoot(), 'credential-audit.jsonl');
 
 // Provider → expected env vars. Source of truth for the credentials surface,
 // the per-provider health classification ("not configured" vs "unhealthy"),
@@ -97,7 +98,7 @@ const BUILTIN_CREDENTIAL_MAP = [
   { provider: 'salesforce',          label: 'Salesforce',    kind: 'integration', envVars: ['SALESFORCE_INSTANCE_URL', 'SALESFORCE_ACCESS_TOKEN'] },
 ];
 
-const CUSTOM_CREDENTIALS_FILE = join(HOME, '.construct', 'custom-credentials.json');
+const CUSTOM_CREDENTIALS_FILE = join(configDir(HOME), 'custom-credentials.json');
 
 // Env-var name validator: must match POSIX shell variable syntax and avoid
 // stomping built-in entries. Refusing $PATH / $HOME / OS-special prefixes
@@ -182,7 +183,7 @@ function resolveCredential(varName, env) {
     } catch { /* not available */ }
   }
 
-  const paths = [join(homeDir, '.construct', 'config.env'), join(homeDir, '.env')];
+  const paths = [join(configDir(homeDir), 'config.env'), join(homeDir, '.env')];
   for (const p of paths) {
     try {
       if (existsSync(p)) {
@@ -588,7 +589,7 @@ function handleConfig(req, res) {
         const { type, content } = JSON.parse(body || '{}');
         if (type !== 'env' && type !== 'embed') throw new Error('type must be env or embed');
         if (typeof content !== 'string') throw new Error('content must be a string');
-        mkdirSync(join(HOME, '.construct'), { recursive: true });
+        mkdirSync(configDir(HOME), { recursive: true });
         const target = type === 'env' ? CONFIG_ENV_FILE : EMBED_YAML_FILE;
         writeFileSync(target, content, 'utf8');
         res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -1200,7 +1201,7 @@ const server = createServer(async (req, res) => {
 
   if (url.pathname === '/api/performance/reviews' && req.method === 'GET') {
     try {
-      const dir = join(HOME, '.cx', 'performance-reviews');
+      const dir = join(doctorRoot(), 'performance-reviews');
       if (!existsSync(dir)) {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ reviews: [], total: 0, mockFiltered: 0, generatorImplemented: false }));
@@ -1327,7 +1328,7 @@ const server = createServer(async (req, res) => {
   if (url.pathname === '/api/mode' && req.method === 'GET') {
     try {
       const env = loadConstructEnv();
-      const embedYamlPath = join(HOME, '.construct', 'embed.yaml');
+      const embedYamlPath = join(configDir(HOME), 'embed.yaml');
       const embedStatus = resolveEmbedStatus(env);
       
       // Determine mode based on embed status and configuration
@@ -1374,7 +1375,7 @@ const server = createServer(async (req, res) => {
         parentUrl,
         isEmbedded,
         embedStatus: embedStatus.level,
-        embedConfigExists: existsSync(join(HOME, '.construct', 'embed.yaml')),
+        embedConfigExists: existsSync(join(configDir(HOME), 'embed.yaml')),
         capabilities: {
           modeDetection: true,
           snapshotStatus: true,
@@ -1620,7 +1621,7 @@ const server = createServer(async (req, res) => {
         rootDir: ROOT_DIR,
         guidance: INTAKE_DEPTH_GUIDANCE,
         hardMaxDepth: INTAKE_HARD_MAX_DEPTH,
-        defaults: { projectInbox: '.cx/inbox', docsIntake: 'docs/intake', rootInbox: 'inbox/' },
+        defaults: { rootInbox: 'inbox/' },
         label: rebrand.intakeQueueLabel,
         itemNoun: rebrand.signalNoun,
       }));
@@ -1780,7 +1781,7 @@ const server = createServer(async (req, res) => {
 
   if (url.pathname === '/api/providers/subscriptions' && req.method === 'GET') {
     try {
-      const file = join(HOME, '.construct', 'provider-subscriptions.json');
+      const file = join(configDir(HOME), 'provider-subscriptions.json');
       let data = { subscriptions: [] };
       if (existsSync(file)) {
         try { data = JSON.parse(readFileSync(file, 'utf8')); } catch { /* fall back to empty */ }
@@ -1810,7 +1811,7 @@ const server = createServer(async (req, res) => {
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({
       envPath: CONFIG_ENV_FILE,
-      overridesPath: join(HOME, '.construct', 'providers.json'),
+      overridesPath: join(configDir(HOME), 'providers.json'),
     }));
     return;
   }
@@ -2298,7 +2299,7 @@ const server = createServer(async (req, res) => {
           if (!resolved) throw new Error('op read returned an empty value');
 
           const { writeEnvValues, loadConstructEnv } = await import('../env-config.mjs');
-          mkdirSync(join(HOME, '.construct'), { recursive: true });
+          mkdirSync(configDir(HOME), { recursive: true });
           writeEnvValues(CONFIG_ENV_FILE, { [envVar]: resolved });
           process.env[envVar] = resolved;
           try { chmodSync(CONFIG_ENV_FILE, 0o600); } catch { /* perms best-effort */ }
@@ -2310,7 +2311,7 @@ const server = createServer(async (req, res) => {
           }
 
           try {
-            mkdirSync(join(HOME, '.cx'), { recursive: true });
+            mkdirSync(doctorRoot(), { recursive: true });
             appendFileSync(CREDENTIAL_AUDIT_FILE, JSON.stringify({ ts: new Date().toISOString(), action: 'set', envVar, source: '1password', opRef }) + '\n');
           } catch { /* audit best-effort */ }
 
@@ -2367,9 +2368,6 @@ const server = createServer(async (req, res) => {
           const next = saveIntakeConfig(ROOT_DIR, {
             parentDirs: Array.isArray(data.parentDirs) ? data.parentDirs : undefined,
             maxDepth: data.maxDepth,
-            includeProjectInbox: data.includeProjectInbox,
-            includeDocsIntake: data.includeDocsIntake,
-            includeRootInbox: data.includeRootInbox ?? data.includeArchetypeInbox,
           });
           res.writeHead(200, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({ success: true, config: next }));
@@ -2406,7 +2404,7 @@ const server = createServer(async (req, res) => {
           }
         } else if (url.pathname === '/api/providers/registry') {
           const { BUILT_INS } = await import('../providers/registry.mjs');
-          const overridesPath = join(HOME, '.construct', 'providers.json');
+          const overridesPath = join(configDir(HOME), 'providers.json');
           const { action, id, package: pkg, options } = data;
           if (!id || typeof id !== 'string' || !/^[\w-]+$/.test(id)) throw new Error('Invalid provider id');
           if (BUILT_INS.includes(id)) throw new Error(`cannot override built-in provider '${id}'`);
@@ -2432,7 +2430,7 @@ const server = createServer(async (req, res) => {
             throw new Error('action must be save or delete');
           }
 
-          mkdirSync(join(HOME, '.construct'), { recursive: true });
+          mkdirSync(configDir(HOME), { recursive: true });
           const tmp = overridesPath + '.tmp';
           writeFileSync(tmp, JSON.stringify(current, null, 2) + '\n');
           renameSync(tmp, overridesPath);
@@ -2460,7 +2458,7 @@ const server = createServer(async (req, res) => {
           if (value !== '' && typeof value !== 'string') throw new Error('value must be a string');
 
           const { writeEnvValues, parseEnvFile, loadConstructEnv } = await import('../env-config.mjs');
-          mkdirSync(join(HOME, '.construct'), { recursive: true });
+          mkdirSync(configDir(HOME), { recursive: true });
           const action = value === '' ? 'unset' : 'set';
 
           if (action === 'unset') {
@@ -2480,7 +2478,7 @@ const server = createServer(async (req, res) => {
           }
 
           try {
-            mkdirSync(join(HOME, '.cx'), { recursive: true });
+            mkdirSync(doctorRoot(), { recursive: true });
             appendFileSync(CREDENTIAL_AUDIT_FILE, JSON.stringify({ ts: new Date().toISOString(), action, envVar }) + '\n');
           } catch { /* audit append best-effort */ }
 
@@ -2488,7 +2486,7 @@ const server = createServer(async (req, res) => {
           res.end(JSON.stringify({ success: true }));
           notifyClients();
         } else if (url.pathname === '/api/providers/subscriptions') {
-          const subsPath = join(HOME, '.construct', 'provider-subscriptions.json');
+          const subsPath = join(configDir(HOME), 'provider-subscriptions.json');
           const { action, id, provider, name, config } = data;
           if (!id || typeof id !== 'string' || !/^[\w.-]+$/.test(id)) throw new Error('Invalid subscription id');
 
@@ -2509,7 +2507,7 @@ const server = createServer(async (req, res) => {
             throw new Error('action must be save or delete');
           }
 
-          mkdirSync(join(HOME, '.construct'), { recursive: true });
+          mkdirSync(configDir(HOME), { recursive: true });
           const tmp = subsPath + '.tmp';
           writeFileSync(tmp, JSON.stringify(current, null, 2) + '\n');
           renameSync(tmp, subsPath);