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

package/src/context/runtime-context-graph.js

@@ -0,0 +1,260 @@
+/**
+ * Runtime Context Graph — canonical assembler for all runtime state layers.
+ *
+ * Unifies taskState, runState, evidenceLineage, cognitionState, decisions,
+ * constraints, artifacts, observations, hypotheses, and experiments into a
+ * single ContextGraph. Replaces the shallow buildGraphFromTaskState() that
+ * only saw (task, requirements, evidence) with a layer-aware builder that
+ * creates nodes/edges for every state slice present in the runtime.
+ *
+ * Pattern follows context-graph-builder.js but expands coverage to:
+ *   - task, requirements
+ *   - evidence (lineage)
+ *   - decisions, constraints
+ *   - artifacts
+ *   - observations
+ *   - hypotheses, experiments (only when supplied)
+ *
+ * Edges are added only when both endpoints exist.
+ */
+
+import { ContextGraph } from "./context-graph.js";
+import { buildContextGraph } from "./context-graph-builder.js";
+
+/**
+ * @typedef {Object} BuildRuntimeContextGraphInput
+ * @property {Object} [taskState]
+ * @property {Object} [runState]
+ * @property {Array}  [evidenceLineage]
+ * @property {Object} [cognitionState]
+ * @property {Array}  [decisions]
+ * @property {Array}  [constraints]
+ * @property {Array}  [artifacts]
+ * @property {Array}  [observations]
+ * @property {Array}  [hypotheses]
+ * @property {Array}  [experiments]
+ */
+
+/**
+ * Build a canonical ContextGraph from all runtime state layers.
+ *
+ * @param {BuildRuntimeContextGraphInput} input
+ * @returns {ContextGraph}
+ */
+export function buildRuntimeContextGraph(input = {}) {
+  const {
+    taskState = {},
+    runState = {},
+    evidenceLineage = [],
+    cognitionState = {},
+    decisions = [],
+    constraints = [],
+    artifacts = [],
+    observations = [],
+    hypotheses = [],
+    experiments = [],
+  } = input;
+
+  // Canonical primary source: delegate base graph (task + requirements +
+  // evidence) to context-graph-builder.js so node/edge schema and IDs
+  // stay canonical. The remaining state layers (cognition, decisions,
+  // constraints, artifacts, observations, hypotheses, experiments) are
+  // added below on top of the canonical base.
+  const g = buildContextGraph(taskState, runState, evidenceLineage);
+  const taskId = taskState?.taskId || null;
+
+  // -- Requirement shadow output nodes (router compatibility) --
+  //     The canonical requirement node + the task→requirement edge are
+  //     already produced by buildContextGraph() above. We only need the
+  //     shadow "output" node per requirement so Context Router's Phase 3
+  //     collection can resolve output-type ids.
+  const requirementIds = new Set();
+  for (const req of taskState?.requirements || []) {
+    if (!req?.id) continue;
+    requirementIds.add(req.id);
+    const outputId = `${req.id}::output`;
+      g.addNode({
+        id: outputId,
+        type: "output",
+        content: req.title || req.description || "",
+        metadata: {
+          provenance: "user_decided",
+          shadowOf: req.id,
+        },
+      });
+      if (taskId) {
+        g.addEdge({ from: taskId, to: outputId, type: "related_to" });
+      }
+  }
+
+  // -- Evidence lineage (evidence supports requirement when linked) --
+  for (const ev of evidenceLineage || []) {
+    if (!ev?.id) continue;
+    g.addNode({
+      id: ev.id,
+      type: "evidence",
+      content: ev.content || ev.summary || "",
+      verified: ev.status === "valid" || ev.verified === true,
+      metadata: {
+        provenance: "run_execution",
+        source: ev.source || null,
+        capturedAt: ev.capturedAt || null,
+      },
+    });
+    if (ev.requirementId && requirementIds.has(ev.requirementId)) {
+      g.addEdge({ from: ev.id, to: ev.requirementId, type: "supports" });
+    } else if (taskId) {
+      g.addEdge({ from: ev.id, to: taskId, type: "supports" });
+    }
+  }
+
+  // -- Decisions (decision influences requirement/task) --
+  for (const dec of decisions || []) {
+    if (!dec?.id) continue;
+    g.addNode({
+      id: dec.id,
+      type: "decision",
+      content: dec.summary || dec.description || dec.content || "",
+      metadata: {
+        provenance: dec.provenance || "user_decided",
+        madeAt: dec.madeAt || null,
+        status: dec.status || "accepted",
+      },
+    });
+    if (dec.requirementId && requirementIds.has(dec.requirementId)) {
+      g.addEdge({ from: dec.id, to: dec.requirementId, type: "supports" });
+    } else if (taskId) {
+      g.addEdge({ from: dec.id, to: taskId, type: "supports" });
+    }
+  }
+
+  // -- Constraints (constraint constrains task/requirement) --
+  for (const c of constraints || []) {
+    if (!c?.id) continue;
+    g.addNode({
+      id: c.id,
+      type: "constraint",
+      content: c.description || c.content || c.summary || "",
+      metadata: {
+        provenance: c.provenance || "user_decided",
+        severity: c.severity || "normal",
+        relation: "constraint",
+      },
+    });
+    const target = c.requirementId || taskId;
+    if (target) {
+      g.addEdge({ from: target, to: c.id, type: "related_to" });
+    }
+  }
+
+  // -- Artifacts (task produces artifact) --
+  for (const a of artifacts || []) {
+    if (!a?.id) continue;
+    g.addNode({
+      id: a.id,
+      type: "artifact",
+      content: a.content || a.path || a.summary || "",
+      metadata: {
+        provenance: a.provenance || "run_execution",
+        path: a.path || null,
+        kind: a.kind || "generic",
+      },
+    });
+    // taskId is the canonical producer; fall back to requirement only
+    // when no task is in scope.
+    const producer = taskId || a.taskId || a.requirementId;
+    if (producer) {
+      g.addEdge({ from: producer, to: a.id, type: "produces" });
+    }
+    if (a.requirementId && requirementIds.has(a.requirementId)) {
+      g.addEdge({ from: a.id, to: a.requirementId, type: "supports" });
+    }
+  }
+
+  // -- Observations (observation relates to task) --
+  for (const o of observations || []) {
+    if (!o?.id) continue;
+    g.addNode({
+      id: o.id,
+      type: "observation",
+      content: o.content || o.summary || "",
+      metadata: {
+        provenance: o.provenance || "run_execution",
+        observedAt: o.observedAt || null,
+      },
+    });
+    const target = o.requirementId || o.taskId || taskId;
+    if (target) {
+      g.addEdge({ from: o.id, to: target, type: "related_to" });
+    }
+  }
+
+  // -- Hypotheses (only when present) --
+  for (const h of hypotheses || []) {
+    if (!h?.id) continue;
+    g.addNode({
+      id: h.id,
+      type: "claim",
+      content: h.statement || h.content || "",
+      metadata: {
+        provenance: h.provenance || "user_decided",
+        confidence: h.confidence ?? null,
+        kind: "hypothesis",
+      },
+    });
+    const target = h.requirementId || h.taskId || taskId;
+    if (target) {
+      g.addEdge({ from: h.id, to: target, type: "related_to" });
+    }
+  }
+
+  // -- Experiments (only when present) --
+  for (const x of experiments || []) {
+    if (!x?.id) continue;
+    g.addNode({
+      id: x.id,
+      type: "action",
+      content: x.description || x.content || "",
+      metadata: {
+        provenance: x.provenance || "run_execution",
+        status: x.status || "planned",
+        kind: "experiment",
+      },
+    });
+    if (x.hypothesisId && g.hasNode(x.hypothesisId)) {
+      g.addEdge({ from: x.id, to: x.hypothesisId, type: "supports" });
+    }
+    const target = x.requirementId || taskId;
+    if (target) {
+      g.addEdge({ from: x.id, to: target, type: "produces" });
+    }
+  }
+
+  // -- Cognition summary node (single node when cognitionState present) --
+  if (cognitionState && Object.keys(cognitionState).length > 0) {
+    const cogId = cognitionState.id || `cognition:${taskId || "global"}`;
+    if (!g.hasNode(cogId)) {
+      g.addNode({
+        id: cogId,
+        type: "observation",
+        content:
+          cognitionState.summary ||
+          cognitionState.objective ||
+          "Active cognition state",
+        metadata: {
+          provenance: "run_execution",
+          kind: "cognition",
+          load: cognitionState.load ?? null,
+          focus: cognitionState.focus || null,
+        },
+      });
+      if (taskId) {
+        g.addEdge({ from: cogId, to: taskId, type: "related_to" });
+      }
+    }
+  }
+
+  return g;
+}
+
+export default { buildRuntimeContextGraph };

