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

package/src/context-benchmark-router.mjs

@@ -0,0 +1,125 @@
+/**
+ * Real Context Router Selector for Benchmark
+ * Bridges benchmark scenarios to the canonical WAM Context Router.
+ */
+
+import { ContextGraph, NODE_TYPES, EDGE_TYPES } from "./context/context-graph.js";
+import { resolveContext } from "./context/context-router.js";
+import { estimateTokens } from "./context/context-optimization-metrics.js";
+
+/**
+ * Build a ContextGraph instance from a benchmark scenario object.
+ */
+export function buildBenchmarkGraph(scenario) {
+  const graph = new ContextGraph();
+
+  // Add all scenario nodes
+  if (scenario.nodes) {
+    for (const [id, node] of Object.entries(scenario.nodes)) {
+      graph.addNode({
+        id,
+        type: node.type && NODE_TYPES.includes(node.type) ? node.type : "requirement",
+        content: node.content || "",
+        metadata: {
+          freshness: node.freshness ?? 1.0,
+          importance: node.importance ?? 1.0,
+          aliases: node.aliases || [],
+          admission: node.admission || "CONDITIONAL",
+          ...node.metadata
+        }
+      });
+    }
+  }
+
+  // Add explicit requires edges if provided.
+  // Change 04: Do not derive additional edges from requiredIds when explicit graph is provided.
+  const addedEdges = new Set();
+  const hasExplicitGraph = Array.isArray(scenario.requires);
+
+  if (hasExplicitGraph) {
+    for (const req of scenario.requires) {
+      const requested = req.type || "requires";
+      const type = EDGE_TYPES.includes(requested)
+        ? requested
+        : requested === "requires"
+          ? "requires_completion"
+          : "related_to";
+      const key = `${req.from}->${req.to}:${type}`;
+      if (!addedEdges.has(key)) {
+        addedEdges.add(key);
+        graph.addEdge({
+          from: req.from,
+          to: req.to,
+          type,
+          weight: req.weight ?? 1.0
+        });
+      }
+    }
+  } else if (scenario.requiredIds) {
+    // Legacy synthetic graph derived from requiredIds
+    const taskId = scenario.taskId || "task";
+    for (const reqId of scenario.requiredIds) {
+      const key = `${taskId}->${reqId}:requires_completion`;
+      if (!addedEdges.has(key) && graph.getNode(reqId) && graph.getNode(taskId)) {
+        addedEdges.add(key);
+        graph.addEdge({
+          from: taskId,
+          to: reqId,
+          type: "requires_completion",
+          weight: 1.0
+        });
+      }
+    }
+  }
+
+  // Attach metadata tag indicating synthetic vs explicit ground truth (Change 04)
+  graph.metadata = {
+    syntheticGroundTruth: !hasExplicitGraph
+  };
+
+  return graph;
+}
+
+/**
+ * WAM Router selector function conforming to benchmark selector signature.
+ * @param {Object} [options]
+ * @param {number} [options.budget=4000]
+ */
+export function wamRouterSelector(options = {}) {
+  const tokenBudget = options.budget ?? 4000;
+  return function select(scenario) {
+    const graph = buildBenchmarkGraph(scenario);
+    const taskId = scenario.taskId && graph.getNode(scenario.taskId) ? scenario.taskId : (graph.getNode("task") ? "task" : (scenario.taskId || graph.nodes.values().next().value?.id || "task"));
+
+    let result;
+    try {
+      result = resolveContext(graph, { taskId, maxTokens: tokenBudget });
+    } catch (e) {
+      // Router error: the selection algorithm could not execute.
+      // This is distinct from a page fault (where the selected context
+      // was insufficient and the system recovered additional context).
+      const serializedError = {
+        name: e?.name ?? "Error",
+        message: e?.message ?? String(e),
+        stack: e?.stack ?? null
+      };
+      return {
+        status: "ERROR",
+        errorType: "ROUTER_ERROR",
+        error: serializedError
+      };
+    }
+
+    const selectedIds = (result.nodes || []).map(n => n.id);
+    const usedIds = selectedIds; // Router-selected nodes are used
+
+    return {
+      status: "OK",
+      selectedIds,
+      usedIds: undefined, // Change 05: Do not infer usedIds from selectedIds
+      pageFaults: result.sufficient ? 0 : 1,
+      reacquiredTokens: 0,
+      routerResult: result
+    };
+  };
+}

package/src/evidence/evidence-engine.js

