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

package/src/evidence/freshness-validation.js

@@ -0,0 +1,187 @@
+/**
+ * Context Freshness Validation — derives verification from evidence lineage.
+ *
+ * The Context Graph should NOT be a second source of truth for
+ * epistemological state. It should derive it from Evidence Lineage.
+ *
+ * Rule: `verified` on a ContextNode cannot survive invalidated
+ * supporting evidence. Validity must be resolved from lineage/provenance.
+ */
+
+/**
+ * @typedef {Object} FreshnessResult
+ * @property {string} nodeId
+ * @property {boolean} effectiveVerified
+ * @property {string} reason
+ * @property {string} derivedFrom
+ * @property {number} derivedAt
+ */
+
+/**
+ * @typedef {Object} EvidenceStatus
+ * @property {string} id
+ * @property {string} status - "valid" | "superseded" | "invalidated" | "unverified"
+ * @property {number} updatedAt
+ */
+
+/**
+ * Derive effective verification status for a node.
+ *
+ * A node is effectively verified only if:
+ *   1. It is marked as verified in the graph
+ *   2. ALL supporting evidence is valid (not invalidated)
+ *
+ * @param {Object} node - Context node
+ * @param {EvidenceStatus[]} supportingEvidence - Evidence that supports this node
+ * @returns {FreshnessResult}
+ */
+export function deriveVerification(node, supportingEvidence = []) {
+  if (!node) {
+    return {
+      nodeId: null,
+      effectiveVerified: false,
+      reason: "node not found",
+      derivedFrom: "none",
+      derivedAt: Date.now(),
+    };
+  }
+
+  // If node is not verified, it's not verified
+  if (!node.verified) {
+    return {
+      nodeId: node.id,
+      effectiveVerified: false,
+      reason: "node not verified in graph",
+      derivedFrom: "graph",
+      derivedAt: Date.now(),
+    };
+  }
+
+  // Check if any supporting evidence is invalidated
+  const invalidated = supportingEvidence.filter((e) => e.status === "invalidated");
+  if (invalidated.length > 0) {
+    return {
+      nodeId: node.id,
+      effectiveVerified: false,
+      reason: `${invalidated.length} supporting evidence invalidated`,
+      derivedFrom: "evidence-lineage",
+      derivedAt: Date.now(),
+    };
+  }
+
+  // Check if all supporting evidence is superseded
+  const superseded = supportingEvidence.filter((e) => e.status === "superseded");
+  if (superseded.length > 0 && superseded.length === supportingEvidence.length) {
+    return {
+      nodeId: node.id,
+      effectiveVerified: false,
+      reason: "all supporting evidence superseded",
+      derivedFrom: "evidence-lineage",
+      derivedAt: Date.now(),
+    };
+  }
+
+  // Check if there's any valid evidence
+  const valid = supportingEvidence.filter((e) => e.status === "valid");
+  if (supportingEvidence.length > 0 && valid.length === 0) {
+    return {
+      nodeId: node.id,
+      effectiveVerified: false,
+      reason: "no valid supporting evidence",
+      derivedFrom: "evidence-lineage",
+      derivedAt: Date.now(),
+    };
+  }
+
+  // Node is verified and has valid supporting evidence
+  return {
+    nodeId: node.id,
+    effectiveVerified: true,
+    reason: "verified with valid supporting evidence",
+    derivedFrom: "combined",
+    derivedAt: Date.now(),
+  };
+}
+
+/**
+ * Check if evidence invalidation affects graph nodes.
+ *
+ * @param {string} evidenceId - Invalidated evidence ID
+ * @param {Object} graph - Context graph
+ * @returns {string[]} Affected node IDs
+ */
+export function findAffectedNodes(evidenceId, graph) {
+  const affected = [];
+
+  // Find all nodes that depend on this evidence
+  const edges = graph.getEdgesToByType
+    ? graph.getEdgesToByType(evidenceId, "supports")
+    : [];
+
+  for (const edge of edges) {
+    const node = graph.getNode(edge.from);
+    if (node && node.verified) {
+      affected.push(node.id);
+    }
+  }
+
+  return affected;
+}
+
+/**
+ * Mark graph nodes as stale when evidence is invalidated.
+ *
+ * @param {string} evidenceId - Invalidated evidence ID
+ * @param {Object} graph - Context graph
+ * @returns {string[]} Nodes that were marked stale
+ */
+export function markStaleOnInvalidation(evidenceId, graph) {
+  const affected = findAffectedNodes(evidenceId, graph);
+
+  for (const nodeId of affected) {
+    const node = graph.getNode(nodeId);
+    if (node) {
+      node.verified = false;
+      node.metadata = node.metadata || {};
+      node.metadata.staleReason = `evidence ${evidenceId} invalidated`;
+      node.metadata.staleAt = Date.now();
+    }
+  }
+
+  return affected;
+}
+
+/**
+ * Generate freshness report for a set of nodes.
+ *
+ * @param {Object[]} nodes
+ * @param {Object} evidenceStore - Evidence lookup function
+ * @returns {Object} Freshness report
+ */
+export function generateFreshnessReport(nodes, evidenceStore) {
+  const results = [];
+  let verified = 0;
+  let stale = 0;
+
+  for (const node of nodes) {
+    const evidence = evidenceStore?.getSupportingEvidence?.(node.id) || [];
+    const result = deriveVerification(node, evidence);
+    results.push(result);
+
+    if (result.effectiveVerified) {
+      verified++;
+    } else if (node.verified && !result.effectiveVerified) {
+      stale++;
+    }
+  }
+
+  return {
+    total: nodes.length,
+    verified,
+    stale,
+    unverified: nodes.length - verified - stale,
+    results,
+  };
+}
+
+export default deriveVerification;

