@geraldmaron/construct 1.0.6 → 1.0.7

package/lib/mcp/memory-bridge.mjs

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+/**
+ * lib/mcp/memory-bridge.mjs — stdio MCP bridge for cass-memory (cm).
+ *
+ * Editor MCP clients (OpenCode, Claude Code) expect a host to satisfy the MCP
+ * HTTP+SSE handshake — GET with `Accept: text/event-stream`, POST `initialize`,
+ * `notifications/initialized`, `ping`. cass-memory v0.2.x ships an HTTP server
+ * that answers `tools/list`, `tools/call`, `resources/list`, `resources/read`
+ * over POST but rejects the handshake calls (405 on GET, "Unsupported method"
+ * on POST initialize/ping). That single gap surfaces in editors as
+ * "memory SSE error: Non-200 status code (405)" and the memory tools never
+ * register.
+ *
+ * Sits between editor and cm. Speaks the canonical 2026 MCP stdio transport
+ * (newline-delimited JSON-RPC on stdin/stdout, logs on stderr), answers the
+ * handshake natively, and forwards real work (tools/resources) to cm over its
+ * existing HTTP API. Stays up across cm restarts; surfaces backend outages as
+ * JSON-RPC `-32603` errors rather than crashing, so the editor can retry
+ * without losing the channel.
+ *
+ * Env:
+ *   CONSTRUCT_MEMORY_BRIDGE_URL       cm base URL (default http://127.0.0.1:8765/)
+ *   CONSTRUCT_MEMORY_BRIDGE_AUTOSTART set to 1 to spawn `cm serve` if unreachable
+ *   CONSTRUCT_MEMORY_BRIDGE_TIMEOUT_MS   per-request timeout (default 5000)
+ *
+ * Stdout is reserved for protocol frames. All diagnostic output goes to stderr.
+ */
+
+import { createInterface } from 'node:readline';
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const PROTOCOL_VERSION = '2024-11-05';
+const SERVER_NAME = 'construct-memory-bridge';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+function readPackageVersion() {
+  try {
+    const pkgPath = join(__dirname, '..', '..', 'package.json');
+    return JSON.parse(readFileSync(pkgPath, 'utf8')).version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+const SERVER_VERSION = readPackageVersion();
+
+function normalizeBackendUrl(raw) {
+  const value = (raw && String(raw).trim()) || 'http://127.0.0.1:8765/';
+  return value.endsWith('/') ? value : `${value}/`;
+}
+
+const BACKEND_URL = normalizeBackendUrl(process.env.CONSTRUCT_MEMORY_BRIDGE_URL);
+const REQUEST_TIMEOUT_MS = (() => {
+  const raw = Number(process.env.CONSTRUCT_MEMORY_BRIDGE_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : 5000;
+})();
+const AUTOSTART = process.env.CONSTRUCT_MEMORY_BRIDGE_AUTOSTART === '1';
+
+const FORWARDED_METHODS = new Set([
+  'tools/list',
+  'tools/call',
+  'resources/list',
+  'resources/read',
+  'prompts/list',
+  'prompts/get',
+]);
+
+function log(...parts) {
+  process.stderr.write(`[memory-bridge] ${parts.join(' ')}\n`);
+}
+
+function writeFrame(frame) {
+  process.stdout.write(`${JSON.stringify(frame)}\n`);
+}
+
+function jsonRpcResult(id, result) {
+  return { jsonrpc: '2.0', id, result };
+}
+
+function jsonRpcError(id, code, message, data) {
+  const err = { code, message };
+  if (data !== undefined) err.data = data;
+  return { jsonrpc: '2.0', id, error: err };
+}
+
+// cm forwarding uses fetch with an AbortController so a stuck backend never
+// strands the editor. Failed call returns a JSON-RPC -32603 error frame, not a
+// thrown exception, so the bridge process stays available for retries.
+
+async function forwardToBackend(method, params, id) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    const body = { jsonrpc: '2.0', id: id ?? 0, method, params: params ?? {} };
+    const res = await fetch(BACKEND_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+    if (!res.ok) {
+      return jsonRpcError(
+        id,
+        -32603,
+        `memory backend returned HTTP ${res.status} for ${method}`,
+        { backend: BACKEND_URL, status: res.status },
+      );
+    }
+    const text = await res.text();
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      return jsonRpcError(id, -32603, `memory backend returned non-JSON for ${method}`, { backend: BACKEND_URL });
+    }
+    if (parsed && Object.prototype.hasOwnProperty.call(parsed, 'error')) {
+      return { jsonrpc: '2.0', id, error: parsed.error };
+    }
+    return jsonRpcResult(id, parsed && parsed.result !== undefined ? parsed.result : parsed);
+  } catch (err) {
+    const reason = err?.name === 'AbortError' ? 'timeout' : (err?.message || String(err));
+    return jsonRpcError(id, -32603, `memory backend unreachable at ${BACKEND_URL} (${reason})`, { backend: BACKEND_URL });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// Autostart only fires when CONSTRUCT_MEMORY_BRIDGE_AUTOSTART=1. Detached
+// spawn keeps cm alive after the editor disconnects.
+
+let autostartAttempted = false;
+
+function maybeAutostartCm() {
+  if (!AUTOSTART || autostartAttempted) return;
+  autostartAttempted = true;
+  try {
+    const port = (() => {
+      try {
+        const u = new URL(BACKEND_URL);
+        return u.port || '8765';
+      } catch {
+        return '8765';
+      }
+    })();
+    const child = spawn('cm', ['serve', '--port', String(port)], {
+      detached: true,
+      stdio: 'ignore',
+    });
+    child.unref();
+    log(`autostart: spawned cm serve --port ${port}`);
+  } catch (err) {
+    log(`autostart failed: ${err?.message || err}`);
+  }
+}
+
+// Handshake methods resolve natively. cm cannot answer them; forwarding would
+// return the same "Unsupported method" surface that triggered this bug.
+
+function handleInitialize(id) {
+  return jsonRpcResult(id, {
+    protocolVersion: PROTOCOL_VERSION,
+    capabilities: { tools: {}, resources: {} },
+    serverInfo: { name: SERVER_NAME, version: SERVER_VERSION },
+  });
+}
+
+function handlePing(id) {
+  return jsonRpcResult(id, {});
+}
+
+async function handleShutdown(id) {
+  try { process.stderr.write(''); } catch { /* stderr already closed */ }
+  if (id !== undefined && id !== null) writeFrame(jsonRpcResult(id, null));
+  setImmediate(() => process.exit(0));
+}
+
+async function dispatch(message) {
+  if (!message || typeof message !== 'object') return null;
+  if (message.jsonrpc !== '2.0') return null;
+
+  const { id, method, params } = message;
+  const isNotification = id === undefined || id === null;
+
+  if (method === 'notifications/initialized' || method === 'notifications/cancelled') {
+    return null;
+  }
+  if (method === 'initialize') return handleInitialize(id);
+  if (method === 'ping') return handlePing(id);
+  if (method === 'shutdown') return handleShutdown(id);
+
+  if (FORWARDED_METHODS.has(method)) {
+    maybeAutostartCm();
+    return forwardToBackend(method, params, id);
+  }
+
+  if (isNotification) return null;
+  return jsonRpcError(id, -32601, `Method not found: ${method}`);
+}
+
+async function handleLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return;
+  let message;
+  try {
+    message = JSON.parse(trimmed);
+  } catch (err) {
+    writeFrame(jsonRpcError(null, -32700, `Parse error: ${err?.message || err}`));
+    return;
+  }
+  try {
+    const response = await dispatch(message);
+    if (response) writeFrame(response);
+  } catch (err) {
+    if (message && message.id !== undefined && message.id !== null) {
+      writeFrame(jsonRpcError(message.id, -32603, `Internal bridge error: ${err?.message || err}`));
+    } else {
+      log(`unhandled error on notification: ${err?.message || err}`);
+    }
+  }
+}
+
+export function startBridge({ input = process.stdin, output = process.stdout } = {}) {
+  if (output !== process.stdout) {
+    const writer = (frame) => output.write(`${JSON.stringify(frame)}\n`);
+    return runLoop(input, writer);
+  }
+  return runLoop(input, (frame) => process.stdout.write(`${JSON.stringify(frame)}\n`));
+}
+
+function runLoop(input, writer) {
+  const rl = createInterface({ input, crlfDelay: Infinity });
+  rl.on('line', async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let message;
+    try {
+      message = JSON.parse(trimmed);
+    } catch (err) {
+      writer(jsonRpcError(null, -32700, `Parse error: ${err?.message || err}`));
+      return;
+    }
+    try {
+      const response = await dispatch(message);
+      if (response) writer(response);
+    } catch (err) {
+      if (message && message.id !== undefined && message.id !== null) {
+        writer(jsonRpcError(message.id, -32603, `Internal bridge error: ${err?.message || err}`));
+      } else {
+        log(`unhandled error on notification: ${err?.message || err}`);
+      }
+    }
+  });
+  rl.on('close', () => process.exit(0));
+  return rl;
+}
+
+const isMain = (() => {
+  try { return import.meta.url === `file://${process.argv[1]}`; } catch { return false; }
+})();
+
+if (isMain) {
+  log(`starting (backend=${BACKEND_URL}, autostart=${AUTOSTART ? 'on' : 'off'})`);
+  startBridge();
+}
+
+export const _testing = {
+  dispatch,
+  handleLine,
+  BACKEND_URL,
+  SERVER_VERSION,
+};

package/lib/mcp/server.mjs

@@ -40,6 +40,7 @@ import {
 import {
   workflowInit, workflowAddTask, workflowUpdateTask,
   workflowNeedsMainInput, workflowValidate, workflowImportPlan,
+  workflowContractValidate,
 } from './tools/workflow.mjs';
 import {
   cxTrace, cxTraceUpdate, cxScore, sessionUsage, efficiencySnapshot,
@@ -934,6 +935,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     else if (name === 'workflow_update_task') result = workflowUpdateTask(args);
     else if (name === 'workflow_needs_main_input') result = workflowNeedsMainInput(args);
     else if (name === 'workflow_validate') result = workflowValidate(args);
+    else if (name === 'workflow_contract_validate') result = await workflowContractValidate(args);
     else if (name === 'workflow_import_plan') result = workflowImportPlan(args);
     else if (name === 'list_teams') result = listTeams(opts);
     else if (name === 'get_team') result = getTeam(args, opts);

package/lib/mcp/tools/workflow.mjs

@@ -96,6 +96,31 @@ export function workflowValidate(args) {
   return { cwd, ...result };
 }
 
+/**
+ * Validate a producer→consumer handoff against agents/contracts.json.
+ *
+ * Args:
+ *   producer    — agent or persona name producing the artifact
+ *   consumer    — agent or persona name receiving it
+ *   id          — optional contract id (overrides producer/consumer lookup)
+ *   artifact    — the handoff payload to validate
+ *   enforcement — 'warn' (default) or 'block'; 'block' returns ok:false on
+ *                 violation so the workflow can refuse to advance
+ *
+ * Returns { ok, status?, errors?, warnings?, contract } where status is set
+ * to 'BLOCKED_CONTRACT' on enforced violations.
+ */
+export async function workflowContractValidate(args) {
+  const { validateHandoff } = await import('../../contracts/validate.mjs');
+  return validateHandoff({
+    producer: args.producer,
+    consumer: args.consumer,
+    id: args.id,
+    artifact: args.artifact,
+    enforcement: args.enforcement || process.env.CONSTRUCT_CONTRACT_ENFORCEMENT || 'warn',
+  });
+}
+
 export function workflowImportPlan(args) {
   const cwd = args.cwd ? resolve(args.cwd) : process.cwd();
   const markdown = args.markdown ?? '';

package/lib/mcp-catalog.json

@@ -55,21 +55,25 @@
       "id": "memory",
       "name": "Memory",
       "category": "optional",
-      "description": "cass-memory over HTTP. Persistent cross-session and cross-agent memory for decisions, findings, and handoffs.",
-      "type": "url",
-      "url": "http://127.0.0.1:8765/",
-      "env": {},
+      "description": "cass-memory persistent cross-session and cross-agent memory, fronted by the Construct stdio MCP bridge so editors get a full MCP handshake.",
+      "command": "node",
+      "args": [
+        "__CX_TOOLKIT_DIR__/lib/mcp/memory-bridge.mjs"
+      ],
+      "env": {
+        "CONSTRUCT_MEMORY_BRIDGE_URL": "http://127.0.0.1:__MEMORY_PORT__/"
+      },
       "requiredEnv": [],
       "setupModes": [
         "auto",
         "manual"
       ],
       "hostSupport": {
-        "claude": { "mode": "unsupported", "label": "construct-mcp (project .mcp.json)" },
-        "opencode": { "mode": "unsupported", "label": "construct-mcp (stdio)" },
-        "codex": { "mode": "unsupported", "label": "construct-mcp / local observation tools" }
+        "claude": { "mode": "managed" },
+        "opencode": { "mode": "managed" },
+        "codex": { "mode": "managed" }
       },
-      "setupNote": "Claude Code and Codex reject the cass-memory HTTP endpoint because `cm serve` skips the MCP `initialize` handshake. On Claude, memory tools (memory_search, memory_add_observations, memory_recent, memory_create_entities) are exposed through the project-local construct-mcp stdio server in .mcp.json. OpenCode does not support the cass-memory HTTP endpoint (SSE transport fails with 405) — use construct-mcp stdio server instead, which wraps memory tools correctly.",
+      "setupNote": "Memory is wired as a stdio MCP bridge (lib/mcp/memory-bridge.mjs). The bridge answers the MCP handshake locally (initialize, ping, notifications/initialized) and forwards tools/list, tools/call, resources/list, resources/read to cm at CONSTRUCT_MEMORY_BRIDGE_URL. cm itself never sees the handshake calls that v0.2.x cannot answer.",
       "usedBy": [
         "construct",
         "cx-docs-keeper",

package/lib/mcp-platform-config.mjs

@@ -48,13 +48,21 @@ function buildRemoteHeaders(mcpDef, resolvedValues) {
   return stripUnresolvedValues(resolveTemplateObject(mcpDef.headers ?? {}, resolvedValues));
 }
 
+function withMemoryDefaults(id, values) {
+  if (id !== "memory") return values;
+  if (values.MEMORY_PORT) return values;
+  return { ...values, MEMORY_PORT: "8765" };
+}
+
 export function buildClaudeMcpEntry(id, mcpDef, resolvedValues = {}) {
+  const values = withMemoryDefaults(id, { CX_TOOLKIT_DIR: ROOT_DIR, ...resolvedValues });
+
   if (mcpDef.type === "url") {
-    const headers = buildRemoteHeaders(mcpDef, resolvedValues);
+    const headers = buildRemoteHeaders(mcpDef, values);
     const url =
-      id === "memory" && resolvedValues.MEMORY_PORT
-        ? `http://127.0.0.1:${resolvedValues.MEMORY_PORT}/`
-        : resolveTemplateString(mcpDef.url, resolvedValues);
+      id === "memory" && values.MEMORY_PORT
+        ? `http://127.0.0.1:${values.MEMORY_PORT}/`
+        : resolveTemplateString(mcpDef.url, values);
     return {
       type: "http",
       url,
@@ -62,19 +70,19 @@ export function buildClaudeMcpEntry(id, mcpDef, resolvedValues = {}) {
     };
   }
 
-  const env = buildLocalEnvironment(mcpDef, resolvedValues);
+  const env = buildLocalEnvironment(mcpDef, values);
   return {
     command: mcpDef.command,
-    args: resolveArgs(mcpDef.args, resolvedValues),
+    args: resolveArgs(mcpDef.args, values),
     ...(Object.keys(env).length > 0 ? { env } : {}),
   };
 }
 
 export function buildOpenCodeMcpEntry(id, mcpDef, resolvedValues = {}) {
-  const runtimeValues = {
+  const runtimeValues = withMemoryDefaults(id, {
     CX_TOOLKIT_DIR: ROOT_DIR,
     ...resolvedValues,
-  };
+  });
   const openCodeId = getOpenCodeMcpId(id);
 
   if (mcpDef.type === "url") {

package/lib/migrations/index.mjs

@@ -0,0 +1,106 @@
+/**
+ * lib/migrations/index.mjs — Schema migration registry and runner.
+ *
+ * Construct's machine-readable artifacts (agents/registry.json, contracts.json,
+ * role-manifests.json, .cx/config.json, profile JSON) carry an integer
+ * `version` field. When the installed binary's expected schema version is
+ * higher than the on-disk version, migrations apply in order. When the on-disk
+ * version is higher, the runner refuses to load and instructs the operator to
+ * upgrade.
+ *
+ * Each migration is a module under lib/migrations/ that exports:
+ *   - from: integer
+ *   - to: integer
+ *   - apply(artifactPath, options): Promise<{ changed, summary }>
+ *
+ * v1 is the baseline — no migration needed. The registry below is the contract
+ * between the installed binary and migration authors.
+ */
+
+import v1Baseline from './v1-baseline.mjs';
+
+const REGISTRY = [
+  v1Baseline,
+];
+
+export const CURRENT_SCHEMA_VERSION = Math.max(...REGISTRY.map((m) => m.to));
+
+/**
+ * Compute the migration path from `fromVersion` to CURRENT_SCHEMA_VERSION.
+ * Returns an array of migrations to apply in order, or null if no path exists.
+ */
+export function planMigrations(fromVersion, toVersion = CURRENT_SCHEMA_VERSION) {
+  if (fromVersion === toVersion) return [];
+  if (fromVersion > toVersion) return null;
+  const steps = [];
+  let cursor = fromVersion;
+  while (cursor < toVersion) {
+    const step = REGISTRY.find((m) => m.from === cursor);
+    if (!step) return null;
+    steps.push(step);
+    cursor = step.to;
+  }
+  return steps;
+}
+
+/**
+ * Apply a planned migration sequence. Each step receives the artifact path
+ * and any options. Returns a summary including every step's outcome.
+ *
+ * When dryRun is true, steps must not write to disk; they only report what
+ * they would change.
+ */
+export async function runMigrations({ artifactPath, fromVersion, toVersion = CURRENT_SCHEMA_VERSION, dryRun = false }) {
+  const plan = planMigrations(fromVersion, toVersion);
+  if (plan === null) {
+    return {
+      ok: false,
+      error: `no migration path from version ${fromVersion} to ${toVersion}`,
+      applied: [],
+    };
+  }
+  if (plan.length === 0) {
+    return { ok: true, applied: [], summary: 'no migrations needed' };
+  }
+
+  const applied = [];
+  for (const step of plan) {
+    try {
+      const result = await step.apply(artifactPath, { dryRun });
+      applied.push({ from: step.from, to: step.to, ...result });
+    } catch (err) {
+      return {
+        ok: false,
+        error: `migration ${step.from}→${step.to} failed: ${err.message}`,
+        applied,
+      };
+    }
+  }
+  return { ok: true, applied, summary: `applied ${applied.length} migration(s)` };
+}
+
+/**
+ * Check artifact compatibility. Returns:
+ *   { compatible: true }                              — versions match
+ *   { compatible: false, needsMigration: true,  ... } — on-disk is older
+ *   { compatible: false, needsUpgrade: true, ... }   — on-disk is newer
+ */
+export function checkCompatibility(artifactVersion, expected = CURRENT_SCHEMA_VERSION) {
+  if (artifactVersion === expected) return { compatible: true };
+  if (artifactVersion < expected) {
+    return {
+      compatible: false,
+      needsMigration: true,
+      fromVersion: artifactVersion,
+      toVersion: expected,
+      message: `artifact schema version ${artifactVersion} is older than expected ${expected}; run 'construct migrate'`,
+    };
+  }
+  return {
+    compatible: false,
+    needsUpgrade: true,
+    fromVersion: artifactVersion,
+    toVersion: expected,
+    message: `artifact schema version ${artifactVersion} is newer than this binary supports (${expected}); run 'construct upgrade'`,
+  };
+}

package/lib/migrations/v1-baseline.mjs

@@ -0,0 +1,33 @@
+/**
+ * lib/migrations/v1-baseline.mjs — No-op baseline migration.
+ *
+ * Marks v0 (pre-versioned artifacts) as compatible with v1 by stamping the
+ * artifact with `version: 1` when absent. Schema bumps after v1 will add new
+ * migrations rather than modifying this one.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+
+export default {
+  from: 0,
+  to: 1,
+  description: 'Stamp pre-versioned artifacts with version: 1 (no shape changes)',
+  async apply(artifactPath, { dryRun = false } = {}) {
+    if (!existsSync(artifactPath)) {
+      return { changed: false, summary: `${artifactPath}: not present (skip)` };
+    }
+    let data;
+    try { data = JSON.parse(readFileSync(artifactPath, 'utf8')); }
+    catch (err) { throw new Error(`failed to parse ${artifactPath}: ${err.message}`); }
+
+    if (data && typeof data === 'object' && data.version === 1) {
+      return { changed: false, summary: `${artifactPath}: already at v1` };
+    }
+
+    const next = { ...data, version: 1 };
+    if (!dryRun) {
+      writeFileSync(artifactPath, JSON.stringify(next, null, 2) + '\n');
+    }
+    return { changed: true, summary: `${artifactPath}: stamped version: 1` };
+  },
+};

package/lib/observation-store.mjs

@@ -19,6 +19,7 @@ import { embedSync as embedText } from './storage/embeddings-legacy.mjs';
 import { embedText as embedTextEngine } from './storage/embeddings-engine.mjs';
 import { VectorClient } from './storage/vector-client.mjs';
 import { withFileLockSync } from './storage/file-lock.mjs';
+import { ensureCxDir } from './project-init-shared.mjs';
 
 const OBS_DIR = '.cx/observations';
 const INDEX_FILE = 'index.json';
@@ -36,7 +37,10 @@ const VALID_CATEGORIES = new Set([
   'pattern', 'anti-pattern', 'dependency', 'decision', 'insight', 'session-summary',
 ]);
 
-function ensureDir(dir) {
+function ensureDir(dir, rootDir = null) {
+  // Preserves the construct context invariant: any code that creates a .cx/
+  // subdirectory also initializes context.md from the project template.
+  if (rootDir) ensureCxDir(rootDir);
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 }
 
@@ -91,6 +95,7 @@ function logCapDrop(rootDir, kind, dropped, total) {
   if (dropped <= 0) return;
   try {
     const logPath = path.join(rootDir, '.cx', 'observation-cap-warnings.jsonl');
+    ensureCxDir(rootDir);
     fs.mkdirSync(path.dirname(logPath), { recursive: true });
     const entry = JSON.stringify({
       ts: new Date().toISOString(),
@@ -105,7 +110,7 @@ function logCapDrop(rootDir, kind, dropped, total) {
 }
 
 function writeIndex(rootDir, entries) {
-  ensureDir(obsDir(rootDir));
+  ensureDir(obsDir(rootDir), rootDir);
   const trimmed = entries.slice(0, MAX_INDEX);
   if (entries.length > MAX_INDEX) {
     logCapDrop(rootDir, 'observation-index', entries.length - MAX_INDEX, entries.length);
@@ -124,7 +129,7 @@ function readVectors(rootDir) {
 }
 
 function writeVectors(rootDir, records) {
-  ensureDir(obsDir(rootDir));
+  ensureDir(obsDir(rootDir), rootDir);
   if (records.length > MAX_INDEX) {
     logCapDrop(rootDir, 'observation-vectors', records.length - MAX_INDEX, records.length);
   }
@@ -177,7 +182,7 @@ export async function addObservation(rootDir, {
   // Lock the per-store index so concurrent writers (CLI + hooks) cannot
   // corrupt the index/vectors JSON pair. The observation JSON file is
   // unique-per-id and doesn't need the lock; the shared structures do.
-  ensureDir(obsDir(rootDir));
+  ensureDir(obsDir(rootDir), rootDir);
   fs.writeFileSync(
     path.join(obsDir(rootDir), `${id}.json`),
     JSON.stringify(record, null, 2) + '\n',

package/lib/outcomes/record.mjs

@@ -16,6 +16,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { withFileLockSync } from '../storage/file-lock.mjs';
+import { ensureCxDir } from '../project-init-shared.mjs';
 
 const ROTATE_AT = 10_000;
 const MAX_NOTES = 500;
@@ -65,6 +66,7 @@ function countLines(file) {
 export function recordOutcome(cwd, payload) {
   if (!cwd || !payload || typeof payload.success !== 'boolean') return null;
   try {
+    ensureCxDir(cwd);
     fs.mkdirSync(outcomesDir(cwd), { recursive: true });
     const file = activeFile(cwd, payload.role);
 

package/lib/profiles/rebrand.mjs

@@ -0,0 +1,46 @@
+/**
+ * lib/profiles/rebrand.mjs — Profile-aware language helper.
+ *
+ * Each curated profile carries a `rebrand` block: how the active profile
+ * wants the intake queue and individual signal items named in user-facing
+ * surfaces (CLI output, daemon logs, session-start prelude). The helper
+ * centralises that lookup so every consumer goes through one path with
+ * safe defaults instead of hardcoding "intake queue" / "signal" / "intake".
+ *
+ * Defaults match the legacy strings so behaviour is unchanged for the rnd
+ * profile and for any environment where profile resolution fails.
+ */
+
+import { resolveActiveProfile } from './loader.mjs';
+
+export const DEFAULT_REBRAND = Object.freeze({
+  intakeQueueLabel: 'Intake queue',
+  signalNoun: 'signal',
+});
+
+/**
+ * Return the active profile's rebrand labels.
+ *
+ * @param {string} [rootDir] - project root where profile.json / construct.config.json live.
+ * @returns {{ intakeQueueLabel: string, signalNoun: string }}
+ *
+ * Returns defaults when `rootDir` is missing, when the profile cannot be
+ * loaded, or when the profile omits its `rebrand` block. Never throws.
+ */
+export function getRebrand(rootDir) {
+  if (!rootDir || typeof rootDir !== 'string') return { ...DEFAULT_REBRAND };
+  try {
+    const profile = resolveActiveProfile(rootDir);
+    const rb = profile?.rebrand;
+    if (!rb || typeof rb !== 'object') return { ...DEFAULT_REBRAND };
+    const intakeQueueLabel = typeof rb.intakeQueueLabel === 'string' && rb.intakeQueueLabel.trim()
+      ? rb.intakeQueueLabel.trim()
+      : DEFAULT_REBRAND.intakeQueueLabel;
+    const signalNoun = typeof rb.signalNoun === 'string' && rb.signalNoun.trim()
+      ? rb.signalNoun.trim()
+      : DEFAULT_REBRAND.signalNoun;
+    return { intakeQueueLabel, signalNoun };
+  } catch {
+    return { ...DEFAULT_REBRAND };
+  }
+}