opencode-wait-a-minute 0.0.0-stage → 1.1.0-rc.8

package/src/integration/router-adapter.js

@@ -0,0 +1,269 @@
+/**
+ * Context Router Adapter — transforms router output to assembly format.
+ *
+ * Bridges Context Router (graph-based) to Context Assembly (N3 packing).
+ * Router decides WHAT; Adapter formats for Assembly; Assembly decides HOW.
+ *
+ * Flow:
+ *   Task State → Context Graph → Router → Adapter → Assembly → N3
+ */
+
+import { resolveContext, ADMISSION } from "../context/context-router.js";
+import { buildContextGraph } from "../context/context-graph-builder.js";
+
+/**
+ * @typedef {Object} RouterAdapterOptions
+ * @property {string} taskId
+ * @property {number} budget
+ * @property {string} root
+ * @property {Object} graph - Context Graph instance
+ */
+
+/**
+ * @typedef {Object} AdapterResult
+ * @property {Array} capsules - Capsules in assembly format
+ * @property {string} sufficiency - "ok" | "insufficient"
+ * @property {string[]} missing
+ * @property {Object} contract
+ * @property {Object} routerResult - Raw router output
+ * @property {string} source - "router" | "fallback"
+ * @property {string} status - "READY" | "EMPTY" | "INSUFFICIENT" | "CONFLICTED" | "ERROR"
+ */
+
+/**
+ * Transform a graph node to capsule format for assembly.
+ *
+ * @param {Object} node
+ * @returns {Object} Capsule-like object
+ */
+function nodeToCapsule(node) {
+  return {
+    context_id: node.id,
+    level: node.type === "task" ? "N2" : node.type === "output" ? "N3" : "N3",
+    provenance: node.metadata?.provenance || "inferred",
+    purpose: node.metadata?.purpose || `${node.type}: ${node.id}`,
+    scope: node.type || "unknown",
+    content: node.content || "",
+    tokenEstimate: Math.ceil((node.content || "").length / 4) + 20,
+  };
+}
+
+/**
+ * Adapt router result to assembly-compatible format.
+ *
+ * @param {Object} routerResult - Output from resolveContext()
+ * @param {Object} options
+ * @returns {AdapterResult}
+ */
+export function adaptRouterResult(routerResult, options = {}) {
+  const { budget = 4000 } = options;
+
+  if (!routerResult) {
+    return {
+      capsules: [],
+      sufficiency: "insufficient",
+      missing: ["router returned null"],
+      contract: { conditions: [] },
+      routerResult: null,
+      source: "fallback",
+    };
+  }
+
+  // Transform nodes to capsules
+  const capsules = routerResult.nodes.map(nodeToCapsule);
+
+  // Build contract from missing/omitted
+  const conditions = [];
+  for (const gap of routerResult.missing || []) {
+    conditions.push({
+      id: `SC-${conditions.length + 1}`,
+      type: "dependency",
+      description: gap.description || `Missing: ${gap.requiredBy}`,
+      status: "MISSING",
+      severity: "MANDATORY",
+    });
+  }
+
+  for (const omitted of routerResult.omitted || []) {
+    conditions.push({
+      id: `SC-${conditions.length + 1}`,
+      type: "admission",
+      description: `Omitted: ${omitted.id} (${omitted.reason})`,
+      status: omitted.admission === ADMISSION.MANDATORY ? "MISSING" : "OPTIONAL",
+      severity: omitted.admission,
+    });
+  }
+
+  const missing = conditions
+    .filter((c) => c.status === "MISSING" && c.severity === "MANDATORY")
+    .map((c) => c.description);
+
+  const sufficiency = routerResult.sufficient ? "ok" : "insufficient";
+
+  // Map router results to status
+  let status = "READY";
+  if (!routerResult) status = "ERROR";
+  else if (!routerResult.nodes.length) status = "EMPTY";
+  else if (!routerResult.sufficient) status = "INSUFFICIENT";
+  else if (routerResult.budgetOverflow) status = "INSUFFICIENT";
+  else if ((routerResult.omitted || []).some((o) => o.admission === ADMISSION.MANDATORY)) status = "INSUFFICIENT";
+
+  return {
+    capsules,
+    sufficiency,
+    missing,
+    contract: { conditions },
+    routerResult,
+    source: "router",
+    status
+  };
+}
+
+/**
+ * Execute router and adapt result for assembly.
+ * This is the main integration point.
+ *
+ * Canonical path: Context Router is the sole authority for N3 selection.
+ * Silent fallbacks are forbidden; the only opt-in legacy selector is
+ * gated by env WAM_CONTEXT_SELECTOR=legacy OR options.useLegacySelector=true.
+ *
+ * @param {Object} graph - Context Graph (canonical ContextGraph instance)
+ * @param {RouterAdapterOptions} options
+ * @returns {AdapterResult}
+ */
+export function routeAndAdapt(graph, options) {
+  const { taskId, budget = 4000, useLegacySelector = false } = options;
+  const legacySelectorAllowed =
+    process.env.WAM_CONTEXT_SELECTOR === "legacy" || useLegacySelector === true;
+
+  if (!graph || !taskId) {
+    return {
+      capsules: [],
+      sufficiency: "insufficient",
+      missing: ["no graph or taskId"],
+      contract: { conditions: [] },
+      routerResult: null,
+      source: "fallback",
+    };
+  }
+
+  try {
+    const routerResult = resolveContext(graph, { taskId, maxTokens: budget });
+    const adapted = adaptRouterResult(routerResult, { budget });
+    // C02: mark source as legacy only when caller explicitly opted in
+    // AND router returned empty/insufficient — never silent.
+    // Equivalent to the previous `adapted.capsules.length === 0` check, but
+    // evaluated before N2 injection so the opt-in path is unchanged.
+    const routerSelectedNothing = !routerResult.nodes || routerResult.nodes.length === 0;
+    if (legacySelectorAllowed && routerSelectedNothing) {
+      return { ...adapted, source: "legacy-allowed" };
+    }
+
+    // N2 obligation: the current task node is always assembled. The router
+    // selects supporting context (N3) only and never emits the task node
+    // itself, so the adapter injects it here (nodeToCapsule maps task -> N2).
+    const taskNode = typeof graph.getNode === "function" ? graph.getNode(taskId) : null;
+    if (taskNode && !adapted.capsules.some((c) => c.context_id === taskNode.id)) {
+      adapted.capsules = [nodeToCapsule(taskNode), ...adapted.capsules];
+    }
+    return adapted;
+  } catch (error) {
+    // Surface error: do NOT swap in legacy selector unless explicitly allowed.
+    if (!legacySelectorAllowed) {
+      return {
+        capsules: [],
+        sufficiency: "insufficient",
+        missing: [`router error: ${error.message}`],
+        contract: { conditions: [] },
+        routerResult: null,
+        source: "router-error",
+      };
+    }
+    return {
+      capsules: [],
+      sufficiency: "insufficient",
+      missing: [`router error: ${error.message}`],
+      contract: { conditions: [] },
+      routerResult: null,
+      source: "fallback",
+    };
+  }
+}
+
+/**
+ * Build a minimal context graph from task state.
+ * Used when no pre-existing graph is available.
+ *
+ * @deprecated Callers should use buildRuntimeContextGraph() instead so all
+ * runtime layers (evidence, decisions, constraints, artifacts, observations,
+ * cognition, hypotheses, experiments) are represented. This helper is kept
+ * only for the legacy selector opt-in path (WAM_CONTEXT_SELECTOR=legacy).
+ *
+ * @param {Object} taskState
+ * @param {string} root
+ * @returns {Object} Minimal graph-like structure
+ */
+export function buildGraphFromTaskState(taskState, root) {
+  const nodes = [];
+  const edges = [];
+
+  // Add task node
+  if (taskState?.taskId) {
+    nodes.push({
+      id: taskState.taskId,
+      type: "task",
+      content: taskState.lastAction || taskState.contract?.objective || "",
+      metadata: {
+        purpose: "Current task",
+        provenance: "user_decided",
+      },
+    });
+  }
+
+  // Add requirement nodes
+  for (const req of taskState?.requirements || []) {
+    nodes.push({
+      id: req.id,
+      type: "output",
+      content: req.title || req.description || "",
+      metadata: {
+        purpose: `Requirement: ${req.title}`,
+        provenance: "user_decided",
+      },
+    });
+    edges.push({
+      from: taskState.taskId,
+      to: req.id,
+      type: "depends_on",
+    });
+  }
+
+  // Build graph interface
+  const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+  return {
+    getNode: (id) => nodeMap.get(id) || null,
+    getEdgesFrom: (id) => edges.filter((e) => e.from === id),
+    getEdgesTo: (id) => edges.filter((e) => e.to === id),
+    getEdgesFromByType: (id, type) => edges.filter((e) => e.from === id && e.type === type),
+    getEdgesToByType: (id, type) => edges.filter((e) => e.to === id && e.type === type),
+    getUpstream: (id, depth) => {
+      const result = [];
+      const visited = new Set();
+      const queue = [id];
+      while (queue.length > 0 && result.length < 100) {
+        const nodeId = queue.shift();
+        if (visited.has(nodeId)) continue;
+        visited.add(nodeId);
+        const node = nodeMap.get(nodeId);
+        if (node) result.push(node);
+        for (const edge of edges.filter((e) => e.to === nodeId)) {
+          if (!visited.has(edge.from)) queue.push(edge.from);
+        }
+      }
+      return result;
+    },
+    getContradicting: () => [],
+  };
+}
+
+export { ADMISSION };

