@geraldmaron/construct 1.0.20 → 1.0.23

package/lib/model-registry.mjs

@@ -20,17 +20,14 @@ import path from 'node:path';
  * 1. Environment variables (CX_MODEL_*): Emergency overrides
  * 2. User config (~/.construct/config.env): Personal defaults
  * 3. Registry (specialists/registry.json): Project recommendations
- * 4. Built-in defaults: Last resort fallbacks
- * 
- * Primary resolution path. All code must use this function.
+ *
+ * Construct ships with NO implicit model defaults (ADR-0027,
+ * tests/model-router-no-defaults.test.mjs). When none of the three sources
+ * resolves a tier, that tier returns null with source 'not configured'.
+ * Callers must surface a clear remediation hint rather than silently
+ * substituting a vendor-specific default.
  */
 
-const BUILTIN_DEFAULTS = {
-  reasoning: 'anthropic/claude-3-5-sonnet',
-  standard: 'anthropic/claude-3-haiku',
-  fast: 'anthropic/claude-3-haiku',
-};
-
 const ENV_PREFIX = 'CX_MODEL';
 
 // ---------------------------------------------------------------------------
@@ -86,28 +83,30 @@ export function resolveModelTiers(options = {}) {
       }
     }
     
-    // Built-in default
-    result[tier] = BUILTIN_DEFAULTS[tier];
-    sources[tier] = 'default';
+    // No source resolved this tier — leave null + 'not configured' so callers
+    // can surface a clear remediation hint. Aligns with the wired path
+    // (lib/model-router.mjs:resolveTierAssignments) and the no-defaults
+    // contract locked in by tests/model-router-no-defaults.test.mjs.
+
+    result[tier] = null;
+    sources[tier] = 'not configured';
   }
-  
-  // Validation
+
   const configured = Object.values(result).filter(Boolean).length;
-  
+
   if (strict && configured < 3) {
     const missing = Object.entries(result)
       .filter(([, v]) => !v)
       .map(([k]) => k);
     errors.push(`Missing configuration for tiers: ${missing.join(', ')}`);
   }
-  
+
   return {
     models: result,
     sources,
     configured,
     complete: configured === 3,
     errors: errors.length > 0 ? errors : null,
-    defaultsUsed: Object.values(sources).filter(s => s === 'default').length,
   };
 }
 
