@geraldmaron/construct 1.1.1 → 1.2.1

package/lib/server/index.mjs

@@ -4,7 +4,7 @@
  * Serves the single-page dashboard from lib/server/static/, provides a JSON
  * status API, SSE live-reload, REST endpoints for registry management,
  * artifact generation/listing, approval queue inspection, snapshot data,
- * token-based auth, and SSE-streamed chat via the claude CLI.
+ * token-based auth, legacy claude CLI chat, and owned-loop SSE web chat.
  * Runs on port 4242 (overridable via PORT env var), bound to 127.0.0.1.
  */
 import { createServer } from 'http';
@@ -19,15 +19,21 @@ import { buildStatus as buildSharedStatus } from '../status.mjs';
 import { generateArtifact, listArtifacts } from '../embed/artifact.mjs';
 import { ApprovalQueue } from '../embed/approval-queue.mjs';
 import { resolveEmbedStatus } from '../embed/cli.mjs';
-import { loadConstructEnv } from '../env-config.mjs';
+import { loadConstructEnv, prepareConstructEnv } from '../runtime-env.mjs';
 import {
   isAuthConfigured, isAuthenticated, rejectUnauthorized,
   validateToken, createSession, sessionCookieHeader, clearSessionCookieHeader,
   getDashboardToken, getAuthConfig,
 } from './auth.mjs';
 import { handleChatStream, handleChat, handleChatHistory } from './chat.mjs';
+import {
+  handleChatLoopStream, handleChatLoopPermission, handleChatLoopPending, handleChatLoopConfig,
+  handleChatLoopCommand, handleChatLoopHistory, handleChatLoopCancel, handleChatModels, handleChatModelSelect,
+} from './chat-loop.mjs';
 import { createWebhookHandler, createSlackCommandHandler } from './webhook.mjs';
 import { onEmbedNotification } from '../embed/notifications.mjs';
+import { artifactTypes, templateMetadata } from '../artifact-manifest.mjs';
+import { resolveDemoPreviewPath, demoPreviewMime } from './demo-preview.mjs';
 
 const __dirname = fileURLToPath(new URL('.', import.meta.url));
 const ROOT_DIR = join(__dirname, '..', '..');
@@ -355,6 +361,9 @@ async function buildStatus() {
     ...status,
     skills: listSkills(),
     commands: listCommands(),
+    artifactManifest: Object.fromEntries(
+      artifactTypes({ rootDir: ROOT_DIR }).map((type) => [type, templateMetadata(type, { rootDir: ROOT_DIR })]),
+    ),
   };
 }
 
