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

package/src/context/capsule-staleness.js

@@ -0,0 +1,267 @@
+/**
+ * Capsule Staleness Detection — proactive detection and auto-staling.
+ *
+ * Detects stale capsules proactively and auto-stales them.
+ * Estimates max staleness (MSL) per session from activity patterns.
+ *
+ * MSL = max gap between consecutive selections + safety margin.
+ * If no selections yet, default = 24h.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+/** Default TTL in days */
+const DEFAULT_TTL_DAYS = 30;
+
+/** Safety margin multiplier for MSL */
+const SAFETY_MARGIN = 1.5;
+
+/**
+ * @typedef {Object} StalenessConfig
+ * @property {number} ttl_days - Default TTL in days
+ * @property {number} msl_hours - Max staleness limit in hours
+ * @property {boolean} auto_stale - Whether to auto-mark stale capsules
+ */
+
+/**
+ * @typedef {Object} StalenessResult
+ * @property {string} contextId
+ * @property {boolean} stale
+ * @property {string} reason
+ * @property {number} age_days
+ * @property {number} freshness
+ */
+
+/**
+ * Default staleness configuration.
+ */
+export const DEFAULT_CONFIG = {
+  ttl_days: DEFAULT_TTL_DAYS,
+  msl_hours: 24,
+  auto_stale: true,
+};
+
+/**
+ * Calculate capsule freshness based on age.
+ *
+ * @param {Object} capsule
+ * @param {number} now - Current timestamp (ms)
+ * @returns {number} Freshness score 0-1
+ */
+export function freshness(capsule, now = Date.now()) {
+  const updated = new Date(capsule.updated_at || capsule.created_at).getTime();
+  const days = Math.max(0, (now - updated) / 86400000);
+  return Math.max(0.1, 1 - days / DEFAULT_TTL_DAYS);
+}
+
+/**
+ * Check if a capsule is stale based on TTL and MSL.
+ *
+ * @param {Object} capsule
+ * @param {StalenessConfig} config
+ * @param {number} now - Current timestamp (ms)
+ * @returns {StalenessResult}
+ */
+export function checkStaleness(capsule, config = DEFAULT_CONFIG, now = Date.now()) {
+  const created = new Date(capsule.created_at).getTime();
+  const updated = new Date(capsule.updated_at || capsule.created_at).getTime();
+  const ageDays = (now - created) / 86400000;
+  const lastUpdateDays = (now - updated) / 86400000;
+
+  // Check TTL expiration
+  if (ageDays > config.ttl_days) {
+    return {
+      contextId: capsule.context_id,
+      stale: true,
+      reason: `ttl_exceeded: age ${ageDays.toFixed(1)}d > TTL ${config.ttl_days}d`,
+      age_days: ageDays,
+      freshness: freshness(capsule, now),
+    };
+  }
+
+  // Check MSL (max staleness limit)
+  const mslDays = config.msl_hours / 24;
+  if (lastUpdateDays > mslDays) {
+    return {
+      contextId: capsule.context_id,
+      stale: true,
+      reason: `msl_exceeded: last update ${lastUpdateDays.toFixed(1)}d > MSL ${mslDays.toFixed(1)}d`,
+      age_days: ageDays,
+      freshness: freshness(capsule, now),
+    };
+  }
+
+  // Check if lifecycle is already stale
+  if (capsule.lifecycle === "stale") {
+    return {
+      contextId: capsule.context_id,
+      stale: true,
+      reason: "already_stale",
+      age_days: ageDays,
+      freshness: freshness(capsule, now),
+    };
+  }
+
+  return {
+    contextId: capsule.context_id,
+    stale: false,
+    reason: "fresh",
+    age_days: ageDays,
+    freshness: freshness(capsule, now),
+  };
+}
+
+/**
+ * Estimate MSL (max staleness limit) from session activity patterns.
+ *
+ * @param {string} root - Project root
+ * @param {string} sessionId - Session ID
+ * @returns {number} MSL in hours
+ */
+export function estimateMSL(root, sessionId) {
+  const tracesDir = path.join(root, ".wam", "traces");
+  const selectionLog = path.join(tracesDir, "selection-log.jsonl");
+
+  if (!fs.existsSync(selectionLog)) {
+    return DEFAULT_CONFIG.msl_hours;
+  }
+
+  try {
+    const content = fs.readFileSync(selectionLog, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+
+    // Get timestamps for this session
+    const timestamps = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.session_id === sessionId || !entry.session_id) {
+          timestamps.push(new Date(entry.timestamp).getTime());
+        }
+      } catch {}
+    }
+
+    if (timestamps.length < 2) {
+      return DEFAULT_CONFIG.msl_hours;
+    }
+
+    // Calculate gaps between consecutive selections
+    timestamps.sort((a, b) => a - b);
+    const gaps = [];
+    for (let i = 1; i < timestamps.length; i++) {
+      gaps.push(timestamps[i] - timestamps[i - 1]);
+    }
+
+    // MSL = max gap + safety margin
+    const maxGap = Math.max(...gaps);
+    const mslMs = maxGap * SAFETY_MARGIN;
+    const mslHours = Math.max(1, mslMs / 3600000);
+
+    // Clamp to reasonable bounds
+    return Math.min(72, Math.max(1, mslHours));
+  } catch {
+    return DEFAULT_CONFIG.msl_hours;
+  }
+}
+
+/**
+ * Scan all active capsules and return staleness results.
+ *
+ * @param {string} root - Project root
+ * @param {StalenessConfig} config
+ * @returns {StalenessResult[]}
+ */
+export function scanForStale(root, config = DEFAULT_CONFIG) {
+  const capsulesDir = path.join(root, ".wam", "capsules");
+  if (!fs.existsSync(capsulesDir)) {
+    return [];
+  }
+
+  const results = [];
+  const files = fs.readdirSync(capsulesDir).filter((f) => f.endsWith(".json"));
+
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(path.join(capsulesDir, file), "utf-8");
+      const capsule = JSON.parse(content);
+
+      if (capsule.lifecycle === "active") {
+        results.push(checkStaleness(capsule, config));
+      }
+    } catch {}
+  }
+
+  return results;
+}
+
+/**
+ * Auto-mark stale capsules in a directory.
+ *
+ * @param {string} root - Project root
+ * @param {StalenessConfig} config
+ * @returns {string[]} List of capsule IDs that were marked stale
+ */
+export function autoMarkStale(root, config = DEFAULT_CONFIG) {
+  if (!config.auto_stale) {
+    return [];
+  }
+
+  const capsulesDir = path.join(root, ".wam", "capsules");
+  if (!fs.existsSync(capsulesDir)) {
+    return [];
+  }
+
+  const marked = [];
+  const files = fs.readdirSync(capsulesDir).filter((f) => f.endsWith(".json"));
+
+  for (const file of files) {
+    try {
+      const filePath = path.join(capsulesDir, file);
+      const content = fs.readFileSync(filePath, "utf-8");
+      const capsule = JSON.parse(content);
+
+      if (capsule.lifecycle === "active") {
+        const result = checkStaleness(capsule, config);
+        if (result.stale) {
+          capsule.lifecycle = "stale";
+          capsule.updated_at = new Date().toISOString();
+          fs.writeFileSync(filePath, JSON.stringify(capsule, null, 2) + "\n");
+          marked.push(capsule.context_id);
+        }
+      }
+    } catch {}
+  }
+
+  return marked;
+}
+
+/**
+ * Get staleness report for a project.
+ *
+ * @param {string} root - Project root
+ * @param {StalenessConfig} config
+ * @returns {Object} Staleness report
+ */
+export function getStalenessReport(root, config = DEFAULT_CONFIG) {
+  const results = scanForStale(root, config);
+  const stale = results.filter((r) => r.stale);
+  const fresh = results.filter((r) => !r.stale);
+
+  return {
+    total: results.length,
+    stale: stale.length,
+    fresh: fresh.length,
+    staleCapsules: stale.map((r) => ({
+      id: r.contextId,
+      reason: r.reason,
+      age_days: r.age_days,
+    })),
+    freshCapsules: fresh.map((r) => ({
+      id: r.contextId,
+      freshness: r.freshness,
+      age_days: r.age_days,
+    })),
+    config,
+  };
+}