package/src/evidence/lineage.js

@@ -0,0 +1,4 @@
+export function createLineage(reqId, hypId, expId, obsId, evId) {
+  return { requirementId: reqId, hypothesisId: hypId, experimentId: expId, observationId: obsId, evidenceId: evId };
+}
+export function getLineage(evidenceId) { return null; }

package/src/execution/action-evaluation.js

@@ -0,0 +1,179 @@
+/**
+ * Action Evaluation — Separation of action results, observations,
+ * requirement evaluation, and task verification.
+ *
+ * Core insight: ActionResult ≠ Observation ≠ RequirementEvaluation ≠ TaskVerification
+ * A tool succeeding does NOT mean its requirement is satisfied.
+ */
+
+// -- ActionResult: directly from tool execution --
+
+/**
+ * @typedef {Object} ActionResult
+ * @property {string} actionId
+ * @property {boolean} success
+ * @property {number} exitCode
+ * @property {string} output
+ * @property {number} durationMs
+ * @property {number} timestamp
+ */
+
+/**
+ * Creates an ActionResult directly from tool execution metadata.
+ */
+export function createActionResult({
+  actionId,
+  success,
+  exitCode,
+  output,
+  durationMs,
+  timestamp = Date.now(),
+}) {
+  return { actionId, success, exitCode, output, durationMs, timestamp };
+}
+
+// -- Observation: interpretation of action result --
+
+/**
+ * @typedef {Object} Observation
+ * @property {string} id
+ * @property {string} actionId
+ * @property {string} requirementId
+ * @property {string} observation
+ * @property {"direct" | "derived" | "inferred"} relevance
+ * @property {number} timestamp
+ */
+
+/**
+ * Creates an Observation — an interpretation of what happened during execution.
+ */
+export function createObservation({
+  actionId,
+  requirementId,
+  observation,
+  relevance = "direct",
+}) {
+  return {
+    id: `obs-${actionId}-${Date.now().toString(36)}`,
+    actionId,
+    requirementId,
+    observation,
+    relevance,
+    timestamp: Date.now(),
+  };
+}
+
+// -- Requirement evaluation: mapping observation to requirement --
+
+/**
+ * @typedef {Object} RequirementEvaluation
+ * @property {string} requirementId
+ * @property {string} observationId
+ * @property {"unknown" | "supports" | "contradicts" | "neutral"} evaluation
+ * @property {string} reason
+ * @property {number} timestamp
+ */
+
+import { assessObservation, AssessmentResult } from "../policy/assessment-engine.js";
+const EVALUATION_BY_RESULT = { [AssessmentResult.SUPPORTED]: "supports", [AssessmentResult.CONTRADICTED]: "contradicts", [AssessmentResult.INCONCLUSIVE]: "unknown" };
+/**
+ * Evaluates an observation against a requirement.
+ * Returns an evaluation, NOT a status change. Delegates to assessment-engine.
+ */
+export function evaluateObservationAgainst(observation, requirement) {
+  const expected = (requirement && (requirement.expectedObservation ?? requirement.description)) ?? undefined;
+  const actual = (observation && (observation.observation ?? observation.actual)) ?? undefined;
+  const assessment = assessObservation({ expectedObservation: expected }, actual);
+  const evaluation = EVALUATION_BY_RESULT[assessment.result] || "unknown";
+  const isNoExpected = assessment.reasoning === "No expectedObservation defined for this experiment.";
+  return { requirementId: observation.requirementId, observationId: observation.id, evaluation, reason: isNoExpected ? "" : assessment.reasoning || "", timestamp: Date.now(), assessment };
+}
+
+// -- Task verification: final result --
+
+/**
+ * @typedef {Object} TaskVerification
+ * @property {string} taskId
+ * @property {boolean} verified
+ * @property {RequirementEvaluation[]} evaluations
+ * @property {string} summary
+ * @property {number} timestamp
+ */
+
+/**
+ * Verifies a task by aggregating all requirement evaluations.
+ */
+export function verifyTask({ taskId, evaluations, summary }) {
+  const verified =
+    evaluations.length > 0 &&
+    evaluations.every((e) => e.evaluation === "supports");
+  return {
+    taskId,
+    verified,
+    evaluations,
+    summary,
+    timestamp: Date.now(),
+  };
+}
+
+// -- Classic bug demonstrations --
+
+/**
+ * Bug demo #1: Command succeeded ≠ Requirement satisfied.
+ * A command exiting with 0 does not prove the underlying requirement is met.
+ */
+export function demoCommandSucceedsNotRequirementSatisfied() {
+  const actionResult = createActionResult({
+    actionId: "act-1",
+    success: true,
+    exitCode: 0,
+    output: "Chromium executable exists at /usr/bin/chromium",
+    durationMs: 12,
+  });
+
+  const observation = createObservation({
+    actionId: actionResult.actionId,
+    requirementId: "req-playwright-chromium",
+    observation: "Chromium executable exists",
+    relevance: "direct",
+  });
+
+  const requirement = {
+    id: "req-playwright-chromium",
+    description: "Playwright can launch required Chromium",
+  };
+
+  const evaluation = evaluateObservationAgainst(observation, requirement);
+
+  return { actionResult, observation, requirement, evaluation };
+}
+
+/**
+ * Bug demo #2: Tool output exists ≠ Requirement verified.
+ * Having output does not mean the requirement is actually satisfied.
+ */
+export function demoToolOutputExistsNotRequirementVerified() {
+  const actionResult = createActionResult({
+    actionId: "act-2",
+    success: true,
+    exitCode: 0,
+    output: "npm install completed with 0 warnings",
+    durationMs: 4500,
+  });
+
+  const observation = createObservation({
+    actionId: actionResult.actionId,
+    requirementId: "req-deps-installed",
+    observation: "npm install completed",
+    relevance: "derived",
+  });
+
+  const requirement = {
+    id: "req-deps-installed",
+    description: "All runtime dependencies are installed and importable",
+  };
+
+  const evaluation = evaluateObservationAgainst(observation, requirement);
+
+  return { actionResult, observation, requirement, evaluation };
+}