package/src/integration/telemetry.js

@@ -0,0 +1,45 @@
+export function createTelemetry({ sink, onError, clock = () => Date.now() } = {}) {
+  const buffer = [];
+
+  function emit(event, data) {
+    if (typeof event !== 'string' || event.length === 0) {
+      if (onError) onError(new Error('Telemetry event name must be a non-empty string'));
+      return;
+    }
+    buffer.push({ event, data, timestamp: clock() });
+  }
+
+  async function flush() {
+    if (!sink || buffer.length === 0) {
+      const out = buffer.splice(0, buffer.length);
+      return { sent: out.length, dropped: 0 };
+    }
+    const drain = buffer.splice(0, buffer.length);
+    let sent = 0;
+    let dropped = 0;
+    try {
+      const result = await sink(drain);
+      sent = drain.length;
+      if (typeof result === 'number') sent = Math.min(sent, Math.max(0, result));
+      dropped = drain.length - sent;
+    } catch (err) {
+      dropped = drain.length;
+      if (onError) onError(err);
+    }
+    return { sent, dropped };
+  }
+
+  function size() {
+    return buffer.length;
+  }
+
+  function clear() {
+    buffer.length = 0;
+  }
+
+  function peek() {
+    return [...buffer];
+  }
+
+  return { emit, flush, size, clear, peek };
+}