@@ -693,8 +702,11 @@ const server = createServer(async (req, res) => {
     ensureCsrfCookie(req, res);
   }
   const rateTier = url.pathname === '/api/chat/stream' || url.pathname === '/api/chat'
+    || url.pathname === '/api/chat/loop/stream'
     ? 'chat'
-    : (req.method !== 'GET' && req.method !== 'HEAD' ? 'write' : 'read');
+    : url.pathname === '/api/chat/loop/command'
+      ? 'command'
+      : (req.method !== 'GET' && req.method !== 'HEAD' ? 'write' : 'read');
   if (checkRateLimit) {
     const limit = checkRateLimit(req, rateTier, { env: process.env });
     if (!limit.allowed) {
@@ -836,6 +848,141 @@ const server = createServer(async (req, res) => {
     return;
   }
 
+  if (url.pathname === '/api/certification/status' && req.method === 'GET') {
+    try {
+      const { buildCertificationDashboard } = await import('../certification/dashboard-api.mjs');
+      const capabilityId = url.searchParams.get('capabilityId');
+      const payload = capabilityId
+        ? (await import('../certification/status.mjs')).buildCertificationStatus({
+          rootDir: process.cwd(),
+          capabilityId,
+        })
+        : buildCertificationDashboard({ rootDir: process.cwd() });
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(payload));
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: err.message }));
+    }
+    return;
+  }
+
+  if (url.pathname === '/api/oracle/pending' && req.method === 'GET') {
+    try {
+      const { listPending } = await import('../oracle/actions.mjs');
+      const pending = listPending(process.cwd()).filter((p) => p.status !== 'approved');
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ pending }));
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: err.message }));
+    }
+    return;
+  }
+
+  if (url.pathname === '/api/improvement/pending' && req.method === 'GET') {
+    try {
+      const { listPending } = await import('../improvement/surface.mjs');
+      const pending = listPending(process.cwd());
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ pending }));
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: err.message }));
+    }
+    return;
+  }
+
+  if (url.pathname.startsWith('/api/improvement/') && req.method === 'POST') {
+    const action = url.pathname.slice('/api/improvement/'.length);
+    let body = '';
+    req.on('data', (chunk) => { body += chunk; });
+    req.on('end', async () => {
+      try {
+        const data = JSON.parse(body || '{}');
+        const projectDir = process.cwd();
+        const { reviewRecord, approveRecord, applyRecord, rollbackRecord } = await import('../improvement/surface.mjs');
+        let result;
+        if (action === 'review') {
+          if (!data.id) throw new Error('Missing id');
+          result = reviewRecord(projectDir, data.id);
+        } else if (action === 'approve') {
+          if (!data.id) throw new Error('Missing id');
+          result = approveRecord(projectDir, data.id, { identity: data.identity });
+        } else if (action === 'apply') {
+          if (!data.id) throw new Error('Missing id');
+          result = applyRecord(projectDir, data.id, { monitor: data.monitor });
+        } else if (action === 'rollback') {
+          if (!data.id) throw new Error('Missing id');
+          result = rollbackRecord(projectDir, data.id, { reason: data.reason });
+        } else {
+          throw new Error(`Unknown improvement action: ${action}`);
+        }
+        const status = result.ok === false && result.error ? 400 : 200;
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(result));
+        notifyClients();
+      } catch (err) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+    });
+    return;
+  }
+
+  if (url.pathname.startsWith('/api/improvement/') && req.method === 'GET') {
+    const id = decodeURIComponent(url.pathname.slice('/api/improvement/'.length));
+    if (id && id !== 'pending') {
+      try {
+        const { loadRecord } = await import('../improvement/store.mjs');
+        const record = loadRecord(process.cwd(), id);
+        if (!record) {
+          res.writeHead(404, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'not-found' }));
+          return;
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(record));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+  }
+
+  if (url.pathname === '/api/oracle' && req.method === 'GET') {
+    try {
+      const { homedir: osHome } = await import('node:os');
+      const { readHeartbeat } = await import('../daemons/contract.mjs');
+      const { heartbeatPath, readLastTick } = await import('../oracle/index.mjs');
+      const { collectReadModel, enrichReadModel } = await import('../oracle/read-model.mjs');
+      const { synthesizeVerdict } = await import('../oracle/synthesize.mjs');
+      const home = osHome();
+      const projectDir = process.cwd();
+      const readModel = collectReadModel({ rootDir: ROOT_DIR, projectDir, homeDir: home });
+      const enriched = await enrichReadModel(readModel);
+      const synthesis = synthesizeVerdict(enriched);
+      const hb = readHeartbeat(heartbeatPath(home));
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        running: !!hb,
+        heartbeat: hb,
+        lastTick: readLastTick(home),
+        verdict: synthesis.verdict,
+        gaps: synthesis.gaps,
+        recommendedActions: synthesis.recommendedActions,
+        orgGraph: enriched.orgGraph,
+        openBeads: enriched.beads?.openCount ?? null,
+        lastPropagationCheck: enriched.orgGraph?.propagation ?? null,
+      }));
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: err.message }));
+    }
+    return;
+  }
+
   if (url.pathname === '/api/doctor') {
     try {
       const { readState } = await import('../doctor/index.mjs');
@@ -1435,17 +1582,47 @@ const server = createServer(async (req, res) => {
     return;
   }
 
+  if (url.pathname === '/api/sources' && req.method === 'GET') {
+    try {
+      const { loadProjectConfig } = await import('../config/project-config.mjs');
+      const {
+        resolveEffectiveSourceTargetsFromConfig,
+        legacyEnvSourceTargets,
+        normalizeConfigTarget,
+      } = await import('../config/source-targets.mjs');
+      const loaded = loadProjectConfig(ROOT_DIR, process.env);
+      const configTargets = (loaded.config.sources?.targets ?? []).map(normalizeConfigTarget);
+      const envTargets = legacyEnvSourceTargets(process.env);
+      const effective = resolveEffectiveSourceTargetsFromConfig(loaded.config, process.env);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        path: loaded.path,
+        configTargets,
+        envTargets,
+        effective,
+      }));
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: err.message }));
+    }
+    return;
+  }
+
   if (url.pathname === '/api/intake/config' && req.method === 'GET') {
     try {
       const { loadIntakeConfig, INTAKE_DEPTH_GUIDANCE, INTAKE_HARD_MAX_DEPTH } = await import('../intake/intake-config.mjs');
+      const { getRebrand } = await import('../profiles/rebrand.mjs');
       const config = loadIntakeConfig(ROOT_DIR, process.env);
+      const rebrand = getRebrand(ROOT_DIR);
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({
         config,
         rootDir: ROOT_DIR,
         guidance: INTAKE_DEPTH_GUIDANCE,
         hardMaxDepth: INTAKE_HARD_MAX_DEPTH,
-        defaults: { projectInbox: '.cx/inbox', docsIntake: 'docs/intake' },
+        defaults: { projectInbox: '.cx/inbox', docsIntake: 'docs/intake', rootInbox: 'inbox/' },
+        label: rebrand.intakeQueueLabel,
+        itemNoun: rebrand.signalNoun,
       }));
     } catch (err) {
       res.writeHead(500, { 'Content-Type': 'application/json' });
@@ -1457,10 +1634,17 @@ const server = createServer(async (req, res) => {
   if (url.pathname === '/api/intake/list' && req.method === 'GET') {
     try {
       const { createIntakeQueue } = await import('../intake/queue.mjs');
+      const { getRebrand } = await import('../profiles/rebrand.mjs');
       const queue = createIntakeQueue(ROOT_DIR, process.env);
       const items = queue.listPending();
+      const rebrand = getRebrand(ROOT_DIR);
       res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ items, total: items.length }));
+      res.end(JSON.stringify({
+        items,
+        total: items.length,
+        label: rebrand.intakeQueueLabel,
+        itemNoun: rebrand.signalNoun,
+      }));
     } catch (err) {
       res.writeHead(500, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ error: err.message }));