package/src/context/selection.js

@@ -0,0 +1,2 @@
+import { selectContext, retrieveContext } from "./context.js";
+export { selectContext, retrieveContext };

package/src/context/session.js

@@ -0,0 +1,2 @@
+import { getSessionId } from "./context.js";
+export { getSessionId };

package/src/context/sufficiency-contract.js

@@ -0,0 +1,300 @@
+/**
+ * Context Sufficiency Contract — task-derived conditions for safe execution.
+ *
+ * Replaces lexical keyword matching with structured conditions that
+ * must be satisfied before autonomous execution is permitted.
+ *
+ * States: SATISFIED | MISSING | BLOCKED | UNKNOWN
+ */
+
+/**
+ * @typedef {"SATISFIED" | "MISSING" | "BLOCKED" | "UNKNOWN"} ConditionStatus
+ */
+
+/**
+ * @typedef {Object} SufficiencyCondition
+ * @property {string} id
+ * @property {string} type - Type of required knowledge
+ * @property {string} description
+ * @property {ConditionStatus} status
+ * @property {string} source - What satisfied or blocked this condition
+ * @property {"MANDATORY" | "CONDITIONAL"} severity
+ */
+
+/**
+ * @typedef {Object} SufficiencyContract
+ * @property {string} taskId
+ * @property {SufficiencyCondition[]} conditions
+ * @property {boolean} sufficient - True only when all MANDATORY conditions are SATISFIED
+ * @property {string[]} missing - List of missing MANDATORY condition descriptions
+ */
+
+/** Condition types derived from task analysis */
+const CONDITION_TYPES = {
+  PROJECT_KNOWLEDGE: "project-knowledge",
+  DECISION: "decision",
+  CONSTRAINT: "constraint",
+  DEPENDENCY: "dependency",
+  VERIFICATION: "verification",
+  UNKNOWN_RESOLUTION: "unknown-resolution",
+};
+
+/**
+ * Patterns that indicate required context domains.
+ * Each pattern maps to one or more condition types.
+ */
+const DOMAIN_PATTERNS = [
+  {
+    domain: "auth",
+    patterns: /\b(auth|oauth|jwt|token|login|credential|password|session)\b/i,
+    conditions: [
+      { type: CONDITION_TYPES.DECISION, description: "Auth mechanism decision (OAuth, JWT, etc.)" },
+      { type: CONDITION_TYPES.PROJECT_KNOWLEDGE, description: "Existing auth implementation" },
+    ],
+  },
+  {
+    domain: "migration",
+    patterns: /\b(migrat|schema.*change|database.*change|column.*add|table.*rename)\b/i,
+    conditions: [
+      { type: CONDITION_TYPES.DECISION, description: "Migration strategy (forward, backward-compatible)" },
+      { type: CONDITION_TYPES.CONSTRAINT, description: "Data integrity constraints" },
+      { type: CONDITION_TYPES.DEPENDENCY, description: "Migration tool version" },
+    ],
+  },
+  {
+    domain: "security",
+    patterns: /\b(security|vulnerability|cve|encrypt|hash|sanitiz|xss|csrf|injection)\b/i,
+    conditions: [
+      { type: CONDITION_TYPES.DECISION, description: "Security approach decision" },
+      { type: CONDITION_TYPES.CONSTRAINT, description: "Security constraints and compliance requirements" },
+    ],
+  },
+  {
+    domain: "testing",
+    patterns: /\b(test|spec|coverage|e2e|unit|integration)\b/i,
+    conditions: [
+      { type: CONDITION_TYPES.PROJECT_KNOWLEDGE, description: "Test framework and patterns" },
+      { type: CONDITION_TYPES.VERIFICATION, description: "Verification criteria" },
+    ],
+  },
+  {
+    domain: "architecture",
+    patterns: /\b(architect|refactor|restructur|monolith|microservice|modul)\b/i,
+    conditions: [
+      { type: CONDITION_TYPES.DECISION, description: "Architecture decision" },
+      { type: CONDITION_TYPES.CONSTRAINT, description: "Architectural constraints" },
+      { type: CONDITION_TYPES.PROJECT_KNOWLEDGE, description: "Current architecture state" },
+    ],
+  },
+  {
+    domain: "performance",
+    patterns: /\b(performance|optim|cache|redis|latency|throughput|bottleneck)\b/i,
+    conditions: [
+      { type: CONDITION_TYPES.DECISION, description: "Performance optimization strategy" },
+      { type: CONDITION_TYPES.PROJECT_KNOWLEDGE, description: "Current performance baseline" },
+    ],
+  },
+  {
+    domain: "scraping",
+    patterns: /\b(scrap|crawl|puppeteer|playwright|selenium|parser)\b/i,
+    conditions: [
+      { type: CONDITION_TYPES.PROJECT_KNOWLEDGE, description: "Scraping framework and patterns" },
+      { type: CONDITION_TYPES.DEPENDENCY, description: "Browser automation dependency" },
+    ],
+  },
+];
+
+/**
+ * Concrete terms per domain. When a domain's condition is unsatisfied, the
+ * matched terms are surfaced verbatim in `missing` so the caller can name the
+ * exact missing concept (e.g. "cache") instead of only a prose description.
+ */
+const DOMAIN_TERMS = {
+  auth: ["auth", "oauth", "jwt", "token", "login", "credential", "password", "session"],
+  migration: ["migration", "schema", "column", "table"],
+  security: ["security", "vulnerability", "encrypt", "hash", "sanitize", "xss", "csrf", "injection"],
+  testing: ["test", "coverage", "e2e", "unit", "integration"],
+  architecture: ["architecture", "refactor", "structure", "monolith", "microservice", "module"],
+  performance: ["performance", "optimization", "cache", "redis", "latency", "throughput", "bottleneck"],
+  scraping: ["scraping", "crawl", "puppeteer", "playwright", "selenium", "parser"],
+};
+
+/**
+ * Collect the MANDATORY missing descriptions plus the matched domain terms.
+ * Descriptions stay first so existing consumers keep working; the terms are
+ * appended so a caller can test for a concrete missing concept.
+ *
+ * @param {SufficiencyCondition[]} conditions
+ * @returns {string[]}
+ */
+function collectMissing(conditions) {
+  const out = [];
+  const seen = new Set();
+  for (const c of conditions) {
+    if (c.status !== "MISSING" && c.status !== "BLOCKED") continue;
+    if (c.severity !== "MANDATORY") continue;
+    if (!seen.has(c.description)) {
+      out.push(c.description);
+      seen.add(c.description);
+    }
+    for (const term of c.terms || []) {
+      if (!seen.has(term)) {
+        out.push(term);
+        seen.add(term);
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * Generate a sufficiency contract from a task description.
+ *
+ * @param {string} taskDescription
+ * @param {string} taskId
+ * @returns {SufficiencyContract}
+ */
+export function generateContract(taskDescription, taskId) {
+  const conditions = [];
+  const seen = new Set();
+
+  for (const domain of DOMAIN_PATTERNS) {
+    if (domain.patterns.test(taskDescription)) {
+      const terms = (DOMAIN_TERMS[domain.domain] || []).filter((t) =>
+        new RegExp(`\\b${t}`, "i").test(taskDescription)
+      );
+      for (const cond of domain.conditions) {
+        const key = `${cond.type}:${cond.description}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          conditions.push({
+            id: `SC-${conditions.length + 1}`,
+            type: cond.type,
+            description: cond.description,
+            domain: domain.domain,
+            terms,
+            status: "MISSING",
+            source: "",
+            severity: "MANDATORY",
+          });
+        }
+      }
+    }
+  }
+
+  // Always require project knowledge as a baseline
+  const projectKnowledgeKey = `${CONDITION_TYPES.PROJECT_KNOWLEDGE}:Project structure and dependencies`;
+  if (!seen.has(projectKnowledgeKey)) {
+    seen.add(projectKnowledgeKey);
+    conditions.push({
+      id: `SC-${conditions.length + 1}`,
+      type: CONDITION_TYPES.PROJECT_KNOWLEDGE,
+      description: "Project structure and dependencies",
+      status: "MISSING",
+      source: "",
+      severity: "MANDATORY",
+    });
+  }
+
+  const missing = collectMissing(conditions);
+
+  return {
+    taskId,
+    conditions,
+    sufficient: missing.length === 0,
+    missing,
+  };
+}
+
+/**
+ * Evaluate a sufficiency contract against available context capsules.
+ *
+ * @param {SufficiencyContract} contract
+ * @param {Array} capsules - Selected context capsules
+ * @returns {SufficiencyContract} Updated contract with statuses
+ */
+export function evaluateContract(contract, capsules) {
+  const capsuleText = capsules
+    .map((c) => `${c.purpose || ""} ${c.scope || ""} ${c.content || ""}`)
+    .join(" ")
+    .toLowerCase();
+
+  for (const condition of contract.conditions) {
+    // Check if any capsule covers this condition
+    const covered = capsules.some((c) => {
+      const text = `${c.purpose || ""} ${c.scope || ""} ${c.content || ""}`.toLowerCase();
+      return conditionMatchesText(condition, text);
+    });
+
+    if (covered) {
+      condition.status = "SATISFIED";
+      condition.source = "capsule";
+    }
+  }
+
+  // Recalculate sufficiency
+  contract.missing = collectMissing(contract.conditions);
+  contract.sufficient = contract.missing.length === 0;
+
+  return contract;
+}
+
+/**
+ * Check if a condition is covered by text content.
+ */
+function conditionMatchesText(condition, text) {
+  // Type-specific matching
+  switch (condition.type) {
+    case CONDITION_TYPES.PROJECT_KNOWLEDGE:
+      return /\b(project|package\.json|dependenc|structure|architect)\b/i.test(text);
+    case CONDITION_TYPES.DECISION:
+      return /\b(decision|decid|chose|selected|approach|strategy)\b/i.test(text);
+    case CONDITION_TYPES.CONSTRAINT:
+      return /\b(constraint|requirement|must|shall|mandatory|compliance)\b/i.test(text);
+    case CONDITION_TYPES.DEPENDENCY:
+      return /\b(dependency|version|package|library|framework)\b/i.test(text);
+    case CONDITION_TYPES.VERIFICATION:
+      return /\b(verification|verify|test|pass|evidence|criteria)\b/i.test(text);
+    case CONDITION_TYPES.UNKNOWN_RESOLUTION:
+      return /\b(answer|resolved|clarified|confirmed)\b/i.test(text);
+    default:
+      return false;
+  }
+}
+
+/**
+ * Merge a sufficiency contract with assumptions from the analysis.
+ * Assumptions with DECISION_CRITICAL classification become MANDATORY conditions.
+ *
+ * @param {SufficiencyContract} contract
+ * @param {Array} assumptions - From analysis.assumptions
+ * @returns {SufficiencyContract}
+ */
+export function mergeAssumptions(contract, assumptions) {
+  for (const assumption of assumptions || []) {
+    if (assumption.classification === "DECISION_CRITICAL" && assumption.status === "active") {
+      const key = `${CONDITION_TYPES.UNKNOWN_RESOLUTION}:${assumption.statement}`;
+      const exists = contract.conditions.some(
+        (c) => c.type === CONDITION_TYPES.UNKNOWN_RESOLUTION && c.description === assumption.statement
+      );
+      if (!exists) {
+        contract.conditions.push({
+          id: `SC-${contract.conditions.length + 1}`,
+          type: CONDITION_TYPES.UNKNOWN_RESOLUTION,
+          description: assumption.statement,
+          status: "BLOCKED",
+          source: `assumption ${assumption.id}`,
+          severity: "MANDATORY",
+        });
+      }
+    }
+  }
+
+  // Recalculate
+  contract.missing = collectMissing(contract.conditions);
+  contract.sufficient = contract.missing.length === 0;
+
+  return contract;
+}
+
+export { CONDITION_TYPES };

package/src/context/tokenizer.js

@@ -0,0 +1,17 @@
+export function countTokens(text) {
+  if (text == null || text === '') return 0;
+  const str = String(text);
+  // Approximation: GPT-2 BPE rule of thumb.
+  // Common regex from OpenAI's gpt-3.5-turbo tokenizer approximations
+  // and tiktoken's "cl100k_base" approximated regex pattern.
+  const re = /'s|'t|'re|'ve|'m|'ll|'d| ?[A-Za-z]+| ?[0-9]+| ?[^\sA-Za-z0-9]+|\s+(?!\S)/g;
+  const matches = str.match(re);
+  if (!matches) return 0;
+  // Each matched piece is roughly 1 token for short ASCII; multi-byte chars add overhead.
+  let tokens = matches.length;
+  // Account for multi-byte characters (emojis, accented, CJK) — roughly 2 tokens each.
+  const multibyteCount = (str.match(/[^\x00-\x7F]/g) || []).length;
+  // Multi-byte chars are already counted once in matches; roughly double-count them.
+  tokens += multibyteCount;
+  return tokens;
+}