@geraldmaron/construct 1.0.0 → 1.0.1

package/lib/ollama-manager.mjs

@@ -0,0 +1,428 @@
+#!/usr/bin/env node
+/**
+ * lib/ollama-manager.mjs — Ollama local LLM management.
+ *
+ * Provides commands for checking Ollama status, listing models,
+ * pulling new models, and configuring Ollama as a provider.
+ */
+
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const OLLAMA_BASE_URL = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+
+/**
+ * Check if Ollama is installed and running
+ */
+export function checkOllamaStatus() {
+  try {
+    execSync('which ollama', { stdio: 'pipe' });
+    const installed = true;
+    
+    try {
+      const response = execSync(`curl -s ${OLLAMA_BASE_URL}/api/tags`, { 
+        encoding: 'utf8',
+        timeout: 3000
+      });
+      const data = JSON.parse(response);
+      return {
+        installed,
+        running: true,
+        models: data.models || [],
+        baseUrl: OLLAMA_BASE_URL
+      };
+    } catch (e) {
+      return {
+        installed,
+        running: false,
+        error: 'Ollama server not responding',
+        baseUrl: OLLAMA_BASE_URL
+      };
+    }
+  } catch (e) {
+    return {
+      installed: false,
+      running: false,
+      error: 'Ollama not installed'
+    };
+  }
+}
+
+/**
+ * List available Ollama models
+ */
+export function listModels() {
+  try {
+    const response = execSync(`curl -s ${OLLAMA_BASE_URL}/api/tags`, { 
+      encoding: 'utf8',
+      timeout: 5000
+    });
+    const data = JSON.parse(response);
+    return data.models || [];
+  } catch (e) {
+    throw new Error(`Failed to fetch models: ${e.message}`);
+  }
+}
+
+/**
+ * Pull a model from Ollama registry
+ */
+export function pullModel(modelName, { verbose = false } = {}) {
+  console.log(`Pulling ${modelName}...`);
+  try {
+    const output = execSync(`ollama pull ${modelName}`, {
+      encoding: 'utf8',
+      stdio: verbose ? 'inherit' : 'pipe'
+    });
+    return { success: true, output };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+/**
+ * Remove a model
+ */
+export function removeModel(modelName) {
+  try {
+    execSync(`ollama rm ${modelName}`, { encoding: 'utf8' });
+    return { success: true };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+/**
+ * Show model details
+ */
+export function showModel(modelName) {
+  try {
+    const response = execSync(`curl -s ${OLLAMA_BASE_URL}/api/show -d '{"name":"${modelName}"}'`, {
+      encoding: 'utf8',
+      timeout: 5000
+    });
+    return JSON.parse(response);
+  } catch (e) {
+    throw new Error(`Failed to fetch model details: ${e.message}`);
+  }
+}
+
+/**
+ * Run a quick inference test
+ */
+export function testModel(modelName, prompt = 'Say hello in one sentence.') {
+  try {
+    const response = execSync(`curl -s ${OLLAMA_BASE_URL}/api/generate -d '${JSON.stringify({
+      model: modelName,
+      prompt: prompt,
+      stream: false
+    })}'`, {
+      encoding: 'utf8',
+      timeout: 30000
+    });
+    const data = JSON.parse(response);
+    return {
+      success: true,
+      response: data.response,
+      duration: data.total_duration ? `${(data.total_duration / 1e9).toFixed(2)}s` : 'unknown'
+    };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+/**
+ * CLI entry point
+ */
+export async function cmdOllama(argv = process.argv.slice(2)) {
+  const command = argv[0];
+  const args = argv.slice(1);
+  
+  if (!command || command === '--help' || command === '-h') {
+    printHelp();
+    return;
+  }
+  
+  switch (command) {
+    case 'status':
+      await cmdOllamaStatus();
+      break;
+    case 'list':
+    case 'ls':
+      await cmdOllamaList(args);
+      break;
+    case 'pull':
+      await cmdOllamaPull(args);
+      break;
+    case 'rm':
+    case 'remove':
+      await cmdOllamaRemove(args);
+      break;
+    case 'show':
+      await cmdOllamaShow(args);
+      break;
+    case 'test':
+      await cmdOllamaTest(args);
+      break;
+    case 'setup':
+      await cmdOllamaSetup(args);
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+
+function printHelp() {
+  console.log(`
+Usage: construct ollama <command> [options]
+
+Commands:
+  status              Check if Ollama is installed and running
+  list, ls            List available local models
+  pull <model>        Pull a model from Ollama registry
+  rm <model>          Remove a local model
+  show <model>        Show model details (architecture, parameters)
+  test <model>        Run a quick inference test
+  setup               Interactive setup: install, start service, pull default model
+
+Options:
+  --verbose           Show detailed output (for pull)
+  --help, -h          Show this help message
+
+Examples:
+  construct ollama status
+  construct ollama list
+  construct ollama pull llama3.2
+  construct ollama test llama3.2
+  construct ollama setup --yes
+`);
+}
+
+async function cmdOllamaStatus() {
+  const status = checkOllamaStatus();
+  
+  if (!status.installed) {
+    console.log('❌ Ollama is not installed');
+    console.log('   Install with: brew install ollama');
+    process.exit(1);
+  }
+  
+  if (!status.running) {
+    console.log('⚠️  Ollama is installed but not running');
+    console.log('   Start with: brew services start ollama');
+    console.log(`   Base URL: ${status.baseUrl}`);
+    process.exit(1);
+  }
+  
+  console.log('✅ Ollama is running');
+  console.log(`   Base URL: ${status.baseUrl}`);
+  console.log(`   Models: ${status.models.length}`);
+  
+  if (status.models.length > 0) {
+    console.log('\n   Available models:');
+    status.models.forEach(m => {
+      console.log(`   - ${m.name} (${formatSize(m.size)})`);
+    });
+  }
+}
+
+async function cmdOllamaList(args) {
+  const status = checkOllamaStatus();
+  if (!status.running) {
+    console.error('Error: Ollama is not running. Start with: brew services start ollama');
+    process.exit(1);
+  }
+  
+  const models = listModels();
+  if (models.length === 0) {
+    console.log('No models installed. Pull one with: construct ollama pull <model>');
+    console.log('\nPopular models:');
+    console.log('  - llama3.2 (3B, fast)');
+    console.log('  - llama3.1:8b (8B, balanced)');
+    console.log('  - llama3.1:70b (70B, reasoning)');
+    console.log('  - qwen2.5:7b (7B, balanced)');
+    console.log('  - mistral:7b (7B, fast)');
+    return;
+  }
+  
+  console.log('NAME'.padEnd(25), 'SIZE'.padEnd(12), 'MODIFIED');
+  console.log('─'.repeat(50));
+  models.forEach(m => {
+    const name = m.name.padEnd(25);
+    const size = formatSize(m.size).padEnd(12);
+    const modified = new Date(m.modified_at).toLocaleDateString();
+    console.log(name, size, modified);
+  });
+}
+
+async function cmdOllamaPull(args) {
+  const modelName = args[0];
+  const verbose = args.includes('--verbose') || args.includes('-v');
+  
+  if (!modelName) {
+    console.error('Error: Model name required');
+    console.log('Usage: construct ollama pull <model>');
+    console.log('\nPopular models:');
+    console.log('  - llama3.2 (3B, fast)');
+    console.log('  - llama3.1:8b (8B, balanced)');
+    console.log('  - llama3.1:70b (70B, reasoning)');
+    process.exit(1);
+  }
+  
+  const result = pullModel(modelName, { verbose });
+  if (result.success) {
+    console.log(`✅ Successfully pulled ${modelName}`);
+  } else {
+    console.error(`❌ Failed to pull ${modelName}: ${result.error}`);
+    process.exit(1);
+  }
+}
+
+async function cmdOllamaRemove(args) {
+  const modelName = args[0];
+  
+  if (!modelName) {
+    console.error('Error: Model name required');
+    console.log('Usage: construct ollama rm <model>');
+    process.exit(1);
+  }
+  
+  const result = removeModel(modelName);
+  if (result.success) {
+    console.log(`✅ Removed ${modelName}`);
+  } else {
+    console.error(`❌ Failed to remove ${modelName}: ${result.error}`);
+    process.exit(1);
+  }
+}
+
+async function cmdOllamaShow(args) {
+  const modelName = args[0];
+  
+  if (!modelName) {
+    console.error('Error: Model name required');
+    console.log('Usage: construct ollama show <model>');
+    process.exit(1);
+  }
+  
+  try {
+    const details = showModel(modelName);
+    console.log(`Model: ${modelName}`);
+    console.log('─'.repeat(50));
+    
+    if (details.details) {
+      console.log(`  Format: ${details.details.format || 'unknown'}`);
+      console.log(`  Family: ${details.details.family || 'unknown'}`);
+      console.log(`  Parameters: ${details.details.parameter_size || 'unknown'}`);
+      console.log(`  Quantization: ${details.details.quantization_level || 'unknown'}`);
+    }
+    
+    if (details.model_info) {
+      const keys = Object.keys(details.model_info);
+      if (keys.length > 0) {
+        console.log('\n  Info:');
+        keys.slice(0, 5).forEach(key => {
+          console.log(`    ${key}: ${details.model_info[key]}`);
+        });
+      }
+    }
+  } catch (e) {
+    console.error(e.message);
+    process.exit(1);
+  }
+}
+
+async function cmdOllamaTest(args) {
+  const modelName = args[0];
+  
+  if (!modelName) {
+    console.error('Error: Model name required');
+    console.log('Usage: construct ollama test <model>');
+    process.exit(1);
+  }
+  
+  console.log(`Testing ${modelName}...`);
+  const result = testModel(modelName);
+  
+  if (result.success) {
+    console.log(`✅ Response (${result.duration}):`);
+    console.log('─'.repeat(50));
+    console.log(result.response);
+  } else {
+    console.error(`❌ Test failed: ${result.error}`);
+    process.exit(1);
+  }
+}
+
+async function cmdOllamaSetup(args) {
+  const autoYes = args.includes('--yes') || args.includes('-y');
+  
+  console.log('Ollama Setup');
+  console.log('─'.repeat(50));
+  
+  // Check installation
+  const status = checkOllamaStatus();
+  
+  if (!status.installed) {
+    console.log('❌ Ollama is not installed');
+    if (autoYes || process.platform === 'darwin') {
+      console.log('Installing via Homebrew...');
+      try {
+        execSync('brew install ollama', { stdio: 'inherit' });
+        console.log('✅ Ollama installed');
+      } catch (e) {
+        console.error('❌ Installation failed. Please install manually: https://ollama.com');
+        process.exit(1);
+      }
+    } else {
+      console.log('Install with: brew install ollama');
+      process.exit(1);
+    }
+  } else {
+    console.log('✅ Ollama is installed');
+  }
+  
+  // Check if running
+  if (!status.running) {
+    console.log('⚠️  Ollama is not running');
+    console.log('Starting Ollama service...');
+    try {
+      execSync('brew services start ollama', { stdio: 'pipe' });
+      console.log('✅ Ollama service started');
+      // Wait for it to be ready
+      console.log('Waiting for Ollama to be ready...');
+      execSync('sleep 3');
+    } catch (e) {
+      console.log('You can start it manually with: ollama serve');
+    }
+  } else {
+    console.log('✅ Ollama is running');
+  }
+  
+  // Pull default model
+  console.log('\nPulling default model (llama3.2)...');
+  const pullResult = pullModel('llama3.2', { verbose: false });
+  if (pullResult.success) {
+    console.log('✅ llama3.2 ready');
+  } else {
+    console.log('⚠️  Could not pull llama3.2, you can pull it later with: construct ollama pull llama3.2');
+  }
+  
+  console.log('\n─'.repeat(50));
+  console.log('Setup complete!');
+  console.log('\nUsage:');
+  console.log('  construct ollama list     # List available models');
+  console.log('  construct ollama test llama3.2  # Test a model');
+  console.log('  construct models --set=ollama/llama3.2  # Set as default');
+}
+
+function formatSize(bytes) {
+  if (!bytes) return 'unknown';
+  const gb = bytes / (1024 * 1024 * 1024);
+  if (gb >= 1) return `${gb.toFixed(1)} GB`;
+  const mb = bytes / (1024 * 1024);
+  return `${mb.toFixed(0)} MB`;
+}

package/lib/opencode-config.mjs

@@ -1,7 +1,10 @@
 /**
- * lib/opencode-config.mjs — <one-line purpose>
+ * lib/opencode-config.mjs — Read and write the OpenCode settings.json config file.
  *
- * <2–6 line summary: what it does, who calls it, key side effects.>
+ * Locates the active OpenCode config across standard install paths, parses it,
+ * and provides typed helpers to read provider settings, MCP registrations, and
+ * model assignments. Changes are written atomically. Backs model-router,
+ * mcp-manager, and the runtime plugin.
  */
 import fs from "node:fs";
 import path from "node:path";
@@ -36,9 +39,16 @@ export function readOpenCodeConfig() {
   };
 }
 
+export function sanitizeOpenCodeConfig(config) {
+  if (!config || Array.isArray(config) || typeof config !== "object") return config;
+  const sanitized = { ...config };
+  delete sanitized.construct;
+  return sanitized;
+}
+
 export function writeOpenCodeConfig(config, file = findOpenCodeConfigPath()) {
   const canonical = getCanonicalOpenCodeConfigPath();
   fs.mkdirSync(path.dirname(canonical), { recursive: true });
-  fs.writeFileSync(canonical, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+  fs.writeFileSync(canonical, `${JSON.stringify(sanitizeOpenCodeConfig(config), null, 2)}\n`, "utf8");
   return canonical;
 }

package/lib/opencode-runtime-plugin.mjs

@@ -1,8 +1,8 @@
 /**
- * lib/opencode-runtime-plugin.mjs — OpenCode plugin: Langfuse telemetry + model fallback.
+ * lib/opencode-runtime-plugin.mjs — OpenCode plugin: Telemetry + model fallback.
  *
  * Intercepts OpenCode session events (session.created, session.idle, session.error),
- * records each as a Langfuse trace, and applies model fallback on rate-limit errors.
+ * records each as a telemetry trace, and applies model fallback on rate-limit errors.
  */
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -11,7 +11,7 @@ import { spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { findOpenCodeConfigPath } from "./opencode-config.mjs";
 import { classifyProviderFailure, readCurrentModels, resolveExecutionContractModelMetadata, resolveFallbackAction, selectModelTierForWorkCategory } from "./model-router.mjs";
-import { resolveRuntimePromptMetadata } from "./prompt-composer.mjs";
+import { resolveRuntimePromptMetadata } from "./prompt-composer.js";
 import { enrichMetadataWithPrompt } from "./prompt-metadata.mjs";
 import { loadToolkitEnv } from "./toolkit-env.mjs";
 import { routeRequest } from "./orchestration-policy.mjs";
@@ -25,8 +25,9 @@ import {
   onCommandBefore,
   getIngestClient,
 } from "./opencode-telemetry.mjs";
-import { syncModelPricing } from "./telemetry/langfuse-model-sync.mjs";
-import { estimateUsageCost } from "./telemetry/langfuse-model-sync.mjs";
+import { syncModelPricing, refreshPricingCatalog } from "./telemetry/model-pricing-catalog.mjs";
+import { estimateUsageCost } from "./telemetry/model-pricing-catalog.mjs";
+import { buildSessionPrelude } from "./intake/session-prelude.mjs";
 
 const EFFICIENCY_SESSION_IDLE_RESET_MS = 2 * 60 * 60 * 1000;
 const EFFICIENCY_REPEATED_READ_THRESHOLD = 5;
@@ -63,6 +64,32 @@ const RUNTIME_TRACE_EVENTS = new Set([
   "message.updated",
 ]);
 
+// One-shot prelude emission per session id — kept in module scope so the
+// prelude surfaces on session.created and not on every subsequent event
+// that carries the same session id.
+const preludeEmittedSessions = new Set();
+
+export function _resetPreludeForTests() {
+  preludeEmittedSessions.clear();
+}
+
+export async function emitSessionPrelude(event, { client, env = process.env, cwd } = {}) {
+  if (event?.type !== "session.created") return false;
+  const sessionId = getSessionId(event) || "anonymous";
+  if (preludeEmittedSessions.has(sessionId)) return false;
+  preludeEmittedSessions.add(sessionId);
+  const prelude = buildSessionPrelude({ cwd: cwd || env.CX_TOOLKIT_DIR || process.cwd(), env });
+  if (!prelude) return false;
+  await client?.app?.log?.({
+    body: {
+      service: "construct",
+      level: "info",
+      message: prelude,
+    },
+  }).catch(() => {});
+  return true;
+}
+
 const COOLDOWN_MS = 10 * 60 * 1000;
 
 function getStatePath(env = process.env) {
@@ -179,12 +206,25 @@ function sanitizeUsage(event) {
     legacyUsage?.cacheReadInputTokens,
     legacyUsage?.prompt_tokens_details?.cached_tokens,
   );
+  const cacheCreation5mInputTokens = positiveNumber(
+    infoTokens?.cache?.write_5m,
+    infoTokens?.cache?.create_5m,
+    legacyUsage?.cache_creation?.ephemeral_5m_input_tokens,
+    legacyUsage?.cache_creation_5m_input_tokens,
+    legacyUsage?.cacheCreation5mInputTokens,
+  );
+  const cacheCreation1hInputTokens = positiveNumber(
+    infoTokens?.cache?.write_1h,
+    infoTokens?.cache?.create_1h,
+    legacyUsage?.cache_creation?.ephemeral_1h_input_tokens,
+    legacyUsage?.cache_creation_1h_input_tokens,
+    legacyUsage?.cacheCreation1hInputTokens,
+  );
   const cacheCreationInputTokens = positiveNumber(
     infoTokens?.cache?.write,
     legacyUsage?.cache_creation_input_tokens,
     legacyUsage?.cacheCreationInputTokens,
-    (legacyUsage?.cache_creation?.ephemeral_5m_input_tokens ?? 0) +
-      (legacyUsage?.cache_creation?.ephemeral_1h_input_tokens ?? 0),
+    cacheCreation5mInputTokens + cacheCreation1hInputTokens,
   );
   const totalTokens = positiveNumber(
     legacyUsage?.total_tokens,
@@ -201,6 +241,8 @@ function sanitizeUsage(event) {
     totalTokens,
     ...(cacheReadInputTokens ? { cacheReadInputTokens } : {}),
     ...(cacheCreationInputTokens ? { cacheCreationInputTokens } : {}),
+    ...(cacheCreation5mInputTokens ? { cacheCreation5mInputTokens } : {}),
+    ...(cacheCreation1hInputTokens ? { cacheCreation1hInputTokens } : {}),
     ...(reasoningTokens ? { reasoningTokens } : {}),
     ...(cost ? { costUsd: cost, costSource: "event" } : {}),
   };
@@ -367,7 +409,7 @@ function buildHostConstraints() {
   return {
     runtime: "opencode",
     providerAgnostic: true,
-    telemetryBackend: "langfuse",
+    telemetryBackend: "telemetry",
   };
 }
 
@@ -426,12 +468,12 @@ export function buildRuntimeTracePayload(event, { env = process.env } = {}) {
     eventType: event.type,
     agent: agent || undefined,
     status: stripPlaceholder(event?.status || event?.session?.status || event?.data?.status),
+    ...runtimePromptMetadata,
     ...usage,
     ...(pricing.costUsd ? { costUsd: pricing.costUsd, costSource: pricing.costSource, costModel: pricing.modelName } : { costUsd: 0, costSource: pricing.costSource, costModel: pricing.modelName }),
     ...(modelInfo.modelName ? { modelName: modelInfo.modelName } : {}),
     ...(modelInfo.provider ? { provider: modelInfo.provider } : {}),
     ...errorMeta,
-    ...runtimePromptMetadata,
   }, { rootDir });
 
   // Extract assistant response text for message.updated events so the trace output is populated.
@@ -632,23 +674,6 @@ export function trackReadEfficiencyFromMessage(event, { env = process.env, cwd =
   return { warnings };
 }
 
-function langfuseAvailable(env = process.env) {
-  return Boolean(env.LANGFUSE_PUBLIC_KEY && env.LANGFUSE_SECRET_KEY);
-}
-
-function langfuseHeaders(env = process.env) {
-  const key = env.LANGFUSE_PUBLIC_KEY;
-  const secret = env.LANGFUSE_SECRET_KEY;
-  return {
-    Authorization: `Basic ${Buffer.from(`${key}:${secret}`).toString('base64')}`,
-    'Content-Type': 'application/json',
-  };
-}
-
-function langfuseBaseUrl(env = process.env) {
-  return (env.LANGFUSE_BASEURL ?? 'https://cloud.langfuse.com').replace(/\/$/, '');
-}
-
 async function emitRuntimeTrace(event, { client, env = process.env }) {
   const payload = buildRuntimeTracePayload(event, { env });
   if (!payload) return;
@@ -683,7 +708,7 @@ async function emitRuntimeTrace(event, { client, env = process.env }) {
         return text || undefined;
       })();
       const toolCalls = extractReadToolCalls(info);
-      const langfuseUsage = usage.inputTokens ? {
+      const telemetryUsage = usage.inputTokens ? {
         input: usage.inputTokens,
         output: usage.outputTokens,
         total: usage.totalTokens,
@@ -697,7 +722,7 @@ async function emitRuntimeTrace(event, { client, env = process.env }) {
         startTime: info?.time?.created ? new Date(info.time.created).toISOString() : payload.timestamp,
         endTime: info?.time?.completed ? new Date(info.time.completed).toISOString() : new Date().toISOString(),
         model,
-        usage: langfuseUsage,
+        usage: telemetryUsage,
         output: {
           kind: "assistant_generation",
           agent: payload.metadata?.agent || undefined,
@@ -709,12 +734,12 @@ async function emitRuntimeTrace(event, { client, env = process.env }) {
           costSource: pricing.costSource,
           costModel: pricing.modelName,
           toolCalls: toolCalls.length ? toolCalls.map((call) => ({ filePath: call.filePath, limit: call.limit, callId: call.callId })) : undefined,
-          usage: langfuseUsage ? {
-            input: langfuseUsage.input,
-            output: langfuseUsage.output,
-            total: langfuseUsage.total,
-            unit: langfuseUsage.unit,
-            ...(langfuseUsage.totalCost ? { totalCost: langfuseUsage.totalCost } : {}),
+          usage: telemetryUsage ? {
+            input: telemetryUsage.input,
+            output: telemetryUsage.output,
+            total: telemetryUsage.total,
+            unit: telemetryUsage.unit,
+            ...(telemetryUsage.totalCost ? { totalCost: telemetryUsage.totalCost } : {}),
           } : undefined,
         },
         metadata: {
@@ -725,6 +750,9 @@ async function emitRuntimeTrace(event, { client, env = process.env }) {
           costModel: pricing.modelName,
           ...(usage.reasoningTokens ? { reasoningTokens: usage.reasoningTokens } : {}),
           ...(usage.cacheReadInputTokens ? { cacheReadInputTokens: usage.cacheReadInputTokens } : {}),
+          ...(usage.cacheCreationInputTokens ? { cacheCreationInputTokens: usage.cacheCreationInputTokens } : {}),
+          ...(usage.cacheCreation5mInputTokens ? { cacheCreation5mInputTokens: usage.cacheCreation5mInputTokens } : {}),
+          ...(usage.cacheCreation1hInputTokens ? { cacheCreation1hInputTokens: usage.cacheCreation1hInputTokens } : {}),
         },
       });
       await ingest.flush();
@@ -856,11 +884,14 @@ export function createConstructOpenCodePlugin({
   configPath = findOpenCodeConfigPath(),
 } = {}) {
   loadToolkitEnv(toolkitDir, env);
-  // Fire-and-forget: sync model pricing into Langfuse on plugin load.
+  // Refresh local pricing catalog from LiteLLM (24h cached, no auth). Runs before
+  // Sync pricing so estimateUsageCost uses live rates from the first assistant turn.
+  void refreshPricingCatalog().catch(() => {});
+  // Fire-and-forget: sync model pricing into telemetry backend on plugin load.
   void syncModelPricing({
-    baseUrl: env.LANGFUSE_BASEURL,
-    publicKey: env.LANGFUSE_PUBLIC_KEY,
-    secretKey: env.LANGFUSE_SECRET_KEY,
+    baseUrl: env.CONSTRUCT_TELEMETRY_URL,
+    publicKey: env.CONSTRUCT_TELEMETRY_PUBLIC_KEY,
+    secretKey: env.CONSTRUCT_TELEMETRY_SECRET_KEY,
   }).catch(() => {});
   const safe = async (fn, label, client) => {
     try {
@@ -879,6 +910,7 @@ export function createConstructOpenCodePlugin({
     event: async ({ event }) => {
       await safe(() => onBusEvent(event, { env }), "event", client);
       await safe(() => emitRuntimeTrace(event, { client, env }), "legacy-trace", client);
+      await safe(() => emitSessionPrelude(event, { client, env, cwd: toolkitDir }), "session-prelude", client);
       await maybeApplyModelFallback(event, { client, env, toolkitDir, configPath });
       try {
         const { warnings } = trackReadEfficiencyFromMessage(event, { env, cwd: toolkitDir || process.cwd() });