@geraldmaron/construct 1.0.23 → 1.1.0

package/lib/strategy-store.mjs

@@ -6,23 +6,19 @@
  * Strategy documents are NEVER auto-updated from ingested documents — they require
  * an explicit writeStrategy() call from a privileged caller.
  *
- * In team/enterprise mode Postgres is the secondary store (best-effort). Each scope
- * is stored as a separate row whose content is prefixed with `scope:{name}\n` so we
- * can store and retrieve scopes without adding a new column to the existing schema.
+ * Construct now uses embedded LanceDB for vectors only; strategy remains
+ * filesystem-primary for simplicity and Git-backed collaboration.
  *
  * getStrategyDigest() / getStrategyDigestSync() return a compact block (≤ 500 tokens)
  * suitable for injection into agent prompts. getStrategyDigestSync() is the file-only
  * synchronous path required where await is not available (e.g. prompt assembly).
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { cxDir } from './paths.mjs';
-import { hasSqlStore } from './storage/sql-store.mjs';
-import { createSqlClient } from './storage/backend.mjs';
 
 const VALID_SCOPES = ['product', 'technical', 'gtm', 'platform'];
-const SCOPE_PREFIX = 'scope:';
 
 // ── Path helpers ──────────────────────────────────────────────────────────────
 