package/src/context/capsules.js

@@ -0,0 +1,2 @@
+import { listCapsules, getCapsule, promoteCapsule, migrateLegacyCapsules } from "./context.js";
+export { listCapsules, getCapsule, promoteCapsule, migrateLegacyCapsules };

package/src/context/compare-array.js

@@ -0,0 +1,98 @@
+/**
+ * Array comparison — element-wise with placeholder tolerance.
+ *
+ * Rules:
+ *   - both empty           → SUPPORTED
+ *   - expected empty, actual non-empty → INCONCLUSIVE (allowed extras)
+ *   - actual shorter than expected → CONTRADICTED for every missing expected element
+ *   - actual longer  than expected → INCONCLUSIVE for extras
+ *   - element-wise:
+ *       nested array  → recurse
+ *       nested object → compareObject
+ *       scalar        → compareValues
+ */
+
+import { AssessmentResult } from "./assessment-rules.js";
+import { compareValues } from "./compare-values.js";
+import { compareObject } from "./compare-object.js";
+
+export function compareArray(expected, actual, path = "") {
+  const findings = [];
+
+  if (!Array.isArray(expected) || !Array.isArray(actual)) {
+    findings.push({
+      result: AssessmentResult.INCONCLUSIVE,
+      path,
+      expected,
+      actual,
+      reason: "expected/actual is not an array",
+    });
+    return findings;
+  }
+
+  if (expected.length === 0 && actual.length === 0) {
+    findings.push({
+      result: AssessmentResult.SUPPORTED,
+      path,
+      expected,
+      actual,
+      reason: "both arrays empty",
+    });
+    return findings;
+  }
+
+  if (expected.length === 0) {
+    findings.push({
+      result: AssessmentResult.INCONCLUSIVE,
+      path,
+      expected,
+      actual,
+      reason: "expected empty, actual has extras",
+    });
+    return findings;
+  }
+
+  for (let i = 0; i < expected.length; i++) {
+    const childPath = `${path}[${i}]`;
+    if (i >= actual.length) {
+      findings.push({
+        result: AssessmentResult.CONTRADICTED,
+        path: childPath,
+        expected: expected[i],
+        actual: undefined,
+        reason: "missing array element",
+      });
+      continue;
+    }
+
+    const expEl = expected[i];
+    const actEl = actual[i];
+
+    if (Array.isArray(expEl) && Array.isArray(actEl)) {
+      findings.push(...compareArray(expEl, actEl, childPath));
+    } else if (
+      expEl !== null &&
+      typeof expEl === "object" &&
+      actEl !== null &&
+      typeof actEl === "object" &&
+      !Array.isArray(actEl)
+    ) {
+      findings.push(...compareObject(expEl, actEl, childPath));
+    } else {
+      findings.push(...compareValues(expEl, actEl, childPath));
+    }
+  }
+
+  for (let i = expected.length; i < actual.length; i++) {
+    const childPath = `${path}[${i}]`;
+    findings.push({
+      result: AssessmentResult.INCONCLUSIVE,
+      path: childPath,
+      expected: undefined,
+      actual: actual[i],
+      reason: "extra array element",
+    });
+  }
+
+  return findings;
+}