package/src/integration/update-checker.js

@@ -0,0 +1,10 @@
+export async function checkUpdates(currentVersion, registryUrl) {
+  // Simulate network check
+  if (registryUrl === 'https://error.com') throw new Error('Registry unreachable');
+  
+  const latest = '1.1.0';
+  return {
+    latest,
+    needsUpdate: currentVersion !== latest
+  };
+}

package/src/persistence/event-sourcing.js

@@ -0,0 +1,75 @@
+/**
+ * Event Sourcing — append-only event store with reduce.
+ *
+ * Stores immutable events keyed by stream. Reduces them into a derived
+ * state via a user-provided reducer. Production hardening (M5-51).
+ */
+
+/**
+ * @typedef {Object} StoredEvent
+ * @property {number} seq
+ * @property {string} streamId
+ * @property {string} type
+ * @property {*} payload
+ * @property {number} timestamp
+ */
+
+/**
+ * @typedef {Object} EventStore
+ * @property {(streamId: string, type: string, payload?: unknown) => StoredEvent} append
+ * @property {(streamId: string) => StoredEvent[]} query
+ * @property {(streamId: string, reducer: Function, initial: unknown) => unknown} reduce
+ * @property {() => number} totalEvents
+ * @property {() => string[]} streams
+ */
+
+/**
+ * Create an event store.
+ * @returns {EventStore}
+ */
+export function createEventStore() {
+  /** @type {Map<string, StoredEvent[]>} */
+  const byStream = new Map();
+  let seq = 0;
+
+  function append(streamId, type, payload) {
+    if (!streamId || typeof streamId !== "string") throw new TypeError("streamId required");
+    if (!type || typeof type !== "string") throw new TypeError("type required");
+    const event = {
+      seq: ++seq,
+      streamId,
+      type,
+      payload,
+      timestamp: Date.now(),
+    };
+    let list = byStream.get(streamId);
+    if (!list) {
+      list = [];
+      byStream.set(streamId, list);
+    }
+    list.push(event);
+    return event;
+  }
+
+  function query(streamId) {
+    const list = byStream.get(streamId);
+    return list ? [...list] : [];
+  }
+
+  function reduce(streamId, reducer, initial) {
+    const list = byStream.get(streamId) ?? [];
+    return list.reduce((state, ev) => reducer(state, ev), initial);
+  }
+
+  function totalEvents() {
+    let n = 0;
+    for (const list of byStream.values()) n += list.length;
+    return n;
+  }
+
+  function streams() {
+    return [...byStream.keys()];
+  }
+
+  return { append, query, reduce, totalEvents, streams };
+}