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

package/src/context/context-history-relevance.js

@@ -0,0 +1,321 @@
+/**
+ * WAM Context History Relevance
+ *
+ * Extends context selection to include historical task information
+ * based on relevance to the current task.
+ *
+ * Historical information is selected when related to:
+ * - current task
+ * - current requirement
+ * - current workflow stage
+ * - current artifact
+ * - active dependency
+ * - previous failure
+ * - previous decision
+ * - unresolved issue
+ * - verification state
+ *
+ * Ranking priority:
+ * 1. Explicit dependency
+ * 2. Active requirement
+ * 3. Same task/stage
+ * 4. Same artifact
+ * 5. Related failure
+ * 6. Related decision
+ * 7. Recency
+ *
+ * Invariant: Historical information retains provenance (current, historical,
+ * superseded, stale, invalidated, unresolved). Router must never silently
+ * convert historical information into current knowledge.
+ */
+
+import { ContextGraph } from "./context-graph.js";
+import { getRuns, getPreviousFailures, getPreviousDecisions, getUnresolvedRequirements } from "../state/task-runs.js";
+import { getDependencies, detectContextGaps } from "../state/task-dependencies.js";
+import { getTaskState } from "../skills/engine.js";
+
+/**
+ * @typedef {Object} HistoricalCandidate
+ * @property {string} id
+ * @property {string} type - "run", "failure", "decision", "evidence"
+ * @property {string} content
+ * @property {number} relevanceScore
+ * @property {string} relevanceReason
+ * @property {string} status - "current", "historical", "superseded", "stale", "invalidated", "unresolved"
+ * @property {number} timestamp
+ * @property {string} runId
+ */
+
+function estimateTokens(text = "") {
+  const str = typeof text === "string" ? text : "";
+  return Math.ceil(str.length / 4);
+}
+
+/**
+ * Coerce any run-item (string, {text}, {content}, null, etc.) into a
+ * lowercase-string token set for keyword analysis. Returns "" for empty/unknown
+ * inputs so callers never have to deal with `.toLowerCase is not a function`.
+ */
+function asText(item) {
+  if (item == null) return "";
+  if (typeof item === "string") return item;
+  if (typeof item === "number" || typeof item === "boolean") return String(item);
+  if (typeof item === "object") {
+    if (typeof item.text === "string") return item.text;
+    if (typeof item.content === "string") return item.content;
+    if (typeof item.decision === "string") return item.decision;
+    if (typeof item.outcome === "string") return item.outcome;
+    try {
+      return JSON.stringify(item);
+    } catch {
+      return "";
+    }
+  }
+  return "";
+}
+
+function asLower(item) {
+  return asText(item).toLowerCase();
+}
+
+export function getHistoricalCandidates(taskId, root, graph = null) {
+  const candidates = [];
+  const runs = getRuns(taskId, root);
+  const failures = getPreviousFailures(taskId, root);
+  const decisions = getPreviousDecisions(taskId, root, 10);
+  const unresolved = getUnresolvedRequirements(taskId, root);
+
+  // Get current task context for relevance scoring
+  const taskNode = graph ? graph.getNode(taskId) : null;
+  const taskContent = taskNode?.content || "";
+  
+  // Get keywords from task state if no graph content
+  const taskState = getTaskState(taskId, root);
+  const stateObjective = taskState?.contract?.objective || "";
+  const combinedContent = taskContent + " " + stateObjective;
+  const taskKeywords = new Set(combinedContent.toLowerCase().split(/\s+/).filter(Boolean));
+
+  // Score candidates based on relevance
+  for (const run of runs) {
+    // Determine status based on run outcome
+    let status = "historical";
+    if (run.status === "active") {
+      status = "current";
+    } else if (run.outcome?.toLowerCase().includes("superseded")) {
+      status = "superseded";
+    } else if (run.status === "abandoned") {
+      status = "stale";
+    }
+
+    // Score observations from this run
+    for (const obs of run.observations || []) {
+      const obsStr = asText(obs);
+      const obsLower = asLower(obs);
+      const obsKeywords = new Set(obsLower.split(/\s+/).filter(Boolean));
+      const overlap = [...taskKeywords].filter((k) => obsKeywords.has(k)).length;
+      const score = computeRelevanceScore({
+        hasExplicitDependency: false,
+        matchesActiveRequirement: unresolved.some((r) => obsLower.includes(asLower(r.title))),
+        sameTask: true,
+        sameArtifact: obsLower.includes("artifact") || obsLower.includes("build"),
+        relatedFailure: failures.some((f) => f.outcome && obsLower.includes(asLower(f.outcome))),
+        relatedDecision: decisions.some((d) => obsLower.includes(asLower(d.decision))),
+        keywordOverlap: overlap,
+        isRecent: run.startedAt > Date.now() - 86400000 * 7, // last 7 days
+      });
+
+      if (score > 0.15) {
+        candidates.push({
+          id: `obs-${run.id}-${candidates.length}`,
+          type: "observation",
+          content: obsStr,
+          relevanceScore: score,
+          relevanceReason: getRelevanceReason({ sameTask: true, keywordOverlap: overlap }),
+          status,
+          timestamp: run.startedAt,
+          runId: run.id,
+        });
+      }
+    }
+
+    // Score decisions from this run
+    for (const decision of run.decisions || []) {
+      const decisionStr = asText(decision);
+      const decisionLower = asLower(decision);
+      const decisionKeywords = new Set(decisionLower.split(/\s+/).filter(Boolean));
+      const overlap = [...taskKeywords].filter((k) => decisionKeywords.has(k)).length;
+      const score = computeRelevanceScore({
+        hasExplicitDependency: graph ? graph.getDependencies(taskId).some((d) => asLower(d.content).includes(decisionLower)) : false,
+        matchesActiveRequirement: unresolved.some((r) => decisionLower.includes(asLower(r.title))),
+        sameTask: true,
+        sameArtifact: decisionLower.includes("artifact") || decisionLower.includes("build"),
+        relatedFailure: false,
+        relatedDecision: false,
+        keywordOverlap: overlap,
+        isRecent: run.startedAt > Date.now() - 86400000 * 7,
+      });
+
+      if (score > 0.15) {
+        candidates.push({
+          id: `decision-${run.id}-${candidates.length}`,
+          type: "decision",
+          content: decisionStr,
+          relevanceScore: score,
+          relevanceReason: getRelevanceReason({ hasExplicitDependency: score > 0.8, sameTask: true, keywordOverlap: overlap }),
+          status,
+          timestamp: run.startedAt,
+          runId: run.id,
+        });
+      }
+    }
+
+    // Score evidence from this run
+    for (const evidence of run.evidence || []) {
+      const evidenceStr = asText(evidence);
+      const evidenceLower = asLower(evidence);
+      const score = computeRelevanceScore({
+        hasExplicitDependency: false,
+        matchesActiveRequirement: unresolved.some((r) => evidenceLower.includes(asLower(r.title))),
+        sameTask: true,
+        sameArtifact: false,
+        relatedFailure: false,
+        relatedDecision: false,
+        keywordOverlap: 0,
+        isRecent: run.startedAt > Date.now() - 86400000 * 7,
+      });
+
+      if (score > 0.15) {
+        candidates.push({
+          id: `evidence-${run.id}-${candidates.length}`,
+          type: "evidence",
+          content: evidenceStr,
+          relevanceScore: score,
+          relevanceReason: getRelevanceReason({ sameTask: true }),
+          status,
+          timestamp: run.startedAt,
+          runId: run.id,
+        });
+      }
+    }
+  }
+
+  // Add previous failures as candidates
+  for (const failure of failures) {
+    const failureOutcomeLower = asLower(failure.outcome);
+    const score = computeRelevanceScore({
+      hasExplicitDependency: false,
+      matchesActiveRequirement: false,
+      sameTask: true,
+      sameArtifact: failureOutcomeLower.includes("artifact") || failureOutcomeLower.includes("build"),
+      relatedFailure: true,
+      relatedDecision: false,
+      keywordOverlap: 0,
+      isRecent: false,
+    });
+
+    if (score > 0.1) {
+      candidates.push({
+        id: `failure-${failure.id}`,
+        type: "failure",
+        content: asText(failure.outcome) || "Failed run",
+        relevanceScore: score,
+        relevanceReason: getRelevanceReason({ relatedFailure: true }),
+        status: "historical",
+        timestamp: failure.completedAt || failure.startedAt,
+        runId: failure.id,
+      });
+    }
+  }
+
+  // Add unresolved requirements as candidates
+  for (const req of unresolved) {
+    const reqTitleLower = asLower(req.title);
+    const reqKeywords = new Set(reqTitleLower.split(/\s+/).filter(Boolean));
+    const overlap = [...taskKeywords].filter((k) => reqKeywords.has(k)).length;
+
+    if (overlap > 0) {
+      candidates.push({
+        id: `req-${req.id}`,
+        type: "requirement",
+        content: asText(req.title),
+        relevanceScore: 0.9,
+        relevanceReason: "active requirement",
+        status: "unresolved",
+        timestamp: Date.now(),
+        runId: null,
+      });
+    }
+  }
+
+  return candidates.sort((a, b) => b.relevanceScore - a.relevanceScore);
+}
+
+function computeRelevanceScore({
+  hasExplicitDependency,
+  matchesActiveRequirement,
+  sameTask,
+  sameArtifact,
+  relatedFailure,
+  relatedDecision,
+  keywordOverlap,
+  isRecent,
+}) {
+  let score = 0;
+
+  if (hasExplicitDependency) score += 0.5;
+  if (matchesActiveRequirement) score += 0.4;
+  if (sameTask) score += 0.2;
+  if (sameArtifact) score += 0.15;
+  if (relatedFailure) score += 0.12;
+  if (relatedDecision) score += 0.1;
+  score += Math.min(keywordOverlap * 0.05, 0.2);
+  if (isRecent) score += 0.05;
+
+  return Math.min(score, 1.0);
+}
+
+function getRelevanceReason(props) {
+  if (props.hasExplicitDependency) return "explicit dependency";
+  if (props.matchesActiveRequirement) return "matches active requirement";
+  if (props.relatedFailure) return "related to previous failure";
+  if (props.relatedDecision) return "related to previous decision";
+  if (props.sameArtifact) return "same artifact context";
+  if (props.sameTask) return "same task";
+  if (props.keywordOverlap > 0) return `keyword overlap (${props.keywordOverlap})`;
+  return "recent";
+}
+
+export function selectHistoricalContext(taskId, root, graph, maxTokens = 1000) {
+  const candidates = getHistoricalCandidates(taskId, root, graph);
+
+  const selected = [];
+  let tokenCount = 0;
+
+  for (const candidate of candidates) {
+    const candidateTokens = estimateTokens(candidate.content) + 30;
+    if (tokenCount + candidateTokens > maxTokens) break;
+
+    selected.push(candidate);
+    tokenCount += candidateTokens;
+  }
+
+  return {
+    candidates: selected,
+    totalTokens: tokenCount,
+    tokenBudget: maxTokens,
+    includesCurrent: selected.some((s) => s.status === "current"),
+    includesHistorical: selected.some((s) => s.status === "historical"),
+    includesUnresolved: selected.some((s) => s.status === "unresolved"),
+  };
+}
+
+export function getRelevanceRankingExplanation(candidates, limit = 5) {
+  return candidates.slice(0, limit).map((c, i) => ({
+    rank: i + 1,
+    id: c.id,
+    type: c.type,
+    relevanceScore: c.relevanceScore,
+    reason: c.relevanceReason,
+    status: c.status,
+  }));
+}

