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

package/src/state/state-transition.js

@@ -0,0 +1,84 @@
+/**
+ * State Transition — Unified transition layer for all WAM lifecycles.
+ * 
+ * Guarantees: All state transitions follow (OldState + Event) → NewState pattern.
+ * No scattered state mutation across modules.
+ */
+
+import { PHASE_TRANSITIONS } from "../integration/orchestration.js";
+
+/**
+ * Transition Task state based on event
+ */
+export function transitionTask(state, event) {
+  const { type, payload } = event;
+  
+  switch (type) {
+    case "REQUIREMENT_VERIFIED":
+      return {
+        ...state,
+        requirements: state.requirements.map(r => 
+          r.id === payload.requirementId ? { ...r, status: "verified" } : r
+        ),
+        updatedAt: Date.now()
+      };
+      
+    case "PHASE_CHANGE":
+      const allowed = PHASE_TRANSITIONS[state.phase] || [];
+      if (!allowed.includes(payload.phase)) {
+        throw new Error(`Invalid phase transition: ${state.phase} → ${payload.phase}`);
+      }
+      return { ...state, phase: payload.phase, updatedAt: Date.now() };
+      
+    case "CONTRACT_APPROVED":
+      return { ...state, contract: { ...state.contract, status: "APPROVED" }, updatedAt: Date.now() };
+      
+    case "NEXT_ACTION":
+      return { ...state, nextAction: payload.action, updatedAt: Date.now() };
+      
+    default:
+      return state;
+  }
+}
+
+/**
+ * Transition Verification state
+ */
+export function transitionVerification(state, event) {
+  const { type, payload } = event;
+  
+  switch (type) {
+    case "VERIFY_START":
+      return { ...state, verificationStatus: "VERIFYING", updatedAt: Date.now() };
+    case "VERIFY_PASS":
+      return { ...state, verificationStatus: "VERIFIED", updatedAt: Date.now() };
+    case "VERIFY_FAIL":
+      return { ...state, verificationStatus: "FAILED", updatedAt: Date.now() };
+    case "INVALIDATE":
+      return { ...state, verificationStatus: "INVALIDATED", updatedAt: Date.now() };
+    default:
+      return state;
+  }
+}
+
+/**
+ * Transition Cognition (Hypothesis) state
+ */
+export function transitionHypothesis(state, event) {
+  const { type, payload } = event;
+  
+  switch (type) {
+    case "HYPOTHESIS_PROPOSED":
+      return { ...state, hypotheses: [...(state.hypotheses || []), payload.hypothesis] };
+    case "HYPOTHESIS_SUPPORTED":
+      return { ...state, hypotheses: state.hypotheses.map(h => 
+        h.id === payload.hypothesisId ? { ...h, status: "SUPPORTED" } : h
+      )};
+    case "HYPOTHESIS_REJECTED":
+      return { ...state, hypotheses: state.hypotheses.map(h => 
+        h.id === payload.hypothesisId ? { ...h, status: "REJECTED" } : h
+      )};
+    default:
+      return state;
+  }
+}

package/src/state/task-dependencies.js

