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

package/src/context/context-routing-shadow.js

@@ -0,0 +1,237 @@
+/**
+ * WAM Context Routing — Shadow Mode
+ *
+ * Computes what context WAM would send for a task, without modifying
+ * OpenCode context. Used for evaluation against the current context pack.
+ */
+
+import { ContextGraph } from "./context-graph.js";
+import { getResumeContext, getPreviousFailures, getPreviousDecisions } from "../state/task-runs.js";
+import { getDependencies, getUpstream, detectMissingDependencies, detectContextGaps } from "../state/task-dependencies.js";
+import { resolveContext } from "./context-router.js";
+import { getTaskState } from "../skills/engine.js";
+
+// -- Types --
+
+/**
+ * @typedef {Object} ContextSnapshot
+ * @property {string[]} nodeIds
+ * @property {number} tokenEstimate
+ * @property {string[]} sources - Where each piece of context came from
+ */
+
+/**
+ * @typedef {Object} ContextGap
+ * @property {string} type
+ * @property {string} severity
+ * @property {string} description
+ */
+
+/**
+ * @typedef {Object} ShadowContextResult
+ * @property {string} taskId
+ * @property {ContextSnapshot} currentContext
+ * @property {ContextSnapshot} proposedContext
+ * @property {ContextGap[]} missing
+ * @property {{ current: number, proposed: number }} tokenEstimate
+ * @property {string[]} routingDecisions - Why each piece was selected
+ */
+
+// -- Token estimation --
+
+function estimateTokens(text = "") {
+  return Math.ceil((text || "").length / 4);
+}
+
+function nodeTokens(node) {
+  return estimateTokens(node.content) + 20;
+}
+
+// -- Current Context Pack (simulates what WAM currently sends) --
+
+/**
+ * Simulate the current WAM context pack for a task.
+ * This represents the N0-N3 model.
+ */
+export function getCurrentContextPack(taskId, root) {
+  const sources = [];
+  const nodeIds = [];
+  let tokens = 0;
+
+  // N0: Global policy (minimal)
+  sources.push("N0:global-policy");
+  tokens += 50;
+
+  // N2: Task state (required)
+  const state = getTaskState(taskId, root);
+  if (state) {
+    nodeIds.push(`task-${taskId}`);
+    const taskTokens = estimateTokens(JSON.stringify(state));
+    tokens += taskTokens;
+    sources.push(`N2:task-state (${taskTokens} tokens)`);
+  }
+
+  // N3: Session context (top-level only)
+  sources.push("N3:session-context");
+  tokens += 200;
+
+  return { nodeIds, tokenEstimate: tokens, sources };
+}
+
+// -- Proposed Context (shadow routing) --
+
+/**
+ * Compute proposed context using dependency-aware routing.
+ * Combines: task state + dependencies + evidence + relevant history.
+ */
+export function getProposedContext(taskId, graph, root) {
+  const sources = [];
+  const nodeIds = [];
+  let tokens = 0;
+
+  // 1. Current task state (always included)
+  nodeIds.push(taskId);
+  sources.push("task-state");
+  tokens += 200;
+
+  // 2. Required dependencies (from graph)
+  if (graph) {
+    const deps = graph.getDependencies(taskId);
+    for (const dep of deps) {
+      nodeIds.push(dep.id);
+      tokens += nodeTokens(dep);
+      sources.push(`dependency:${dep.type}`);
+    }
+
+    // 3. Upstream context (transitive deps)
+    const upstream = graph.getUpstream(taskId, 3);
+    for (const u of upstream) {
+      if (!nodeIds.includes(u.id)) {
+        nodeIds.push(u.id);
+        tokens += nodeTokens(u);
+        sources.push(`upstream:${u.type}`);
+      }
+    }
+  }
+
+  // 4. Required evidence
+  if (graph) {
+    const evidenceNodes = graph.getNodes("evidence");
+    for (const e of evidenceNodes) {
+      if (!nodeIds.includes(e.id)) {
+        // Check if this evidence supports any of our dependencies
+        const supports = graph.getEdgesFrom(e.id);
+        const relevant = supports.some((s) => nodeIds.includes(s.to));
+        if (relevant) {
+          nodeIds.push(e.id);
+          tokens += nodeTokens(e);
+          sources.push("evidence:supports-dependency");
+        }
+      }
+    }
+  }
+
+  // 5. Relevant execution history (last 2 failures + 3 decisions)
+  const failures = getPreviousFailures(taskId, root);
+  for (const f of failures.slice(-2)) {
+    nodeIds.push(`exec-failure-${f.id}`);
+    tokens += estimateTokens(f.outcome || "") + 20;
+    sources.push(`history:failure`);
+  }
+
+  const decisions = getPreviousDecisions(taskId, root, 3);
+  for (const d of decisions) {
+    nodeIds.push(`exec-decision-${d.executionId}`);
+    tokens += estimateTokens(d.decision) + 20;
+    sources.push(`history:decision`);
+  }
+
+  // 6. Context gaps
+  let gaps = [];
+  if (graph) {
+    // Detect missing deps by checking edges from this task
+    const edges = graph.getEdgesFrom(taskId);
+    for (const edge of edges) {
+      if (["requires_output", "requires_completion", "requires_evidence",
+           "requires_decision", "depends_on_artifact"].includes(edge.type)) {
+        const targetNode = graph.getNode(edge.to);
+        if (!targetNode) {
+          gaps.push({ type: "missing_dependency", severity: "blocking", description: `Output ${edge.to} not found` });
+        } else if (!targetNode.verified) {
+          gaps.push({ type: "unverified_dependency", severity: "warning", description: `Output ${edge.to} not verified` });
+        }
+      }
+    }
+  }
+
+  return {
+    nodeIds,
+    tokenEstimate: tokens,
+    sources,
+    gaps,
+  };
+}
+
+// -- Shadow Router --
+
+/**
+ * Run shadow routing: compute both current and proposed context.
+ * Never modifies OpenCode input.
+ */
+export function shadowRoute(taskId, graph, root) {
+  const current = getCurrentContextPack(taskId, root);
+  const proposed = getProposedContext(taskId, graph, root);
+  const missing = proposed.gaps || [];
+
+  const routingDecisions = proposed.sources.map((s) => `Include: ${s}`);
+
+  if (missing.length > 0) {
+    routingDecisions.push(`Block: ${missing.length} context gaps detected`);
+  }
+
+  return {
+    taskId,
+    currentContext: {
+      nodeIds: current.nodeIds,
+      tokenEstimate: current.tokenEstimate,
+      sources: current.sources,
+    },
+    proposedContext: {
+      nodeIds: proposed.nodeIds,
+      tokenEstimate: proposed.tokenEstimate,
+      sources: proposed.sources,
+    },
+    missing,
+    tokenEstimate: {
+      current: current.tokenEstimate,
+      proposed: proposed.tokenEstimate,
+    },
+    routingDecisions,
+  };
+}
+
+// -- Evaluation Helpers --
+
+/**
+ * Check if proposed context includes all required items from current context.
+ */
+export function hasRequiredContext(proposed, required) {
+  return required.every((r) => proposed.nodeIds.includes(r));
+}
+
+/**
+ * Compute context overlap between current and proposed.
+ */
+export function computeOverlap(current, proposed) {
+  const currentSet = new Set(current.nodeIds);
+  const proposedSet = new Set(proposed.nodeIds);
+  const intersection = [...currentSet].filter((id) => proposedSet.has(id));
+  const union = new Set([...currentSet, ...proposedSet]);
+
+  return {
+    shared: intersection.length,
+    onlyInCurrent: currentSet.size - intersection.length,
+    onlyInProposed: proposedSet.size - intersection.length,
+    jaccard: union.size > 0 ? intersection.length / union.size : 0,
+  };
+}

