opencode-swarm 7.164.11 → 7.164.12

package/dist/cli/index-c45662wc.js

@@ -0,0 +1,361 @@
+// @bun
+import {
+  DURABILITY_CLASSES,
+  getProjectDb,
+  projectDbExists,
+  withImmediateTransaction
+} from "./index-es64amqt.js";
+
+// src/db/coordination-store.ts
+import { createHash } from "crypto";
+var MAX_KEY_CHARS = 512;
+var MAX_STATUS_CHARS = 128;
+var MAX_PAYLOAD_CHARS = 1048576;
+var MAX_EVENTS_PER_STREAM = 2048;
+var MAX_TOTAL_EVENTS = 1e5;
+var MAX_EVENT_FENCES_PER_STREAM = 8192;
+var MAX_TOTAL_EVENT_FENCES = 400000;
+var MAX_COORDINATION_STATE_LIST_ROWS = 25000;
+var COORDINATION_STATE_PAGE_SIZE = 5000;
+var _internals = {
+  maxEventsPerStream: MAX_EVENTS_PER_STREAM,
+  maxTotalEvents: MAX_TOTAL_EVENTS,
+  maxEventFencesPerStream: MAX_EVENT_FENCES_PER_STREAM,
+  maxTotalEventFences: MAX_TOTAL_EVENT_FENCES
+};
+function boundedText(value, label, max) {
+  if (value.length === 0 || value.length > max) {
+    throw new Error(`${label} must contain 1..${max} characters`);
+  }
+  return value;
+}
+function validatePayload(payload) {
+  boundedText(payload, "payload", MAX_PAYLOAD_CHARS);
+  JSON.parse(payload);
+  return payload;
+}
+function digestPayload(payload) {
+  return createHash("sha256").update(payload, "utf8").digest("hex");
+}
+function rowToState(row) {
+  if (!row)
+    return null;
+  validatePayload(row.payload);
+  return {
+    namespace: row.namespace,
+    entityKey: row.entity_key,
+    revision: row.revision,
+    generation: row.generation,
+    status: row.status,
+    payload: row.payload,
+    updatedAt: row.updated_at
+  };
+}
+function readState(db, namespace, entityKey) {
+  const row = db.query(`SELECT namespace, entity_key, revision, generation, status, payload, updated_at
+		 FROM coordination_state WHERE namespace = ? AND entity_key = ?`).get(namespace, entityKey) ?? null;
+  return rowToState(row);
+}
+function transactionHooks() {
+  return {
+    beforeBegin: (db) => _internals.coordinationFaultInjector?.("before_begin", db),
+    beforeOuterCommit: (db) => _internals.coordinationFaultInjector?.("before_outer_commit", db)
+  };
+}
+function withCoordinationTransaction(directory, fn) {
+  return withImmediateTransaction(getProjectDb(directory), DURABILITY_CLASSES.coordination_state, fn, transactionHooks());
+}
+function getCoordinationState(directory, namespace, entityKey) {
+  if (!projectDbExists(directory))
+    return null;
+  return readState(getProjectDb(directory), namespace, entityKey);
+}
+function listCoordinationStates(directory, namespace, limit = 5000) {
+  if (!projectDbExists(directory))
+    return [];
+  const boundedLimit = Number.isFinite(limit) ? Math.max(0, Math.min(MAX_COORDINATION_STATE_LIST_ROWS, Math.trunc(limit))) : 0;
+  if (boundedLimit === 0)
+    return [];
+  const db = getProjectDb(directory);
+  const states = [];
+  let lastEntityKey;
+  while (states.length < boundedLimit) {
+    const pageLimit = Math.min(COORDINATION_STATE_PAGE_SIZE, boundedLimit - states.length);
+    const rows = lastEntityKey === undefined ? db.query(`SELECT namespace, entity_key, revision, generation, status, payload, updated_at
+						 FROM coordination_state WHERE namespace = ? ORDER BY entity_key LIMIT ?`).all(namespace, pageLimit) : db.query(`SELECT namespace, entity_key, revision, generation, status, payload, updated_at
+						 FROM coordination_state
+						 WHERE namespace = ? AND entity_key > ?
+						 ORDER BY entity_key LIMIT ?`).all(namespace, lastEntityKey, pageLimit);
+    if (rows.length === 0)
+      break;
+    states.push(...rows.map((row) => rowToState(row)));
+    lastEntityKey = rows[rows.length - 1]?.entity_key;
+    if (rows.length < pageLimit)
+      break;
+  }
+  return states;
+}
+function countCoordinationStates(directory, namespace) {
+  if (!projectDbExists(directory))
+    return 0;
+  const row = getProjectDb(directory).query("SELECT COUNT(*) AS count FROM coordination_state WHERE namespace = ?").get(namespace);
+  return row?.count ?? 0;
+}
+function deleteCoordinationState(directory, namespace, entityKey, expectedRevision) {
+  return withCoordinationTransaction(directory, () => {
+    const db = getProjectDb(directory);
+    const result = expectedRevision === undefined ? db.run("DELETE FROM coordination_state WHERE namespace = ? AND entity_key = ?", [namespace, entityKey]) : db.run(`DELETE FROM coordination_state
+					 WHERE namespace = ? AND entity_key = ? AND revision = ?`, [namespace, entityKey, expectedRevision]);
+    return result.changes === 1;
+  });
+}
+function deleteCoordinationStateWithinTransaction(directory, namespace, entityKey, expectedRevision) {
+  const db = getProjectDb(directory);
+  const result = expectedRevision === undefined ? db.run("DELETE FROM coordination_state WHERE namespace = ? AND entity_key = ?", [namespace, entityKey]) : db.run(`DELETE FROM coordination_state
+					 WHERE namespace = ? AND entity_key = ? AND revision = ?`, [namespace, entityKey, expectedRevision]);
+  return result.changes === 1;
+}
+function validateTransitionInput(input) {
+  boundedText(input.namespace, "namespace", MAX_KEY_CHARS);
+  boundedText(input.entityKey, "entityKey", MAX_KEY_CHARS);
+  boundedText(input.status, "status", MAX_STATUS_CHARS);
+  validatePayload(input.payload);
+  if (!Number.isSafeInteger(input.generation) || input.generation < 0) {
+    throw new Error("generation must be a nonnegative safe integer");
+  }
+  if (input.event) {
+    if (input.expectedRevision === undefined) {
+      throw new Error("event-bearing coordination transitions require expectedRevision");
+    }
+    boundedText(input.event.streamId, "streamId", MAX_KEY_CHARS);
+    boundedText(input.event.idempotencyKey, "idempotencyKey", MAX_KEY_CHARS);
+    boundedText(input.event.eventType, "eventType", MAX_STATUS_CHARS);
+    validatePayload(input.event.payload);
+    if (input.event.expectedStreamVersion !== undefined && (!Number.isSafeInteger(input.event.expectedStreamVersion) || input.event.expectedStreamVersion < 0)) {
+      throw new Error("expectedStreamVersion must be a nonnegative safe integer");
+    }
+  }
+}
+function transitionCoordinationStateWithinTransaction(directory, input) {
+  validateTransitionInput(input);
+  const db = getProjectDb(directory);
+  const current = readState(db, input.namespace, input.entityKey);
+  if (input.event) {
+    const duplicate = db.query(`SELECT event_type, generation, payload_digest FROM coordination_event_fence
+				 WHERE stream_id = ? AND idempotency_key = ?`).get(input.event.streamId, input.event.idempotencyKey);
+    if (duplicate) {
+      const exact = duplicate.event_type === input.event.eventType && duplicate.generation === input.generation && duplicate.payload_digest === digestPayload(input.event.payload);
+      return {
+        outcome: exact ? "duplicate" : "idempotency_conflict",
+        state: current
+      };
+    }
+  }
+  if (current && input.generation < current.generation) {
+    return { outcome: "stale_generation", state: current };
+  }
+  if (input.expectedRevision === null && current !== null || typeof input.expectedRevision === "number" && current?.revision !== input.expectedRevision) {
+    return { outcome: "revision_conflict", state: current };
+  }
+  const nextRevision = (current?.revision ?? 0) + 1;
+  const now = new Date().toISOString();
+  if (input.event) {
+    const currentStreamVersion = db.query("SELECT MAX(version) AS max FROM coordination_event WHERE stream_id = ?").get(input.event.streamId)?.max ?? 0;
+    if (input.event.expectedStreamVersion !== undefined && input.event.expectedStreamVersion !== currentStreamVersion) {
+      return { outcome: "stream_version_conflict", state: current };
+    }
+    const nextVersion = currentStreamVersion + 1;
+    const payloadDigest = digestPayload(input.event.payload);
+    db.run(`INSERT INTO coordination_event
+				 (stream_id, version, idempotency_key, event_type, generation, payload, created_at)
+				 VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+      input.event.streamId,
+      nextVersion,
+      input.event.idempotencyKey,
+      input.event.eventType,
+      input.generation,
+      input.event.payload,
+      now
+    ]);
+    db.run(`INSERT INTO coordination_event_fence
+				 (stream_id, idempotency_key, event_type, generation, payload_digest, created_at)
+				 VALUES (?, ?, ?, ?, ?, ?)
+				 ON CONFLICT(stream_id, idempotency_key) DO UPDATE SET
+				 event_type = excluded.event_type, generation = excluded.generation,
+				 payload_digest = excluded.payload_digest, created_at = excluded.created_at`, [
+      input.event.streamId,
+      input.event.idempotencyKey,
+      input.event.eventType,
+      input.generation,
+      payloadDigest,
+      now
+    ]);
+    const streamFenceOverflow = (db.query("SELECT COUNT(*) AS count FROM coordination_event_fence WHERE stream_id = ?").get(input.event.streamId)?.count ?? 0) - _internals.maxEventFencesPerStream;
+    if (streamFenceOverflow > 0) {
+      db.run(`DELETE FROM coordination_event_fence WHERE rowid IN (
+					SELECT rowid FROM coordination_event_fence
+					WHERE stream_id = ? ORDER BY created_at, rowid LIMIT ?
+				)`, [input.event.streamId, streamFenceOverflow]);
+    }
+    const totalFenceCount = db.query("SELECT COUNT(*) AS count FROM coordination_event_fence").get()?.count ?? 0;
+    const totalFenceOverflow = totalFenceCount - _internals.maxTotalEventFences;
+    if (totalFenceOverflow > 0) {
+      db.run(`DELETE FROM coordination_event_fence WHERE rowid IN (
+					SELECT rowid FROM coordination_event_fence
+					ORDER BY created_at, stream_id, rowid LIMIT ?
+				)`, [totalFenceOverflow]);
+    }
+    const streamFloor = nextVersion - _internals.maxEventsPerStream;
+    if (streamFloor > 0) {
+      db.run("DELETE FROM coordination_event WHERE stream_id = ? AND version <= ?", [input.event.streamId, streamFloor]);
+    }
+    const total = db.query("SELECT COUNT(*) AS count FROM coordination_event").get()?.count ?? 0;
+    const overflow = total - _internals.maxTotalEvents;
+    if (overflow > 0) {
+      db.run(`DELETE FROM coordination_event WHERE rowid IN (
+						SELECT candidate.rowid FROM coordination_event AS candidate
+						WHERE candidate.version < (
+							SELECT MAX(head.version) FROM coordination_event AS head
+							WHERE head.stream_id = candidate.stream_id
+						)
+						ORDER BY candidate.created_at, candidate.stream_id, candidate.version LIMIT ?
+					)`, [overflow]);
+    }
+    _internals.coordinationFaultInjector?.("after_event_before_state", db);
+  }
+  db.run(`INSERT INTO coordination_state
+			 (namespace, entity_key, revision, generation, status, payload, updated_at)
+			 VALUES (?, ?, ?, ?, ?, ?, ?)
+			 ON CONFLICT(namespace, entity_key) DO UPDATE SET
+			 revision = excluded.revision, generation = excluded.generation,
+			 status = excluded.status, payload = excluded.payload, updated_at = excluded.updated_at`, [
+    input.namespace,
+    input.entityKey,
+    nextRevision,
+    input.generation,
+    input.status,
+    input.payload,
+    now
+  ]);
+  return {
+    outcome: "applied",
+    state: readState(db, input.namespace, input.entityKey)
+  };
+}
+function transitionCoordinationState(directory, input) {
+  validateTransitionInput(input);
+  return withCoordinationTransaction(directory, () => transitionCoordinationStateWithinTransaction(directory, input));
+}
+function getCoordinationLease(directory, namespace, entityKey) {
+  boundedText(namespace, "namespace", MAX_KEY_CHARS);
+  boundedText(entityKey, "entityKey", MAX_KEY_CHARS);
+  const row = getProjectDb(directory).query(`SELECT generation, owner_token, lease_expires_at, payload, updated_at
+			 FROM coordination_lease WHERE namespace = ? AND entity_key = ?`).get(namespace, entityKey);
+  return row ? {
+    namespace,
+    entityKey,
+    generation: row.generation,
+    ownerToken: row.owner_token,
+    leaseExpiresAt: row.lease_expires_at,
+    payload: row.payload,
+    updatedAt: row.updated_at
+  } : null;
+}
+function acquireCoordinationLease(directory, input) {
+  boundedText(input.namespace, "namespace", MAX_KEY_CHARS);
+  boundedText(input.entityKey, "entityKey", MAX_KEY_CHARS);
+  boundedText(input.ownerToken, "ownerToken", MAX_KEY_CHARS);
+  validatePayload(input.payload);
+  if (!Number.isSafeInteger(input.generation) || input.generation < 0) {
+    throw new Error("generation must be a nonnegative safe integer");
+  }
+  const expiryMs = Date.parse(input.leaseExpiresAt);
+  if (!Number.isFinite(expiryMs) || new Date(expiryMs).toISOString() !== input.leaseExpiresAt) {
+    throw new Error("leaseExpiresAt must be a canonical ISO timestamp");
+  }
+  return withCoordinationTransaction(directory, () => {
+    const db = getProjectDb(directory);
+    const row = db.query(`SELECT generation, owner_token, lease_expires_at FROM coordination_lease
+			 WHERE namespace = ? AND entity_key = ?`).get(input.namespace, input.entityKey);
+    if (row && input.generation < row.generation)
+      return { outcome: "stale_generation" };
+    if (row && row.lease_expires_at > new Date().toISOString() && row.owner_token !== input.ownerToken) {
+      return { outcome: "held" };
+    }
+    const now = new Date().toISOString();
+    db.run(`INSERT INTO coordination_lease
+			 (namespace, entity_key, generation, owner_token, lease_expires_at, payload, updated_at)
+			 VALUES (?, ?, ?, ?, ?, ?, ?)
+			 ON CONFLICT(namespace, entity_key) DO UPDATE SET
+			 generation = excluded.generation, owner_token = excluded.owner_token,
+			 lease_expires_at = excluded.lease_expires_at, payload = excluded.payload,
+			 updated_at = excluded.updated_at`, [
+      input.namespace,
+      input.entityKey,
+      input.generation,
+      input.ownerToken,
+      input.leaseExpiresAt,
+      input.payload,
+      now
+    ]);
+    return { outcome: "acquired" };
+  });
+}
+function releaseCoordinationLease(directory, namespace, entityKey, generation, ownerToken) {
+  return withCoordinationTransaction(directory, () => {
+    const result = getProjectDb(directory).run(`DELETE FROM coordination_lease
+			 WHERE namespace = ? AND entity_key = ? AND generation = ? AND owner_token = ?`, [namespace, entityKey, generation, ownerToken]);
+    return result.changes === 1;
+  });
+}
+function importCoordinationOnce(directory, input, importer) {
+  boundedText(input.source, "source", MAX_KEY_CHARS);
+  boundedText(input.sourceDigest, "sourceDigest", MAX_KEY_CHARS);
+  boundedText(input.emptyNamespace, "emptyNamespace", MAX_KEY_CHARS);
+  if (!Number.isSafeInteger(input.rowCount) || input.rowCount < 0) {
+    throw new Error("rowCount must be a nonnegative safe integer");
+  }
+  const result = withCoordinationTransaction(directory, () => {
+    const db = getProjectDb(directory);
+    const prior = db.query("SELECT 1 AS present FROM coordination_import WHERE source = ?").get(input.source);
+    if (prior)
+      return "already_imported";
+    const count = db.query("SELECT COUNT(*) AS count FROM coordination_state WHERE namespace = ?").get(input.emptyNamespace)?.count ?? 0;
+    if (count !== 0)
+      return "state_exists";
+    importer();
+    db.run(`INSERT INTO coordination_import
+			 (source, imported_at, source_digest, row_count) VALUES (?, ?, ?, ?)`, [
+      input.source,
+      new Date().toISOString(),
+      input.sourceDigest,
+      input.rowCount
+    ]);
+    return "imported";
+  });
+  if (result === "imported") {
+    _internals.coordinationFaultInjector?.("after_commit_before_archive", getProjectDb(directory));
+  }
+  return result;
+}
+function deleteCoordinationImports(directory, sources) {
+  const boundedSources = sources.map((source) => boundedText(source, "source", MAX_KEY_CHARS));
+  if (boundedSources.length === 0 || !projectDbExists(directory))
+    return 0;
+  return withCoordinationTransaction(directory, () => {
+    const placeholders = boundedSources.map(() => "?").join(", ");
+    const result = getProjectDb(directory).run(`DELETE FROM coordination_import WHERE source IN (${placeholders})`, boundedSources);
+    return result.changes;
+  });
+}
+
+// src/plan/utils.ts
+import { createHash as createHash2 } from "crypto";
+function derivePlanId(plan) {
+  return `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
+}
+function derivePlanIdentityHash(plan) {
+  return createHash2("sha256").update(JSON.stringify([plan.swarm, plan.title]), "utf8").digest("hex");
+}
+
+export { MAX_COORDINATION_STATE_LIST_ROWS, withCoordinationTransaction, getCoordinationState, listCoordinationStates, countCoordinationStates, deleteCoordinationState, deleteCoordinationStateWithinTransaction, transitionCoordinationStateWithinTransaction, transitionCoordinationState, getCoordinationLease, acquireCoordinationLease, releaseCoordinationLease, importCoordinationOnce, deleteCoordinationImports, derivePlanId, derivePlanIdentityHash };

package/dist/cli/{index-aqppaaqx.js → index-cgewrpw5.js}

@@ -21,7 +21,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.164.11",
+    version: "7.164.12",
     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",
@@ -119,6 +119,7 @@ var init_package = __esm(() => {
       "lint:ci": "biome ci .",
       "test:unit:ci": "bun scripts/ci/run-unit-tests-local.ts",
       "drift:check": "bun run scripts/drift-check.ts",
+      "check:pre-push": "bun run scripts/drift-check.ts --enforce --no-report && bun run check:registry-citations",
       "schema:generate": "bun run scripts/generate-config-schema.ts",
       "check:runtime-src-refs": "bun run scripts/check-runtime-src-refs.ts",
       "drift:fix": "bun run scripts/drift-check.ts --fix --confirm",
@@ -162,7 +163,7 @@ var init_package = __esm(() => {
       "proper-lockfile": "^4.1.2",
       "quick-lru": "^7.3.0",
       "web-tree-sitter": "^0.25.0",
-      zod: "^4.1.8"
+      zod: "4.3.6"
     },
     devDependencies: {
       "@biomejs/biome": "2.3.14",