package/src/context/compare-object.js

@@ -0,0 +1,89 @@
+/**
+ * Object comparison — recurses into nested keys, classifies missing/partial/extra.
+ *
+ * Findings classification:
+ *   - missing key (in expected, not in actual)  → CONTRADICTED
+ *   - extra key (in actual, not in expected)    → INCONCLUSIVE (allowed extras)
+ *   - nested object → recurse via compareObject
+ *   - nested array  → delegate to compareArray
+ *   - scalar        → compareValues
+ */
+
+import { AssessmentResult } from "./assessment-rules.js";
+import { compareValues } from "./compare-values.js";
+import { compareArray } from "./compare-array.js";
+
+export function compareObject(expected, actual, path = "") {
+  const findings = [];
+
+  if (expected === null || typeof expected !== "object" || Array.isArray(expected)) {
+    findings.push({
+      result: AssessmentResult.INCONCLUSIVE,
+      path,
+      expected,
+      actual,
+      reason: "expected is not an object",
+    });
+    return findings;
+  }
+
+  if (actual === null || typeof actual !== "object" || Array.isArray(actual)) {
+    findings.push({
+      result: AssessmentResult.CONTRADICTED,
+      path,
+      expected,
+      actual,
+      reason: "actual is not an object",
+    });
+    return findings;
+  }
+
+  const expectedKeys = Object.keys(expected);
+  const actualKeys = Object.keys(actual);
+
+  for (const key of expectedKeys) {
+    const childPath = path ? `${path}.${key}` : key;
+    if (!(key in actual)) {
+      findings.push({
+        result: AssessmentResult.CONTRADICTED,
+        path: childPath,
+        expected: expected[key],
+        actual: undefined,
+        reason: "missing key",
+      });
+      continue;
+    }
+
+    const expVal = expected[key];
+    const actVal = actual[key];
+
+    if (Array.isArray(expVal) && Array.isArray(actVal)) {
+      findings.push(...compareArray(expVal, actVal, childPath));
+    } else if (
+      expVal !== null &&
+      typeof expVal === "object" &&
+      actVal !== null &&
+      typeof actVal === "object" &&
+      !Array.isArray(actVal)
+    ) {
+      findings.push(...compareObject(expVal, actVal, childPath));
+    } else {
+      findings.push(...compareValues(expVal, actVal, childPath));
+    }
+  }
+
+  for (const key of actualKeys) {
+    if (!(key in expected)) {
+      const childPath = path ? `${path}.${key}` : key;
+      findings.push({
+        result: AssessmentResult.INCONCLUSIVE,
+        path: childPath,
+        expected: undefined,
+        actual: actual[key],
+        reason: "extra key",
+      });
+    }
+  }
+
+  return findings;
+}

