@smartmemory/compose 0.1.1-beta → 0.1.2-beta

package/server/decision-events-snapshot.js

@@ -0,0 +1,166 @@
+/**
+ * decision-events-snapshot.js — Derive DecisionEvent[] from persisted lifecycle state.
+ *
+ * COMP-OBS-TIMELINE A6: on WS connect the server re-derives the current
+ * feature's DecisionEvents from already-persisted sources so the client can
+ * seed its store without waiting for a live replay.
+ *
+ * Sources:
+ *   - kind=phase_transition  → lifecycle.phaseHistory[]  (populated by lifecycle-phase-history.js)
+ *   - kind=iteration         → lifecycle.iterationState  (start + complete pairs)
+ *   - kind=branch            → lifecycle.lifecycle_ext.branch_lineage.branches[]
+ *   - kind=gate              → gate-log.jsonl (populated by COMP-OBS-GATELOG)
+ *   - kind=drift_threshold   → lifecycle.lifecycle_ext.drift_axes[] (COMP-OBS-DRIFT)
+ *
+ * Deterministic ids: re-derive == identity with the live emitters because both
+ * use the same id helpers from decision-event-id.js.
+ */
+
+import {
+  phaseTransitionDecisionEventId,
+  iterationDecisionEventId,
+  branchDecisionEventId,
+} from './decision-event-id.js';
+import { buildPhaseTransitionEvent, buildIterationEvent, buildGateEvent, buildDriftThresholdEvent } from './decision-event-emit.js';
+import { readGateLog } from './gate-log-store.js';
+
+/**
+ * Derive all DecisionEvents for a given featureCode from persisted lifecycle state.
+ *
+ * @param {object} state — { items: Map<id, item> } (from VisionStore.getState or internal)
+ * @param {string} featureCode — the feature to filter for
+ * @returns {DecisionEvent[]} array sorted by timestamp ascending
+ */
+export function deriveDecisionEvents(state, featureCode) {
+  const events = [];
+
+  // state may expose items as Map (internal) or Array (getState). Handle both.
+  const itemsIterable = state.items instanceof Map
+    ? state.items.values()
+    : (Array.isArray(state.items) ? state.items : []);
+
+  for (const item of itemsIterable) {
+    const lc = item?.lifecycle;
+    if (!lc) continue;
+    if (lc.featureCode !== featureCode) continue;
+
+    // ── phase_transition events ─────────────────────────────────────────────
+    for (const entry of lc.phaseHistory || []) {
+      events.push(buildPhaseTransitionEvent({
+        featureCode,
+        from: entry.from,
+        to: entry.to,
+        outcome: entry.outcome,
+        agent_id: entry.agent_id || null,
+        timestamp: entry.timestamp,
+      }));
+    }
+
+    // ── iteration events ────────────────────────────────────────────────────
+    const iter = lc.iterationState;
+    if (iter?.loopId) {
+      // Always emit start event
+      events.push(buildIterationEvent({
+        featureCode,
+        loopId: iter.loopId,
+        loopType: iter.loopType,
+        stage: 'start',
+        attempt: null,
+        outcome: 'retry',
+        timestamp: iter.startedAt,
+      }));
+
+      // Emit complete event only when loop has actually completed
+      if (iter.status === 'complete' && iter.completedAt) {
+        events.push(buildIterationEvent({
+          featureCode,
+          loopId: iter.loopId,
+          loopType: iter.loopType,
+          stage: 'complete',
+          attempt: iter.count,
+          outcome: iter.outcome,
+          timestamp: iter.completedAt,
+        }));
+      }
+    }
+
+    // ── branch events ───────────────────────────────────────────────────────
+    // Production lineage is persisted at `item.lifecycle.lifecycle_ext.branch_lineage`
+    // by `vision-store.updateLifecycleExt`. Earlier drafts read `item.lifecycle_ext`
+    // (top-level), which is why test fixtures occasionally produced the wrong shape.
+    const lineage = lc.lifecycle_ext?.branch_lineage;
+    if (lineage?.branches) {
+      // Compute sibling_branch_ids per branch — all branches sharing the same
+      // non-null fork_uuid (the convention BRANCH's live emitter uses).
+      const siblingsByFork = new Map();
+      for (const b of lineage.branches) {
+        if (!b.fork_uuid) continue;
+        if (!siblingsByFork.has(b.fork_uuid)) siblingsByFork.set(b.fork_uuid, []);
+        siblingsByFork.get(b.fork_uuid).push(b.branch_id);
+      }
+      for (const branch of lineage.branches) {
+        const eventId = branchDecisionEventId(featureCode, branch.branch_id);
+        const siblingIds = branch.fork_uuid ? siblingsByFork.get(branch.fork_uuid) ?? [] : [];
+        events.push({
+          id: eventId,
+          feature_code: featureCode,
+          timestamp: branch.started_at,
+          kind: 'branch',
+          title: `New branch ${branch.branch_id.slice(0, 8)}…`,
+          metadata: {
+            branch_id: branch.branch_id,
+            fork_uuid: branch.fork_uuid || null,
+            sibling_branch_ids: siblingIds,
+          },
+          roles: [],
+        });
+      }
+    }
+
+    // ── drift_threshold events (kind=drift_threshold) — COMP-OBS-DRIFT ────────
+    // Rehydrate from persisted DriftAxis.breach_event_id + breach_started_at.
+    // Using persisted fields guarantees byte-for-byte identity with the live emit
+    // — we do NOT recompute from current computed_at, which would produce a
+    // different id on every reconnect.
+    const driftAxes = lc.lifecycle_ext?.drift_axes ?? [];
+    for (const axis of driftAxes) {
+      if (axis.breached === true && axis.breach_event_id && axis.breach_started_at) {
+        events.push(buildDriftThresholdEvent({
+          featureCode,
+          axisId: axis.axis_id,
+          ratio: axis.ratio,
+          threshold: axis.threshold,
+          breachStartedAt: axis.breach_started_at,
+          breachEventId: axis.breach_event_id,
+        }));
+      }
+    }
+  }
+
+  // ── gate events (kind=gate) — rehydrate from project gate-log.jsonl ──────
+  // Without this, live gate cards on the timeline disappear after WS reconnect.
+  // The gate log is project-scoped (NOT app-global), so cross-feature filter is safe.
+  try {
+    const entries = readGateLog({ featureCode });
+    for (const entry of entries) {
+      // Translate route-vocab decision (approve/revise/kill) into schema vocab
+      // before composing the event. Entry already stores schema vocab, but
+      // buildGateEvent re-maps for safety.
+      const event = buildGateEvent({
+        featureCode,
+        gateLogEntryId: entry.id,
+        gateId: entry.gate_id,
+        decision: entry.decision, // already schema vocab — buildGateEvent passes through
+        timestamp: entry.timestamp,
+      });
+      events.push(event);
+    }
+  } catch (err) {
+    // Gate log read is best-effort; missing/unreadable files yield no gate events.
+    // Existing rehydration of phase/iteration/branch events still proceeds.
+  }
+
+  // Sort by timestamp ascending (oldest first — strip renders newest-right)
+  events.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  return events;
+}

