@geraldmaron/construct 1.0.3 → 1.0.4

package/agents/prompts/cx-security.md

@@ -36,55 +36,17 @@ Check in this order:
 
 Provide: severity, location (file:line), description, trigger condition, and concrete fix. For CVE checks, delegate to cx-researcher. Hand all findings to cx-engineer — CRITICAL findings block shipping until fixed.
 
-## Tool Contracts
-
-### scan_secrets
-- **Input:** `{ files: string[], content?: string[], diff?: string }`
-- **Output:** `{ findings: SecretFinding[], falsePositives: string[], scanDuration: number }`
-- **Errors:** FILE_NOT_FOUND, SCAN_TIMEOUT, RATE_LIMITED
-- **Rate:** 20/min
-
-### audit_auth
-- **Input:** `{ authFlow: AuthFlow, trustBoundaries: string[], jwtValidation: boolean }`
-- **Output:** `{ vulnerabilities: AuthVulnerability[], bypassPaths: string[], severity: Severity }`
-- **Errors:** INCOMPLETE_FLOW, MISSING_VALIDATION
-- **Rate:** 10/min
-
-### check_injection
-- **Input:** `{ sinks: string[], sources: string[], sanitizers?: string[] }`
-- **Output:** `{ injectionPoints: InjectionPoint[], severity: Severity, fix: string }`
-- **Errors:** UNREACHABLE_SINK, FALSE_POSITIVE
-- **Rate:** 15/min
-
-### assess_dependencies
-- **Input:** `{ dependencies: Dependency[], ecosystem: string, severityThreshold: string }`
-- **Output:** `{ cves: CVE[], upgrades: UpgradeRecommendation[], sbom: SBOM }`
-- **Errors:** UNKNOWN_PACKAGE, RATE_LIMITED
-- **Rate:** 5/min
-
-## Parallel Execution
-
-When auditing code or reviewing changes, these checks run in parallel:
-
-- **Secrets scan** (always runs — fast, non-blocking)
-- **Auth/authorization audit** (if auth logic, JWT, sessions touched)
-- **Injection path analysis** (if user input reaches sinks)
-- **Data exposure check** (if logging, errors, APIs return data)
-- **Dependency CVE scan** (if package.json or lock files changed)
-
-All checks are independent — run concurrently and aggregate findings.
-
-### Execution Pattern
-```javascript
-// Parallel security checks
-const [secrets, auth, injection, exposure, deps] = await Promise.all([
-  scan_secrets({ files }),
-  audit_auth({ authFlow }),
-  check_injection({ sinks, sources }),
-  assess_data_exposure({ logs, errors }),
-  assess_dependencies({ dependencies })
-]);
-```
+## Parallel audit discipline
+
+Run these checks concurrently — they are independent and can be grep-driven in parallel:
+
+- **Secrets scan** (always — fast, covers all files in scope)
+- **Auth/authorization audit** (if auth logic, JWT, sessions, or privilege paths touched)
+- **Injection path analysis** (if user input reaches sinks — exec, eval, query, template)
+- **Data exposure check** (if logging, error responses, or APIs return data)
+- **Dependency CVE scan** (if package.json or lock files changed — delegate to cx-researcher for CVE lookups)
+
+Aggregate findings by severity before reporting. Do not report each category separately.
 
 ## Learning Capture
 

package/agents/prompts/cx-sre.md

@@ -25,49 +25,15 @@ RUNBOOK for each alert:
 
 Review code changes for: missing error handling on request paths, N+1 queries, unbounded operations, missing timeouts, operations that don't degrade gracefully.
 