package/src/context/compare-values.js

@@ -0,0 +1,42 @@
+/**
+ * Scalar comparison — atomic value vs atomic value.
+ * Produces a finding: { result, path, expected, actual }
+ */
+
+import { AssessmentResult, classifyScalar, isMissing } from "./assessment-rules.js";
+
+export function compareValues(expected, actual, path = "") {
+  if (isMissing(expected)) {
+    return [
+      {
+        result: AssessmentResult.INCONCLUSIVE,
+        path,
+        expected,
+        actual,
+        reason: "expected value missing",
+      },
+    ];
+  }
+
+  if (isMissing(actual)) {
+    return [
+      {
+        result: AssessmentResult.CONTRADICTED,
+        path,
+        expected,
+        actual,
+        reason: "actual value missing",
+      },
+    ];
+  }
+
+  return [
+    {
+      result: classifyScalar(expected, actual),
+      path,
+      expected,
+      actual,
+      reason: null,
+    },
+  ];
+}

package/src/context/context-assembly-contract.js

@@ -0,0 +1,71 @@
+import { assembleContext } from "./assembly.js";
+import { buildContextQuery, CONTEXT_PURPOSE } from "./context-query-contract.js";
+import { checkSufficiency, SufficiencyGate, SUFFICIENCY_LEVEL } from "./context-sufficiency-gate.js";
+
+export const CONTEXT_ASSEMBLY_STATUS = Object.freeze({
+  PROCEED: "PROCEED",
+  BLOCK: "BLOCK",
+});
+
+export function assembleContextWithQuery(params = {}) {
+  const query = params.query || buildContextQuery({
+    taskId: params.taskId,
+    purpose: params.purpose || CONTEXT_PURPOSE.PLANNING,
+    requirementId: params.requirementId,
+    hypothesisId: params.hypothesisId,
+    experimentId: params.experimentId,
+    executionId: params.executionId,
+    taskType: params.taskType,
+    phase: params.phase,
+    activeFiles: params.activeFiles || [],
+    activeTools: params.activeTools || [],
+    knownFailures: params.knownFailures || [],
+    unresolvedQuestions: params.unresolvedQuestions || [],
+    budget: params.budget,
+  });
+
+  const sufficiency = checkSufficiency(params.items || [], query.purpose);
+  const gate = new SufficiencyGate({
+    purpose: query.purpose,
+    minLevel: params.minLevel || SUFFICIENCY_LEVEL.SUFFICIENT,
+    requireMandatory: params.requireMandatory || false,
+  });
+  const gateResult = gate.evaluate(params.items || []);
+  const hasNoItems = !params.items || params.items.length === 0;
+  const minLevel = params.minLevel || SUFFICIENCY_LEVEL.SUFFICIENT;
+  const shouldBlock = !hasNoItems && (
+    gateResult.sufficiency.level === SUFFICIENCY_LEVEL.INSUFFICIENT ||
+    (params.minLevel && gateResult.sufficiency.level !== minLevel &&
+     gateResult.decision !== "PROCEED")
+  );
+
+  if (shouldBlock) {
+    return {
+      status: CONTEXT_ASSEMBLY_STATUS.BLOCK,
+      query,
+      sufficiency: gateResult.sufficiency,
+      gate: gateResult,
+      context: null,
+    };
+  }
+
+  const context = assembleContext({
+    ...params,
+    query,
+    taskState: {
+      ...(params.taskState || {}),
+      query,
+      unresolvedCriticalUnknowns: gateResult.sufficiency.unresolvedCriticalUnknowns,
+    },
+  });
+
+  return {
+    status: CONTEXT_ASSEMBLY_STATUS.PROCEED,
+    query,
+    sufficiency: gateResult.sufficiency,
+    gate: gateResult,
+    context,
+  };
+}
+
+export { assembleContext };