package/server/design-routes.js

@@ -12,7 +12,34 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
+import { randomUUID } from 'node:crypto';
 import { parseDecisionBlocks } from '../src/components/vision/designSessionState.js';
+import { StratumMcpClient } from '../lib/stratum-mcp-client.js';
+
+// Lazy singleton — design conversations share one stratum-mcp connection
+// across the server process lifetime. Concurrent runs are correlation-id scoped.
+let _stratumClient = null;
+let _stratumConnectPromise = null;
+async function _getStratum() {
+  if (_stratumClient) return _stratumClient;
+  if (!_stratumConnectPromise) {
+    const c = new StratumMcpClient();
+    _stratumConnectPromise = c.connect()
+      .then(() => { _stratumClient = c; return c; })
+      .catch((err) => { _stratumConnectPromise = null; throw err; });
+  }
+  return _stratumConnectPromise;
+}
+
+/** Tear down the cached stratum-mcp connection. Tests should call this in after(). */
+export async function closeDesignStratum() {
+  const c = _stratumClient;
+  _stratumClient = null;
+  _stratumConnectPromise = null;
+  if (c) {
+    try { await c.close(); } catch { /* ignore */ }
+  }
+}
 
 /** @type {Map<string, Set<import('node:http').ServerResponse>>} — key is `${scope}:${featureCode || ''}` */
 export const designListeners = new Map();