package/src/context/context-interception.js

@@ -0,0 +1,145 @@
+/**
+ * Context Interception — filter and prioritize raw context before it reaches the LLM.
+ *
+ * Change 75: interceptContext(raw)
+ *
+ * Provides a gate through which all raw context must pass before being
+ * sent to the LLM. Filters noise, deduplicates, and re-sorts by
+ * relevance/priority. Deterministic, no side effects.
+ *
+ * Pipeline stages:
+ *   1. Deduplicate (by id or content hash)
+ *   2. Filter (by type, scope, relevance score, custom predicates)
+ *   3. Prioritize (sort by score, then by recency)
+ *   4. Cap (limit to maxItems)
+ */
+
+/**
+ * @typedef {Object} InterceptedItem
+ * @property {string} id
+ * @property {string} content
+ * @property {string} source
+ * @property {string} type
+ * @property {number} timestamp
+ * @property {string} scope
+ * @property {number} relevanceScore
+ * @property {Object} [metadata]
+ */
+
+/**
+ * @typedef {Object} InterceptOptions
+ * @property {number} [maxItems=50] - Maximum items after interception
+ * @property {string[]} [allowedTypes] - Only include these types
+ * @property {string[]} [allowedScopes] - Only include these scopes
+ * @property {number} [minRelevance=0] - Minimum relevance score 0-1
+ * @property {Function} [predicate] - Custom filter predicate (item => boolean)
+ * @property {string[]} [priorityTypes] - Types sorted first (higher priority)
+ * @property {boolean} [deduplicate=true] - Deduplicate by id
+ */
+
+/**
+ * Compute a simple relevance score for an item.
+ * Higher = more relevant. Based on presence of keywords and recency.
+ * @param {Object} item
+ * @param {string[]} [keywords]
+ * @returns {number}
+ */
+export function relevanceScore(item, keywords = []) {
+  if (!item || !item.content) return 0.5;
+  const content = String(item.content).toLowerCase();
+  let score = 0.5;
+  if (keywords.length > 0) {
+    const matches = keywords.filter((kw) => content.includes(kw.toLowerCase()));
+    score = 0.5 + (matches.length / keywords.length) * 0.5;
+  }
+  // Recency bonus: newer items slightly boosted
+  const age = Date.now() - (item.timestamp || 0);
+  const hoursOld = age / (1000 * 60 * 60);
+  const recencyBonus = Math.max(0, 0.1 - hoursOld * 0.001);
+  return Math.min(1, Math.max(0, score + recencyBonus));
+}
+
+/**
+ * Change 75 — interceptContext
+ *
+ * Filters, deduplicates, prioritizes, and caps raw context items
+ * before they reach the LLM.
+ *
+ * @param {Object[]} raw - Array of raw context items
+ * @param {InterceptOptions} [options={}]
+ * @returns {InterceptedItem[]} Filtered and ordered items
+ */
+export function interceptContext(raw, options = {}) {
+  if (!Array.isArray(raw)) {
+    throw new TypeError("raw must be an array");
+  }
+
+  const {
+    maxItems = 50,
+    allowedTypes = null,
+    allowedScopes = null,
+    minRelevance = 0,
+    predicate = null,
+    priorityTypes = [],
+    deduplicate = true,
+  } = options;
+
+  // Stage 1: Deduplicate by id
+  let items = raw;
+  if (deduplicate) {
+    const seen = new Set();
+    items = raw.filter((item) => {
+      if (!item || !item.id) return false;
+      if (seen.has(item.id)) return false;
+      seen.add(item.id);
+      return true;
+    });
+  }
+
+  // Stage 2: Filter
+  items = items.filter((item) => {
+    if (!item || !item.id) return false;
+    if (allowedTypes && !allowedTypes.includes(item.type)) return false;
+    if (allowedScopes && !allowedScopes.includes(item.scope)) return false;
+    if (predicate && !predicate(item)) return false;
+    return true;
+  });
+
+  // Stage 3: Score and sort
+  items = items.map((item) => ({
+    ...item,
+    relevanceScore: relevanceScore(item, options.keywords || []),
+  }));
+
+  // Sort by: priority type first, then relevance score desc, then timestamp desc
+  items.sort((a, b) => {
+    const aPriority = priorityTypes.indexOf(a.type);
+    const bPriority = priorityTypes.indexOf(b.type);
+    const aRank = aPriority === -1 ? Infinity : aPriority;
+    const bRank = bPriority === -1 ? Infinity : bPriority;
+    if (aRank !== bRank) return aRank - bRank;
+    if (b.relevanceScore !== a.relevanceScore) return b.relevanceScore - a.relevanceScore;
+    return (b.timestamp || 0) - (a.timestamp || 0);
+  });
+
+  // Stage 4: Apply min relevance and cap
+  items = items.filter((item) => item.relevanceScore >= minRelevance);
+  items = items.slice(0, maxItems);
+
+  return items;
+}
+
+/**
+ * Build a quick filter that only keeps items matching a set of requirement IDs.
+ * Useful when only context related to specific requirements should reach the LLM.
+ * @param {string[]} requirementIds
+ * @returns {InterceptOptions}
+ */
+export function requirementFilter(requirementIds) {
+  return {
+    predicate: (item) => {
+      const reqs = item.relatedRequirements || [];
+      return reqs.some((r) => requirementIds.includes(r));
+    },
+  };
+}