-## Tool Contracts
-
-### define_slo
-- **Input:** `{ service: string, metric: string, measurementMethod: string, target: number }`
-- **Output:** `{ slo: SLO, errorBudget: number, alertThreshold: number, dashboard: DashboardConfig }`
-- **Errors:** INVALID_METRIC, UNMEASURABLE_TARGET
-- **Rate:** 10/min
-
-### create_runbook
-- **Input:** `{ alertName: string, triggerCondition: string, triageSteps: Step[] }`
-- **Output:** `{ runbook: Runbook, escalationPath: string[], rollbackProcedure: Rollback }`
-- **Errors:** MISSING_TRIGGER, INCOMPLETE_TRIAGE
-- **Rate:** 10/min
-
-### review_reliability
-- **Input:** `{ codeChanges: Diff[], statefulOps: boolean, degradationPlan?: string }`
-- **Output:** `{ findings: ReliabilityFinding[], missingAlerts: string[], rollbackGaps: string[] }`
-- **Errors:** MISSING_DEGRADATION_PLAN, UNBOUNDED_OPERATION
-- **Rate:** 15/min
-
-## Parallel Execution
-
-When reviewing changes for production readiness, these checks run in parallel:
-
-- **SLO definition check** (if new service or changed behavior)
-- **Alerting coverage** (if error paths or failure modes exist)
-- **Rollback procedure** (if stateful or irreversible operation)
-- **Error handling audit** (if request paths or external calls)
-- **Resource limits** (if N+1 queries, unbounded operations, missing timeouts)
-
-All checks are independent — run concurrently and aggregate findings.
-
-### Execution Pattern
-```javascript
-// Parallel SRE checks
-const [slo, alerts, rollback, errors, resources] = await Promise.all([
-  define_slo({ service, metric, target }),
-  check_alerting_coverage({ failureModes }),
-  verify_rollback({ statefulOps }),
-  audit_error_handling({ requestPaths }),
-  check_resource_limits({ queries, operations })
-]);
-```
+## Production readiness checklist
+
+For each change review, check these independently and aggregate before reporting:
+
+- **SLO definition** — is there a measurable target with an error budget for this service or behavior?
+- **Alerting coverage** — is every meaningful failure mode covered by an alert with a runbook?
+- **Rollback procedure** — is there a tested, documented path back from this change?
+- **Error handling** — do request paths and external calls fail gracefully and within timeouts?
+- **Resource bounds** — are there N+1 queries, unbounded loops, or missing timeouts?
 
 ## Learning Capture
 

package/agents/prompts/cx-ux-researcher.md

@@ -14,6 +14,7 @@ You have watched enough users fail to know that what they say they want and what
 **Failure mode warning**: If your brief has no friction points, you haven't talked to users. Every product has places where users get stuck.
 
 **Role guidance**: call `get_skill("roles/researcher.ux")` before drafting.
+**Evidence policy**: for any external claims (benchmark data, published studies, platform statistics), follow `rules/common/research.md` — most-recent-first, primary sources, verified URLs. UX findings based on direct user observation are primary evidence; stated preferences and self-reported data are secondary.
 
 Produce a UX brief:
 

package/agents/role-manifests.json

