opencode-swarm 7.164.11 → 7.164.13

package/dist/cli/index-6m24v15v.js

@@ -0,0 +1,429 @@
+// @bun
+import {
+  derivePlanId,
+  derivePlanIdentityHash
+} from "./index-e45htt92.js";
+import {
+  DURABILITY_CLASSES,
+  getProjectDb,
+  projectDbExists,
+  withImmediateTransaction
+} from "./index-w6988bbc.js";
+import {
+  init_logger,
+  warn
+} from "./index-zgwm4ryv.js";
+// src/db/qa-gate-profile.ts
+import { createHash } from "crypto";
+
+// src/qa-gate/recovery.ts
+function formatLegacyQaBindingOnlyCall(identity) {
+  return `set_qa_gates({ swarm_id: ${JSON.stringify(identity.swarm)}, plan_title: ${JSON.stringify(identity.title)}, adopt_legacy_binding_only: true })`;
+}
+function formatLegacyQaBindingRecovery(identity, retryAction) {
+  return `Run ${formatLegacyQaBindingOnlyCall(identity)} from the current persisted plan identity to exact-bind the existing QA profile without changing gates or its lock, then ${retryAction}.`;
+}
+
+// src/db/qa-gate-profile.ts
+init_logger();
+var _internals = {
+  getProfile,
+  getProfileLookupForIdentity,
+  getProfileForIdentity,
+  getOrCreateProfile,
+  getOrCreateProfileForIdentity,
+  setGates,
+  setGatesForIdentity,
+  lockProfileForIdentity,
+  getEffectiveGates,
+  computeProfileHash,
+  hasAnyProfileWithEnabledGate,
+  afterSetGatesRead: () => {},
+  lastTxnSynchronous: -1
+};
+var DEFAULT_QA_GATES = {
+  reviewer: true,
+  test_engineer: true,
+  council_mode: false,
+  sme_enabled: true,
+  critic_pre_plan: true,
+  hallucination_guard: false,
+  sast_enabled: true,
+  mutation_test: false,
+  phase_council: false,
+  drift_check: true,
+  final_council: false
+};
+
+class QaGateProfileIdentityUnboundError extends Error {
+  identity;
+  constructor(identity) {
+    super(`QA gate profile exists for readable plan_id='${identity.planId}' but is not exact-bound to swarm_id='${identity.swarm}' and plan_title='${identity.title}'. ${formatLegacyQaBindingRecovery(identity, "retry the blocked read-only or enforcement operation")}`);
+    this.name = "QaGateProfileIdentityUnboundError";
+    this.identity = identity;
+  }
+}
+function buildProfileIdentity(identity) {
+  return {
+    swarm: identity.swarm,
+    title: identity.title,
+    planId: derivePlanId(identity),
+    identityHash: derivePlanIdentityHash(identity)
+  };
+}
+function withImmediateTransaction2(db, fn) {
+  return withImmediateTransaction(db, DURABILITY_CLASSES.qa_gate_profile, fn, {
+    beforeOuterCommit: (connection) => {
+      _internals.lastTxnSynchronous = connection.query("PRAGMA synchronous").get()?.synchronous ?? -1;
+    }
+  });
+}
+function rowToProfile(row) {
+  return rowToProfileWithBinding(row);
+}
+function rowToProfileWithBinding(row, binding) {
+  let parsed = {};
+  try {
+    const maybeGates = JSON.parse(row.gates);
+    if (maybeGates && typeof maybeGates === "object" && !Array.isArray(maybeGates)) {
+      parsed = maybeGates;
+    }
+  } catch {
+    parsed = {};
+  }
+  const raw = parsed;
+  if (raw.council_mode === true && raw.phase_council === undefined) {
+    parsed.phase_council = true;
+    parsed.council_mode = false;
+  }
+  const knownKeys = new Set(Object.keys(DEFAULT_QA_GATES));
+  const filteredParsed = {};
+  for (const key of Object.keys(parsed)) {
+    if (knownKeys.has(key) && typeof parsed[key] === "boolean") {
+      filteredParsed[key] = parsed[key];
+    }
+  }
+  const gates = { ...DEFAULT_QA_GATES, ...filteredParsed };
+  return {
+    id: row.id,
+    plan_id: binding?.readable_plan_id ?? row.plan_id,
+    created_at: row.created_at,
+    project_type: row.project_type,
+    gates,
+    locked_at: row.locked_at,
+    locked_by_snapshot_seq: row.locked_by_snapshot_seq,
+    raw_swarm: binding?.raw_swarm ?? row.raw_swarm,
+    raw_title: binding?.raw_title ?? row.raw_title,
+    identity_hash: binding?.identity_hash ?? row.identity_hash
+  };
+}
+function readProfileRowByPlanId(db, planId) {
+  return db.query("SELECT * FROM qa_gate_profile WHERE plan_id = ?").get(planId) ?? null;
+}
+function readProfileRowById(db, id) {
+  return db.query("SELECT * FROM qa_gate_profile WHERE id = ?").get(id) ?? null;
+}
+function readIdentityBindingByHash(db, identityHash) {
+  return db.query("SELECT * FROM qa_gate_profile_identity WHERE identity_hash = ?").get(identityHash) ?? null;
+}
+function readUnboundLegacyProfileRowByReadablePlanId(db, readablePlanId) {
+  return db.query(`SELECT p.*
+				FROM qa_gate_profile AS p
+				LEFT JOIN qa_gate_profile_identity AS qi
+					ON qi.profile_id = p.id
+				WHERE p.plan_id = ?
+					AND qi.profile_id IS NULL
+				LIMIT 1`).get(readablePlanId) ?? null;
+}
+function buildExactStoragePlanId(identityHash) {
+  return `qa2-${identityHash}`;
+}
+function hasAnyGatePatch(gates) {
+  return Object.values(gates).some((value) => value !== undefined);
+}
+function verifyBoundIdentityBinding(binding, identity) {
+  if (binding.identity_hash !== identity.identityHash || binding.raw_swarm !== identity.swarm || binding.raw_title !== identity.title || binding.readable_plan_id !== identity.planId) {
+    throw new Error(`QA gate profile identity binding is corrupt for swarm_id='${identity.swarm}' and plan_title='${identity.title}'`);
+  }
+}
+function lookupProfileForIdentityTx(db, identity) {
+  const binding = readIdentityBindingByHash(db, identity.identityHash);
+  if (binding) {
+    verifyBoundIdentityBinding(binding, identity);
+    const row = readProfileRowById(db, binding.profile_id);
+    if (!row) {
+      throw new Error(`QA gate profile identity binding points to missing profile_id=${binding.profile_id}`);
+    }
+    return {
+      kind: "bound",
+      identity,
+      profile: rowToProfileWithBinding(row, binding)
+    };
+  }
+  const legacyRow = readUnboundLegacyProfileRowByReadablePlanId(db, identity.planId);
+  if (legacyRow) {
+    return {
+      kind: "unbound_legacy",
+      identity,
+      profile: rowToProfile(legacyRow)
+    };
+  }
+  return {
+    kind: "missing",
+    identity
+  };
+}
+function createExactIdentityBindingTx(db, profileId, identity) {
+  db.run("INSERT INTO qa_gate_profile_identity (identity_hash, profile_id, raw_swarm, raw_title, readable_plan_id) VALUES (?, ?, ?, ?, ?)", [
+    identity.identityHash,
+    profileId,
+    identity.swarm,
+    identity.title,
+    identity.planId
+  ]);
+}
+function createExactProfileTx(db, identity, projectType, initialGates) {
+  const gatesJson = JSON.stringify({ ...DEFAULT_QA_GATES, ...initialGates });
+  db.run("INSERT INTO qa_gate_profile (plan_id, project_type, gates) VALUES (?, ?, ?)", [
+    buildExactStoragePlanId(identity.identityHash),
+    projectType ?? null,
+    gatesJson
+  ]);
+  const row = readProfileRowByPlanId(db, buildExactStoragePlanId(identity.identityHash));
+  if (!row) {
+    throw new Error(`Failed to create QA gate profile row for exact identity plan_id=${identity.planId}`);
+  }
+  createExactIdentityBindingTx(db, row.id, identity);
+  const binding = readIdentityBindingByHash(db, identity.identityHash);
+  if (!binding) {
+    throw new Error(`Failed to create QA gate profile identity binding for plan_id=${identity.planId}`);
+  }
+  return rowToProfileWithBinding(row, binding);
+}
+function shouldAdoptLegacyProfile(identity, options) {
+  if (options.allowLegacyAdoption !== true) {
+    return false;
+  }
+  return options.legacyAdoptionIdentity?.swarm === identity.swarm && options.legacyAdoptionIdentity?.title === identity.title;
+}
+function getProfile(directory, planId) {
+  if (!projectDbExists(directory))
+    return null;
+  const db = getProjectDb(directory);
+  const row = readProfileRowByPlanId(db, planId);
+  return row ? rowToProfile(row) : null;
+}
+function getProfileForIdentity(directory, identity) {
+  const lookup = getProfileLookupForIdentity(directory, identity);
+  if (lookup.kind === "bound") {
+    return lookup.profile;
+  }
+  if (lookup.kind === "unbound_legacy") {
+    throw new QaGateProfileIdentityUnboundError(lookup.identity);
+  }
+  return null;
+}
+function getProfileLookupForIdentity(directory, identity) {
+  const exact = buildProfileIdentity(identity);
+  if (!projectDbExists(directory)) {
+    return {
+      kind: "missing",
+      identity: exact
+    };
+  }
+  const db = getProjectDb(directory);
+  return lookupProfileForIdentityTx(db, exact);
+}
+function hasAnyProfileWithEnabledGate(directory, gate) {
+  if (!projectDbExists(directory))
+    return false;
+  const db = getProjectDb(directory);
+  const rows = db.query("SELECT gates FROM qa_gate_profile").all();
+  for (const row of rows) {
+    try {
+      const parsed = JSON.parse(row.gates);
+      if (parsed?.[gate] === true)
+        return true;
+    } catch (err) {
+      warn(`[qa-gate-profile] skipping unparseable qa_gate_profile row while checking gate "${gate}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return false;
+}
+function getOrCreateProfile(directory, planId, projectType, initialGates = {}) {
+  const existing = _internals.getProfile(directory, planId);
+  if (existing)
+    return existing;
+  const db = getProjectDb(directory);
+  const seededGates = { ...DEFAULT_QA_GATES };
+  for (const key of Object.keys(DEFAULT_QA_GATES)) {
+    if (typeof initialGates[key] === "boolean") {
+      seededGates[key] = initialGates[key];
+    }
+  }
+  const gatesJson = JSON.stringify(seededGates);
+  try {
+    withImmediateTransaction2(db, () => {
+      db.run("INSERT INTO qa_gate_profile (plan_id, project_type, gates) VALUES (?, ?, ?)", [planId, projectType ?? null, gatesJson]);
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (!msg.toLowerCase().includes("unique")) {
+      throw err;
+    }
+  }
+  const after = _internals.getProfile(directory, planId);
+  if (!after) {
+    throw new Error(`Failed to create or load QA gate profile for plan_id=${planId}`);
+  }
+  return after;
+}
+function getOrCreateProfileForIdentity(directory, identity, projectType, initialGates = {}) {
+  const db = getProjectDb(directory);
+  const exact = buildProfileIdentity(identity);
+  return withImmediateTransaction2(db, () => {
+    const lookup = lookupProfileForIdentityTx(db, exact);
+    if (lookup.kind === "bound") {
+      return lookup.profile;
+    }
+    return createExactProfileTx(db, exact, projectType, initialGates);
+  });
+}
+function setGates(directory, planId, gates) {
+  const db = getProjectDb(directory);
+  return withImmediateTransaction2(db, () => {
+    const currentRow = db.query("SELECT * FROM qa_gate_profile WHERE plan_id = ?").get(planId);
+    if (!currentRow) {
+      throw new Error(`No QA gate profile found for plan_id=${planId} \u2014 call getOrCreateProfile first`);
+    }
+    const current = rowToProfile(currentRow);
+    if (current.locked_at !== null) {
+      throw new Error("Cannot modify gates: QA gate profile is locked after critic approval");
+    }
+    _internals.afterSetGatesRead(current);
+    const merged = { ...current.gates };
+    for (const key of Object.keys(gates)) {
+      const incoming = gates[key];
+      if (incoming === undefined)
+        continue;
+      if (incoming === false && current.gates[key] === true) {
+        throw new Error(`Cannot disable gate '${key}': sessions can only ratchet tighter`);
+      }
+      if (incoming === true) {
+        merged[key] = true;
+      }
+    }
+    db.run("UPDATE qa_gate_profile SET gates = ? WHERE plan_id = ?", [
+      JSON.stringify(merged),
+      planId
+    ]);
+    const updatedRow = db.query("SELECT * FROM qa_gate_profile WHERE plan_id = ?").get(planId);
+    if (!updatedRow) {
+      throw new Error(`Failed to re-read QA gate profile after update for plan_id=${planId}`);
+    }
+    return rowToProfile(updatedRow);
+  });
+}
+function setGatesForIdentity(directory, identity, gates, options = {}) {
+  const db = getProjectDb(directory);
+  const exact = buildProfileIdentity(identity);
+  return withImmediateTransaction2(db, () => {
+    let lookup = lookupProfileForIdentityTx(db, exact);
+    if (lookup.kind === "missing") {
+      return createExactProfileTx(db, exact, options.projectType, gates);
+    }
+    if (lookup.kind === "unbound_legacy") {
+      if (shouldAdoptLegacyProfile(exact, options)) {
+        createExactIdentityBindingTx(db, lookup.profile.id, exact);
+        lookup = lookupProfileForIdentityTx(db, exact);
+        if (lookup.kind !== "bound") {
+          throw new Error(`Failed to adopt legacy QA gate profile for exact identity plan_id=${exact.planId}`);
+        }
+      } else if (options.allowLegacyCollisionCreate === true) {
+        return createExactProfileTx(db, exact, options.projectType, gates);
+      } else {
+        throw new QaGateProfileIdentityUnboundError(lookup.identity);
+      }
+    }
+    const current = lookup.profile;
+    const currentRow = readProfileRowById(db, current.id);
+    if (!currentRow) {
+      throw new Error(`Failed to read QA gate profile row for profile_id=${current.id}`);
+    }
+    _internals.afterSetGatesForIdentityRead?.({
+      directory,
+      identity: exact,
+      profileId: current.id,
+      storagePlanId: currentRow.plan_id
+    });
+    if (current.locked_at !== null) {
+      if (!hasAnyGatePatch(gates)) {
+        return current;
+      }
+      throw new Error("Cannot modify gates: QA gate profile is locked after critic approval");
+    }
+    const merged = { ...current.gates };
+    for (const key of Object.keys(gates)) {
+      const incoming = gates[key];
+      if (incoming === undefined)
+        continue;
+      if (incoming === false && current.gates[key] === true) {
+        throw new Error(`Cannot disable gate '${key}': sessions can only ratchet tighter`);
+      }
+      if (incoming === true) {
+        merged[key] = true;
+      }
+    }
+    db.run("UPDATE qa_gate_profile SET gates = ? WHERE id = ?", [
+      JSON.stringify(merged),
+      current.id
+    ]);
+    const updatedRow = readProfileRowById(db, current.id);
+    const binding = readIdentityBindingByHash(db, exact.identityHash);
+    if (!updatedRow || !binding) {
+      throw new Error(`Failed to re-read QA gate profile after exact-identity update for plan_id=${exact.planId}`);
+    }
+    return rowToProfileWithBinding(updatedRow, binding);
+  });
+}
+function lockProfileForIdentity(directory, identity, snapshotSeq) {
+  const db = getProjectDb(directory);
+  const exact = buildProfileIdentity(identity);
+  return withImmediateTransaction2(db, () => {
+    const lookup = lookupProfileForIdentityTx(db, exact);
+    if (lookup.kind === "missing") {
+      throw new Error(`No QA gate profile found for exact identity plan_id=${exact.planId} \u2014 cannot lock`);
+    }
+    if (lookup.kind === "unbound_legacy") {
+      throw new QaGateProfileIdentityUnboundError(lookup.identity);
+    }
+    if (lookup.profile.locked_at !== null) {
+      return lookup.profile;
+    }
+    db.run("UPDATE qa_gate_profile SET locked_at = datetime('now'), locked_by_snapshot_seq = ? WHERE id = ?", [snapshotSeq, lookup.profile.id]);
+    const updatedRow = readProfileRowById(db, lookup.profile.id);
+    const binding = readIdentityBindingByHash(db, exact.identityHash);
+    if (!updatedRow || !binding) {
+      throw new Error(`Failed to re-read locked QA gate profile for exact identity plan_id=${exact.planId}`);
+    }
+    return rowToProfileWithBinding(updatedRow, binding);
+  });
+}
+function computeProfileHash(profile) {
+  const payload = JSON.stringify({
+    plan_id: profile.plan_id,
+    identity_hash: profile.identity_hash,
+    gates: profile.gates
+  });
+  return createHash("sha256").update(payload).digest("hex");
+}
+function getEffectiveGates(profile, sessionOverrides) {
+  const merged = { ...profile.gates };
+  for (const key of Object.keys(sessionOverrides)) {
+    if (sessionOverrides[key] === true) {
+      merged[key] = true;
+    }
+  }
+  return merged;
+}
+export { formatLegacyQaBindingOnlyCall, DEFAULT_QA_GATES, getProfileLookupForIdentity, setGatesForIdentity, computeProfileHash, getEffectiveGates };

package/dist/cli/{index-vdn32nws.js → index-6rx1rdaq.js}

@@ -1,10 +1,10 @@
 // @bun
-import {
-  atomicWriteFile
-} from "./index-xnb3tk7x.js";
 import {
   canonicalRootKeyFresh
 } from "./index-7qefgq4j.js";
+import {
+  atomicWriteFile
+} from "./index-jre6tm3v.js";
 import {
   init_logger,
   warn

package/dist/cli/{index-x43debgx.js → index-74514zkh.js}

@@ -2,18 +2,27 @@
 import {
   autoCommitDirty,
   cleanUntrackedFiles
-} from "./index-4vb6qa73.js";
+} from "./index-5h60rtaa.js";
+import {
+  validateSwarmPath
+} from "./index-anxs69ad.js";
+import {
+  bunSpawn,
+  classifySpawnFailure
+} from "./index-p612v1mv.js";
 import {
   isPathWithinDeclaredScope,
   unsafePathTextReason
 } from "./index-556ja8an.js";
 import {
-  validateSwarmPath
-} from "./index-zjg4chy2.js";
+  assertProjectRoot,
+  atomicWriteFile,
+  taskEvidencePath,
+  withTaskEvidenceLock
+} from "./index-jre6tm3v.js";
 import {
-  bunSpawn,
-  classifySpawnFailure
-} from "./index-r3mvsbtq.js";
+  telemetry
+} from "./index-5ebgzb5a.js";
 import {
   init_git_executable,
   resolveGitExecutable
@@ -22,17 +31,6 @@ import {
   advisoryWarn,
   init_warning_buffer
 } from "./index-4rhhvd1a.js";
-import {
-  atomicWriteFile,
-  taskEvidencePath,
-  withTaskEvidenceLock
-} from "./index-xnb3tk7x.js";
-import {
-  assertProjectRoot
-} from "./index-2bgr671r.js";
-import {
-  telemetry
-} from "./index-ww6zm5hr.js";
 import {
   exports_external,
   init_zod

package/dist/cli/{index-1ww7wj8d.js → index-7f2r3ysr.js}

@@ -1,22 +1,29 @@
 // @bun
-import {
-  ALLOWED_SKILL_PATH_PREFIXES,
-  validateSkillPath
-} from "./index-kc2tgcm7.js";
 import {
   withTimeoutSignal
 } from "./index-q7sjgr1y.js";
+import {
+  effectiveRetrievalOutcomes,
+  readAuthoritativeKnowledgeCounterRollups
+} from "./index-qtxevgdx.js";
+import {
+  ALLOWED_SKILL_PATH_PREFIXES,
+  validateSkillPath
+} from "./index-7z9zqxqt.js";
 import {
   computeOutcomeSignal,
   readKnowledge,
   resolveHiveKnowledgePath,
   resolveSwarmKnowledgePath,
   transactKnowledge
-} from "./index-qbw3yw2d.js";
+} from "./index-grn6tkbt.js";
 import {
-  effectiveRetrievalOutcomes,
-  readAuthoritativeKnowledgeCounterRollups
-} from "./index-ggrp3v00.js";
+  canonicalRootKeyFresh
+} from "./index-7qefgq4j.js";
+import {
+  atomicWriteFileAnyRoot,
+  atomicWriteSwarmFile
+} from "./index-gy0nyfbw.js";
 import {
   advisoryWarn,
   init_warning_buffer
@@ -25,13 +32,6 @@ import {
   init_knowledge_types,
   isActiveStatus
 } from "./index-bk5tah7q.js";
-import {
-  canonicalRootKeyFresh
-} from "./index-7qefgq4j.js";
-import {
-  atomicWriteFileAnyRoot,
-  atomicWriteSwarmFile
-} from "./index-9gxbjkts.js";
 import {
   init_logger,
   log,
@@ -73,7 +73,7 @@ var BUNDLED_PROJECT_SKILLS = [
   "swarm-pr-subscribe",
   "swarm-ci-monitor",
   "issue-ingest",
-  "plan",
+  "swarm-plan",
   "critic-gate",
   "execute",
   "phase-wrap",
@@ -95,7 +95,10 @@ var BUNDLED_PROJECT_SKILLS = [
   "orchestrating-subagents",
   "durable-session-state"
 ];
-var RETIRED_BUNDLED_PROJECT_SKILLS = ["resume"];
+var RETIRED_BUNDLED_PROJECT_SKILLS = [
+  "resume",
+  "plan"
+];
 var BUNDLED_PROJECT_SKILL_ROOT = ".swarm/bundled-skills";
 function bundledProjectSkillFileReference(slug) {
   return `file:${BUNDLED_PROJECT_SKILL_ROOT}/${slug}/SKILL.md`;
@@ -304,6 +307,27 @@ async function removeRetiredBundledSkillDirsAsync(skillsDir) {
           continue;
         throw err;
       }
+      const backupTarget = `${target}.retired-backup`;
+      let backupExists = true;
+      try {
+        await fsp.lstat(backupTarget);
+      } catch {
+        backupExists = false;
+      }
+      if (!backupExists) {
+        try {
+          await fsp.rename(target, backupTarget);
+          log("preserved retired bundled skill as .retired-backup", {
+            slug
+          });
+          continue;
+        } catch (renameErr) {
+          log("could not preserve retired bundled skill (continuing to removal)", {
+            slug,
+            message: renameErr instanceof Error ? renameErr.message : String(renameErr)
+          });
+        }
+      }
       await fsp.rm(target, { recursive: true, force: true });
       log("removed retired bundled skill", { slug });
     } catch (err) {

package/dist/cli/{index-kc2tgcm7.js → index-7z9zqxqt.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   authorizeCuration
-} from "./index-ggtmsm84.js";
+} from "./index-ajknebrc.js";
 import {
   findNearDuplicate,
   inferTags,
@@ -9,13 +9,13 @@ import {
   resolveSwarmKnowledgePath,
   resolveSwarmRejectedPath,
   transactKnowledge
-} from "./index-qbw3yw2d.js";
+} from "./index-grn6tkbt.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-vdn32nws.js";
+} from "./index-6rx1rdaq.js";
 import {
   atomicWriteFile
-} from "./index-xnb3tk7x.js";
+} from "./index-jre6tm3v.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";

package/dist/cli/{index-n8688d12.js → index-8bdk7124.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-zjg4chy2.js";
+} from "./index-anxs69ad.js";
 import {
   atomicWriteSwarmFileSync
-} from "./index-9gxbjkts.js";
+} from "./index-gy0nyfbw.js";
 
 // src/hooks/delegation-gate/worktree-provisioning-owner.ts
 import { createHash } from "crypto";

package/dist/cli/{index-3146wmgv.js → index-8d90gzaz.js}

@@ -4,7 +4,7 @@ import {
 } from "./index-z6xqpmqg.js";
 import {
   bunSpawnSync
-} from "./index-r3mvsbtq.js";
+} from "./index-p612v1mv.js";
 import {
   warn
 } from "./index-zgwm4ryv.js";