@@ -1934,6 +2118,51 @@ const server = createServer(async (req, res) => {
     return;
   }
 
+  if (url.pathname === '/api/chat/loop/stream' && req.method === 'GET') {
+    handleChatLoopStream(req, res, { rootDir: ROOT_DIR });
+    return;
+  }
+
+  if (url.pathname === '/api/chat/loop/pending' && req.method === 'GET') {
+    handleChatLoopPending(req, res);
+    return;
+  }
+
+  if (url.pathname === '/api/chat/loop/permission' && req.method === 'POST') {
+    handleChatLoopPermission(req, res);
+    return;
+  }
+
+  if (url.pathname === '/api/chat/config' && (req.method === 'GET' || req.method === 'POST')) {
+    handleChatLoopConfig(req, res, { rootDir: ROOT_DIR });
+    return;
+  }
+
+  if (url.pathname === '/api/chat/models' && req.method === 'GET') {
+    void handleChatModels(req, res, { rootDir: ROOT_DIR });
+    return;
+  }
+
+  if (url.pathname === '/api/chat/models/select' && req.method === 'POST') {
+    handleChatModelSelect(req, res, { rootDir: ROOT_DIR });
+    return;
+  }
+
+  if (url.pathname === '/api/chat/loop/command' && req.method === 'POST') {
+    handleChatLoopCommand(req, res, { rootDir: ROOT_DIR });
+    return;
+  }
+
+  if (url.pathname === '/api/chat/loop/history' && req.method === 'GET') {
+    handleChatLoopHistory(req, res, { rootDir: ROOT_DIR });
+    return;
+  }
+
+  if (url.pathname === '/api/chat/loop/cancel' && req.method === 'POST') {
+    handleChatLoopCancel(req, res);
+    return;
+  }
+
   if (req.method === 'POST') {
     let body = '';
     req.on('data', chunk => { body += chunk; });
@@ -2140,6 +2369,7 @@ const server = createServer(async (req, res) => {
             maxDepth: data.maxDepth,
             includeProjectInbox: data.includeProjectInbox,
             includeDocsIntake: data.includeDocsIntake,
+            includeRootInbox: data.includeRootInbox ?? data.includeArchetypeInbox,
           });
           res.writeHead(200, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({ success: true, config: next }));
@@ -2298,9 +2528,21 @@ const server = createServer(async (req, res) => {
     return;
   }
 
+  if (url.pathname.startsWith('/demo-preview/')) {
+    const preview = resolveDemoPreviewPath(url.pathname);
+    if (!preview.ok) {
+      res.writeHead(preview.status);
+      res.end(preview.message);
+      return;
+    }
+    res.writeHead(200, { 'Content-Type': demoPreviewMime(preview.ext) });
+    res.end(readFileSync(preview.filePath));
+    return;
+  }
+
   // Static files
   let filePath = url.pathname === '/' ? '/index.html' : url.pathname;
-  const fullPath = join(STATIC_DIR, filePath);
+  let fullPath = join(STATIC_DIR, filePath);
 
   if (!fullPath.startsWith(STATIC_DIR)) {
     res.writeHead(403);
@@ -2308,7 +2550,14 @@ const server = createServer(async (req, res) => {
     return;
   }
 
-  if (!existsSync(fullPath)) {
+  if (existsSync(fullPath) && statSync(fullPath).isDirectory()) {
+    fullPath = join(fullPath, 'index.html');
+  } else if (!existsSync(fullPath)) {
+    const indexCandidate = join(STATIC_DIR, filePath, 'index.html');
+    if (existsSync(indexCandidate)) fullPath = indexCandidate;
+  }
+
+  if (!existsSync(fullPath) || statSync(fullPath).isDirectory()) {
     res.writeHead(404);
     res.end('Not found');
     return;
@@ -2345,11 +2594,12 @@ function runEmbedSync() {
 // from process.env (telemetry credentials, model provider keys, etc.) find them
 // even when the server is started directly (not through bin/construct).
 try {
-  const { loadConstructEnv, getUserEnvPath } = await import('../env-config.mjs');
+  const { getUserEnvPath } = await import('../env-config.mjs');
+  const { prepareConstructEnv } = await import('../runtime-env.mjs');
   const homeDir = HOME || homedir();
   const envPath = getUserEnvPath(homeDir);
   if (existsSync(envPath)) {
-    const ENV = loadConstructEnv({ rootDir: ROOT_DIR, homeDir, env: process.env });
+    const ENV = prepareConstructEnv({ rootDir: ROOT_DIR, homeDir, env: process.env });
     for (const [key, value] of Object.entries(ENV)) {
       if (!(key in process.env)) process.env[key] = value;
     }

package/lib/server/rate-limit.mjs

@@ -3,9 +3,10 @@
  *
  * Three tiers, configurable via env:
  *
- *   read    60 req/min/key  (dashboard polling, list endpoints)
- *   chat    10 req/min/key  (/api/chat/stream — bursty + expensive)
- *   write    5 req/min/key  (state-mutating endpoints — approvals, config)
+ *   read     60 req/min/key  (dashboard polling, list endpoints)
+ *   chat     10 req/min/key  (/api/chat/stream — bursty + expensive)
+ *   command 120 req/min/key  (/api/chat/loop/command — slash cmds, no LLM)
+ *   write     5 req/min/key  (state-mutating endpoints — approvals, config)
  *
  * `key` is by default the request's source IP, with the active session id
  * mixed in when present so two users behind the same NAT get separate
@@ -18,6 +19,7 @@
 const DEFAULT_TIERS = {
   read:  { capacity: 60, refillPerMs: 60 / 60_000 },
   chat:  { capacity: 10, refillPerMs: 10 / 60_000 },
+  command: { capacity: 120, refillPerMs: 120 / 60_000 },
   write: { capacity:  5, refillPerMs:  5 / 60_000 },
 };
 

package/lib/server/webhook.mjs

@@ -306,8 +306,9 @@ async function runSnapshotForSlack() {
     const { SnapshotEngine, renderMarkdown } = await import('../embed/snapshot.mjs');
     const { EMPTY_CONFIG } = await import('../embed/config.mjs');
 
-    const registry = ProviderRegistry.fromEnv(env);
-    const sources = registry.autoSources(env);
+    const registry = await ProviderRegistry.fromEnv(env);
+    const { resolveAutoEmbedSources } = await import('../embed/auto-sources.mjs');
+    const sources = resolveAutoEmbedSources({ cwd: process.cwd(), env, registry });
     if (!sources.length) return '⚠️ No embed sources configured. Add credentials to config.env.';
 
     const config = { ...EMPTY_CONFIG, sources, snapshot: { maxItems: 10 } };

package/lib/service-manager.mjs

@@ -13,10 +13,13 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import { findAvailablePort } from './host-capabilities.mjs';
+import { wrapWithOpRun } from './providers/op-run.mjs';
 import { getUserEnvPath, loadConstructEnv, parseEnvFile, writeEnvValues } from './env-config.mjs';
 import { runPressureRelease } from './runtime-pressure.mjs';
 import { resolveTraceBackend, telemetryProviderLabel } from './telemetry/client.mjs';
 import { memoryPort as derivedMemoryPort } from './home-namespace.mjs';
+import { readHeartbeat } from './daemons/contract.mjs';
+import { heartbeatPath } from './oracle/index.mjs';
 
 const DASHBOARD_STATE_FILE = 'dashboard.json';
 
@@ -95,7 +98,7 @@ export function buildRuntimeRecoverySummary({ rootDir, homeDir = os.homedir(), r
 }
 
 export function isManagedConstructPostgresUrl(databaseUrl = '') {
-  // Construct no longer manages local Postgres containers.
+  // Local Postgres lifecycle is out of Construct's scope, so no URL is Construct-managed.
   return false;
 }
 
@@ -249,6 +252,25 @@ export function startDoctor({ rootDir, homeDir = os.homedir() } = {}) {
   return { started: true, logPath };
 }
 
+export function startOracle({ rootDir, homeDir = os.homedir(), projectDir = rootDir } = {}) {
+  if (process.env.CONSTRUCT_ORACLE === 'off' || process.env.CONSTRUCT_ORACLE === '0') {
+    return { started: false, reason: 'disabled' };
+  }
+  const entry = path.join(INSTALL_ROOT, 'lib', 'oracle', 'daemon-entry.mjs');
+  if (!fs.existsSync(entry)) return { started: false, reason: 'missing-binary' };
+  const live = readHeartbeat(heartbeatPath(homeDir));
+  if (live) return { started: false, reused: true, pid: live.pid };
+  const { logPath } = spawnDetached('node', [entry], homeDir, 'oracle-daemon.log', {
+    cwd: projectDir,
+    env: {
+      ...process.env,
+      CONSTRUCT_ORACLE_ROOT: rootDir,
+      CONSTRUCT_ORACLE_PROJECT: projectDir,
+    },
+  });
+  return { started: true, logPath };
+}
+
 export async function startDashboard({ rootDir, homeDir = os.homedir(), preferredPort = 4242 } = {}) {
   const existing = readDashboardState(homeDir);
   if (existing && await isDashboardRunning(existing.port)) {
@@ -262,7 +284,16 @@ export async function startDashboard({ rootDir, homeDir = os.homedir(), preferre
   fs.mkdirSync(path.dirname(outPath), { recursive: true });
   const out = fs.openSync(outPath, 'a');
   const err = fs.openSync(outPath, 'a');
-  const child = spawn(process.execPath, [path.join(INSTALL_ROOT, 'lib', 'server', 'index.mjs')], {
+
+  // Opt-in: with CONSTRUCT_OP_ENV_FILE set, launch the daemon under `op run` so
+  // 1Password op:// refs resolve once at startup into its env. The biometric
+  // unlock prompt makes first launch slower, so widen the readiness window then.
+  const { command, args, wrapped } = wrapWithOpRun(
+    process.execPath,
+    [path.join(INSTALL_ROOT, 'lib', 'server', 'index.mjs')],
+    { env: process.env },
+  );
+  const child = spawn(command, args, {
     detached: true,
     stdio: ['ignore', out, err],
     env: { ...process.env, PORT: String(port) },
@@ -270,7 +301,8 @@ export async function startDashboard({ rootDir, homeDir = os.homedir(), preferre
   child.unref();
 
   let ready = false;
-  for (let i = 0; i < 30; i += 1) {
+  const maxTries = wrapped ? 150 : 30;
+  for (let i = 0; i < maxTries; i += 1) {
     if (await probeRuntimePort(port)) { ready = true; break; }
     await new Promise((resolve) => setTimeout(resolve, 200));
   }
@@ -278,7 +310,8 @@ export async function startDashboard({ rootDir, homeDir = os.homedir(), preferre
   if (!ready) {
     let logTail = '';
     try { logTail = fs.readFileSync(outPath, 'utf8').split('\n').slice(-12).join('\n'); } catch { /* log unreadable */ }
-    return { started: false, failed: true, port, logPath: outPath, error: `dashboard did not bind 127.0.0.1:${port} within 6s`, logTail };
+    const window = wrapped ? '30s (op run awaits 1Password unlock)' : '6s';
+    return { started: false, failed: true, port, logPath: outPath, error: `dashboard did not bind 127.0.0.1:${port} within ${window}`, logTail };
   }
 
   const state = {
@@ -342,6 +375,16 @@ export const SELECTABLE_SERVICES = Object.freeze([
   { key: 'copilot-bridge', label: 'Copilot Bridge', description: 'Host-native Copilot bridge proxy (requires gh auth).' },
 ]);
 
+// Construct does not impose an Ollama keep-alive: an operator value is honored when
+// present, otherwise the variable is left unset so the Ollama server applies its own
+// default and idle models unload on their own. A forced value would keep every
+// requested model resident in unified memory for the whole window.
+
+export function resolveOllamaKeepAlive(env = {}) {
+  const operatorValue = typeof env?.OLLAMA_KEEP_ALIVE === 'string' ? env.OLLAMA_KEEP_ALIVE.trim() : '';
+  return operatorValue || null;
+}
+
 export async function startServices({
   rootDir,
   homeDir = os.homedir(),
@@ -370,10 +413,10 @@ export async function startServices({
 
   const liveEnv = loadConstructEnvFn({ rootDir, homeDir });
   const results = [];
-  
-  // Set Ollama persistence for local inference performance
-  liveEnv.OLLAMA_KEEP_ALIVE = "-1";
-  
+
+  const operatorKeepAlive = resolveOllamaKeepAlive(liveEnv);
+  if (operatorKeepAlive) liveEnv.OLLAMA_KEEP_ALIVE = operatorKeepAlive;
+
   const pressureReport = runPressureReleaseFn({ env: { ...liveEnv, HOME: homeDir } });
   if (pressureReport?.killed?.length) {
     results.push({
@@ -481,6 +524,15 @@ export async function startServices({
     results.push({ name: 'Doctor', status: 'unavailable', note: doctor.reason });
   }
 
+  const oracle = startOracle({ rootDir, homeDir, projectDir: rootDir });
+  if (oracle.started) {
+    results.push({ name: 'Oracle', status: 'started', note: `L0.5 overseer · logs: ${oracle.logPath}` });
+  } else if (oracle.reused) {
+    results.push({ name: 'Oracle', status: 'reused', note: `pid ${oracle.pid}` });
+  } else if (oracle.reason !== 'disabled') {
+    results.push({ name: 'Oracle', status: 'unavailable', note: oracle.reason });
+  }
+
   emitServiceFailures(results);
 
   return {