@@ -0,0 +1,161 @@
+/**
+ * Evidence Engine — produces validated evidence from observation + assessment.
+ *
+ * Decoupled from execution-engine: builds evidence records via the
+ * evidence-lineage store, then routes them to the lineage graph when
+ * the observation carries a requirement binding.
+ *
+ * Evidence is what proves a hypothesis. An evidence record must:
+ *   1. Be created from a concrete observation (or explicit content).
+ *   2. Carry provenance (hypothesisId, source).
+ *   3. Optionally link to a requirement when the execution was targeted.
+ *
+ * Does NOT own: hypothesis status transitions (state-machine.js) or
+ * observation persistence (observation-engine.js).
+ */
+
+import { createEvidence, linkEvidenceToRequirement } from "./evidence-lineage.js";
+
+/**
+ * Default evidence type for execution-engine outputs.
+ */
+export const EVIDENCE_TYPE_TOOL_OUTPUT = "TOOL_OUTPUT";
+export const EVIDENCE_SOURCE_EXECUTION = "execution-engine";
+
+/**
+ * Pure content serializer — turns a tool result into a stable string content.
+ * Centralized so evidence content shape stays consistent.
+ *
+ * @param {*} result
+ * @returns {string}
+ */
+export function serializeEvidenceContent(result) {
+  if (result === undefined || result === null) return "ok";
+  if (typeof result === "string") return result;
+  try {
+    return JSON.stringify(result);
+  } catch {
+    return String(result);
+  }
+}
+
+/**
+ * Resolve a requirementId from a possibly-incomplete requirement object
+ * or a pre-resolved id. Returns the id only when it is a non-empty string;
+ * otherwise returns undefined (evidence stays unbound).
+ *
+ * @param {object} [args]
+ * @param {object} [args.requirement] - requirement object; may be incomplete
+ * @param {string} [args.requirementId] - pre-resolved id (may be undefined)
+ * @returns {string|undefined}
+ */
+export function resolveRequirementId({ requirement, requirementId } = {}) {
+  if (requirement && typeof requirement === "object" && typeof requirement.id === "string" && requirement.id.length > 0) {
+    return requirement.id;
+  }
+  if (typeof requirementId === "string" && requirementId.length > 0) {
+    return requirementId;
+  }
+  return undefined;
+}
+
+/**
+ * Build the evidence payload from a successful observation.
+ * Pure: no I/O, no lineage graph mutation.
+ *
+ * @param {object} args
+ * @param {string} [args.requirementId] - pre-resolved id; ignored if invalid
+ * @param {object} [args.requirement] - requirement object; only used when .id is a non-empty string
+ * @param {*} args.result - tool output (string|object|primitive)
+ * @param {string} [args.type] - evidence type (default TOOL_OUTPUT)
+ * @param {string} [args.source] - source identifier (default execution-engine)
+ * @param {string} args.hypothesisId
+ * @returns {object} payload ready for createEvidence
+ */
+export function buildEvidencePayload({
+  requirement,
+  requirementId,
+  result,
+  type = EVIDENCE_TYPE_TOOL_OUTPUT,
+  source = EVIDENCE_SOURCE_EXECUTION,
+  hypothesisId,
+}) {
+  const resolvedId = resolveRequirementId({ requirement, requirementId });
+  return {
+    requirementId: resolvedId,
+    content: serializeEvidenceContent(result),
+    type,
+    source,
+    hypothesisId,
+  };
+}
+
+/**
+ * Create evidence from a successful tool observation.
+ * Pure wrapper around evidence-lineage: returns the evidence record.
+ *
+ * @param {string} taskId
+ * @param {object} payload - see buildEvidencePayload
+ * @param {string} root
+ * @returns {object} created evidence record
+ */
+export function createExecutionEvidence(taskId, payload, root) {
+  return createEvidence(taskId, payload, root);
+}
+
+/**
+ * Link evidence into the lineage graph once the observation has been recorded.
+ * Requires both observationId and requirementId; otherwise this is a no-op
+ * (unbound evidence — the hypothesis chain still references it via facts).
+ *
+ * @param {object} args
+ * @param {string} args.evidenceId
+ * @param {string} args.requirementId
+ * @param {string} args.hypothesisId
+ * @param {string|null} args.experimentId
+ * @param {string|null} args.observationId
+ * @param {string} args.taskId
+ * @param {string} args.taskRoot
+ * @returns {boolean} true when the lineage was linked; false when skipped.
+ */
+export function linkEvidenceIfBound({
+  evidenceId,
+  requirementId,
+  hypothesisId,
+  experimentId,
+  observationId,
+  taskId,
+  taskRoot,
+}) {
+  if (!evidenceId || !requirementId || !observationId) return false;
+  linkEvidenceToRequirement(
+    evidenceId,
+    requirementId,
+    hypothesisId,
+    experimentId ?? null,
+    observationId,
+    taskId,
+    taskRoot,
+  );
+  return true;
+}
+
+/**
+ * Full success-path: build → create → (later) link.
+ * Returns the evidence record so the caller can carry its id into the
+ * observation's facts list.
+ *
+ * Safely resolves requirement binding: when args.requirement is incomplete
+ * or args.requirementId is not a non-empty string, the produced evidence
+ * stays unbound (no requirement.id access, no lineage link).
+ *
+ * @param {string} taskId
+ * @param {string} taskRoot
+ * @param {object} args - see buildEvidencePayload
+ * @returns {{evidence: object, payload: object}}
+ */
+export function produceExecutionEvidence(taskId, taskRoot, args) {
+  const payload = buildEvidencePayload(args);
+  const evidence = createExecutionEvidence(taskId, payload, taskRoot);
+  return { evidence, payload };
+}

package/src/evidence/evidence-factory.js

@@ -0,0 +1,3 @@
+export function createEvidence(type, content, source) {
+  return { id: "ev-" + Date.now(), type, content, source, createdAt: Date.now() };
+}