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

package/src/state/task-runs.js

@@ -0,0 +1,361 @@
+/**
+ * WAM Persistent Task Runs
+ *
+ * Task = identidad persistente.
+ * Run = ejecución concreta, almacenada como archivo separado.
+ *
+ * Estructura:
+ * .wam/tasks/<taskId>/
+ * ├── state.yaml        (estado actual canónico)
+ * └── runs/
+ *     ├── <runId>.json
+ *     └── <runId>.json
+ *
+ * Invariant: Task permanece en .wam/tasks/ aunque ejecución termine.
+ * Runs terminados no se mueven a .wam/history/ - permanecen bajo runs/.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { getTaskState, persistTaskState } from "../skills/engine.js";
+
+function getRunsDir(taskId, root) {
+  return path.join(root || process.cwd(), ".wam", "tasks", taskId, "runs");
+}
+
+function ensureRunsDir(taskId, root) {
+  const dir = getRunsDir(taskId, root);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+function generateRunId(taskId, index) {
+  return `${taskId}-run-${String(index).padStart(3, "0")}`;
+}
+
+function now() {
+  return Date.now();
+}
+
+function getRunFile(taskId, runId, root) {
+  return path.join(getRunsDir(taskId, root), `${runId}.json`);
+}
+
+function readRunFile(taskId, runId, root) {
+  const file = getRunFile(taskId, runId, root);
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeRunFile(taskId, runId, data, root) {
+  const file = getRunFile(taskId, runId, root);
+  fs.writeFileSync(file, JSON.stringify(data, null, 2));
+}
+
+function getNextRunIndex(taskId, root) {
+  const dir = getRunsDir(taskId, root);
+  if (!fs.existsSync(dir)) return 1;
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  return files.length + 1;
+}
+
+export function startRun(taskId, root) {
+  const state = getTaskState(taskId, root);
+  if (!state) throw new Error(`Task ${taskId} not found`);
+
+  ensureRunsDir(taskId, root);
+  const index = getNextRunIndex(taskId, root);
+  const runId = generateRunId(taskId, index);
+
+  const run = {
+    id: runId,
+    taskId,
+    startedAt: now(),
+    status: "active",
+    phase: state.phase || "IMPLEMENTING",
+    observations: [],
+    decisions: [],
+    evidence: [],
+    actions: [],
+    outcome: null,
+  };
+
+  writeRunFile(taskId, runId, run, root);
+
+  state.currentRunId = runId;
+  persistTaskState(taskId, state, root);
+
+  return run;
+}
+
+export function closeRun(taskId, runId, status, outcome, root) {
+  const run = readRunFile(taskId, runId, root);
+  if (!run) throw new Error(`Run ${runId} not found`);
+
+  run.completedAt = now();
+  run.status = status;
+  if (outcome) run.outcome = outcome;
+
+  writeRunFile(taskId, runId, run, root);
+
+  const state = getTaskState(taskId, root);
+  if (state?.currentRunId === runId) {
+    state.currentRunId = null;
+    persistTaskState(taskId, state, root);
+  }
+
+  return run;
+}
+
+export function updateRun(taskId, runId, updates, root) {
+  const run = readRunFile(taskId, runId, root);
+  if (!run) throw new Error(`Run ${runId} not found`);
+
+  Object.assign(run, updates);
+  writeRunFile(taskId, runId, run, root);
+  return run;
+}
+
+function syncRunToState(taskId, run, root) {
+  const state = getTaskState(taskId, root);
+  if (!state) return;
+  if (!Array.isArray(state.executions)) state.executions = [];
+  const normalized = normalizeRun(run);
+  const idx = state.executions.findIndex((e) => e.id === run.id);
+  if (idx >= 0) {
+    state.executions[idx] = normalized;
+  } else {
+    state.executions.push(normalized);
+  }
+  persistTaskState(taskId, state, root);
+}
+
+export function addObservation(taskId, runId, text, root) {
+  const run = readRunFile(taskId, runId, root);
+  if (!run) throw new Error(`Run ${runId} not found`);
+
+  if (!run.observations) run.observations = [];
+  run.observations.push({
+    id: `obs-${run.observations.length + 1}`,
+    text,
+    timestamp: now(),
+  });
+
+  writeRunFile(taskId, runId, run, root);
+  return run;
+}
+
+export function addDecision(taskId, runId, text, root) {
+  const run = readRunFile(taskId, runId, root);
+  if (!run) throw new Error(`Run ${runId} not found`);
+
+  if (!run.decisions) run.decisions = [];
+  run.decisions.push({
+    id: `dec-${run.decisions.length + 1}`,
+    text,
+    timestamp: now(),
+  });
+
+  writeRunFile(taskId, runId, run, root);
+  return run;
+}
+
+export function addEvidence(taskId, runId, text, root) {
+  const run = readRunFile(taskId, runId, root);
+  if (!run) throw new Error(`Run ${runId} not found`);
+
+  if (!run.evidence) run.evidence = [];
+  run.evidence.push({
+    id: `ev-${run.evidence.length + 1}`,
+    text,
+    timestamp: now(),
+  });
+
+  writeRunFile(taskId, runId, run, root);
+  return run;
+}
+
+export function addAction(taskId, runId, action, root) {
+  const run = readRunFile(taskId, runId, root);
+  if (!run) throw new Error(`Run ${runId} not found`);
+
+  if (!run.actions) run.actions = [];
+  run.actions.push({
+    id: `act-${run.actions.length + 1}`,
+    ...action,
+    timestamp: now(),
+  });
+
+  writeRunFile(taskId, runId, run, root);
+  return run;
+}
+
+export function getRun(taskId, runId, root) {
+  return readRunFile(taskId, runId, root);
+}
+
+export function getRuns(taskId, root) {
+  const dir = getRunsDir(taskId, root);
+  if (!fs.existsSync(dir)) return [];
+
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  const runs = [];
+
+  for (const file of files) {
+    try {
+      const run = JSON.parse(fs.readFileSync(path.join(dir, file), "utf-8"));
+      runs.push(run);
+    } catch {
+      // Skip invalid files
+    }
+  }
+
+  return runs.sort((a, b) => (a.startedAt || 0) - (b.startedAt || 0));
+}
+
+// Legacy-compatible accessor: returns runs with observations/decisions/evidence
+// normalized to string[] form for the task-execution.js compatibility layer.
+export function getRunsNormalized(taskId, root) {
+  return getRuns(taskId, root).map(normalizeRun);
+}
+
+export function getLastRun(taskId, root) {
+  const runs = getRuns(taskId, root);
+  return runs.length > 0 ? runs[runs.length - 1] : null;
+}
+
+export function getCurrentRun(taskId, root) {
+  const state = getTaskState(taskId, root);
+  if (!state?.currentRunId) return null;
+  return getRun(taskId, state.currentRunId, root);
+}
+
+export function getActiveRun(taskId, root) {
+  const runs = getRuns(taskId, root);
+  return runs.find((r) => r.status === "active") || null;
+}
+
+export function getLastRunSummary(taskId, root) {
+  const last = getLastRun(taskId, root);
+  if (!last) return null;
+
+  return {
+    executionId: last.id,
+    runId: last.id,
+    completedAt: last.completedAt,
+    status: last.status,
+    outcome: last.outcome,
+    observationsCount: last.observations?.length || 0,
+    decisionsCount: last.decisions?.length || 0,
+    evidenceCount: last.evidence?.length || 0,
+  };
+}
+
+export function getUnresolvedRequirements(taskId, root) {
+  const state = getTaskState(taskId, root);
+  if (!state) return [];
+  return (state.requirements || []).filter((r) => r.status !== "done");
+}
+
+export function getPreviousFailures(taskId, root) {
+  const runs = getRuns(taskId, root);
+  return runs.filter((r) => r.status === "failed" || r.status === "abandoned");
+}
+
+export function getPreviousDecisions(taskId, root, limit = 5) {
+  const runs = getRuns(taskId, root);
+  const allDecisions = [];
+
+  for (const run of runs) {
+    for (const d of run.decisions || []) {
+      allDecisions.push({
+        executionId: run.id,
+        runId: run.id,
+        decision: typeof d === "string" ? d : d.text,
+        timestamp: typeof d === "string" ? run.completedAt : d.timestamp,
+        completedAt: run.completedAt,
+      });
+    }
+  }
+
+  return allDecisions.slice(-limit);
+}
+
+// Normalize run fields to legacy string[] form (for task-execution.js compat)
+function normalizeRun(run) {
+  if (!run) return run;
+  const normalize = (arr) =>
+    Array.isArray(arr) ? arr.map((item) => (typeof item === "string" ? item : item.text)) : arr;
+  return {
+    ...run,
+    observations: normalize(run.observations),
+    decisions: normalize(run.decisions),
+    evidence: normalize(run.evidence),
+  };
+}
+export function getResumeContext(taskId, root) {
+  const state = getTaskState(taskId, root);
+  if (!state) return null;
+
+  const lastRun = getLastRun(taskId, root);
+  const unresolved = getUnresolvedRequirements(taskId, root);
+  const failures = getPreviousFailures(taskId, root);
+  const recentDecisions = getPreviousDecisions(taskId, root, 3);
+
+  return {
+    taskSummary: state.lastAction || state.contract?.objective || "",
+    phase: state.phase,
+    currentRunId: state.currentRunId,
+    lastExecution: lastRun
+      ? {
+          id: lastRun.id,
+          status: lastRun.status,
+          outcome: lastRun.outcome,
+          completedAt: lastRun.completedAt,
+        }
+      : null,
+    lastRun: lastRun
+      ? {
+          id: lastRun.id,
+          status: lastRun.status,
+          outcome: lastRun.outcome,
+          completedAt: lastRun.completedAt,
+        }
+      : null,
+    unresolvedRequirements: unresolved.map((r) => ({ id: r.id, title: r.title })),
+    recentFailures: failures.map((f) => ({
+      executionId: f.id,
+      runId: f.id,
+      outcome: f.outcome,
+      completedAt: f.completedAt,
+    })),
+    recentDecisions,
+    totalExecutions: getRuns(taskId, root).length,
+    totalRuns: getRuns(taskId, root).length,
+  };
+}
+
+export function needsNewRun(taskId, root) {
+  const active = getActiveRun(taskId, root);
+  if (active) return false;
+
+  const current = getCurrentRun(taskId, root);
+  if (current) return false;
+
+  return true;
+}
+
+export function getRunCount(taskId, root) {
+  return getRuns(taskId, root).length;
+}
+
+export function getRunsByStatus(taskId, root, status) {
+  const runs = getRuns(taskId, root);
+  return runs.filter((r) => r.status === status);
+}

package/src/state/task-state-file.js

@@ -0,0 +1,86 @@
+/**
+ * Task State File — Normalize and validate the persisted `.wam/task-state.json`.
+ *
+ * This is the state-file model (one file holding many tasks keyed by id), and is
+ * deliberately kept separate from the single live-task model in task-state.js.
+ * Conflating the two caused writer/reader drift and false-completion reports.
+ *
+ * Guarantee: every task read from disk has a canonical, lowercased status from
+ * TASK_STATUS. Unknown statuses are rejected loudly instead of being silently
+ * treated as "not pending" (the root cause of the "all tasks completed" lie).
+ */
+
+import {
+  TASK_STATUS_VALUES,
+  normalizeStatus,
+  isValidStatus,
+} from "./task-status.js";
+
+export function normalizeTaskFile(taskId, task) {
+  if (!task || typeof task !== "object") {
+    return null;
+  }
+
+  return {
+    ...task,
+    id: task.id || taskId,
+    status: normalizeStatus(task.status),
+    validations: Array.isArray(task.validations) ? task.validations : [],
+    startedAt: task.startedAt || null,
+    completedAt: task.completedAt || null,
+    createdAt: task.createdAt || new Date().toISOString(),
+  };
+}
+
+export function normalizeStateFile(fileState) {
+  const state = fileState || {};
+  const rawTasks = state.tasks || {};
+  const tasks = {};
+
+  for (const [taskId, task] of Object.entries(rawTasks)) {
+    const normalized = normalizeTaskFile(taskId, task);
+    if (!normalized) {
+      throw new Error(`Task ${taskId} is not a valid object.`);
+    }
+    if (!isValidStatus(normalized.status)) {
+      throw new Error(
+        `Task ${taskId} has invalid status "${task.status}". ` +
+          `Valid values: ${TASK_STATUS_VALUES.join(", ")}.`
+      );
+    }
+    tasks[taskId] = normalized;
+  }
+
+  return {
+    version: state.version || "1",
+    tasks,
+    lastCheckpoint: state.lastCheckpoint || null,
+  };
+}
+
+export function validateStateFile(fileState) {
+  if (!fileState || typeof fileState !== "object") {
+    return { valid: false, error: "State is not an object" };
+  }
+  const tasks = fileState.tasks;
+  if (!tasks || typeof tasks !== "object") {
+    return { valid: false, error: "Missing tasks" };
+  }
+  const taskIds = Object.keys(tasks);
+  if (taskIds.length === 0) {
+    return { valid: false, error: "No tasks defined" };
+  }
+  for (const taskId of taskIds) {
+    const status = normalizeStatus(tasks[taskId]?.status);
+    if (!status) {
+      return {
+        valid: false,
+        error: `Task ${taskId} has invalid status: "${tasks[taskId]?.status}"`,
+      };
+    }
+    if (!tasks[taskId].createdAt) {
+      return { valid: false, error: `Task ${taskId} missing createdAt` };
+    }
+  }
+  return { valid: true };
+}

