@geraldmaron/construct 1.0.2 → 1.0.4

package/lib/roles/catalog.mjs

@@ -0,0 +1,133 @@
+/**
+ * lib/roles/catalog.mjs — role listing and display helpers.
+ *
+ * Reads agents/registry.json to produce a list of available roles with
+ * optional department grouping and consolidated-role views. Consumed by the
+ * `roles:list` CLI command.
+ */
+
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REGISTRY_PATH = join(__dirname, '..', '..', 'agents', 'registry.json');
+
+let cached = null;
+
+function loadRegistry() {
+  if (cached) return cached;
+  cached = JSON.parse(readFileSync(REGISTRY_PATH, 'utf8'));
+  return cached;
+}
+
+/**
+ * Return a list of role descriptors.
+ *
+ * @param {object}  opts
+ * @param {boolean} opts.departments   Group by department when true.
+ * @param {boolean} opts.consolidated  Return consolidated 12-role view when true.
+ * @returns {Array<object>}
+ */
+export function listRoles({ departments = false, consolidated = false } = {}) {
+  const registry = loadRegistry();
+
+  if (consolidated) {
+    const c = registry.consolidatedRoles || {};
+    return (c.roles || []).map((r) => ({
+      id: r.id,
+      absorbs: r.absorbs || [],
+      whenToUse: r.whenToUse || '',
+    }));
+  }
+
+  const agents = Array.isArray(registry.agents)
+    ? registry.agents
+    : Object.values(registry.agents || {});
+
+  if (!departments) {
+    return agents.map((a) => ({
+      id: a.name,
+      name: `cx-${a.name}`,
+      description: a.description || '',
+      internal: !!a.internal,
+    }));
+  }
+
+  // Group by department based on subDepartment membership in registry.departments
+  const depts = registry.departments || {};
+  const grouped = {};
+  for (const [deptId, dept] of Object.entries(depts)) {
+    grouped[deptId] = {
+      name: dept.name || deptId,
+      roles: [],
+    };
+  }
+  grouped._ungrouped = { name: 'Other', roles: [] };
+
+  for (const agent of agents) {
+    let placed = false;
+    for (const [deptId, dept] of Object.entries(depts)) {
+      const subs = dept.subDepartments || {};
+      for (const sub of Object.values(subs)) {
+        if ((sub.roles || []).includes(agent.name) || (sub.roles || []).includes(`cx-${agent.name}`)) {
+          grouped[deptId].roles.push({ id: agent.name, name: `cx-${agent.name}`, description: agent.description || '' });
+          placed = true;
+          break;
+        }
+      }
+      if (placed) break;
+    }
+    if (!placed) {
+      grouped._ungrouped.roles.push({ id: agent.name, name: `cx-${agent.name}`, description: agent.description || '' });
+    }
+  }
+
+  return Object.entries(grouped)
+    .filter(([, g]) => g.roles.length > 0)
+    .map(([id, g]) => ({ departmentId: id, departmentName: g.name, roles: g.roles }));
+}
+
+/**
+ * Format the role list as a human-readable string.
+ *
+ * @param {object}  opts  Same options as listRoles.
+ * @returns {string}
+ */
+export function formatRoleList({ departments = false, consolidated = false } = {}) {
+  const roles = listRoles({ departments, consolidated });
+  const lines = [];
+
+  if (consolidated) {
+    lines.push('Consolidated Roles (12-role simplified structure)');
+    lines.push('=================================================');
+    for (const r of roles) {
+      lines.push(`\n${r.id}`);
+      lines.push(`  Absorbs: ${r.absorbs.join(', ')}`);
+      lines.push(`  Use when: ${r.whenToUse}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+  }
+
+  if (departments) {
+    lines.push('Available Roles by Department');
+    lines.push('=============================');
+    for (const group of roles) {
+      lines.push(`\n${group.departmentName}`);
+      for (const role of group.roles) {
+        lines.push(`  ${role.name.padEnd(30)} ${role.description}`);
+      }
+    }
+    lines.push('');
+    return lines.join('\n');
+  }
+
+  lines.push('Available Roles');
+  lines.push('===============');
+  for (const role of roles) {
+    lines.push(`  ${role.name.padEnd(30)} ${role.description}`);
+  }
+  lines.push('');
+  return lines.join('\n');
+}

package/lib/roles/preference.mjs

@@ -0,0 +1,74 @@
+/**
+ * lib/roles/preference.mjs — per-user primary/secondary role preferences.
+ *
+ * Persists role preferences to ~/.construct/config.env under the keys
+ * CONSTRUCT_ROLE_PRIMARY and CONSTRUCT_ROLE_SECONDARY. Consumed by the
+ * `roles:set` CLI command and the orchestration layer.
+ */
+
+import os from 'node:os';
+import path from 'node:path';
+
+import { getUserEnvPath, ensureUserConfigDir, writeEnvValues, parseEnvFile } from '../env-config.mjs';
+
+const ENV_KEYS = {
+  primary: 'CONSTRUCT_ROLE_PRIMARY',
+  secondary: 'CONSTRUCT_ROLE_SECONDARY',
+};
+
+/**
+ * Read the stored role preference for the given slot.
+ *
+ * @param {'primary'|'secondary'} slot
+ * @returns {string|null}  The stored role id, or null if unset.
+ */
+export function getRolePreference(slot) {
+  const envKey = ENV_KEYS[slot];
+  if (!envKey) return null;
+
+  // Env var takes priority (allows per-session override)
+  if (process.env[envKey]) return process.env[envKey];
+
+  const envPath = getUserEnvPath(os.homedir());
+  const stored = parseEnvFile(envPath);
+  return stored[envKey] || null;
+}
+
+/**
+ * Persist a role preference for the given slot.
+ *
+ * @param {'primary'|'secondary'} slot
+ * @param {string} role  Role id (e.g. "cx-engineer" or "engineer").
+ * @returns {{ slot: string, role: string }}
+ */
+export function setRolePreference(slot, role) {
+  const envKey = ENV_KEYS[slot];
+  if (!envKey) throw new Error(`Unknown role slot "${slot}". Use "primary" or "secondary".`);
+
+  // Normalise: accept both "engineer" and "cx-engineer"
+  const normalised = role.startsWith('cx-') ? role : `cx-${role}`;
+
+  ensureUserConfigDir(os.homedir());
+  const envPath = getUserEnvPath(os.homedir());
+  writeEnvValues(envPath, { [envKey]: normalised });
+
+  // Also set in current process so the change is visible immediately
+  process.env[envKey] = normalised;
+
+  return { slot, role: normalised };
+}
+
+/**
+ * Clear a stored role preference.
+ *
+ * @param {'primary'|'secondary'} slot
+ */
+export function clearRolePreference(slot) {
+  const envKey = ENV_KEYS[slot];
+  if (!envKey) return;
+
+  delete process.env[envKey];
+
+  const envPath = getUserEnvPath(os.homedir());
+  writeEnvValues(envPath, { [envKey]: '' });
+}

package/lib/server/index.mjs

@@ -250,6 +250,25 @@ const MIME = {
   '.js': 'text/javascript; charset=utf-8',
   '.css': 'text/css; charset=utf-8',
   '.json': 'application/json',
+  '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.xml': 'application/xml',
+  '.txt': 'text/plain; charset=utf-8',
+  '.manifest': 'text/cache-manifest',
+  '.map': 'application/json',
+  '.eot': 'application/vnd.ms-fontobject',
+  '.otf': 'font/otf',
+  '.mp4': 'video/mp4',
+  '.mp3': 'audio/mpeg',
+  '.pdf': 'application/pdf',
 };
 
 function listCommands() {
@@ -1062,56 +1081,10 @@ const server = createServer(async (req, res) => {
     try {
       const env = loadConstructEnv();
       const instanceId = env.CONSTRUCT_INSTANCE_ID || 'default';
-      
-      // Check if we're running inside another Construct instance
-      const parentConstruct = env.CONSTRUCT_PARENT_INSTANCE || null;
-      const parentUrl = env.CONSTRUCT_PARENT_URL || null;
-      
-      // Determine embedding boundary status
-      const isEmbedded = !!parentConstruct;
-      const boundaryStatus = isEmbedded ? 'embedded' : 'standalone';
-      
-      // Get current embed status
-      const embedStatus = resolveEmbedStatus(env);
-      
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ 
-        boundaryStatus,
-        instanceId,
-        parentConstruct,
-        parentUrl,
-        isEmbedded,
-        embedStatus: embedStatus.level,
-        embedConfigExists: existsSync(join(HOME, '.construct', 'embed.yaml')),
-        // Boundary capabilities that could be exposed to parent
-        capabilities: {
-          modeDetection: true,
-          snapshotStatus: true,
-          approvalQueue: true,
-          configManagement: true
-        }
-      }));
-    } catch (err) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: err.message }));
-    }
-    return;
-  }
-
-  if (url.pathname === '/api/embed/boundary' && req.method === 'GET') {
-    try {
-      const env = loadConstructEnv();
-      const instanceId = env.CONSTRUCT_INSTANCE_ID || 'default';
-      
-      // Check if we're running inside another Construct instance
       const parentConstruct = env.CONSTRUCT_PARENT_INSTANCE || null;
       const parentUrl = env.CONSTRUCT_PARENT_URL || null;
-      
-      // Determine embedding boundary status
       const isEmbedded = !!parentConstruct;
       const boundaryStatus = isEmbedded ? 'embedded' : 'standalone';
-      
-      // Get current embed status
       const embedStatus = resolveEmbedStatus(env);
       
       res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -1123,7 +1096,6 @@ const server = createServer(async (req, res) => {
         isEmbedded,
         embedStatus: embedStatus.level,
         embedConfigExists: existsSync(join(HOME, '.construct', 'embed.yaml')),
-        // Boundary capabilities that could be exposed to parent
         capabilities: {
           modeDetection: true,
           snapshotStatus: true,
@@ -1358,6 +1330,20 @@ const server = createServer(async (req, res) => {
     return;
   }
 
+  if (url.pathname === '/api/intake/list' && req.method === 'GET') {
+    try {
+      const { createIntakeQueue } = await import('../intake/queue.mjs');
+      const queue = createIntakeQueue(ROOT_DIR, process.env);
+      const items = queue.listPending();
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ items, total: items.length }));
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: err.message }));
+    }
+    return;
+  }
+
   if (url.pathname === '/api/providers' && req.method === 'GET') {
     try {
       const probe = url.searchParams.get('probe') === '1';
@@ -1514,6 +1500,82 @@ const server = createServer(async (req, res) => {
     return;
   }
 
+  // ── Recommendations API ────────────────────────────────────────────────────
+  if (url.pathname === '/api/recommendations') {
+    if (req.method === 'GET') {
+      const { listActiveRecommendations, recommendationStats } = await import('../embed/recommendation-store.mjs');
+      const priority = url.searchParams.get('priority') || undefined;
+      const type = url.searchParams.get('type') || undefined;
+      const limit = Number(url.searchParams.get('limit') || 50);
+      const items = listActiveRecommendations({ priority, type, limit });
+      const stats = recommendationStats();
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ items, stats }));
+      return;
+    }
+    if (req.method === 'PATCH' || req.method === 'POST') {
+      const chunks = [];
+      await new Promise((resolve, reject) => { req.on('data', c => chunks.push(c)); req.on('end', resolve); req.on('error', reject); });
+      let body;
+      try { body = JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}'); } catch { body = {}; }
+      const action = body.action || url.searchParams.get('action');
+      const dedupKey = body.dedupKey || url.searchParams.get('dedupKey');
+      if (!action || !dedupKey) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'action and dedupKey are required' }));
+        return;
+      }
+      const { dismissRecommendation, reviveRecommendation } = await import('../embed/recommendation-store.mjs');
+      try {
+        if (action === 'dismiss') {
+          const result = dismissRecommendation(dedupKey, { reason: body.reason, suppressDays: body.suppressDays });
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(result));
+        } else if (action === 'revive') {
+          const result = reviveRecommendation(dedupKey, { signalCount: body.signalCount, sourceSignalIds: body.sourceSignalIds });
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(result));
+        } else {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: `unknown action: ${action}` }));
+        }
+      } catch (err) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err?.message || 'not found' }));
+      }
+      return;
+    }
+  }
+
+  // ── Strategy API ───────────────────────────────────────────────────────────
+  if (url.pathname === '/api/strategy') {
+    if (req.method === 'GET') {
+      const { readAllStrategies } = await import('../strategy-store.mjs');
+      const result = await readAllStrategies(process.env);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ scopes: Object.fromEntries(result) }));
+      return;
+    }
+    if (req.method === 'PUT' || req.method === 'POST') {
+      const chunks = [];
+      await new Promise((resolve, reject) => { req.on('data', c => chunks.push(c)); req.on('end', resolve); req.on('error', reject); });
+      let body;
+      try { body = JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}'); } catch { body = {}; }
+      const content = (body.content || '').trim();
+      const scope = (body.scope || 'product').trim();
+      if (!content) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'content is required' }));
+        return;
+      }
+      const { writeStrategy } = await import('../strategy-store.mjs');
+      await writeStrategy(content, scope, { updatedBy: 'dashboard', env: process.env });
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true }));
+      return;
+    }
+  }
+
   if (url.pathname === '/api/snapshots') {
     handleSnapshots(req, res);
     return;

package/lib/server/insights.mjs

@@ -42,7 +42,7 @@ async function fetchTelemetrySummary(env, { limit = 100 } = {}) {
       });
       clearTimeout(timer);
       if (res.status === 401 || res.status === 403) {
-        return { state: 'misconfigured', message: `Telemetry credentials rejected (HTTP ${res.status}). Run construct setup.` };
+        return { state: 'misconfigured', message: `Telemetry credentials rejected (HTTP ${res.status}). Run construct init.` };
       }
       if (!res.ok) return { state: 'unreachable', message: `Telemetry HTTP ${res.status}` };
       const json = await res.json();

package/lib/server/telemetry-login.mjs

@@ -1,21 +1,15 @@
 /**
- * lib/server/telemetry-login.mjs — magic-link bridge for a local telemetry backend.
+ * lib/server/telemetry-login.mjs — magic-link bridge for a configured telemetry UI.
  *
- * When a self-hosted telemetry backend (e.g. a self-hosted or cloud telemetry backend)
- * is running locally, this bridge turns the "Open Telemetry" link in the
- * dashboard into a one-click sign-in. The server fetches a CSRF token from
- * the backend, then returns an HTML auto-submit form that POSTs the seeded
- * credentials to NextAuth's callback.
- *
- * The seeded creds are NOT secret — they are deterministic local defaults
- * for zero-touch local development. Not used when CONSTRUCT_TELEMETRY_URL
- * points at a remote backend.
+ * CONSTRUCT_TELEMETRY_URL may point at a Langfuse-compatible deployment.
+ * The dashboard link can use this bridge for one-click sign-in by fetching a
+ * CSRF token and returning an HTML auto-submit form for NextAuth's callback.
  */
 
 const HTML_HEADERS = { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store' };
 
 /**
- * Resolve the telemetry backend URL from env with backward compat.
+ * Resolve the configured telemetry UI URL from env.
  */
 function resolveTelemetryUrl(env = process.env) {
   return (
@@ -45,10 +39,10 @@ function escapeHtml(value) {
  */
 export function renderAutoSubmitForm({ csrfToken, callbackUrl, redirectAfter, email, password }) {
   return `<!doctype html>
-<html><head><meta charset="utf-8"><title>Signing in to telemetry backend…</title>
+<html><head><meta charset="utf-8"><title>Signing in to telemetry UI…</title>
 <style>body{font-family:system-ui,sans-serif;display:flex;align-items:center;justify-content:center;height:100vh;margin:0;color:#666;background:#fff}</style>
 </head><body>
-<p>Signing you in to telemetry backend…</p>
+<p>Signing you in to telemetry UI…</p>
 <form id="tf" method="POST" action="${escapeHtml(callbackUrl)}">
 <input type="hidden" name="csrfToken" value="${escapeHtml(csrfToken)}">
 <input type="hidden" name="email" value="${escapeHtml(email)}">
@@ -63,8 +57,8 @@ export function renderAutoSubmitForm({ csrfToken, callbackUrl, redirectAfter, em
 /**
  * HTTP handler: GET /api/services/telemetry/login
  *
- * Returns an HTML page that immediately POSTs credentials to the backend's
- * NextAuth callback. Returns 502 when the backend is unreachable.
+ * Returns an HTML page that immediately POSTs credentials to the configured
+ * NextAuth callback. Returns 502 when the endpoint is unreachable.
  */
 export async function handleTelemetryLogin(req, res, {
   baseUrl,
@@ -76,8 +70,8 @@ export async function handleTelemetryLogin(req, res, {
 
   if (!resolvedBaseUrl) {
     res.writeHead(503, HTML_HEADERS);
-    res.end(`<!doctype html><meta charset="utf-8"><title>Telemetry backend not configured</title>` +
-      `<pre>CONSTRUCT_TELEMETRY_URL is not set. Configure a telemetry backend to use this feature.</pre>`);
+    res.end(`<!doctype html><meta charset="utf-8"><title>Telemetry UI not configured</title>` +
+      `<pre>CONSTRUCT_TELEMETRY_URL is not set. Configure a Langfuse-compatible telemetry UI to use this feature.</pre>`);
     return;
   }
 
@@ -87,9 +81,9 @@ export async function handleTelemetryLogin(req, res, {
     });
     if (!csrfResponse.ok) {
       res.writeHead(502, HTML_HEADERS);
-      res.end(`<!doctype html><meta charset="utf-8"><title>Telemetry backend unreachable</title>` +
-        `<pre>Could not reach telemetry backend at ${escapeHtml(resolvedBaseUrl)}. Status: ${csrfResponse.status}. ` +
-        `Try \`construct up\` first.</pre>`);
+      res.end(`<!doctype html><meta charset="utf-8"><title>Telemetry UI unreachable</title>` +
+        `<pre>Could not reach telemetry UI at ${escapeHtml(resolvedBaseUrl)}. Status: ${csrfResponse.status}. ` +
+        `Check CONSTRUCT_TELEMETRY_URL and the configured service.</pre>`);
       return;
     }
     const { csrfToken } = await csrfResponse.json();
@@ -99,10 +93,8 @@ export async function handleTelemetryLogin(req, res, {
     res.end(renderAutoSubmitForm({ csrfToken, callbackUrl, redirectAfter, email, password }));
   } catch (err) {
     res.writeHead(502, HTML_HEADERS);
-    res.end(`<!doctype html><meta charset="utf-8"><title>Telemetry backend unreachable</title>` +
-      `<pre>Could not reach telemetry backend: ${escapeHtml(err?.message || 'unknown error')}. ` +
-      `Try \`construct up\` first.</pre>`);
+    res.end(`<!doctype html><meta charset="utf-8"><title>Telemetry UI unreachable</title>` +
+      `<pre>Could not reach telemetry UI: ${escapeHtml(err?.message || 'unknown error')}. ` +
+      `Check CONSTRUCT_TELEMETRY_URL and the configured service.</pre>`);
   }
 }
-
-

package/lib/service-manager.mjs

@@ -20,8 +20,8 @@ import {
   pruneStashDir,
   verifyTelemetryKeys,
   isRemoteTelemetry,
-  startManagedServices,
-} from './services/telemetry-backend.mjs';
+} from './services/local-postgres.mjs';
+import { resolveTraceBackend, telemetryProviderLabel } from './telemetry/client.mjs';
 
 const CONSTRUCT_PG_COMPOSE_DIR = 'services/postgres';
 const CONSTRUCT_PG_CONTAINER = 'construct-postgres';
@@ -379,7 +379,7 @@ function startConstructPostgres({ rootDir, homeDir = os.homedir(), spawnSyncFn =
   if (!composeRunner) return { status: 'unavailable', note: 'Docker not available' };
 
   const composeFile = constructPgComposePath(rootDir);
-  if (!fs.existsSync(composeFile)) return { status: 'unavailable', note: 'Postgres compose file not found — run construct setup first' };
+  if (!fs.existsSync(composeFile)) return { status: 'unavailable', note: 'Postgres compose file not found — run construct init first' };
 
   const args = [...composeRunner.argsPrefix, '-p', 'construct-postgres', '-f', composeFile, 'up', '-d'];
   const r = spawnSyncFn(composeRunner.command, args, { stdio: 'pipe', encoding: 'utf8' });
@@ -464,7 +464,7 @@ export async function startServices({
   // On macOS, auto-launch Docker Desktop when the CLI is present but the
   // daemon is down. Polls up to 60s so downstream Postgres startup sees a working
   // compose runner instead of "Docker not available".
-  await tryStartDockerDaemonFn({ env: process.env });
+  await tryStartDockerDaemonFn({ env: { ...process.env, HOME: homeDir }, timeoutMs: 5000 });
 
   writeEnvValues(envPath, {
     DASHBOARD_PORT: String(ports.dashboard),
@@ -475,7 +475,7 @@ export async function startServices({
   // Construct Postgres — start if DATABASE_URL points to managed container
   const liveEnv = loadConstructEnvFn({ rootDir, homeDir });
   const results = [];
-  const pressureReport = runPressureReleaseFn({ env: liveEnv });
+  const pressureReport = runPressureReleaseFn({ env: { ...liveEnv, HOME: homeDir } });
   if (pressureReport?.killed?.length) {
     results.push({
       name: 'Pressure Guard',
@@ -527,31 +527,39 @@ export async function startServices({
     status: dashboard.reused ? 'reused' : 'started',
   });
 
-  // Telemetry backend — delegated to lib/services/telemetry-backend.mjs.
-  // Remote URLs short-circuit inside startManagedServices and return `configured`.
-
   const telemetryUrl = liveEnv.CONSTRUCT_TELEMETRY_URL ?? '';
-  if (telemetryUrl && isRemoteTelemetry(telemetryUrl)) {
+  const traceBackend = resolveTraceBackend(liveEnv);
+  if (traceBackend === 'local') {
+    results.push({
+      name: 'Telemetry',
+      url: path.join(rootDir, '.cx', 'traces'),
+      status: 'configured',
+      note: 'local JSONL traces; remote export not configured',
+    });
+  } else if (traceBackend === 'none') {
+    results.push({
+      name: 'Telemetry',
+      url: path.join(rootDir, '.cx', 'traces'),
+      status: 'configured',
+      note: 'remote export disabled; local JSONL traces preserved',
+    });
+  } else if (traceBackend === 'otel') {
+    const endpoint = liveEnv.CONSTRUCT_OTEL_EXPORTER_OTLP_ENDPOINT || '';
+    results.push({
+      name: 'Telemetry',
+      url: endpoint || undefined,
+      status: endpoint ? 'configured' : 'unavailable',
+      note: endpoint ? `OTLP export (${telemetryProviderLabel(liveEnv)})` : 'CONSTRUCT_OTEL_EXPORTER_OTLP_ENDPOINT not set',
+    });
+  } else if (telemetryUrl && (isRemoteTelemetry(telemetryUrl) || traceBackend === 'langfuse' || traceBackend === 'http')) {
     results.push({
       name: 'Telemetry',
       url: telemetryUrl,
       status: 'configured',
-      note: `remote — ${telemetryUrl}`,
+      note: `${telemetryProviderLabel(liveEnv)} export — ${telemetryUrl}`,
     });
   } else {
-    const composeRunner = detectDockerComposeFn();
-    if (composeRunner) {
-      const svc = await startManagedServices({
-        rootDir,
-        homeDir,
-        env: liveEnv,
-        composeRunner,
-        spawnDetached: spawnDetachedFn,
-      });
-      results.push({ name: 'Telemetry', url: svc.url, status: svc.status, note: svc.note });
-    } else {
-      results.push({ name: 'Telemetry', status: 'unavailable', note: 'Docker not available' });
-    }
+    results.push({ name: 'Telemetry', status: 'unavailable', note: 'remote export requested but endpoint is not configured' });
   }
 
   // Memory (cm)
@@ -563,7 +571,7 @@ export async function startServices({
       results.push({ name: 'Memory (cm)', url: `http://127.0.0.1:${ports.memory}`, status: 'started' });
     }
   } else {
-    results.push({ name: 'Memory (cm)', status: 'unavailable', note: 'cm not installed — run: construct setup or brew install dicklesworthstone/tap/cm' });
+    results.push({ name: 'Memory (cm)', status: 'unavailable', note: 'cm not installed — run: construct init or brew install dicklesworthstone/tap/cm' });
   }
 
   // OpenCode (optional)

package/lib/services/local-postgres.mjs

@@ -0,0 +1,15 @@
+/**
+ * lib/services/local-postgres.mjs — local Postgres helper exports.
+ *
+ * Compatibility wrappers live in telemetry-backend.mjs until downstream imports
+ * move, but new service-management code should use this name.
+ */
+export {
+  POSTGRES_LOCAL_PORT,
+  isRemoteTelemetry,
+  servicesComposePath,
+  pruneStashDir,
+  verifyPostgresHealth,
+  verifyTelemetryKeys,
+  startManagedServices,
+} from './telemetry-backend.mjs';

package/lib/services/telemetry-backend.mjs

@@ -18,7 +18,7 @@ import path from 'node:path';
 import { getUserEnvPath, writeEnvValues } from '../env-config.mjs';
 
 /** Local Postgres port (within Construct's 54329-54339 reserved block). */
-export const POSTGRES_LOCAL_PORT = 54332;
+export const POSTGRES_LOCAL_PORT = 54329;
 
 export function isRemoteTelemetry(url = '') {
   if (!url) return false;
@@ -53,7 +53,7 @@ export async function verifyPostgresHealth({
   maxRetries = 5,
   intervalMs = 2000,
 } = {}) {
-  // We can't use fetch against Postgres (it's not HTTP), so just check pg_isready via docker
+  // Postgres is not HTTP — health is checked via pg_isready in docker instead
   for (let attempt = 0; attempt < maxRetries; attempt++) {
     try {
       const result = spawnSync('docker', [
@@ -175,4 +175,3 @@ export async function startManagedServices({
   };
 }
 
-

package/lib/setup-prompts.mjs

@@ -1,5 +1,5 @@
 /**
- * lib/setup-prompts.mjs — yes/no consent helper for `construct setup`.
+ * lib/setup-prompts.mjs — yes/no consent helper for `construct init`.
  *
  * Centralises the "should we install this service?" decision so Postgres,
  * telemetry, and any future service share the same prompt + consent-caching
@@ -14,7 +14,7 @@
  *   5. interactive        → prompt [Y/n], cache the answer
  *
  * Consent is stored as BOOTSTRAP_<NAME>=yes|no in ~/.construct/config.env
- * so subsequent runs of `construct setup` don't re-prompt for the same
+ * so subsequent runs of `construct init` don't re-prompt for the same
  * services. Pass `force = true` to skip the cache and re-prompt.
  */