@@ -125,7 +125,7 @@
       "events": ["handoff.received", "backlog.stale", "prd.requested"],
       "severityImmediate": [],
       "fence": {
-        "allowedPaths": ["docs/prd/**", "docs/meta-prd/**", "docs/prfaq/**", "docs/one-pager/**", ".cx/product-intel/**"],
+        "allowedPaths": ["docs/prd/**", "docs/meta-prd/**", "docs/prfaq/**", "docs/one-pager/**", ".cx/knowledge/**"],
         "allowedBdLabels": ["product", "prd", "backlog", "feature"],
         "allowedCommands": ["bd create", "bd note", "bd update", "bd label", "bd priority"],
         "approvalRequired": ["commit", "push", "edit:lib/**", "edit:bin/**"]
@@ -192,7 +192,7 @@
     "trace-reviewer": { "events": ["handoff.received", "trace.anomaly"], "severityImmediate": [], "fence": { "allowedPaths": ["docs/traces/**", ".cx/traces/**"], "allowedBdLabels": ["trace", "observability"], "allowedCommands": ["bd create", "bd note", "bd update"], "approvalRequired": ["commit", "push", "edit:**"] }, "outputs": { "bdLabels": ["trace"], "docTypes": ["memo"] }, "handoffCandidates": ["sre", "ai-engineer", "engineer"], "killSwitchEnv": "CONSTRUCT_ROLE_TRACE_REVIEWER" },
     "test-automation": { "events": ["handoff.received"], "severityImmediate": [], "fence": { "allowedPaths": ["tests/**", "docs/test-automation/**"], "allowedBdLabels": ["test-automation", "ci", "test-infra"], "allowedCommands": ["bd create", "bd note", "bd update"], "approvalRequired": ["commit", "push", "edit:lib/**", "edit:bin/**"] }, "outputs": { "bdLabels": ["test-automation"], "docTypes": ["memo"] }, "handoffCandidates": ["qa", "engineer", "platform-engineer"], "killSwitchEnv": "CONSTRUCT_ROLE_TEST_AUTOMATION" },
     "ai-engineer": { "events": ["handoff.received"], "severityImmediate": [], "fence": { "allowedPaths": ["docs/ai/**", "docs/agents/**", "agents/**", "skills/ai/**"], "allowedBdLabels": ["ai", "agent", "model"], "allowedCommands": ["bd create", "bd note", "bd update"], "approvalRequired": ["commit", "push", "edit:lib/**", "edit:bin/**"] }, "outputs": { "bdLabels": ["ai"], "docTypes": ["memo"] }, "handoffCandidates": ["engineer", "architect", "evaluator"], "killSwitchEnv": "CONSTRUCT_ROLE_AI_ENGINEER" },
-    "business-strategist": { "events": ["handoff.received"], "severityImmediate": [], "fence": { "allowedPaths": ["docs/strategy/**", ".cx/strategy/**"], "allowedBdLabels": ["strategy", "business"], "allowedCommands": ["bd create", "bd note", "bd update"], "approvalRequired": ["commit", "push", "edit:**"] }, "outputs": { "bdLabels": ["strategy"], "docTypes": ["memo"] }, "handoffCandidates": ["product-manager", "researcher"], "killSwitchEnv": "CONSTRUCT_ROLE_BUSINESS_STRATEGIST" },
+    "business-strategist": { "events": ["handoff.received"], "severityImmediate": [], "fence": { "allowedPaths": ["docs/strategy/**", ".cx/knowledge/decisions/strategy/**"], "allowedBdLabels": ["strategy", "business"], "allowedCommands": ["bd create", "bd note", "bd update"], "approvalRequired": ["commit", "push", "edit:**"] }, "outputs": { "bdLabels": ["strategy"], "docTypes": ["memo", "strategy"] }, "handoffCandidates": ["product-manager", "researcher"], "killSwitchEnv": "CONSTRUCT_ROLE_BUSINESS_STRATEGIST" },
     "researcher": {
       "events": ["handoff.received", "research.requested", "evidence.requested"],
       "severityImmediate": [],
@@ -209,9 +209,9 @@
     "ux-researcher": { "events": ["handoff.received"], "severityImmediate": [], "fence": { "allowedPaths": ["docs/ux-research/**", ".cx/ux-research/**"], "allowedBdLabels": ["ux-research", "user-research"], "allowedCommands": ["bd create", "bd note", "bd update"], "approvalRequired": ["commit", "push", "edit:**"] }, "outputs": { "bdLabels": ["ux-research"], "docTypes": ["memo"] }, "handoffCandidates": ["product-manager", "designer", "researcher"], "killSwitchEnv": "CONSTRUCT_ROLE_UX_RESEARCHER" },
     "explorer": { "events": ["handoff.received"], "severityImmediate": [], "fence": { "allowedPaths": ["docs/explorations/**", ".cx/explorations/**"], "allowedBdLabels": ["exploration", "spike"], "allowedCommands": ["bd create", "bd note", "bd update"], "approvalRequired": ["commit", "push", "edit:**"] }, "outputs": { "bdLabels": ["exploration"], "docTypes": ["memo"] }, "handoffCandidates": ["engineer", "architect", "researcher"], "killSwitchEnv": "CONSTRUCT_ROLE_EXPLORER" },
     "operations": { "events": ["handoff.received"], "severityImmediate": [], "fence": { "allowedPaths": ["docs/ops/**", "docs/operations/**"], "allowedBdLabels": ["ops", "operations"], "allowedCommands": ["bd create", "bd note", "bd update"], "approvalRequired": ["commit", "push", "edit:**"] }, "outputs": { "bdLabels": ["ops"], "docTypes": ["memo", "runbook"] }, "handoffCandidates": ["sre", "platform-engineer", "release-manager"], "killSwitchEnv": "CONSTRUCT_ROLE_OPERATIONS" },
-    "orchestrator": { "events": ["handoff.received"], "severityImmediate": [], "fence": { "allowedPaths": ["docs/orchestration/**", "docs/workflows/**"], "allowedBdLabels": ["orchestration", "workflow"], "allowedCommands": ["bd create", "bd note", "bd update"], "approvalRequired": ["commit", "push", "edit:**"] }, "outputs": { "bdLabels": ["orchestration"], "docTypes": ["memo"] }, "handoffCandidates": ["product-manager", "architect", "engineer"], "killSwitchEnv": "CONSTRUCT_ROLE_ORCHESTRATOR" },
+    "orchestrator": { "events": ["handoff.received"], "severityImmediate": [], "fence": { "allowedPaths": ["docs/**", "plan.md", ".cx/context.md"], "allowedBdLabels": ["orchestration", "workflow", "dispatch"], "allowedCommands": ["bd create", "bd note", "bd update", "bd label", "bd link"], "approvalRequired": ["commit", "push", "edit:lib/**", "edit:bin/**", "edit:agents/**"] }, "outputs": { "bdLabels": ["orchestration", "dispatch"], "docTypes": ["memo"] }, "handoffCandidates": ["product-manager", "architect", "engineer", "security", "qa", "sre"], "killSwitchEnv": "CONSTRUCT_ROLE_ORCHESTRATOR" },
     "rd-lead": { "events": ["handoff.received"], "severityImmediate": [], "fence": { "allowedPaths": ["docs/research/**", "docs/experiments/**", ".cx/experiments/**"], "allowedBdLabels": ["rd", "research", "experiment"], "allowedCommands": ["bd create", "bd note", "bd update"], "approvalRequired": ["commit", "push", "edit:**"] }, "outputs": { "bdLabels": ["rd"], "docTypes": ["memo", "research-brief"] }, "handoffCandidates": ["researcher", "architect", "ai-engineer"], "killSwitchEnv": "CONSTRUCT_ROLE_RD_LEAD" },
-    "legal-compliance": { "events": ["handoff.received"], "severityImmediate": [], "fence": { "allowedPaths": ["docs/legal/**", "docs/compliance/**"], "allowedBdLabels": ["legal", "compliance", "privacy"], "allowedCommands": ["bd create", "bd note", "bd update"], "approvalRequired": ["commit", "push", "edit:**"] }, "outputs": { "bdLabels": ["legal", "compliance"], "docTypes": ["memo"] }, "handoffCandidates": ["security", "product-manager"], "killSwitchEnv": "CONSTRUCT_ROLE_LEGAL_COMPLIANCE" },
+    "legal-compliance": { "events": ["handoff.received"], "severityImmediate": [], "fence": { "allowedPaths": ["docs/legal/**", "docs/compliance/**", "docs/security/**", ".cx/knowledge/**"], "allowedBdLabels": ["legal", "compliance", "privacy"], "allowedCommands": ["bd create", "bd note", "bd update"], "approvalRequired": ["commit", "push", "edit:**"] }, "outputs": { "bdLabels": ["legal", "compliance"], "docTypes": ["memo"] }, "handoffCandidates": ["security", "product-manager"], "killSwitchEnv": "CONSTRUCT_ROLE_LEGAL_COMPLIANCE" },
     "devil-advocate": { "events": ["handoff.received"], "severityImmediate": [], "fence": { "allowedPaths": ["docs/critiques/**"], "allowedBdLabels": ["critique", "devil-advocate"], "allowedCommands": ["bd create", "bd note", "bd update"], "approvalRequired": ["commit", "push", "edit:**"] }, "outputs": { "bdLabels": ["critique"], "docTypes": ["memo"] }, "handoffCandidates": ["architect", "product-manager", "engineer"], "killSwitchEnv": "CONSTRUCT_ROLE_DEVIL_ADVOCATE" }
   }
 }