package/src/state/task-state.js

@@ -0,0 +1,41 @@
+/**
+ * Task State — Create, normalize, and validate task state.
+ */
+
+import { PHASE_PROPOSED } from "../integration/orchestration.js";
+
+export function createState(taskId) {
+  return {
+    taskId,
+    phase: PHASE_PROPOSED,
+    contract: { status: "DRAFT", requirements: [] },
+    requirements: [],
+    nextAction: null,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  };
+}
+
+export function normalizeState(state) {
+  if (!state) return createState("unknown");
+  
+  return {
+    ...state,
+    phase: state.phase || PHASE_PROPOSED,
+    contract: state.contract || { status: "DRAFT", requirements: [] },
+    requirements: state.requirements || [],
+    nextAction: state.nextAction || null,
+    createdAt: state.createdAt || Date.now(),
+    updatedAt: Date.now(),
+  };
+}
+
+export function validateState(state) {
+  if (!state || !state.taskId) {
+    return { valid: false, error: "Missing taskId" };
+  }
+  if (!state.phase) {
+    return { valid: false, error: "Missing phase" };
+  }
+  return { valid: true };
+}

package/src/state/task-status.js

@@ -0,0 +1,54 @@
+/**
+ * Task Status — Single source of truth for task status values.
+ * Prevents case-sensitivity bugs and drift between writers/readers.
+ */
+
+export const TASK_STATUS = Object.freeze({
+  PENDING: "pending",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed",
+});
+
+export const TASK_STATUS_VALUES = Object.values(TASK_STATUS);
+
+export function normalizeStatus(value) {
+  if (typeof value !== "string") return null;
+  const v = value.trim().toLowerCase();
+  return TASK_STATUS_VALUES.includes(v) ? v : null;
+}
+
+export function isValidStatus(value) {
+  return normalizeStatus(value) !== null;
+}
+
+export function countByStatus(tasks) {
+  const counts = {
+    pending: 0,
+    running: 0,
+    completed: 0,
+    failed: 0,
+    total: 0,
+  };
+
+  for (const task of Object.values(tasks || {})) {
+    const normalized = normalizeStatus(task?.status);
+    if (normalized && counts.hasOwnProperty(normalized)) {
+      counts[normalized]++;
+    }
+    counts.total++;
+  }
+
+  return counts;
+}
+
+export function getNextPendingTask(tasks) {
+  if (!tasks) return null;
+  const taskIds = Object.keys(tasks).sort();
+  for (const taskId of taskIds) {
+    if (normalizeStatus(tasks[taskId]?.status) === TASK_STATUS.PENDING) {
+      return taskId;
+    }
+  }
+  return null;
+}

package/src/state/task-store.js

@@ -0,0 +1,48 @@
+/**
+ * Task Store — IO operations for task persistence.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+const TASK_FILE = "task.json";
+
+export function taskFilePath(taskId, root) {
+  return path.join(root || process.cwd(), ".wam", "tasks", taskId, TASK_FILE);
+}
+
+export function loadTask(taskId, root) {
+  const file = taskFilePath(taskId, root);
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+export function saveTask(taskId, state, root) {
+  const dir = path.join(root || process.cwd(), ".wam", "tasks", taskId);
+  fs.mkdirSync(dir, { recursive: true });
+  const file = path.join(dir, TASK_FILE);
+  fs.writeFileSync(file, JSON.stringify(state, null, 2));
+}
+
+export function taskExists(taskId, root) {
+  return fs.existsSync(taskFilePath(taskId, root));
+}
+
+export function listTasks(root) {
+  const dir = path.join(root || process.cwd(), ".wam", "tasks");
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+}
+
+export function deleteTask(taskId, root) {
+  const dir = path.join(root || process.cwd(), ".wam", "tasks", taskId);
+  if (fs.existsSync(dir)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}