@@ -117,7 +116,7 @@ export function resolveModelTiers(options = {}) {
 
 export function getModelForTier(tier, options = {}) {
   const resolved = resolveModelTiers(options);
-  return resolved.models[tier] || BUILTIN_DEFAULTS[tier];
+  return resolved.models[tier];
 }
 
 export function getModelSource(tier, options = {}) {
@@ -131,12 +130,15 @@ export function getModelSource(tier, options = {}) {
 
 export function validateModelTiers(options = {}) {
   const resolved = resolveModelTiers({ ...options, strict: true });
-  
+  const unconfigured = Object.entries(resolved.sources)
+    .filter(([, source]) => source === 'not configured')
+    .map(([tier]) => tier);
+
   return {
     valid: resolved.complete && !resolved.errors,
     errors: resolved.errors,
-    warnings: resolved.defaultsUsed > 0 
-      ? [`Using ${resolved.defaultsUsed} built-in default(s). Consider configuring custom models.`]
+    warnings: unconfigured.length > 0
+      ? [`Unconfigured tier${unconfigured.length === 1 ? '' : 's'}: ${unconfigured.join(', ')}. Run 'construct models --apply' or set CX_MODEL_<TIER>.`]
       : [],
     resolution: resolved,
   };
@@ -144,25 +146,30 @@ export function validateModelTiers(options = {}) {
 
 export function formatModelStatus(options = {}) {
   const resolved = resolveModelTiers(options);
-  
+
   let output = 'Model Configuration:\n\n';
-  
+
   for (const tier of ['reasoning', 'standard', 'fast']) {
     const model = resolved.models[tier];
     const source = resolved.sources[tier];
-    const icon = source === 'default' ? '⚠' : '✓';
-    
-    output += `${icon} ${tier.padEnd(10)} ${model}\n`;
+    const icon = source === 'not configured' ? '⚠' : '✓';
+    const display = model ?? '(not configured)';
+
+    output += `${icon} ${tier.padEnd(10)} ${display}\n`;
     output += `  Source: ${source}\n\n`;
   }
-  
-  if (resolved.defaultsUsed > 0) {
-    output += '\nNote: Using built-in defaults. To customize:\n';
-    output += '  export CX_MODEL_REASONING=your-model\n';
-    output += '  export CX_MODEL_STANDARD=your-model\n';
-    output += '  export CX_MODEL_FAST=your-model\n';
+
+  const unconfigured = Object.entries(resolved.sources)
+    .filter(([, source]) => source === 'not configured')
+    .map(([tier]) => tier);
+  if (unconfigured.length > 0) {
+    output += `\nUnconfigured: ${unconfigured.join(', ')}. To configure:\n`;
+    output += '  construct models --apply        (interactive, picks from available providers)\n';
+    output += '  export CX_MODEL_REASONING=...   (env override)\n';
+    output += '  export CX_MODEL_STANDARD=...\n';
+    output += '  export CX_MODEL_FAST=...\n';
   }
-  
+
   return output;
 }
 

package/lib/observation-store.mjs

@@ -238,8 +238,12 @@ export async function addObservation(rootDir, {
       return record;
     }
     await client.close();
-  } catch {
-    // Fall through to local vector storage
+  } catch (err) {
+    // A reachable backend that still fails to store (dimension drift, auth, transient
+    // network) must not look identical to "no backend configured" — surface it, then
+    // preserve the observation in the local index so the write never silently vanishes.
+
+    process.stderr.write(`[observation-store] SQL store failed; kept observation in local index: ${err?.message || err}\n`);
   }
 
   // Fallback: local JSON vector index with hashing-bow-v1.

package/lib/opencode-config.mjs

@@ -48,7 +48,7 @@ export function sanitizeOpenCodeConfig(config) {
 
 export function writeOpenCodeConfig(config, file = findOpenCodeConfigPath()) {
   // Treat the canonical home config as the default target; any explicit path
-  // outside the canonical home dir (e.g. project-scoped .opencode/config.json)
+  // outside the canonical home dir (e.g. project-scoped .opencode/opencode.json)
   // is honored as-is so per-project sync writes to the right tree.
 
   const canonical = getCanonicalOpenCodeConfigPath();

package/lib/orchestration/events.mjs

@@ -0,0 +1,66 @@
+/**
+ * lib/orchestration/events.mjs — in-process run lifecycle event bus.
+ *
+ * The orchestration runtime persists runs to a store and appends durable JSONL
+ * traces, but has no live pub/sub a server can stream from. This is that
+ * primitive: a process-local EventEmitter keyed by runId so an HTTP SSE handler
+ * can subscribe to a single run's transitions (planned → running → per-task →
+ * completed) and forward them to a thin client. Events are lightweight status
+ * deltas — never task output or any credential — so the stream stays cheap and
+ * secret-free; clients fetch full run records (envelope-guarded) for outputs.
+ *
+ * Process-local by design: it streams runs executing in THIS process. Durable,
+ * cross-process history lives in the run store and the trace log.
+ */
+
+import { EventEmitter } from 'node:events';
+
+const bus = new EventEmitter();
+bus.setMaxListeners(0);
+
+function channel(runId) {
+  return `run:${runId}`;
+}
+
+/**
+ * Emit a run lifecycle event. Stamps runId + an ISO timestamp; callers pass a
+ * small status delta (type, status, taskId, role, executor, error).
+ *
+ * @param {string} runId
+ * @param {object} event
+ */
+export function emitRunEvent(runId, event = {}) {
+  if (!runId) return;
+  bus.emit(channel(runId), { runId, at: new Date().toISOString(), ...event });
+}
+
+/**
+ * Subscribe to one run's events.
+ *
+ * @param {string} runId
+ * @param {(event:object)=>void} handler
+ * @returns {() => void} unsubscribe
+ */
+export function onRunEvent(runId, handler) {
+  const ch = channel(runId);
+  bus.on(ch, handler);
+  return () => bus.off(ch, handler);
+}
+
+// Cooperative, between-task cancellation. executeRun checks this before each
+// task and stops cleanly if set — an honest soft cancel (it cannot abort a
+// model call already in flight), not a forced kill.
+
+const cancelled = new Set();
+
+export function requestCancel(runId) {
+  if (runId) cancelled.add(runId);
+}
+
+export function isCancelRequested(runId) {
+  return cancelled.has(runId);
+}
+
+export function clearCancel(runId) {
+  cancelled.delete(runId);
+}

package/lib/orchestration/run-store-postgres.mjs

@@ -0,0 +1,85 @@
+/**
+ * lib/orchestration/run-store-postgres.mjs — Postgres-backed run store (Mode-C).
+ *
+ * Mirrors lib/intake/postgres-queue.mjs: a class taking the tagged-template `sql`
+ * client from createSqlClient(env) (porsager/postgres style) and a project key.
+ * Orchestration runs persist to `construct_orchestration_runs`; triage-like
+ * columns (status, execution_mode) are flattened for filtering while the full run
+ * round-trips in `payload jsonb`. Multi-project isolation comes from the
+ * (run_id, project) composite primary key.
+ *
+ * Scope: the STORE is the deliverable. Container-worker spawning (Mode-C's
+ * optional worker topology) is out of scope (ADR-0021); a Postgres run store lets
+ * a team/enterprise deployment share durable runs across processes today.
+ */
+
+export class PostgresRunStore {
+  constructor({ sql, project } = {}) {
+    if (!sql) throw new Error('PostgresRunStore: sql client is required');
+    if (!project) throw new Error('PostgresRunStore: project is required');
+    this.sql = sql;
+    this.project = project;
+  }
+
+  async ensureSchema() {
+    await this.sql`
+      CREATE TABLE IF NOT EXISTS construct_orchestration_runs (
+        run_id TEXT,
+        project TEXT,
+        created_at TEXT,
+        status TEXT,
+        execution_mode TEXT,
+        payload JSONB,
+        PRIMARY KEY (run_id, project)
+      )
+    `;
+  }
+
+  async saveRun(run) {
+    if (!run?.runId) throw new Error('saveRun: run.runId is required');
+    await this.sql`
+      INSERT INTO construct_orchestration_runs (
+        run_id, project, created_at, status, execution_mode, payload
+      ) VALUES (
+        ${run.runId}, ${this.project}, ${run.createdAt || null},
+        ${run.status || null}, ${run.execution?.executionMode || null},
+        ${this.sql.json(run)}
+      )
+      ON CONFLICT (run_id, project) DO UPDATE SET
+        created_at = EXCLUDED.created_at,
+        status = EXCLUDED.status,
+        execution_mode = EXCLUDED.execution_mode,
+        payload = EXCLUDED.payload
+    `;
+    return run;
+  }
+
+  async loadRun(runId) {
+    if (!runId) return null;
+    const rows = await this.sql`
+      SELECT payload FROM construct_orchestration_runs
+      WHERE run_id = ${runId} AND project = ${this.project}
+      LIMIT 1
+    `;
+    return rows[0]?.payload || null;
+  }
+
+  async listRuns({ limit = 20 } = {}) {
+    const rows = await this.sql`
+      SELECT payload FROM construct_orchestration_runs
+      WHERE project = ${this.project}
+      ORDER BY created_at DESC
+      LIMIT ${limit}
+    `;
+    return rows.map((row) => {
+      const run = row.payload || {};
+      return {
+        runId: run.runId,
+        status: run.status,
+        executionMode: run.execution?.executionMode || null,
+        createdAt: run.createdAt,
+        request: run.request?.summary || null,
+      };
+    });
+  }
+}

package/lib/orchestration/run-store-sqlite.mjs

@@ -0,0 +1,122 @@
+/**
+ * lib/orchestration/run-store-sqlite.mjs — SQLite-backed run store (Mode-B).
+ *
+ * Same saveRun/loadRun/listRuns surface as the filesystem store (run-store.mjs),
+ * backed by a single `node:sqlite` database under
+ * `.cx/runtime/orchestration/runs.db`. A daemon-grade local store: durable,
+ * single-file, queryable, with no Postgres/Docker dependency.
+ *
+ * Node compatibility boundary: `node:sqlite` exists only on Node >=22.5, but the
+ * CI matrix also runs Node 20. So the import is LAZY (inside a function, never at
+ * module top level) and `sqliteAvailable()` reports false when it throws. The
+ * store factory throws a structured SQLITE_UNAVAILABLE error (with remediation)
+ * rather than crashing, so the resolver can fall back to filesystem. Nothing on
+ * the default test path statically imports node:sqlite.
+ */
+
+import { mkdirSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const RUNTIME_REL = join('.cx', 'runtime', 'orchestration');
+
+let cachedDatabaseSync;
+
+// The node:sqlite probe is cached and synchronous. createRequire above is a
+// plain static import of node:module (always present); only node:sqlite itself
+// is loaded lazily here, so Node 20 never touches the unavailable builtin.
+
+function loadDatabaseSync() {
+  if (cachedDatabaseSync !== undefined) return cachedDatabaseSync;
+  try {
+    cachedDatabaseSync = require('node:sqlite').DatabaseSync;
+  } catch {
+    cachedDatabaseSync = null;
+  }
+  return cachedDatabaseSync;
+}
+
+export function sqliteAvailable() {
+  return loadDatabaseSync() != null;
+}
+
+function projectRoot(cwd) {
+  return isAbsolute(cwd) ? cwd : resolve(cwd);
+}
+
+function dbPath(cwd) {
+  const dir = join(projectRoot(cwd), RUNTIME_REL);
+  mkdirSync(dir, { recursive: true });
+  return join(dir, 'runs.db');
+}
+
+function openDb(cwd) {
+  const DatabaseSync = loadDatabaseSync();
+  if (!DatabaseSync) {
+    const err = new Error('SQLite run store requires Node >=22.5 (node:sqlite is unavailable on this runtime).');
+    err.code = 'SQLITE_UNAVAILABLE';
+    err.remediation = 'Upgrade to Node >=22.5, or set orchestration.store to "filesystem" / "postgres".';
+    throw err;
+  }
+  const db = new DatabaseSync(dbPath(cwd));
+  db.exec(`CREATE TABLE IF NOT EXISTS runs (
+    run_id TEXT PRIMARY KEY,
+    created_at TEXT,
+    status TEXT,
+    execution_mode TEXT,
+    json TEXT
+  )`);
+  return db;
+}
+
+/**
+ * Build a SQLite-backed run store bound to a project directory.
+ *
+ * @param {object} opts
+ * @param {string} opts.cwd
+ * @returns {{ saveRun(run):object, loadRun(runId):object|null, listRuns(opts):Array }}
+ */
+export function createSqliteRunStore({ cwd = process.cwd() } = {}) {
+  const db = openDb(cwd);
+  return {
+    saveRun(run) {
+      const stmt = db.prepare(`INSERT INTO runs (run_id, created_at, status, execution_mode, json)
+        VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT(run_id) DO UPDATE SET
+          created_at = excluded.created_at,
+          status = excluded.status,
+          execution_mode = excluded.execution_mode,
+          json = excluded.json`);
+      stmt.run(run.runId, run.createdAt || null, run.status || null, run.execution?.executionMode || null, JSON.stringify(run));
+      return run;
+    },
+    loadRun(runId) {
+      if (!runId) return null;
+      const row = db.prepare('SELECT json FROM runs WHERE run_id = ?').get(runId);
+      if (!row || !row.json) return null;
+      try {
+        return JSON.parse(row.json);
+      } catch {
+        return null;
+      }
+    },
+    listRuns({ limit = 20 } = {}) {
+      const rows = db.prepare('SELECT json FROM runs ORDER BY created_at DESC LIMIT ?').all(limit);
+      const out = [];
+      for (const row of rows) {
+        try {
+          const run = JSON.parse(row.json);
+          out.push({
+            runId: run.runId,
+            status: run.status,
+            executionMode: run.execution?.executionMode || null,
+            createdAt: run.createdAt,
+            request: run.request?.summary || null,
+          });
+        } catch { /* a corrupt row is skipped, not fatal to listing */ }
+      }
+      return out;
+    },
+  };
+}