@@ -64,6 +91,9 @@ export function broadcastDesignEvent(key, type, data) {
 async function dispatchDesignAgent(sessionManager, projectRoot, scope, featureCode) {
   const key = sessionKey(scope, featureCode, projectRoot);
   if (_inFlight.has(key)) return; // already running
+  // Tests assert on the HTTP response only — skip the LLM round-trip to avoid
+  // keeping a stratum-mcp subprocess alive past the test lifetime.
+  if (process.env.NODE_ENV === 'test' || process.env.COMPOSE_DESIGN_DISPATCH === '0') return;
   _inFlight.add(key);
   // Snapshot message count so we can detect new messages arriving during the run
   let promptMessageCount = 0;
@@ -107,44 +137,60 @@ Conversation history:
 ${formattedMessages}`;
 
     let fullContent = '';
-    let lastToolName = null;
     let toolUseCounter = 0;
-    let lastToolUseId = null;
-
-    const { ClaudeSDKConnector } = await import('./connectors/claude-sdk-connector.js');
-    const connector = new ClaudeSDKConnector({ cwd: projectRoot });
-
-    for await (const event of connector.run(systemPrompt)) {
-      if (event.type === 'assistant' && event.content) {
-        fullContent += event.content;
-        broadcastDesignEvent(key, 'text', { content: event.content });
-      } else if (event.type === 'result' && event.content) {
-        // Final aggregated text — use it if we haven't accumulated anything
-        if (!fullContent) {
-          fullContent = event.content;
-          broadcastDesignEvent(key, 'text', { content: event.content });
+
+    const stratum = await _getStratum();
+    const correlationId = randomUUID();
+    const subStepId = '_agent_run';
+
+    const unsub = stratum.onEvent(correlationId, subStepId, (env) => {
+      if (!env || env.schema_version !== '0.2.5') return;
+      const m = env.metadata ?? {};
+      switch (env.kind) {
+        case 'agent_relay':
+          if (m.role === 'assistant' && typeof m.text === 'string' && m.text.length > 0) {
+            fullContent += m.text;
+            broadcastDesignEvent(key, 'text', { content: m.text });
+          }
+          break;
+        case 'tool_use_summary': {
+          const toolUseId = `tu-${++toolUseCounter}`;
+          if (m.tool) {
+            broadcastDesignEvent(key, 'research', {
+              id: toolUseId,
+              tool: m.tool,
+              input: m.input ?? {},
+              timestamp: new Date().toISOString(),
+            });
+          }
+          if (m.summary) {
+            broadcastDesignEvent(key, 'research_result', {
+              id: toolUseId,
+              tool: m.tool ?? null,
+              summary: String(m.summary).slice(0, 200),
+              timestamp: new Date().toISOString(),
+            });
+          }
+          break;
         }
-      } else if (event.type === 'error') {
-        broadcastDesignEvent(key, 'error', { message: event.message });
-        return;
-      } else if (event.type === 'tool_use') {
-        lastToolName = event.tool;
-        lastToolUseId = `tu-${++toolUseCounter}`;
-        broadcastDesignEvent(key, 'research', {
-          id: lastToolUseId,
-          tool: event.tool,
-          input: event.input,
-          timestamp: new Date().toISOString(),
-        });
-      } else if (event.type === 'tool_use_summary') {
-        broadcastDesignEvent(key, 'research_result', {
-          id: lastToolUseId,
-          tool: lastToolName,
-          summary: (event.summary || '').slice(0, 200),
-          timestamp: new Date().toISOString(),
-        });
+        default:
+          break;
       }
-      // Ignore other system init/complete events
+    });
+
+    let runResult;
+    try {
+      runResult = await stratum.agentRun('claude', systemPrompt, {
+        cwd: projectRoot,
+        correlationId,
+      });
+    } finally {
+      unsub();
+    }
+    // Fall back to result.text if no agent_relay events arrived (older producers).
+    if (!fullContent && runResult?.text) {
+      fullContent = runResult.text;
+      broadcastDesignEvent(key, 'text', { content: fullContent });
     }
 
     // Parse for decision blocks and broadcast them
@@ -190,9 +236,9 @@ ${formattedMessages}`;
  * surviving project switches via /api/project/switch.
  *
  * @param {object} app — Express app
- * @param {{ getSessionManager: () => import('./design-session.js').DesignSessionManager, getConnector: () => import('./connectors/claude-sdk-connector.js').ClaudeSDKConnector|null, getProjectRoot: () => string }} deps
+ * @param {{ getSessionManager: () => import('./design-session.js').DesignSessionManager, getProjectRoot: () => string }} deps
  */
-export function attachDesignRoutes(app, { getSessionManager, getConnector, getProjectRoot }) {
+export function attachDesignRoutes(app, { getSessionManager, getProjectRoot }) {
   // POST /api/design/start
   app.post('/api/design/start', (req, res) => {
     const { scope, featureCode } = req.body || {};
@@ -328,8 +374,10 @@ export function attachDesignRoutes(app, { getSessionManager, getConnector, getPr
         return res.status(404).json({ error: `No session found for ${scope}${featureCode ? `:${featureCode}` : ''}` });
       }
 
-      // If no connector available or no projectRoot, mark complete and skip doc generation
-      if (!getConnector() || !projectRoot) {
+      // No projectRoot, or test/dispatch-disabled mode → mark complete and skip doc generation.
+      const dispatchDisabled =
+        process.env.NODE_ENV === 'test' || process.env.COMPOSE_DESIGN_DISPATCH === '0';
+      if (!projectRoot || dispatchDisabled) {
         const completedSession = sessionManager.completeSession(scope, featureCode);
         res.json({ session: completedSession });
         return;
@@ -379,18 +427,13 @@ Write the design document in Markdown format. Include:
 
 Output ONLY the Markdown content, no code fences.`;
 
-      // Generate the design doc via a fresh connector
-      const { ClaudeSDKConnector } = await import('./connectors/claude-sdk-connector.js');
-      const connector = new ClaudeSDKConnector({ cwd: projectRoot });
+      // Generate the design doc via the persistent stratum-mcp client.
+      // No streaming needed for the one-shot doc generation.
       let docContent = '';
       try {
-        for await (const event of connector.run(docPrompt)) {
-          if (event.type === 'assistant' && event.content) {
-            docContent += event.content;
-          } else if (event.type === 'result' && event.content && !docContent) {
-            docContent = event.content;
-          }
-        }
+        const stratum = await _getStratum();
+        const result = await stratum.runAgentText('claude', docPrompt, { cwd: projectRoot });
+        docContent = result || '';
       } catch (err) {
         // If generation fails, don't complete — let user retry
         console.error('[design] Doc generation failed:', err.message);