package/src/context/context-scope.js

@@ -0,0 +1,181 @@
+/**
+ * Context Scope — define and assign scope boundaries to context items.
+ *
+ * Scopes: GLOBAL, PROJECT, TASK, REQUIREMENT, ACTION, SESSION, TURN.
+ *
+ * Scope determines the visibility and lifetime of a context item.
+ * A context item's scope is assigned by analyzing the item's metadata,
+ * type, and associated identifiers.
+ */
+
+/** @typedef {"GLOBAL"|"PROJECT"|"TASK"|"REQUIREMENT"|"ACTION"|"SESSION"|"TURN"} ContextScope */
+
+/**
+ * @typedef {Object} ScopeResult
+ * @property {ContextScope} scope
+ * @property {number} confidence 0-1
+ * @property {string} reason
+ */
+
+// Scope hierarchy (smaller = more specific)
+const SCOPE_LEVELS = ["GLOBAL", "PROJECT", "TASK", "REQUIREMENT", "ACTION", "SESSION", "TURN"];
+
+// Type-to-scope hints
+const TYPE_SCOPE_HINTS = {
+  tool_call: "ACTION",
+  tool_result: "ACTION",
+  agent_message: "SESSION",
+  system_message: "GLOBAL",
+  file_modification: "ACTION",
+  git_change: "PROJECT",
+  requirement_change: "REQUIREMENT",
+  verification_result: "ACTION",
+  clarification_request: "SESSION",
+  plan: "TASK",
+  rationale: "SESSION",
+  assumption: "SESSION",
+};
+
+/**
+ * Infer scope from metadata fields.
+ * @param {Object} metadata
+ * @returns {ContextScope|null}
+ */
+function inferFromMetadata(metadata) {
+  if (!metadata || typeof metadata !== "object") return null;
+
+  // Explicit scope in metadata (uppercase normalized)
+  if (metadata.scope) {
+    const raw = String(metadata.scope).toUpperCase();
+    if (SCOPE_LEVELS.includes(raw)) {
+      return raw;
+    }
+  }
+
+  // Task ID implies TASK scope (or more specific if requirementId present)
+  if (metadata.taskId || metadata.task_id) {
+    if (metadata.requirementId || metadata.requirement_id) {
+      return "REQUIREMENT";
+    }
+    if (metadata.actionId || metadata.action_id) {
+      return "ACTION";
+    }
+    return "TASK";
+  }
+
+  // Requirement ID implies REQUIREMENT scope
+  if (metadata.requirementId || metadata.requirement_id) {
+    return "REQUIREMENT";
+  }
+
+  // Session ID implies SESSION scope
+  if (metadata.sessionId || metadata.session_id || metadata.session) {
+    return "SESSION";
+  }
+
+  // Turn number implies TURN scope
+  if (metadata.turn !== undefined || metadata.turnNumber !== undefined) {
+    return "TURN";
+  }
+
+  // Project name/id implies PROJECT scope
+  if (metadata.projectId || metadata.project_id || metadata.project) {
+    return "PROJECT";
+  }
+
+  return null;
+}
+
+/**
+ * Infer scope from item type and content.
+ * @param {Object} item
+ * @returns {ContextScope|null}
+ */
+function inferFromType(item) {
+  const type = (item.type || "").toLowerCase();
+  return TYPE_SCOPE_HINTS[type] || null;
+}
+
+/**
+ * Assign scope to a context item.
+ * @param {Object} item - Context item with type, metadata, content
+ * @param {Object} [metadata] - Additional context for scoping decisions
+ * @returns {ScopeResult}
+ */
+export function scopeContextItem(item, metadata = {}) {
+  if (!item || typeof item !== "object") {
+    return { scope: "SESSION", confidence: 0.3, reason: "default_fallback" };
+  }
+
+  const combinedMetadata = { ...item.metadata, ...metadata };
+
+  // 1. Explicit scope in metadata (highest priority)
+  const explicit = inferFromMetadata(combinedMetadata);
+  if (explicit) {
+    return { scope: explicit, confidence: 0.95, reason: "explicit_metadata" };
+  }
+
+  // 2. Type-based inference
+  const typeScope = inferFromType(item);
+  if (typeScope) {
+    return { scope: typeScope, confidence: 0.8, reason: `type:${item.type}` };
+  }
+
+  // 3. Content-based keywords
+  const text = typeof item.content === "string"
+    ? item.content
+    : typeof item.summary === "string"
+      ? item.summary
+      : JSON.stringify(item.content || "");
+
+  const lower = text.toLowerCase();
+
+  if (metadata.globalScope || combinedMetadata.globalScope || lower.includes("global")) {
+    return { scope: "GLOBAL", confidence: 0.7, reason: "global_signal" };
+  }
+  if (lower.includes("project") || combinedMetadata.project) {
+    return { scope: "PROJECT", confidence: 0.7, reason: "project_signal" };
+  }
+  if (lower.includes("requirement") || combinedMetadata.requirement) {
+    return { scope: "REQUIREMENT", confidence: 0.7, reason: "requirement_signal" };
+  }
+
+  // 4. Default: SESSION scope
+  return { scope: "SESSION", confidence: 0.6, reason: "default_session" };
+}
+
+/**
+ * Normalize a scope string to a valid ContextScope.
+ * @param {string} scope
+ * @returns {ContextScope}
+ */
+export function normalizeScope(scope) {
+  if (!scope) return "SESSION";
+  const upper = String(scope).toUpperCase();
+  if (SCOPE_LEVELS.includes(upper)) return upper;
+  return "SESSION";
+}
+
+/**
+ * Get parent scope (one level up in hierarchy).
+ * @param {ContextScope} scope
+ * @returns {ContextScope}
+ */
+export function parentScope(scope) {
+  const idx = SCOPE_LEVELS.indexOf(scope);
+  if (idx <= 0) return scope; // GLOBAL has no parent
+  return SCOPE_LEVELS[idx - 1];
+}
+
+/**
+ * Check if a scope covers another (is at least as broad).
+ * @param {ContextScope} container
+ * @param {ContextScope} contained
+ * @returns {boolean}
+ */
+export function scopeCovers(container, contained) {
+  const cIdx = SCOPE_LEVELS.indexOf(container);
+  const sIdx = SCOPE_LEVELS.indexOf(contained);
+  if (cIdx < 0 || sIdx < 0) return false;
+  return cIdx <= sIdx;
+}