package/src/context/context-invalidation-events.js

@@ -0,0 +1,154 @@
+import { CONTEXT_EVENT_TYPES } from "./context-event-ingress.js";
+import { invalidateDependentEvidence } from "../evidence/evidence-lineage.js";
+import { transition as lifecycleTransition } from "./context-lifecycle.js";
+
+export const INVALIDATION_REASONS = Object.freeze({
+  REQUIREMENT_CHANGED: "REQUIREMENT_CHANGED",
+  STRATEGY_CHANGED: "STRATEGY_CHANGED",
+  HYPOTHESIS_CONTRADICTED: "HYPOTHESIS_CONTRADICTED",
+  TOOL_RESULT_CONTRADICTS_PREMISE: "TOOL_RESULT_CONTRADICTS_PREMISE",
+  DEPENDENCY_CHANGED: "DEPENDENCY_CHANGED",
+  CONFIG_CHANGED: "CONFIG_CHANGED",
+  USER_DECISION_CHANGED: "USER_DECISION_CHANGED",
+  BRANCH_CHANGED: "BRANCH_CHANGED",
+  FILE_MODIFIED: "FILE_MODIFIED",
+  ENV_CHANGED: "ENV_CHANGED",
+});
+
+export function createInvalidationEvent(taskId, reason, options = {}) {
+  const event = {
+    type: CONTEXT_EVENT_TYPES.CONTEXT_INVALIDATED,
+    taskId,
+    sessionId: options.sessionId || null,
+    executionId: options.executionId || null,
+    provenance: options.provenance || "context-invalidation",
+    payload: {
+      reason,
+      invalidatedAt: Date.now(),
+      invalidatedBy: options.invalidatedBy || "system",
+      scope: options.scope || "TASK",
+      invalidatedIds: options.invalidatedIds || [],
+      unresolvedCriticalUnknowns: options.unresolvedCriticalUnknowns || [],
+      ...options.payload,
+    },
+  };
+  return event;
+}
+
+export function applyInvalidation(contextManager, evidenceLineage, event) {
+  const { taskId, payload } = event;
+  const { reason, invalidatedIds, scope } = payload;
+
+  const affected = [];
+
+  if (invalidatedIds && invalidatedIds.length > 0) {
+    for (const itemId of invalidatedIds) {
+      const item = contextManager.getSource(itemId);
+      if (item) {
+        const updated = lifecycleTransition(item, "INVALIDATED", {
+          invalidationReason: reason,
+          invalidationEventId: event.id,
+          invalidatedAt: payload.invalidatedAt,
+        });
+        contextManager.register(updated);
+        affected.push({ itemId, reason, action: "INVALIDATED" });
+      }
+    }
+  }
+
+  if (reason === INVALIDATION_REASONS.HYPOTHESIS_CONTRADICTED) {
+    const hypothesisId = invalidatedIds?.[0] || options?.hypothesisId;
+    if (hypothesisId && evidenceLineage) {
+      const staleEvidence = invalidateDependentEvidence(taskId, hypothesisId, reason);
+      for (const ev of staleEvidence) {
+        const item = contextManager.getSource(ev.id);
+        if (item) {
+          const updated = lifecycleTransition(item, "INVALIDATED", {
+            invalidationReason: reason,
+            invalidationEventId: event.id,
+          });
+          contextManager.register(updated);
+          affected.push({ itemId: ev.id, reason, action: "INVALIDATED_EVIDENCE" });
+        }
+      }
+    }
+  }
+
+  return affected;
+}
+
+export function createFileModifiedEvent(taskId, path, sessionId, options = {}) {
+  return createInvalidationEvent(taskId, INVALIDATION_REASONS.FILE_MODIFIED, {
+    sessionId,
+    payload: { path, changeType: options.changeType || "modify", affectedItems: options.affectedItems },
+  });
+}
+
+export function createRequirementChangedEvent(taskId, requirementId, sessionId, options = {}) {
+  return createInvalidationEvent(taskId, INVALIDATION_REASONS.REQUIREMENT_CHANGED, {
+    sessionId,
+    invalidatedIds: [requirementId],
+    payload: { requirementId, changeType: options.changeType },
+  });
+}
+
+export function createStrategyChangedEvent(taskId, strategyId, sessionId, options = {}) {
+  return createInvalidationEvent(taskId, INVALIDATION_REASONS.STRATEGY_CHANGED, {
+    sessionId,
+    payload: { strategyId, changeType: options.changeType },
+  });
+}
+
+export function createHypothesisContradictedEvent(taskId, hypothesisId, sessionId, executionId, options = {}) {
+  return createInvalidationEvent(taskId, INVALIDATION_REASONS.HYPOTHESIS_CONTRADICTED, {
+    sessionId,
+    executionId,
+    invalidatedIds: [hypothesisId],
+    payload: { hypothesisId, assessment: options.assessment },
+  });
+}
+
+export function createDependencyChangedEvent(taskId, dependency, sessionId, options = {}) {
+  return createInvalidationEvent(taskId, INVALIDATION_REASONS.DEPENDENCY_CHANGED, {
+    sessionId,
+    payload: { dependency, changeType: options.changeType },
+  });
+}
+
+export function createConfigChangedEvent(taskId, configKey, sessionId, options = {}) {
+  return createInvalidationEvent(taskId, INVALIDATION_REASONS.CONFIG_CHANGED, {
+    sessionId,
+    payload: { configKey, changeType: options.changeType },
+  });
+}
+
+export function createToolResultContradictsPremiseEvent(taskId, premise, executionId, sessionId, options = {}) {
+  return createInvalidationEvent(taskId, INVALIDATION_REASONS.TOOL_RESULT_CONTRADICTS_PREMISE, {
+    sessionId,
+    executionId,
+    payload: { premise, toolResult: options.toolResult },
+  });
+}
+
+export const CONTEXT_INVALIDATION_ACTIONS = Object.freeze({
+  INVALIDATE_ITEM: "INVALIDATE_ITEM",
+  STALE_ITEM: "STALE_ITEM",
+  ARCHIVE_ITEM: "ARCHIVE_ITEM",
+  REEVALUATE_ITEM: "REEVALUATE_ITEM",
+});
+
+export function determineInvalidationAction(item, reason) {
+  if (item.lifecycle === "ARCHIVED" || item.lifecycle === "INVALIDATED") {
+    return CONTEXT_INVALIDATION_ACTIONS.REEVALUATE_ITEM;
+  }
+  if (reason === INVALIDATION_REASONS.HYPOTHESIS_CONTRADICTED) {
+    return CONTEXT_INVALIDATION_ACTIONS.INVALIDATE_ITEM;
+  }
+  if (reason === INVALIDATION_REASONS.FILE_MODIFIED) {
+    return CONTEXT_INVALIDATION_ACTIONS.STALE_ITEM;
+  }
+  if (reason === INVALIDATION_REASONS.CONFIG_CHANGED || reason === INVALIDATION_REASONS.ENV_CHANGED) {
+    return CONTEXT_INVALIDATION_ACTIONS.INVALIDATE_ITEM;
+  }
+  return CONTEXT_INVALIDATION_ACTIONS.INVALIDATE_ITEM;
+}