@@ -38,9 +34,6 @@ export function strategyFilePath(scope = 'product', env = process.env) {
 
 /**
  * Return scope names that have corresponding files in the strategy directory.
- *
- * @param {object} [env]
- * @returns {string[]}
  */
 export function listStrategyScopes(env = process.env) {
   const dir = strategyDir(env);
@@ -57,315 +50,71 @@ export function listStrategyScopes(env = process.env) {
 // ── Read helpers ──────────────────────────────────────────────────────────────
 
 /**
- * Read one strategy scope from Postgres (primary) or file (fallback).
- *
- * @param {string} [scope]
- * @param {object} [env]
- * @returns {Promise<{ content: string, version: number, updatedAt: string, source: 'postgres'|'file'|'none', scope: string }>}
+ * Read one strategy scope from file.
  */
 export async function readStrategy(scope = 'product', env = process.env) {
-  if (hasSqlStore(env)) {
-    const client = createSqlClient(env);
-    try {
-      const project = env.CX_PROJECT || 'default';
-      const prefix = `${SCOPE_PREFIX}${scope}\n`;
-
-      // Rows stored with the scope prefix — match on content prefix
-      const rows = await client`
-        select content, version, updated_at
-        from construct_strategy
-        where project = ${project}
-          and content like ${prefix + '%'}
-        order by version desc
-        limit 1
-      `;
-
-      if (rows.length > 0) {
-        const row = rows[0];
-        return {
-          content: row.content.startsWith(prefix) ? row.content.slice(prefix.length) : row.content,
-          version: row.version,
-          updatedAt: row.updated_at instanceof Date ? row.updated_at.toISOString() : String(row.updated_at),
-          source: 'postgres',
-          scope,
-        };
-      }
-    } catch {
-      // Postgres unavailable — fall through to file
-    } finally {
-      if (client) await client.end({ timeout: 5 }).catch(() => {});
-    }
-  }
-
   const filePath = strategyFilePath(scope, env);
-  if (existsSync(filePath)) {
+  if (!existsSync(filePath)) {
+    return { content: '', version: 0, updatedAt: null, source: 'none', scope };
+  }
+  try {
     const content = readFileSync(filePath, 'utf8');
-    return { content, version: 1, updatedAt: new Date().toISOString(), source: 'file', scope };
+    const stat = statSync(filePath);
+    return {
+      content,
+      version: 1,
+      updatedAt: stat.mtime.toISOString(),
+      source: 'file',
+      scope,
+    };
+  } catch {
+    return { content: '', version: 0, updatedAt: null, source: 'none', scope };
   }
-
-  return { content: '', version: 0, updatedAt: new Date().toISOString(), source: 'none', scope };
 }
 
 /**
- * Read all present strategy scopes.
- *
- * When Postgres is available it reads all rows for the project and parses scope
- * from the prefix. Files are used as the fallback or supplement for scopes that
- * have no Postgres row.
- *
- * @param {object} [env]
- * @returns {Promise<Map<string, { content: string, version: number, updatedAt: string, source: string }>>}
+ * Read all strategy scopes into a Map.
  */
 export async function readAllStrategies(env = process.env) {
   const result = new Map();
-
-  if (hasSqlStore(env)) {
-    const client = createSqlClient(env);
-    try {
-      const project = env.CX_PROJECT || 'default';
-
-      // Fetch all rows — latest version per scope
-      const rows = await client`
-        select distinct on (
-          substring(content from 1 for position(E'\n' in content))
-        ) content, version, updated_at
-        from construct_strategy
-        where project = ${project}
-          and content like ${SCOPE_PREFIX + '%'}
-        order by
-          substring(content from 1 for position(E'\n' in content)),
-          version desc
-      `;
-
-      for (const row of rows) {
-        const firstNewline = row.content.indexOf('\n');
-        if (firstNewline === -1) continue;
-        const header = row.content.slice(0, firstNewline);
-        if (!header.startsWith(SCOPE_PREFIX)) continue;
-        const rowScope = header.slice(SCOPE_PREFIX.length);
-        const content = row.content.slice(firstNewline + 1);
-        result.set(rowScope, {
-          content,
-          version: row.version,
-          updatedAt: row.updated_at instanceof Date ? row.updated_at.toISOString() : String(row.updated_at),
-          source: 'postgres',
-        });
-      }
-    } catch {
-      // Fall through to file-based reads
-    } finally {
-      if (client) await client.end({ timeout: 5 }).catch(() => {});
-    }
-  }
-
-  // Supplement / replace with file-based reads for any scope present on disk
-  const fileScopes = listStrategyScopes(env);
-  for (const fileScope of fileScopes) {
-    if (result.has(fileScope)) continue;
-    const filePath = strategyFilePath(fileScope, env);
-    try {
-      const content = readFileSync(filePath, 'utf8');
-      result.set(fileScope, {
-        content,
-        version: 1,
-        updatedAt: new Date().toISOString(),
-        source: 'file',
-      });
-    } catch {
-      // Skip unreadable files
-    }
+  const scopes = listStrategyScopes(env);
+  for (const scope of scopes) {
+    const data = await readStrategy(scope, env);
+    if (data.source !== 'none') result.set(scope, data);
   }
-
   return result;
 }
 
-// ── Digest helpers ────────────────────────────────────────────────────────────
-
-/**
- * Parse markdown into sections split on ## headers.
- *
- * @param {string} content
- * @returns {Array<{ header: string, body: string }>}
- */
-function parseSections(content) {
-  const lines = content.split('\n');
-  const sections = [];
-  let current = null;
-
-  for (const line of lines) {
-    if (line.startsWith('## ')) {
-      if (current) sections.push(current);
-      current = { header: line.slice(3).trim(), body: '' };
-    } else if (current) {
-      current.body += line + '\n';
-    }
-  }
-  if (current) sections.push(current);
-  return sections;
-}
-
-/**
- * Truncate a body to the first N sentences.
- *
- * @param {string} body
- * @param {number} maxSentences
- * @returns {string}
- */
-function firstSentences(body, maxSentences = 2) {
-  const trimmed = body.trim();
-  if (!trimmed) return '';
-  const sentences = trimmed.match(/[^.!?\n]+[.!?\n]+/g) || [trimmed];
-  return sentences.slice(0, maxSentences).join(' ').trim();
-}
-
-/**
- * Build a compact markdown block from a single scope's content.
- *
- * @param {string} scopeName
- * @param {string} content
- * @param {number} charBudget — remaining character budget; mutated by reference via returned delta
- * @returns {{ text: string, charsUsed: number }}
- */
-function buildScopeBlock(scopeName, content, charBudget) {
-  const sections = parseSections(content);
-  if (!sections.length) return { text: '', charsUsed: 0 };
-
-  const lines = [`### ${scopeName}`];
-  let used = scopeName.length + 5;
-
-  for (const { header, body } of sections) {
-    if (used >= charBudget) break;
-    const excerpt = firstSentences(body, 2);
-    const line = excerpt ? `**${header}:** ${excerpt}` : `**${header}**`;
-    lines.push(line);
-    used += line.length + 1;
-  }
-
-  const text = lines.join('\n');
-  return { text, charsUsed: used };
-}
-
 /**
- * Return a compact strategy digest (≤ 500 tokens) for agent prompt injection.
- *
- * Reads all present scopes asynchronously. Returns empty string when no scopes exist.
- *
- * @param {object} [env]
- * @returns {Promise<string>}
+ * Synchronous digest for prompt assembly.
  */
-export async function getStrategyDigest(env = process.env) {
+export function getStrategyDigestSync(scope = 'product', env = process.env) {
+  const filePath = strategyFilePath(scope, env);
+  if (!existsSync(filePath)) return '';
   try {
-    const all = await readAllStrategies(env);
-    if (!all.size) return '';
-
-    const TOKEN_LIMIT = 500;
-    let charBudget = TOKEN_LIMIT * 4;
-    const parts = ['## Active strategy'];
-
-    for (const [scopeName, { content }] of all) {
-      if (!content) continue;
-      const { text, charsUsed } = buildScopeBlock(scopeName, content, charBudget);
-      if (text) {
-        parts.push(text);
-        charBudget -= charsUsed;
-      }
-      if (charBudget <= 0) break;
-    }
-
-    return parts.length > 1 ? parts.join('\n') : '';
+    const content = readFileSync(filePath, 'utf8');
+    return content.trim().slice(0, 2000); // approx 500 tokens
   } catch {
     return '';
   }
 }
 
 /**
- * Synchronous file-only strategy digest for prompt-composer.js.
- *
- * Reads all .md files present in the strategy directory directly. Never reads
- * Postgres. Returns empty string when the directory is absent or empty.
- *
- * @param {object} [env]
- * @returns {string}
+ * Async digest for general use.
  */
-export function getStrategyDigestSync(env = process.env) {
-  try {
-    const dir = strategyDir(env);
-    if (!existsSync(dir)) return '';
-
-    const files = readdirSync(dir).filter((f) => f.endsWith('.md'));
-    if (!files.length) return '';
-
-    const TOKEN_LIMIT = 500;
-    let charBudget = TOKEN_LIMIT * 4;
-    const parts = ['## Active strategy'];
-
-    for (const file of files) {
-      if (charBudget <= 0) break;
-      const scopeName = basename(file, '.md');
-      let content;
-      try {
-        content = readFileSync(join(dir, file), 'utf8');
-      } catch {
-        continue;
-      }
-      if (!content) continue;
-      const { text, charsUsed } = buildScopeBlock(scopeName, content, charBudget);
-      if (text) {
-        parts.push(text);
-        charBudget -= charsUsed;
-      }
-    }
-
-    return parts.length > 1 ? parts.join('\n') : '';
-  } catch {
-    return '';
-  }
+export async function getStrategyDigest(scope = 'product', env = process.env) {
+  const data = await readStrategy(scope, env);
+  return data.content.trim().slice(0, 2000);
 }
 
-// ── Write ─────────────────────────────────────────────────────────────────────
+// ── Write helpers ─────────────────────────────────────────────────────────────
 
 /**
- * Write a strategy scope to file (always) and Postgres (best-effort if available).
- *
- * The scope parameter defaults to 'product'. When writing to Postgres the content
- * is prefixed with `scope:{name}\n` to allow per-scope storage without a schema change.
- *
- * @param {string} content
- * @param {string} [scope]
- * @param {object} [opts]
- * @param {string} [opts.updatedBy]
- * @param {object} [opts.env]
+ * Write a strategy scope to file.
  */
 export async function writeStrategy(content, scope = 'product', { updatedBy, env = process.env } = {}) {
   const filePath = strategyFilePath(scope, env);
   const dir = strategyDir(env);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   writeFileSync(filePath, content, 'utf8');
-
-  if (!hasSqlStore(env)) return;
-
-  const client = createSqlClient(env);
-  try {
-    const project = env.CX_PROJECT || 'default';
-    const scopedContent = `${SCOPE_PREFIX}${scope}\n${content}`;
-    const prefix = `${SCOPE_PREFIX}${scope}\n`;
-
-    const existing = await client`
-      select version from construct_strategy
-      where project = ${project}
-        and content like ${prefix + '%'}
-      order by version desc
-      limit 1
-    `;
-    const nextVersion = existing.length > 0 ? existing[0].version + 1 : 1;
-
-    await client`
-      insert into construct_strategy (project, content, version, updated_by)
-      values (${project}, ${scopedContent}, ${nextVersion}, ${updatedBy ?? null})
-    `;
-  } catch {
-    // Best-effort Postgres write — file write already succeeded
-  } finally {
-    if (client) await client.end({ timeout: 5 }).catch(() => {});
-  }
 }

package/lib/telemetry/beads-fallback.mjs

@@ -0,0 +1,40 @@
+/**
+ * lib/telemetry/beads-fallback.mjs — count legacy-lock fallback firings.
+ *
+ * The beads write path is optimistic by default; the exclusive file-lock runs only
+ * as the PATH-3 fallback after optimistic retries exhaust. Whether that fallback
+ * ever fires in practice is the evidence that decides if the lock + wait-queue can
+ * be retired (bead construct-nhn5): one JSON line per firing to
+ * ~/.cx/beads-fallback.jsonl. Zero entries over a representative window = safe to
+ * remove; entries name the bd commands that actually contend.
+ *
+ * Errors here are non-fatal — telemetry must never add a failure mode to the
+ * fallback it observes.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { appendBounded } from '../logging/rotate.mjs';
+import { cxDir } from '../paths.mjs';
+
+export function defaultLogPath() {
+  return path.join(cxDir(), 'beads-fallback.jsonl');
+}
+
+export function logBeadsFallback(event, opts = {}) {
+  const logPath = opts.logPath || defaultLogPath();
+  const entry = {
+    ts: new Date().toISOString(),
+    command: event?.command || 'unknown',
+  };
+  try {
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    appendBounded('beads-fallback', logPath, JSON.stringify(entry) + '\n');
+  } catch { /* best-effort */ }
+}
+
+export function readBeadsFallbacks({ logPath = defaultLogPath() } = {}) {
+  if (!fs.existsSync(logPath)) return [];
+  return fs.readFileSync(logPath, 'utf8').split('\n').filter(Boolean).map((l) => {
+    try { return JSON.parse(l); } catch { return null; }
+  }).filter(Boolean);
+}

package/lib/telemetry/hook-calls.mjs

@@ -0,0 +1,138 @@
+/**
+ * lib/telemetry/hook-calls.mjs — measure which hooks fire and which actually block.
+ *
+ * Hooks carry @p95ms latency budgets but no record of how often each one fires or
+ * blocks, so a hook that gates real mistakes and one that has never fired once look
+ * identical. The central dispatcher (`construct hook <name>`) appends one JSON line
+ * per invocation to ~/.cx/hook-calls.jsonl with the hook id, the outcome derived
+ * from its exit code, and latency, so `construct hooks:usage` can answer which hooks
+ * earn their keep before any are consolidated.
+ *
+ * Outcome is what the dispatcher can observe centrally: exit 0 = ok, exit 2 = blocked
+ * (the Claude Code convention for a refused tool call — see block-no-verify), any
+ * other non-zero = error. A hook that mutates state without blocking reads as `ok`
+ * here; per-hook mutation reporting is a separate, opt-in signal.
+ *
+ * Disable with CONSTRUCT_HOOK_TELEMETRY=off. Errors here are non-fatal — telemetry
+ * must never change a hook's exit code or add a failure mode to the hot path.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { appendBounded } from '../logging/rotate.mjs';
+import { resolveProjectScope } from '../project-root.mjs';
+import { cxDir } from '../paths.mjs';
+
+// cxDir() (not os.homedir()) so CX_HOME_OVERRIDE isolates the log in tests and the
+// path stays consistent with the rest of ~/.cx. Resolved per-call so an override
+// set after import still takes effect.
+
+export function defaultLogPath() {
+  return path.join(cxDir(), 'hook-calls.jsonl');
+}
+
+// Exit-code → outcome, using the Claude Code hook convention (2 = block a tool
+// call). Anything else non-zero is a hook that errored rather than deliberately
+// gated, which is itself a value signal (a hook erroring every fire is noise).
+
+export function outcomeFromExit(code) {
+  if (code === 0 || code == null) return 'ok';
+  if (code === 2) return 'blocked';
+  return 'error';
+}
+
+/**
+ * Fire-and-forget log of one hook invocation.
+ *
+ * @param {object} event
+ * @param {string} event.hookId — the hook name, e.g. "block-no-verify"
+ * @param {number} [event.exitCode] — the hook's process exit code
+ * @param {'ok'|'blocked'|'error'} [event.outcome] — derived from exitCode if omitted
+ * @param {number} [event.latencyMs]
+ * @param {object} [opts]
+ * @param {string} [opts.logPath]
+ * @param {NodeJS.ProcessEnv} [opts.env]
+ */
+export function logHookCall(event, opts = {}) {
+  const env = opts.env || process.env;
+  if (env.CONSTRUCT_HOOK_TELEMETRY === 'off') return;
+  if (!event || !event.hookId) return;
+
+  const logPath = opts.logPath || defaultLogPath();
+  const outcome = event.outcome || outcomeFromExit(event.exitCode);
+  const scope = resolveProjectScope();
+  const entry = {
+    ts: new Date().toISOString(),
+    hookId: event.hookId,
+    outcome,
+    ...(event.exitCode != null ? { exitCode: event.exitCode } : {}),
+    ...(scope?.projectId ? { projectId: scope.projectId } : {}),
+    ...(event.latencyMs != null ? { latencyMs: event.latencyMs } : {}),
+  };
+
+  try {
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    appendBounded('hook-calls', logPath, JSON.stringify(entry) + '\n');
+  } catch {
+    // Append-only telemetry; an unwritable home dir is a silent skip rather than
+    // a new failure mode on the hook that triggered the call.
+  }
+}
+
+/**
+ * Roll a hook-calls log up into per-hook stats: fire count, blocked/error counts,
+ * most-recent timestamp, latency percentiles. A hook with calls but zero blocks/
+ * errors over a long window is a pure observer — a demotion candidate.
+ */
+export function summarizeHookCalls({ logPath = defaultLogPath(), since } = {}) {
+  if (!fs.existsSync(logPath)) return { totalEvents: 0, hooks: {} };
+  const lines = fs.readFileSync(logPath, 'utf8').split('\n').filter(Boolean);
+  const sinceTs = since ? _parseSince(since) : null;
+  const hooks = {};
+  for (const line of lines) {
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+    if (!entry?.hookId) continue;
+    if (sinceTs && entry.ts && entry.ts < sinceTs) continue;
+    const slot = hooks[entry.hookId] ||= { calls: 0, blocked: 0, errors: 0, latencies: [], lastCalledAt: null };
+    slot.calls += 1;
+    if (entry.outcome === 'blocked') slot.blocked += 1;
+    if (entry.outcome === 'error') slot.errors += 1;
+    if (entry.latencyMs != null) slot.latencies.push(entry.latencyMs);
+    if (entry.ts && (!slot.lastCalledAt || entry.ts > slot.lastCalledAt)) slot.lastCalledAt = entry.ts;
+  }
+  const result = {};
+  for (const [id, slot] of Object.entries(hooks)) {
+    result[id] = {
+      calls: slot.calls,
+      blocked: slot.blocked,
+      errors: slot.errors,
+      lastCalledAt: slot.lastCalledAt,
+      ...(slot.latencies.length ? _latencyStats(slot.latencies) : {}),
+    };
+  }
+  return { totalEvents: lines.length, hooks: result };
+}
+
+/**
+ * Hooks with zero fire events in the window — they cost a settings entry and a
+ * spawn budget but have never run, so they are consolidation candidates.
+ */
+export function findIdleHooks({ logPath = defaultLogPath(), since = '30d', allHookIds = [] } = {}) {
+  const { hooks } = summarizeHookCalls({ logPath, since });
+  const active = new Set(Object.keys(hooks));
+  return allHookIds.filter((id) => !active.has(id));
+}
+
+function _parseSince(since) {
+  const m = String(since).match(/^(\d+)(d|h|m)$/);
+  if (!m) return null;
+  const ms = parseInt(m[1], 10) * ({ d: 86400000, h: 3600000, m: 60000 }[m[2]]);
+  return new Date(Date.now() - ms).toISOString();
+}
+
+function _latencyStats(arr) {
+  const sorted = [...arr].sort((a, b) => a - b);
+  const p = (pct) => sorted[Math.floor((pct / 100) * (sorted.length - 1))];
+  return { p50LatencyMs: p(50), p95LatencyMs: p(95) };
+}

package/lib/worker/entrypoint.mjs

@@ -24,8 +24,7 @@
 
 import path from 'node:path';
 
-import { createSqlClient, closeSqlClient } from '../storage/backend.mjs';
-import { PostgresIntakeQueue } from '../intake/postgres-queue.mjs';
+import { createIntakeQueue } from '../intake/queue.mjs';
 import { FilesystemTaskGraphStore } from '../task-graph/store.mjs';
 import { runJob } from './run.mjs';
 import { evidenceFromJobResult, recordEvidence, blockedPacket } from './evidence.mjs';
@@ -167,7 +166,6 @@ export async function runWorkerLoop({
   rootDir,
   workspace,
   project,
-  sql,
   queue: injectedQueue = null,
   store: injectedStore = null,
   pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,
@@ -178,10 +176,9 @@ export async function runWorkerLoop({
 } = {}) {
   if (!project) throw new Error('runWorkerLoop: project is required');
   if (!workspace) throw new Error('runWorkerLoop: workspace is required');
-  if (!injectedQueue && !sql) throw new Error('runWorkerLoop: sql client (or injected queue) is required');
 
   const workerName = readWorkerName();
-  const queue = injectedQueue || new PostgresIntakeQueue({ sql, project });
+  const queue = injectedQueue || createIntakeQueue(rootDir, process.env, { project });
   const store = injectedStore || new FilesystemTaskGraphStore(rootDir);
 
   let processed = 0;
@@ -223,19 +220,14 @@ if (invokedDirectly) {
   const pollIntervalMs = Number(args['poll-interval-ms'] || DEFAULT_POLL_INTERVAL_MS);
   const idleTimeoutSeconds = Number(args['idle-timeout-seconds'] || DEFAULT_IDLE_TIMEOUT_SECONDS);
 
-  const sql = createSqlClient(process.env);
-  if (!sql) {
-    process.stderr.write('[worker] DATABASE_URL is required for the worker entrypoint.\n');
-    process.exit(78); // EX_CONFIG
-  }
-
   try {
     const summary = await runWorkerLoop({
-      rootDir, workspace, project, sql, pollIntervalMs, idleTimeoutSeconds,
+      rootDir, workspace, project, pollIntervalMs, idleTimeoutSeconds,
     });
     process.stdout.write(`[worker] exiting after idle timeout — processed=${summary.processed} skipped=${summary.skipped} worker=${summary.workerName}\n`);
     process.exit(0);
-  } finally {
-    await closeSqlClient(sql);
+  } catch (err) {
+    process.stderr.write(`[worker] failed: ${err.stack}\n`);
+    process.exit(1);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geraldmaron/construct",
-  "version": "1.0.23",
+  "version": "1.1.0",
   "type": "module",
   "packageManager": "npm@11.5.1",
   "description": "Construct — agent orchestration layer for OpenCode, Claude Code, and other coding surfaces",
@@ -80,16 +80,17 @@
     "postinstall": "node ./bin/construct-postinstall.mjs"
   },
   "dependencies": {
+    "@lancedb/lancedb": "^0.30.0",
     "@modelcontextprotocol/sdk": "^1.12.0",
-    "js-yaml": "^4.2.0",
-    "postgres": "^3.4.9"
+    "apache-arrow": "^18.1.0",
+    "js-yaml": "^4.2.0"
   },
   "optionalDependencies": {
     "@huggingface/transformers": "^4.2.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/core": "^2.7.1",
     "@opentelemetry/exporter-trace-otlp-http": "^0.218.0",
-    "@opentelemetry/resources": "^1.25.0",
+    "@opentelemetry/resources": "^2.7.1",
     "@opentelemetry/sdk-trace-node": "^1.25.0",
     "@opentelemetry/semantic-conventions": "^1.25.0"
   },
@@ -99,7 +100,7 @@
   "devDependencies": {
     "@eslint/js": "^9.39.4",
     "c8": "^11.0.0",
-    "eslint": "^9.39.4",
+    "eslint": "^10.4.1",
     "globals": "^17.6.0"
   }
 }

package/personas/construct.md

@@ -62,7 +62,7 @@ The active profile (`construct profile show`) sets the intake taxonomy. Session-
 
 Lead with the answer. One question when blocked. Confirm what changed when done.
 
-**Output style**: format human-facing output (terminal, prose, dashboard) for neurodivergent readers — answer first, clear hierarchy, scannable chunks, plain language, explicit next step; never rely on color or motion alone; honor `NO_COLOR` and reduced-motion. Presentation only — never reshape machine-readable output (`--json`, parsed tokens, registries, contracts). See `rules/common/neurodivergent-output.md`.
+**Output style**: format human-facing output (terminal, prose, dashboard) for neurodivergent readers — answer first, clear hierarchy, plain language, explicit next step. Prose for reasoning; lists only for genuinely parallel items where scanning helps, never a wall of bullets. Never rely on color or motion alone; honor `NO_COLOR` and reduced-motion. Presentation only — never reshape machine-readable output (`--json`, parsed tokens, registries, contracts). See `rules/common/neurodivergent-output.md`.
 
 **Tool invisibility**: deliverables are about the user's project, never Construct. Never name Construct, `cx-*` role ids, or internal orchestration mechanics in artifact content unless the subject project is Construct itself. Provenance goes in a comment, not the prose. See `rules/common/tool-invisibility.md`.