package/src/context/context-snapshot.js

@@ -0,0 +1,226 @@
+/**
+ * Context Snapshot — continuation invalidation.
+ * Detects when context has become stale and needs rebuild.
+ *
+ * States: VALID | STALE | INVALID
+ */
+
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+const SNAPSHOT_DIR = ".wam/snapshots";
+
+/**
+ * @typedef {Object} ContextSnapshot
+ * @property {string} taskId
+ * @property {string} gitRevision
+ * @property {string} relevantFilesHash
+ * @property {string} projectContextHash
+ * @property {string} taskStateHash
+ * @property {number} createdAt
+ */
+
+/**
+ * @typedef {"VALID" | "STALE" | "INVALID"} SnapshotStatus
+ */
+
+/**
+ * @typedef {Object} SnapshotCheck
+ * @property {SnapshotStatus} status
+ * @property {string} reason
+ * @property {string[]} changedSignals
+ */
+
+function hashString(str = "") {
+  return crypto.createHash("sha256").update(str || "").digest("hex").slice(0, 16);
+}
+
+function hashFiles(filePaths, root) {
+  const parts = [];
+  for (const fp of filePaths) {
+    const full = path.join(root, fp);
+    try {
+      const content = fs.readFileSync(full, "utf-8");
+      parts.push(`${fp}:${hashString(content)}`);
+    } catch {
+      parts.push(`${fp}:missing`);
+    }
+  }
+  return hashString(parts.join("|"));
+}
+
+function getGitRevision(root) {
+  try {
+    const head = fs.readFileSync(path.join(root, ".git", "HEAD"), "utf-8").trim();
+    const ref = head.replace(/^ref:\s*/, "");
+    const refPath = path.join(root, ".git", ref);
+    if (fs.existsSync(refPath)) {
+      return fs.readFileSync(refPath, "utf-8").trim().slice(0, 12);
+    }
+    return head.slice(0, 12);
+  } catch {
+    return null;
+  }
+}
+
+function getRelevantFiles(root) {
+  const candidates = [
+    "package.json",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "tsconfig.json",
+    "nest-cli.json",
+    "angular.json",
+    "AGENTS.md",
+    ".opencode/opencode.jsonc",
+  ];
+  return candidates.filter((f) => fs.existsSync(path.join(root, f)));
+}
+
+function getProjectContextHash(root) {
+  const relevant = getRelevantFiles(root);
+  return hashFiles(relevant, root);
+}
+
+function getTaskStateHash(taskState) {
+  const serialized = JSON.stringify({
+    phase: taskState?.phase,
+    contractStatus: taskState?.contract?.status,
+    requirements: taskState?.requirements?.map((r) => ({
+      id: r.id,
+      status: r.status,
+    })),
+    approvedStrategy: taskState?.approvedStrategy,
+  });
+  return hashString(serialized);
+}
+
+function snapshotDir(root) {
+  const dir = path.join(root || process.cwd(), SNAPSHOT_DIR);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function snapshotPath(taskId, root) {
+  return path.join(snapshotDir(root), `${taskId}.json`);
+}
+
+/**
+ * Create a context snapshot for a task.
+ */
+export function createSnapshot(taskId, taskState, root) {
+  const snapshot = {
+    taskId,
+    gitRevision: getGitRevision(root),
+    relevantFilesHash: getProjectContextHash(root),
+    projectContextHash: hashString(getRelevantFiles(root).join(",")),
+    taskStateHash: getTaskStateHash(taskState),
+    createdAt: Date.now(),
+  };
+  fs.writeFileSync(snapshotPath(taskId, root), JSON.stringify(snapshot, null, 2));
+  return snapshot;
+}
+
+/**
+ * Load an existing snapshot for a task.
+ */
+export function loadSnapshot(taskId, root) {
+  try {
+    const raw = fs.readFileSync(snapshotPath(taskId, root), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if a continuation can use the fast-path.
+ *
+ * @param {string} taskId
+ * @param {Object} currentTaskState
+ * @param {string} root
+ * @returns {SnapshotCheck}
+ */
+export function checkContinuation(taskId, currentTaskState, root, collector = null) {
+  const finish = (result) => {
+    if (collector) collector.record(result.status === "VALID" ? "Snapshot_hit" : "Snapshot_miss");
+    return result;
+  };
+  const previous = loadSnapshot(taskId, root);
+  if (!previous) {
+    return finish({ status: "STALE", reason: "no-previous-snapshot", changedSignals: ["no-snapshot"] });
+  }
+
+  const changed = [];
+
+  // Check git revision
+  const currentGit = getGitRevision(root);
+  if (currentGit && previous.gitRevision && currentGit !== previous.gitRevision) {
+    changed.push("git-revision");
+  }
+
+  // Check relevant files (package.json, config, etc.)
+  const currentFilesHash = getProjectContextHash(root);
+  if (currentFilesHash !== previous.relevantFilesHash) {
+    changed.push("relevant-files");
+  }
+
+  // Check task state
+  const currentStateHash = getTaskStateHash(currentTaskState);
+  if (currentStateHash !== previous.taskStateHash) {
+    changed.push("task-state");
+  }
+
+  if (changed.length === 0) {
+    return finish({ status: "VALID", reason: "no-changes", changedSignals: [] });
+  }
+
+  // Task state changes = INVALID (need full rebuild)
+  if (changed.includes("task-state")) {
+    return finish({ status: "INVALID", reason: "task-state-changed", changedSignals: changed });
+  }
+
+  // Other changes = STALE (need partial rebuild)
+  return finish({ status: "STALE", reason: "context-changed", changedSignals: changed });
+}
+
+/**
+ * Determine which context levels need rebuild based on changed signals.
+ *
+ * @param {string[]} changedSignals
+ * @returns {{ rebuildN1: boolean, rebuildN2: boolean, rebuildN3: boolean }}
+ */
+export function rebuildScope(changedSignals, collector = null) {
+  if (collector) {
+    collector.record("Reconstruction_count");
+    collector.record("Context_reconstructed");
+  }
+  const scope = { rebuildN1: false, rebuildN2: false, rebuildN3: false };
+
+  for (const signal of changedSignals) {
+    switch (signal) {
+      case "relevant-files":
+      case "git-revision":
+        // Project-level changes → rebuild N1 (project context) and N3 (skills)
+        scope.rebuildN1 = true;
+        scope.rebuildN3 = true;
+        break;
+      case "task-state":
+        // Task-level changes → rebuild everything
+        scope.rebuildN1 = true;
+        scope.rebuildN2 = true;
+        scope.rebuildN3 = true;
+        break;
+      case "no-snapshot":
+        // No previous snapshot → full rebuild
+        scope.rebuildN1 = true;
+        scope.rebuildN2 = true;
+        scope.rebuildN3 = true;
+        break;
+    }
+  }
+
+  return scope;
+}