package/src/execution/circuit-breaker.js

@@ -0,0 +1,70 @@
+/**
+ * Circuit Breaker — fail-fast pattern for unreliable calls.
+ *
+ * States: "closed" (allow), "open" (reject fast), "half-open" (probe).
+ * After `threshold` consecutive failures the breaker opens; after
+ * `timeout` ms it transitions to half-open to allow one probe.
+ *
+ * Production hardening (M5-53).
+ */
+
+/**
+ * @typedef {"closed"|"open"|"half-open"} BreakerState
+ */
+
+/**
+ * @typedef {Object} CircuitBreaker
+ * @property {() => BreakerState} getState
+ * @property {<T>(fn: () => Promise<T>) => Promise<T>} execute
+ * @property {() => void} reset
+ * @property {() => number} failures
+ */
+
+/**
+ * @param {{threshold?: number, timeout?: number}} opts
+ * @returns {CircuitBreaker}
+ */
+export function createCircuitBreaker(opts = {}) {
+  const threshold = opts.threshold ?? 3;
+  const timeout = opts.timeout ?? 1000;
+  /** @type {BreakerState} */
+  let state = "closed";
+  let failures = 0;
+  let openedAt = 0;
+
+  function getState() {
+    if (state === "open" && Date.now() - openedAt >= timeout) {
+      state = "half-open";
+    }
+    return state;
+  }
+
+  async function execute(fn) {
+    const cur = getState();
+    if (cur === "open") {
+      throw new Error("circuit breaker is OPEN");
+    }
+    try {
+      const result = await fn();
+      // success: close if half-open, reset counter
+      state = "closed";
+      failures = 0;
+      return result;
+    } catch (err) {
+      failures++;
+      if (failures >= threshold || state === "half-open") {
+        state = "open";
+        openedAt = Date.now();
+      }
+      throw err;
+    }
+  }
+
+  function reset() {
+    state = "closed";
+    failures = 0;
+    openedAt = 0;
+  }
+
+  return { getState, execute, reset, failures: () => failures };
+}

