opencode-swarm 7.136.4 → 7.137.0

package/dist/utils/stable-stringify.d.ts

@@ -25,6 +25,11 @@
  * Originally introduced for the adversarial-detector spiral hash
  * (issue #2060) and shared with `file-authority.hashArgs` so both code paths
  * use one correct implementation.
+ *
+ * This is a canonicalizer for HASH INPUT, not a drop-in `JSON.stringify`
+ * replacement — see the "Serialization limits" section on
+ * `stableCanonicalStringify` before using it anywhere the output is parsed or
+ * shown to a user.
  */
 /**
  * Recursively produces a canonical JSON string with object keys sorted at
@@ -39,8 +44,48 @@
  * function exists to eliminate. Sorting must be done by rebuilding each object
  * with sorted keys before serialization.
  *
+ * ## Serialization limits (#2062 F-008 — deliberate, verified, do not "fix"
+ * without re-reading this)
+ *
+ * - **No `toJSON` support.** `toJSON` is never consulted. A `Date` therefore
+ *   collapses to `{}` (it has no own enumerable keys) — a genuine divergence
+ *   from `JSON.stringify`, which emits the ISO string.
+ * - **`Map`/`Set` collapse to `{}`.** This MATCHES `JSON.stringify` (neither
+ *   exposes own enumerable string keys), so it is lossy for both rather than a
+ *   divergence between them.
+ * - **`undefined` serializes as `null`** in object-property AND array-element
+ *   position, so no bare `undefined` token or sparse-array hole is emitted for
+ *   it. `JSON.stringify` instead omits an `undefined`-valued property; keeping
+ *   the key here is deliberate — two objects differing only by a
+ *   present-but-undefined key must not hash equal. True sparse array *holes*
+ *   (`[1,,3]`) are NOT covered: `Array.prototype.map` skips holes, so they
+ *   still render as `[1,,3]`.
+ * - **Function and symbol values still emit a bare `undefined` token**, which
+ *   is not valid JSON. It is deterministic, so it is safe as hash input, but
+ *   the result is not always `JSON.parse`-able.
+ *
+ * These limits are safe at every current call site: the cohort fingerprint
+ * input is a flat all-primitive struct, and the hook call sites hash tool-call
+ * arguments that have already round-tripped through JSON transport, so
+ * `Date`/`Map`/`Set`/function values cannot reach them.
+ *
+ * ## Throwing, and how callers must (and must not) handle it
+ *
  * Throws on cyclic structures (infinite recursion) and on values that
- * `JSON.stringify` cannot represent (BigInt); callers should wrap in try/catch
- * and fall back to a stable coarse hash.
+ * `JSON.stringify` cannot represent (BigInt). Correct caller handling depends
+ * on what the hash is FOR:
+ *
+ * - **Repetition / spiral-detection callers** (`hashArgsForSpiral` in
+ *   `hooks/adversarial-detector.ts`, `hashArgs` in
+ *   `hooks/guardrails/file-authority.ts`) SHOULD wrap in try/catch and fall
+ *   back to a stable coarse hash. There, a fallback only degrades detection
+ *   sensitivity for the one call that failed.
+ * - **Identity / fail-closed comparison callers** (e.g.
+ *   `computeMemoryCohortFingerprint` in `memory/redaction.ts`) MUST NOT do
+ *   that. A constant fallback would collapse every failing input to the same
+ *   fingerprint, so two genuinely incompatible cohort members would compare
+ *   equal and the fail-closed coherence check would be silently defeated. Let
+ *   the throw propagate, or rethrow with added context — never return a
+ *   constant.
  */
 export declare function stableCanonicalStringify(value: unknown): string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.136.4",
+	"version": "7.137.0",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -104,7 +104,8 @@
 		"prepare": "bun run build",
 		"repro:704": "node scripts/repro-704.mjs",
 		"repro:1144": "bun scripts/repro-1144.mjs",
-		"repro:1873": "bun build scripts/repro-1873-entry.ts --outdir dist-build-test/repro-1873 --target node --format esm && node scripts/repro-1873.mjs"
+		"repro:1873": "bun build scripts/repro-1873-entry.ts --outdir dist-build-test/repro-1873 --target node --format esm && node scripts/repro-1873.mjs",
+		"check:events": "bun run scripts/check-event-contract.ts"
 	},
 	"dependencies": {
 		"@opencode-ai/plugin": "^1.18.3",

package/dist/cli/index-cze4bq1x.js

@@ -1,358 +0,0 @@
-// @bun
-// src/telemetry.ts
-import * as fs from "fs";
-import { createWriteStream } from "fs";
-import * as os from "os";
-import * as path from "path";
-var _writeStream = null;
-var _projectDirectory = null;
-var _listeners = [];
-var _disabled = false;
-var _heartbeatTrackingActive = false;
-var _heartbeatListener = null;
-var heartbeatTimestamps = new Map;
-function capHeartbeatMap() {
-  while (heartbeatTimestamps.size >= 500) {
-    const oldestKey = heartbeatTimestamps.keys().next().value;
-    if (oldestKey === undefined)
-      break;
-    heartbeatTimestamps.delete(oldestKey);
-  }
-}
-function startHeartbeatTracking() {
-  if (_heartbeatTrackingActive)
-    return;
-  _heartbeatTrackingActive = true;
-  const listener = (event, data) => {
-    if (event !== "heartbeat")
-      return;
-    const payload = data;
-    if (!payload?.sessionId)
-      return;
-    heartbeatTimestamps.set(payload.sessionId, Date.now());
-    capHeartbeatMap();
-  };
-  _heartbeatListener = listener;
-  addTelemetryListener(listener);
-}
-function getLastHeartbeat(sessionId) {
-  return heartbeatTimestamps.get(sessionId);
-}
-function stopHeartbeatTracking() {
-  _heartbeatTrackingActive = false;
-  if (_heartbeatListener !== null) {
-    const idx = _listeners.indexOf(_heartbeatListener);
-    if (idx >= 0)
-      _listeners.splice(idx, 1);
-    _heartbeatListener = null;
-  }
-}
-function resetHeartbeatTrackingForTesting() {
-  _heartbeatTrackingActive = false;
-  heartbeatTimestamps.clear();
-  if (_heartbeatListener !== null) {
-    const idx = _listeners.indexOf(_heartbeatListener);
-    if (idx >= 0)
-      _listeners.splice(idx, 1);
-    _heartbeatListener = null;
-  }
-}
-var _emitCount = 0;
-var ROTATION_CHECK_INTERVAL = 50;
-function resetTelemetryForTesting() {
-  _disabled = false;
-  _projectDirectory = null;
-  _listeners.length = 0;
-  _emitCount = 0;
-  resetHeartbeatTrackingForTesting();
-  if (_writeStream !== null) {
-    _writeStream.end();
-    _writeStream = null;
-  }
-}
-function initTelemetry(projectDirectory) {
-  if (_writeStream !== null || _disabled) {
-    return;
-  }
-  try {
-    _projectDirectory = projectDirectory;
-    const swarmDir = path.join(projectDirectory, ".swarm");
-    if (!fs.existsSync(swarmDir)) {
-      fs.mkdirSync(swarmDir, { recursive: true });
-    }
-    const telemetryPath = path.join(swarmDir, "telemetry.jsonl");
-    const stream = createWriteStream(telemetryPath, { flags: "a" });
-    stream.on("error", () => {
-      if (_writeStream === stream) {
-        _disabled = true;
-        _writeStream = null;
-      }
-    });
-    _writeStream = stream;
-  } catch {
-    _disabled = true;
-    _writeStream = null;
-  }
-}
-function emit(event, data) {
-  try {
-    if (_disabled || _writeStream === null) {
-      return;
-    }
-    const line = JSON.stringify({
-      timestamp: new Date().toISOString(),
-      event,
-      ...data
-    }) + os.EOL;
-    const stream = _writeStream;
-    stream.write(line, (err) => {
-      if (err && _writeStream === stream) {
-        _disabled = true;
-        _writeStream = null;
-      }
-    });
-    for (const listener of _listeners) {
-      try {
-        listener(event, data);
-      } catch {}
-    }
-    _emitCount++;
-    if (_emitCount >= ROTATION_CHECK_INTERVAL) {
-      _emitCount = 0;
-      _internals.rotateTelemetryIfNeeded();
-    }
-  } catch {}
-}
-function addTelemetryListener(callback) {
-  _listeners.push(callback);
-}
-function rotateTelemetryIfNeeded(maxBytes = 10 * 1024 * 1024) {
-  try {
-    if (_projectDirectory === null) {
-      return;
-    }
-    const telemetryPath = path.join(_projectDirectory, ".swarm", "telemetry.jsonl");
-    if (!fs.existsSync(telemetryPath)) {
-      return;
-    }
-    const stats = fs.statSync(telemetryPath);
-    if (stats.size < maxBytes) {
-      return;
-    }
-    const rotatedPath = path.join(_projectDirectory, ".swarm", "telemetry.jsonl.1");
-    fs.renameSync(telemetryPath, rotatedPath);
-    if (_writeStream !== null) {
-      _writeStream.end();
-      const stream = createWriteStream(telemetryPath, { flags: "a" });
-      stream.on("error", () => {
-        if (_writeStream === stream) {
-          _disabled = true;
-          _writeStream = null;
-        }
-      });
-      _writeStream = stream;
-    }
-  } catch {}
-}
-var telemetry = {
-  sessionStarted(sessionId, agentName) {
-    _internals.emit("session_started", { sessionId, agentName });
-  },
-  sessionEnded(sessionId, reason) {
-    _internals.emit("session_ended", { sessionId, reason });
-  },
-  agentActivated(sessionId, agentName, oldName) {
-    _internals.emit("agent_activated", { sessionId, agentName, oldName });
-  },
-  delegationBegin(sessionId, agentName, taskId) {
-    _internals.emit("delegation_begin", { sessionId, agentName, taskId });
-  },
-  delegationEnd(sessionId, agentName, taskId, result, costFields) {
-    _internals.emit("delegation_end", {
-      sessionId,
-      agentName,
-      taskId,
-      result,
-      tokens_input: costFields?.tokens_input ?? 0,
-      tokens_output: costFields?.tokens_output ?? 0,
-      tokens_reasoning: costFields?.tokens_reasoning ?? 0,
-      tokens_cache: costFields?.tokens_cache ?? 0,
-      cost_usd: costFields?.cost_usd ?? null,
-      cost_source: costFields?.cost_source ?? "unavailable",
-      model: costFields?.model,
-      gate: costFields?.gate,
-      retry_index: costFields?.retry_index
-    });
-  },
-  taskStateChanged(sessionId, taskId, newState, oldState) {
-    _internals.emit("task_state_changed", {
-      sessionId,
-      taskId,
-      newState,
-      oldState
-    });
-  },
-  gatePassed(sessionId, gate, taskId) {
-    _internals.emit("gate_passed", { sessionId, gate, taskId });
-  },
-  gateParseError(taskId, error) {
-    _internals.emit("gate_parse_error", {
-      taskId,
-      errorName: error.name,
-      errorMessage: error.message.slice(0, 200)
-    });
-  },
-  gateFailed(sessionId, gate, taskId, reason) {
-    _internals.emit("gate_failed", { sessionId, gate, taskId, reason });
-  },
-  reviewerGateDecision(sessionId, taskId, blocked, reasonCode, evidenceKind) {
-    _internals.emit("reviewer_gate_decision", {
-      sessionId,
-      gate: "qa_gate",
-      taskId,
-      blocked,
-      allowed: !blocked,
-      reasonCode,
-      evidenceKind
-    });
-  },
-  phaseChanged(sessionId, oldPhase, newPhase) {
-    _internals.emit("phase_changed", { sessionId, oldPhase, newPhase });
-  },
-  budgetUpdated(sessionId, budgetPct, agentName) {
-    _internals.emit("budget_updated", { sessionId, budgetPct, agentName });
-  },
-  modelFallback(sessionId, agentName, fromModel, toModel, reason) {
-    _internals.emit("model_fallback", {
-      sessionId,
-      agentName,
-      fromModel,
-      toModel,
-      reason
-    });
-  },
-  hardLimitHit(sessionId, agentName, limitType, value) {
-    _internals.emit("hard_limit_hit", {
-      sessionId,
-      agentName,
-      limitType,
-      value
-    });
-  },
-  revisionLimitHit(sessionId, agentName) {
-    _internals.emit("revision_limit_hit", { sessionId, agentName });
-  },
-  loopDetected(sessionId, agentName, loopType) {
-    _internals.emit("loop_detected", { sessionId, agentName, loopType });
-  },
-  noOpStrongWarning(sessionId, agentName, count, threshold) {
-    _internals.emit("no_op_strong_warning", {
-      sessionId,
-      agentName,
-      count,
-      threshold
-    });
-  },
-  gateDenialLoop(sessionId, tool, code, count) {
-    _internals.emit("gate_denial_loop", { sessionId, tool, code, count });
-  },
-  executionStallWarning(sessionId, count, threshold) {
-    _internals.emit("execution_stall_warning", {
-      sessionId,
-      count,
-      threshold
-    });
-  },
-  executionStallDenied(sessionId, tool, count, threshold) {
-    _internals.emit("execution_stall_denied", {
-      sessionId,
-      tool,
-      count,
-      threshold
-    });
-  },
-  swarmInternalsReadDenied(sessionId, tool, target) {
-    _internals.emit("swarm_internals_read_denied", {
-      sessionId,
-      tool,
-      target
-    });
-  },
-  scopeViolation(sessionId, agentName, file, reason) {
-    _internals.emit("scope_violation", { sessionId, agentName, file, reason });
-  },
-  qaSkipViolation(sessionId, agentName, skipCount) {
-    _internals.emit("qa_skip_violation", { sessionId, agentName, skipCount });
-  },
-  heartbeat(sessionId) {
-    _internals.emit("heartbeat", { sessionId });
-  },
-  turboModeChanged(sessionId, enabled, agentName) {
-    _internals.emit("turbo_mode_changed", { sessionId, enabled, agentName });
-  },
-  autoOversightEscalation(sessionId, reason, interactionCount, deadlockCount, phase) {
-    _internals.emit("auto_oversight_escalation", {
-      sessionId,
-      reason,
-      interactionCount,
-      deadlockCount,
-      phase
-    });
-  },
-  environmentDetected(sessionId, hostOS, shellFamily, executionMode) {
-    _internals.emit("environment_detected", {
-      sessionId,
-      hostOS,
-      shellFamily,
-      executionMode
-    });
-  },
-  prmPatternDetected(sessionId, pattern, severity, category, stepRange) {
-    _internals.emit("prm_pattern_detected", {
-      sessionId,
-      pattern,
-      severity,
-      category,
-      stepRange
-    });
-  },
-  prmCourseCorrectionInjected(sessionId, pattern, level) {
-    _internals.emit("prm_course_correction_injected", {
-      sessionId,
-      pattern,
-      level
-    });
-  },
-  prmEscalationTriggered(sessionId, pattern, level, occurrenceCount) {
-    _internals.emit("prm_escalation_triggered", {
-      sessionId,
-      pattern,
-      level,
-      occurrenceCount
-    });
-  },
-  prmHardStop(sessionId, pattern, level, occurrenceCount) {
-    _internals.emit("prm_hard_stop", {
-      sessionId,
-      pattern,
-      level,
-      occurrenceCount
-    });
-  },
-  prmHardStopDelivered(sessionId, pattern, level, occurrenceCount) {
-    _internals.emit("prm_hard_stop_delivered", {
-      sessionId,
-      pattern,
-      level,
-      occurrenceCount
-    });
-  }
-};
-var _internals = {
-  telemetry,
-  emit,
-  rotateTelemetryIfNeeded,
-  heartbeatListenerCount: () => _heartbeatListener !== null ? 1 : 0
-};
-
-export { startHeartbeatTracking, getLastHeartbeat, stopHeartbeatTracking, resetHeartbeatTrackingForTesting, ROTATION_CHECK_INTERVAL, resetTelemetryForTesting, initTelemetry, emit, addTelemetryListener, rotateTelemetryIfNeeded, telemetry, _internals };