package/bin/construct

@@ -421,6 +421,22 @@ async function cmdDoctor() {
   add('Claude Code agents dir', fs.existsSync(path.join(HOME, '.claude', 'agents')), true);
   add('Codex agents dir', fs.existsSync(path.join(HOME, '.codex', 'agents')), true);
   add('Copilot prompts dir', fs.existsSync(path.join(HOME, '.github', 'prompts')), true);
+  add('Cursor MCP config', fs.existsSync(path.join(HOME, '.cursor', 'mcp.json')), true);
+  const vscodeSettingsPaths = process.platform === 'darwin'
+    ? [
+        path.join(HOME, 'Library', 'Application Support', 'Code', 'User', 'settings.json'),
+        path.join(HOME, 'Library', 'Application Support', 'Code - Insiders', 'User', 'settings.json'),
+      ]
+    : process.platform === 'linux'
+      ? [
+          path.join(HOME, '.config', 'Code', 'User', 'settings.json'),
+          path.join(HOME, '.config', 'Code - Insiders', 'User', 'settings.json'),
+        ]
+      : [
+          path.join(process.env.APPDATA ?? path.join(HOME, 'AppData', 'Roaming'), 'Code', 'User', 'settings.json'),
+          path.join(process.env.APPDATA ?? path.join(HOME, 'AppData', 'Roaming'), 'Code - Insiders', 'User', 'settings.json'),
+        ];
+  add('VS Code settings file', vscodeSettingsPaths.some((candidate) => fs.existsSync(candidate)), true);
   add('User config ready', fs.existsSync(getUserEnvPath(HOME)) || fs.existsSync(path.join(HOME, '.construct')), true);
   add('skills/ directory', fs.existsSync(path.join(ROOT_DIR, 'skills')));
   add('rules/common/', fs.existsSync(path.join(ROOT_DIR, 'rules', 'common')));
@@ -3834,6 +3850,13 @@ if (command === '--help' || command === '-h' || command === 'help') {
   process.exit(0);
 }
 
+// Version flags → print version and exit
+if (command === '--version' || command === '-V') {
+  const pkg = JSON.parse(fs.readFileSync(path.join(ROOT_DIR, 'package.json'), 'utf8'));
+  println(`construct v${pkg.version}`);
+  process.exit(0);
+}
+
 const handler = handlers.get(command);
 if (!handler) {
   errorln(`Unknown command: ${command}`);

package/db/schema/004_recommendations.sql

@@ -0,0 +1,46 @@
+-- 004_recommendations.sql — Recommendations table for team and enterprise mode.
+-- Solo mode uses the JSONL store under .cx/intake/ instead.
+--
+-- Dedup key is enforced at the (project, dedup_key) level — matches the in-memory
+-- dedup contract in lib/embed/recommendation-store.mjs.
+-- Active recommendations: dismissed_at IS NULL AND superseded_at IS NULL.
+
+create table if not exists construct_recommendations (
+  id text primary key,
+  project text not null,
+  dedup_key text not null,
+  type text not null,
+  title text not null,
+  reason text,
+  lane text,
+  signal_count int not null default 1,
+  total_signal_count int not null default 1,
+  customer_impact int not null default 0,
+  recency_bonus int not null default 0,
+  strategic_bonus int not null default 0,
+  score float not null default 0,
+  priority text not null default 'P3',
+  source_signal_ids jsonb not null default '[]'::jsonb,
+  first_seen timestamptz not null default now(),
+  last_seen timestamptz not null default now(),
+  dismissed_at timestamptz,
+  dismiss_reason text,
+  superseded_at timestamptz,
+  superseded_by_id text,
+  suppressed_until timestamptz,
+  suppress_reason text,
+  updated_at timestamptz not null default now()
+);
+
+create unique index if not exists construct_recommendations_project_dedup_key_idx
+  on construct_recommendations (project, dedup_key);
+
+create index if not exists construct_recommendations_priority_score_idx
+  on construct_recommendations (project, priority, score desc);
+
+create index if not exists construct_recommendations_last_seen_idx
+  on construct_recommendations (project, last_seen desc);
+
+create index if not exists construct_recommendations_active_idx
+  on construct_recommendations (project, dismissed_at)
+  where dismissed_at is null;

package/db/schema/005_strategy.sql

@@ -0,0 +1,21 @@
+-- 005_strategy.sql — Product strategy store for team and enterprise mode.
+-- Solo mode uses ~/.cx/strategy.md instead.
+--
+-- Each row is an immutable version snapshot. The latest version for a project
+-- is the row with the highest version number (or max updated_at when equal).
+-- Callers insert a new row on each write; old versions are retained for history.
+
+create table if not exists construct_strategy (
+  id bigserial primary key,
+  project text not null,
+  content text not null,
+  version int not null default 1,
+  updated_at timestamptz not null default now(),
+  updated_by text
+);
+
+create unique index if not exists construct_strategy_project_version_idx
+  on construct_strategy (project, version);
+
+create index if not exists construct_strategy_project_updated_at_idx
+  on construct_strategy (project, updated_at desc);

package/lib/auto-docs.mjs

@@ -88,7 +88,7 @@ const DIR_DESCRIPTIONS = {
   commands: 'Command prompt assets',
   codex: 'GitHub Copilot / Codex integration',
   docs: 'Architecture notes, runbooks, and documentation contract',
-  telemetry: 'Telemetry backend for agent observability',
+  telemetry: 'Local trace capture and optional telemetry export',
   lib: 'Core runtime: CLI, hooks, MCP, status, sync, workflow',
   opencode: 'OpenCode integration config',
   personas: 'Persona prompt definitions',
@@ -470,4 +470,3 @@ export function buildFumadocsReference({ rootDir } = {}) {
 
   return { written };
 }
-

package/lib/beads-automation.mjs

@@ -22,6 +22,11 @@ const HANDOFFS_DIR = '.cx/handoffs';
 const CONFIRM_TIMEOUT = 60000; // 60 second timeout for confirmation prompts
 const POSITIVE_INTENT = /^(y|yes|yeah|yep|yup|sure|ok|okay|go|proceed|do it)\b/i;
 
+function beadsConfirmEnabled(env = process.env) {
+  const raw = String(env.CONSTRUCT_BEADS_CONFIRM ?? '').trim().toLowerCase();
+  return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+
 // ---------------------------------------------------------------------------
 // Confirmation Utility
 // ---------------------------------------------------------------------------
@@ -148,14 +153,18 @@ export async function confirmAndCommit({
   }
   console.error('');
 
-  const confirmed = await confirm(
-    'Commit these changes?',
-    { yes, default: 'n' }
-  );
+  if (yes || beadsConfirmEnabled()) {
+    const confirmed = await confirm(
+      'Commit these changes?',
+      { yes, default: 'n' }
+    );
 
-  if (!confirmed) {
-    console.error('[beads] Commit cancelled');
-    return null;
+    if (!confirmed) {
+      console.error('[beads] Commit cancelled');
+      return null;
+    }
+  } else {
+    console.error('[beads] CONSTRUCT_BEADS_CONFIRM is off — committing without interactive prompt.');
   }
 
   runGit(['commit', '-m', message], { cwd });

package/lib/cli-commands.mjs

@@ -79,7 +79,13 @@ export const CLI_COMMANDS = [
     category: 'Core',
     core: true,
     description: 'Sync agent adapters to AI tools',
-    usage: 'construct sync',
+    usage: 'construct sync [--project] [--dry-run] [--no-docs] [--compress-personas]',
+    options: [
+      { flag: '--project', desc: 'Write project-local Claude adapters into the current repo only' },
+      { flag: '--dry-run', desc: 'Preview adapter changes without writing files' },
+      { flag: '--no-docs', desc: 'Skip AUTO docs regeneration after syncing adapters' },
+      { flag: '--compress-personas', desc: 'Write compressed runtime persona prompts without changing the source prompts' },
+    ],
   },
   {
     name: 'intake',
@@ -475,7 +481,7 @@ export const CLI_COMMANDS = [
     category: 'Advanced',
     core: false,
     description: 'Show version',
-    usage: 'construct version',
+    usage: 'construct version | construct --version',
   },
   {
     name: 'cleanup',

package/lib/embed/conflict-detection.mjs

@@ -11,18 +11,33 @@
  *   2. Contradiction detection — new signal contradicts a documented decision
  *
  * Storage:
- *   ~/.cx/product-intel/artifact-index.json — cached artifact embeddings
+ *   ~/.cx/knowledge/reference/artifact-index.json — cached artifact embeddings
  *   Rebuilt on first use or when artifact file count changes.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
 import { embed, cosineSimilarity, extractTextFromPacket } from './semantic.mjs';
 import { listArtifacts } from './artifact.mjs';
+import { cxDir } from '../paths.mjs';
+import { knowledgeReferenceStore } from '../knowledge/layout.mjs';
 
-const INDEX_DIR = join(homedir(), '.cx', 'product-intel');
-const INDEX_FILE = join(INDEX_DIR, 'artifact-index.json');
+function migrateLegacyIndex(indexFile, legacyFile) {
+  if (existsSync(indexFile) || !existsSync(legacyFile)) return;
+  mkdirSync(join(indexFile, '..'), { recursive: true });
+  try { renameSync(legacyFile, indexFile); } catch { /* compatibility-only */ }
+}
+
+function indexPaths({ migrate = false } = {}) {
+  const indexDir = join(cxDir(), knowledgeReferenceStore());
+  const legacyFile = join(cxDir(), 'product-intel', 'artifact-index.json');
+  const indexFile = join(indexDir, 'artifact-index.json');
+  if (migrate) migrateLegacyIndex(indexFile, legacyFile);
+  return {
+    indexDir,
+    indexFile,
+  };
+}
 
 const OVERLAP_THRESHOLD = 0.6;
 const CONTRADICTION_THRESHOLD = 0.7;
@@ -32,7 +47,8 @@ const STALE_INDEX_HOURS = 24;
  * Ensure index directory exists.
  */
 function ensureDir() {
-  if (!existsSync(INDEX_DIR)) mkdirSync(INDEX_DIR, { recursive: true });
+  const { indexDir } = indexPaths({ migrate: true });
+  if (!existsSync(indexDir)) mkdirSync(indexDir, { recursive: true });
 }
 
 let _artifactIndex = null;
@@ -55,9 +71,10 @@ export async function buildArtifactIndex({ rootDir, forceRebuild = false } = {})
   const cacheHash = cacheKey.length;
 
   // Check if cached index is fresh
-  if (!forceRebuild && existsSync(INDEX_FILE)) {
+  const { indexFile } = indexPaths();
+  if (!forceRebuild && existsSync(indexFile)) {
     try {
-      const cached = JSON.parse(readFileSync(INDEX_FILE, 'utf8'));
+      const cached = JSON.parse(readFileSync(indexFile, 'utf8'));
       if (cached.cacheHash === cacheHash && cached.index?.length === artifacts.length) {
         const age = Date.now() - new Date(cached.builtAt).getTime();
         if (age < STALE_INDEX_HOURS * 60 * 60 * 1000) {
@@ -96,7 +113,7 @@ export async function buildArtifactIndex({ rootDir, forceRebuild = false } = {})
     embedding: a.embedding ? Array.from(a.embedding) : null,
   }));
 
-  writeFileSync(INDEX_FILE, JSON.stringify({
+  writeFileSync(indexFile, JSON.stringify({
     cacheHash,
     builtAt: new Date().toISOString(),
     artifactCount: artifacts.length,

package/lib/embed/customer-profiles.mjs

@@ -1,31 +1,47 @@
 /**
  * lib/embed/customer-profiles.mjs — Global customer profile store.
  *
- * Maintains durable customer/account memory in ~/.cx/product-intel/customer-profiles/.
+ * Maintains durable customer/account memory in ~/.cx/knowledge/internal/customer-profiles/.
  * Profiles are additive — history is preserved unless explicitly deleted.
  * Links signals to customers and detects account-level patterns during intake triage.
  *
  * Storage:
- *   ~/.cx/product-intel/customer-profiles/<customer-id>.md
- *   ~/.cx/product-intel/customer-profiles/index.json — quick lookup by name/email
+ *   ~/.cx/knowledge/internal/customer-profiles/<customer-id>.md
+ *   ~/.cx/knowledge/internal/customer-profiles/index.json — quick lookup by name/email
  *
  * Each profile follows templates/docs/customer-profile.md schema.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, appendFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, appendFileSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { homedir } from 'node:os';
+import { cxDir } from '../paths.mjs';
+import { knowledgeInternalStore } from '../knowledge/layout.mjs';
 
-const PROFILES_DIR = join(homedir(), '.cx', 'product-intel', 'customer-profiles');
-const INDEX_FILE = join(PROFILES_DIR, 'index.json');
+function migrateLegacyDir(modernDir, legacyDir) {
+  if (existsSync(modernDir) || !existsSync(legacyDir)) return;
+  mkdirSync(join(modernDir, '..'), { recursive: true });
+  try { renameSync(legacyDir, modernDir); } catch { /* compatibility-only */ }
+}
+
+function profilePaths({ migrate = false } = {}) {
+  const modernDir = join(cxDir(), knowledgeInternalStore('customer-profiles'));
+  const legacyDir = join(cxDir(), 'product-intel', 'customer-profiles');
+  if (migrate) migrateLegacyDir(modernDir, legacyDir);
+  const profilesDir = existsSync(modernDir) || !existsSync(legacyDir) ? modernDir : legacyDir;
+  return {
+    profilesDir,
+    indexFile: join(profilesDir, 'index.json'),
+  };
+}
 
 /**
  * Ensure profile directory exists.
  */
 function ensureDir() {
-  if (!existsSync(PROFILES_DIR)) {
-    mkdirSync(PROFILES_DIR, { recursive: true });
+  const { profilesDir } = profilePaths({ migrate: true });
+  if (!existsSync(profilesDir)) {
+    mkdirSync(profilesDir, { recursive: true });
   }
 }
 
@@ -34,9 +50,10 @@ function ensureDir() {
  * @returns {{ [key: string]: { id: string, name: string, status: string, updatedAt: string } }}
  */
 function readIndex() {
-  if (!existsSync(INDEX_FILE)) return {};
+  const { indexFile } = profilePaths();
+  if (!existsSync(indexFile)) return {};
   try {
-    return JSON.parse(readFileSync(INDEX_FILE, 'utf8'));
+    return JSON.parse(readFileSync(indexFile, 'utf8'));
   } catch (err) {
     process.stderr.write('[customer-profiles.mjs] readIndex: ' + (err?.message ?? String(err)) + '\n');
     return {};
@@ -48,8 +65,9 @@ function readIndex() {
  * @param {object} index
  */
 function writeIndex(index) {
+  const { indexFile } = profilePaths();
   ensureDir();
-  writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2) + '\n');
+  writeFileSync(indexFile, JSON.stringify(index, null, 2) + '\n');
 }
 
 /**
@@ -95,7 +113,7 @@ export function createCustomerProfile({ name, owner, workspace, status = 'active
   const id = generateCustomerId();
   const slug = slugify(name);
   const filename = `${slug}-${id}.md`;
-  const filePath = join(PROFILES_DIR, filename);
+  const filePath = join(profilePaths().profilesDir, filename);
 
   const date = new Date().toISOString().slice(0, 10);
   const profile = {
@@ -219,12 +237,13 @@ TODO
  */
 export function getCustomerProfile(customerId) {
   ensureDir();
+  const { profilesDir } = profilePaths();
 
   // Try direct lookup by ID in filename
-  const files = readdirSync(PROFILES_DIR).filter(f => f.endsWith('.md'));
+  const files = readdirSync(profilesDir).filter(f => f.endsWith('.md'));
   for (const file of files) {
     if (file.includes(customerId)) {
-      const filePath = join(PROFILES_DIR, file);
+      const filePath = join(profilesDir, file);
       return parseProfileFile(filePath);
     }
   }
@@ -239,6 +258,7 @@ export function getCustomerProfile(customerId) {
  */
 export function searchCustomerProfiles(query) {
   ensureDir();
+  const { profilesDir } = profilePaths();
 
   const index = readIndex();
   const querySlug = slugify(query);
@@ -268,7 +288,7 @@ export function searchCustomerProfiles(query) {
             id: entry.id,
             name: entry.name,
             status: entry.status,
-            path: join(PROFILES_DIR, `${slugify(entry.name)}-${entry.id}.md`),
+            path: join(profilesDir, `${slugify(entry.name)}-${entry.id}.md`),
           });
         }
       }
@@ -328,7 +348,7 @@ export function updateCustomerProfile(customerId, updates) {
     throw new Error(`Customer profile not found: ${customerId}`);
   }
 
-  const filePath = join(PROFILES_DIR, `${slugify(profile.name)}-${customerId}.md`);
+  const filePath = join(profilePaths().profilesDir, `${slugify(profile.name)}-${customerId}.md`);
   let content = readFileSync(filePath, 'utf8');
   const date = new Date().toISOString().slice(0, 10);
 

package/lib/embed/daemon.mjs

@@ -467,15 +467,16 @@ export class EmbedDaemon {
           process.stderr.write(`[embed] Distilled ${itemsWritten} snapshot item(s) into observation store\n`);
         }
 
-        // Regenerate roadmap each tick so .cx/roadmap.md stays current and the
-        // missing-focal-resource gap clears on the next snapshot.
-        try {
-          const roadmap = generateRoadmap({ targetPath: this.#rootDir, snapshot, roles: this.#config?.roles });
-          if (!roadmap.skipped) {
-            process.stderr.write(`[embed] Roadmap refreshed: ${roadmap.itemCount} open item(s) → ${roadmap.path}\n`);
+        // Regenerate roadmap each tick unless disabled by the host config.
+        if (process.env.CONSTRUCT_EMBED_ROADMAP_ENABLED !== '0') {
+          try {
+            const roadmap = generateRoadmap({ targetPath: this.#rootDir, snapshot, roles: this.#config?.roles });
+            if (!roadmap.skipped) {
+              process.stderr.write(`[embed] Roadmap refreshed: ${roadmap.itemCount} open item(s) → ${roadmap.path}\n`);
+            }
+          } catch (err) {
+            process.stderr.write(`[embed] Roadmap refresh failed: ${err.message}\n`);
           }
-        } catch (err) {
-          process.stderr.write(`[embed] Roadmap refresh failed: ${err.message}\n`);
         }
       },
       { runImmediately: true },
@@ -744,6 +745,7 @@ this.#scheduler.register(
       'roadmap',
       60 * 60_000,
       async () => {
+        if (process.env.CONSTRUCT_EMBED_ROADMAP_ENABLED === '0') return;
         if (!this.#lastSnapshot) return; // wait until at least one snapshot exists
         try {
           const result = generateRoadmap({ targetPath: this.#rootDir, snapshot: this.#lastSnapshot, roles: this.#config?.roles });