package/src/execution/claim-interception.js

@@ -0,0 +1,63 @@
+import { classifyClaim } from "../verification/false-completion-prevention.js";
+
+export function interceptAgentClaim(message) {
+  const claimPatterns = {
+    FACT: /\b(is|exists|present|available|installed|configured|has|have)\b/i,
+    HYPOTHESIS: /\b(think|believe|probably|might|could be|suspect)\b/i,
+    OBSERVATION: /\b(see|observe|notice|found|detected)\b/i,
+    INTENT: /\b(will|going to|plan|should|need to|want to)\b/i,
+    CONCLUSION: /\b(therefore|so|thus|conclude)\b/i,
+    COMPLETION: /\b(done|fixed|working|solved|completed|implemented|resolved|ready)\b/i
+  };
+
+  const claims = [];
+
+  for (const [type, pattern] of Object.entries(claimPatterns)) {
+    const match = message.match(pattern);
+    if (match) {
+      claims.push({
+        type,
+        text: match[0],
+        position: match.index,
+        context: message.slice(Math.max(0, match.index - 20), match.index + 20)
+      });
+    }
+  }
+
+  return claims;
+}
+
+export function createClaim(text, type, source = "agent") {
+  return {
+    id: `claim-${Date.now().toString(36)}`,
+    text,
+    type,
+    source,
+    timestamp: Date.now(),
+    validated: false
+  };
+}
+
+export function validateClaim(claim, taskState) {
+  const result = {
+    claimId: claim.id,
+    valid: false,
+    requiresVerification: false,
+    reason: ""
+  };
+
+  if (claim.type === "COMPLETION") {
+    result.requiresVerification = true;
+    result.reason = "Completion claim requires verification";
+  } else if (claim.type === "HYPOTHESIS") {
+    result.reason = "Hypothesis requires validation";
+  } else if (claim.type === "FACT") {
+    result.requiresVerification = true;
+    result.reason = "Fact claims should be verified";
+  } else {
+    result.valid = true;
+    result.reason = "Observation or intent does not require verification";
+  }
+
+  return result;
+}