@@ -0,0 +1,287 @@
+/**
+ * WAM Task Dependencies
+ *
+ * Typed dependencies between tasks. Each dependency connects an output
+ * from one task's execution to a requirement of another task.
+ *
+ * The dependency model extends the existing WAM task model using ContextGraph
+ * as the underlying structure.
+ */
+
+import { ContextGraph } from "../context/context-graph.js";
+import { getTaskState, persistTaskState } from "../skills/engine.js";
+
+// -- Types --
+
+/**
+ * @typedef {"requires_completion"|"requires_output"|"requires_evidence"|"requires_decision"|"depends_on_artifact"|"blocked_by"|"invalidated_by"} DependencyType
+ * @typedef {"decision"|"artifact"|"evidence"|"constraint"|"observation"|"verification"} OutputType
+ */
+
+/**
+ * @typedef {Object} TaskDependency
+ * @property {string} from - Task or node that has the dependency
+ * @property {string} to - Task or node that is depended upon
+ * @property {DependencyType} type
+ * @property {boolean} required
+ * @property {number} createdAt
+ */
+
+/**
+ * @typedef {Object} TaskOutput
+ * @property {string} id
+ * @property {string} taskId
+ * @property {string} executionId
+ * @property {OutputType} type
+ * @property {string} content
+ * @property {boolean} verified
+ * @property {number} createdAt
+ */
+
+// -- Persistent Graph Store --
+
+const GRAPH_FILE = "context-graph.json";
+
+function loadGraph(root) {
+  const graph = new ContextGraph();
+  const stateDir = path.join(root || process.cwd(), ".wam");
+  const graphFile = path.join(stateDir, GRAPH_FILE);
+
+  try {
+    const raw = fs.readFileSync(graphFile, "utf-8");
+    const data = JSON.parse(raw);
+    for (const node of data.nodes || []) graph.addNode(node);
+    for (const edge of data.edges || []) {
+      try { graph.addEdge(edge); } catch { /* skip invalid */ }
+    }
+  } catch { /* fresh graph */ }
+
+  return graph;
+}
+
+function saveGraph(graph, root) {
+  const stateDir = path.join(root || process.cwd(), ".wam");
+  if (!fs.existsSync(stateDir)) fs.mkdirSync(stateDir, { recursive: true });
+
+  const nodes = graph.getNodes().map((n) => ({
+    id: n.id, type: n.type, content: n.content,
+    taskId: n.taskId, verified: n.verified,
+    metadata: n.metadata, createdAt: n.createdAt, updatedAt: n.updatedAt,
+  }));
+
+  const edges = [];
+  const seen = new Set();
+  for (const node of graph.getNodes()) {
+    for (const edge of graph.getEdgesFrom(node.id)) {
+      const key = `${edge.from}|${edge.to}|${edge.type}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        edges.push({ from: edge.from, to: edge.to, type: edge.type, weight: edge.weight });
+      }
+    }
+  }
+
+  fs.writeFileSync(
+    path.join(stateDir, GRAPH_FILE),
+    JSON.stringify({ nodes, edges }, null, 2)
+  );
+}
+
+// Need to import these
+import fs from "node:fs";
+import path from "node:path";
+
+// -- Output Management --
+
+/**
+ * Register an output produced by a task execution.
+ */
+export function registerOutput(taskId, executionId, outputType, content, verified, root) {
+  const graph = loadGraph(root);
+  const outputId = `output-${taskId}-${executionId}-${Date.now()}`;
+
+  const node = {
+    id: outputId,
+    type: "output",
+    content,
+    taskId,
+    verified: verified || false,
+    metadata: { executionId, outputType },
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  };
+
+  graph.addNode(node);
+
+  // Link output to its producing task (use raw taskId as node id)
+  if (!graph.getNode(taskId)) {
+    graph.addNode({
+      id: taskId,
+      type: "task",
+      content: content.slice(0, 200),
+      taskId,
+      verified: false,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+  }
+
+  graph.addEdge({ from: taskId, to: outputId, type: "produces" });
+  saveGraph(graph, root);
+
+  return outputId;
+}
+
+// -- Dependency Management --
+
+/**
+ * Add a dependency between two tasks/nodes.
+ */
+export function addDependency(fromId, toId, type, required, root) {
+  const graph = loadGraph(root);
+
+  // Ensure nodes exist
+  if (!graph.getNode(fromId)) {
+    graph.addNode({
+      id: fromId, type: "task", content: fromId,
+      verified: false, createdAt: Date.now(), updatedAt: Date.now(),
+    });
+  }
+  if (!graph.getNode(toId)) {
+    graph.addNode({
+      id: toId, type: "task", content: toId,
+      verified: false, createdAt: Date.now(), updatedAt: Date.now(),
+    });
+  }
+
+  const edge = graph.addEdge({ from: fromId, to: toId, type, weight: 1.0 });
+  saveGraph(graph, root);
+
+  return { from: fromId, to: toId, type, required: required !== false, createdAt: Date.now() };
+}
+
+/**
+ * Get all dependencies of a node.
+ */
+export function getDependencies(nodeId, root) {
+  const graph = loadGraph(root);
+  return graph.getDependencies(nodeId);
+}
+
+/**
+ * Get all nodes that depend on this node.
+ */
+export function getDependents(nodeId, root) {
+  const graph = loadGraph(root);
+  return graph.getDownstream(nodeId);
+}
+
+/**
+ * Traverse upstream through the dependency graph.
+ */
+export function getUpstream(nodeId, root, maxDepth) {
+  const graph = loadGraph(root);
+  return graph.getUpstream(nodeId, maxDepth);
+}
+
+// -- Missing Dependency Detection --
+
+/**
+ * Detect missing dependencies for a node.
+ * Returns gaps where required outputs are not yet produced.
+ */
+export function detectMissingDependencies(nodeId, root) {
+  const graph = loadGraph(root);
+  const deps = graph.getDependencies(nodeId);
+
+  const missing = [];
+  for (const dep of deps) {
+    const edges = graph.getEdgesFrom(nodeId);
+    const depEdge = edges.find((e) => e.to === dep.id);
+    if (depEdge && ["requires_output", "requires_completion", "requires_evidence",
+                     "requires_decision", "depends_on_artifact"].includes(depEdge.type)) {
+      if (!dep.verified && dep.type === "output") {
+        const outputNode = graph.getNode(dep.id);
+        if (!outputNode) {
+          missing.push({ requiredBy: nodeId, type: "dependency", description: `Output ${dep.id} not found` });
+        }
+      }
+    }
+  }
+
+  return missing;
+}
+
+// -- Invalidation --
+
+/**
+ * Invalidate an output node and all downstream nodes.
+ */
+export function invalidateOutput(outputId, reason, root) {
+  const graph = loadGraph(root);
+
+  const node = graph.getNode(outputId);
+  if (!node) throw new Error(`Output ${outputId} not found`);
+
+  graph.updateNode(outputId, {
+    verified: false,
+    metadata: { ...node.metadata, invalidated: true, invalidationReason: reason },
+  });
+
+  const downstream = graph.getDownstream(outputId);
+
+  for (const d of downstream) {
+    try {
+      graph.addEdge({ from: outputId, to: d.id, type: "invalidates" });
+    } catch { /* already exists */ }
+  }
+
+  saveGraph(graph, root);
+  return { invalidated: outputId, affected: downstream.map((d) => d.id) };
+}
+
+/**
+ * Check if a node has any invalidated dependencies.
+ */
+export function getInvalidatedDependencies(nodeId, root) {
+  const graph = loadGraph(root);
+  const deps = graph.getDependencies(nodeId);
+
+  return deps.filter((dep) => {
+    const meta = dep.metadata;
+    return meta && meta.invalidated;
+  });
+}
+
+// -- Context Gap --
+
+/**
+ * Detect context gaps: nodes that cannot proceed due to missing dependencies.
+ */
+export function detectContextGaps(nodeId, root) {
+  const graph = loadGraph(root);
+  const missing = detectMissingDependencies(nodeId, root);
+  const invalidated = getInvalidatedDependencies(nodeId, root);
+
+  const gaps = [];
+
+  for (const m of missing) {
+    gaps.push({
+      type: "missing_dependency",
+      severity: "blocking",
+      description: m.description,
+      requiredBy: m.requiredBy,
+    });
+  }
+
+  for (const inv of invalidated) {
+    gaps.push({
+      type: "invalidated_dependency",
+      severity: "warning",
+      description: `Dependency ${inv.id} was invalidated`,
+      requiredBy: nodeId,
+    });
+  }
+
+  return gaps;
+}

package/src/state/task-execution.js

@@ -0,0 +1,217 @@
+/**
+ * WAM Task Execution History — DEPRECATED compatibility layer.
+ *
+ * DEPRECATED: Use task-runs.js directly. This module is a thin wrapper
+ * that delegates to task-runs.js for backward compatibility.
+ *
+ * Canonical model: task-runs.js (separate run files in .wam/tasks/<taskId>/runs/)
+ * Legacy model: state.yaml executions[] array (deprecated, will be migrated)
+ *
+ * Migration: On first access, executions[] from state.yaml are migrated
+ * to runs/ directory and the legacy field is removed.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { getTaskState, persistTaskState } from "../skills/engine.js";
+import {
+  startRun,
+  closeRun,
+  addObservation as addRunObservation,
+  addDecision as addRunDecision,
+  addEvidence as addRunEvidence,
+  getRuns,
+  getRunsNormalized,
+  getRun,
+  getLastRun,
+  getLastRunSummary,
+  getUnresolvedRequirements as getUnresolvedReqs,
+  getPreviousFailures as getPrevFailures,
+  getPreviousDecisions as getPrevDecisions,
+  getResumeContext as getResumeCtx,
+  needsNewRun,
+} from "./task-runs.js";
+
+// -- Migration --
+
+/**
+ * Migrate legacy executions[] from state.yaml to runs/ directory.
+ * This is idempotent — safe to call multiple times.
+ */
+export function migrateLegacyExecutions(taskId, root) {
+  const state = getTaskState(taskId, root);
+  if (!state?.executions || state.executions.length === 0) return 0;
+
+  const existingRuns = getRuns(taskId, root);
+  const existingRunIds = new Set(existingRuns.map((r) => r.id));
+
+  let migrated = 0;
+
+  for (const exec of state.executions) {
+    // Skip if already migrated (by ID convention or content match)
+    if (existingRunIds.has(exec.id)) continue;
+
+    // Convert execution to run format
+    const run = {
+      id: exec.id,
+      taskId: exec.taskId || taskId,
+      startedAt: exec.startedAt,
+      completedAt: exec.completedAt,
+      status: exec.status || "active",
+      phase: "IMPLEMENTING",
+      observations: (exec.observations || []).map((text, i) => ({
+        id: `obs-${i + 1}`,
+        text: typeof text === "string" ? text : text.text || String(text),
+        timestamp: exec.startedAt || Date.now(),
+      })),
+      decisions: (exec.decisions || []).map((text, i) => ({
+        id: `dec-${i + 1}`,
+        text: typeof text === "string" ? text : text.text || String(text),
+        timestamp: exec.startedAt || Date.now(),
+      })),
+      evidence: (exec.evidence || []).map((text, i) => ({
+        id: `ev-${i + 1}`,
+        text: typeof text === "string" ? text : text.text || String(text),
+        timestamp: exec.startedAt || Date.now(),
+      })),
+      actions: [],
+      outcome: exec.outcome || null,
+    };
+
+    // Write to runs directory
+    const runsDir = path.join(root || process.cwd(), ".wam", "tasks", taskId, "runs");
+    if (!fs.existsSync(runsDir)) {
+      fs.mkdirSync(runsDir, { recursive: true });
+    }
+    fs.writeFileSync(path.join(runsDir, `${run.id}.json`), JSON.stringify(run, null, 2));
+
+    migrated++;
+  }
+
+  // Remove legacy executions[] from state
+  delete state.executions;
+  persistTaskState(taskId, state, root);
+
+  return migrated;
+}
+
+/**
+ * Check if a task has legacy executions that need migration.
+ */
+export function hasLegacyExecutions(taskId, root) {
+  const state = getTaskState(taskId, root);
+  return state?.executions && state.executions.length > 0;
+}
+
+// -- Delegated API (backward compatible) --
+
+/**
+ * Create a new execution for an existing task.
+ * Delegates to startRun().
+ */
+export function createExecution(taskId, root) {
+  return startRun(taskId, root);
+}
+
+/**
+ * Close an execution with a status and optional outcome.
+ * Delegates to closeRun().
+ */
+export function closeExecution(taskId, execId, status, outcome, root) {
+  return closeRun(taskId, execId, status, outcome, root);
+}
+
+function readExecFromRuns(taskId, execId, root) {
+  // Lazy: read from runs/ directory via task-runs.js
+  return getRun(taskId, execId, root);
+}
+
+/**
+ * Add an observation to an execution.
+ * Delegates to addObservation() in task-runs.js.
+ */
+export function addObservation(taskId, execId, text, root) {
+  return addRunObservation(taskId, execId, text, root);
+}
+
+/**
+ * Add a decision to an execution.
+ * Delegates to addDecision() in task-runs.js.
+ */
+export function addDecision(taskId, execId, text, root) {
+  return addRunDecision(taskId, execId, text, root);
+}
+
+/**
+ * Add evidence to an execution.
+ * Delegates to addEvidence() in task-runs.js.
+ */
+export function addEvidence(taskId, execId, text, root) {
+  return addRunEvidence(taskId, execId, text, root);
+}
+
+// -- Query (delegated) --
+
+/**
+ * Get all executions for a task.
+ * Delegates to getRuns().
+ */
+export function getExecutions(taskId, root) {
+  return getRunsNormalized(taskId, root);
+}
+
+/**
+ * Get the last (most recent) execution for a task.
+ * Delegates to getLastRun().
+ */
+export function getLastExecution(taskId, root) {
+  return getLastRun(taskId, root);
+}
+
+/**
+ * Get the last known state of a task from its most recent execution.
+ * Delegates to getLastRunSummary().
+ */
+export function getLastExecutionSummary(taskId, root) {
+  return getLastRunSummary(taskId, root);
+}
+
+/**
+ * Get unresolved requirements from task state.
+ * Delegates to getUnresolvedRequirements() in task-runs.js.
+ */
+export function getUnresolvedRequirements(taskId, root) {
+  return getUnresolvedReqs(taskId, root);
+}
+
+/**
+ * Get relevant previous failures.
+ * Delegates to getPreviousFailures() in task-runs.js.
+ */
+export function getPreviousFailures(taskId, root) {
+  return getPrevFailures(taskId, root);
+}
+
+/**
+ * Get relevant previous decisions from execution history.
+ * Delegates to getPreviousDecisions() in task-runs.js.
+ */
+export function getPreviousDecisions(taskId, root, limit = 5) {
+  return getPrevDecisions(taskId, root, limit);
+}
+
+/**
+ * Resume context: aggregate what's needed to continue work.
+ * Delegates to getResumeContext() in task-runs.js.
+ */
+export function getResumeContext(taskId, root) {
+  return getResumeCtx(taskId, root);
+}
+
+/**
+ * Check if task needs a new execution (no active one).
+ * Delegates to needsNewRun().
+ */
+export function needsNewExecution(taskId, root) {
+  return needsNewRun(taskId, root);
+}

package/src/state/task-lifecycle.js

@@ -0,0 +1,59 @@
+/**
+ * Task Lifecycle — Task state transitions (Create, Resume, Switch, Pause, Complete, Block).
+ */
+
+import { createState, normalizeState, validateState } from "./task-state.js";
+import { loadTask, saveTask, taskExists, deleteTask } from "./task-store.js";
+
+const TERMINAL_PHASES = new Set(["DONE"]);
+
+export function create(taskId, root) {
+  if (taskExists(taskId, root)) {
+    throw new Error(`Task ${taskId} already exists`);
+  }
+  const state = createState(taskId);
+  saveTask(taskId, state, root);
+  return state;
+}
+
+export function resume(taskId, root) {
+  const state = loadTask(taskId, root);
+  if (!state) {
+    throw new Error(`Task ${taskId} not found`);
+  }
+  return normalizeState(state);
+}
+
+export function switchTo(taskId, newPhase, root) {
+  const state = loadTask(taskId, root);
+  if (!state) throw new Error(`Task ${taskId} not found`);
+
+  if (TERMINAL_PHASES.has(state.phase) && newPhase !== state.phase) {
+    throw new Error(`cannot transition from terminal phase ${state.phase}`);
+  }
+
+  state.phase = newPhase;
+  state.updatedAt = Date.now();
+  saveTask(taskId, state, root);
+  return state;
+}
+
+export function pause(taskId, root) {
+  return switchTo(taskId, "WAITING", root);
+}
+
+export function complete(taskId, root) {
+  return switchTo(taskId, "DONE", root);
+}
+
+export function block(taskId, reason, root) {
+  const state = loadTask(taskId, root);
+  if (!state) throw new Error(`Task ${taskId} not found`);
+  
+  state.blocked = reason;
+  state.updatedAt = Date.now();
+  saveTask(taskId, state, root);
+  return state;
+}
+
+export { createState, normalizeState, validateState };