opencode-swarm 7.119.0 → 7.120.0

package/dist/cli/index-69ms9ny1.js

@@ -0,0 +1,261 @@
+// @bun
+import {
+  cohortConfigFingerprint
+} from "./index-rtry5xyf.js";
+import {
+  readKnowledgeEvents
+} from "./index-nhgw7de8.js";
+import {
+  isLinked,
+  readLinkPointer,
+  resolveKnowledgeStoreDir,
+  resolveLinkDir
+} from "./index-3jvqw5hy.js";
+
+// src/knowledge/curation-policy.ts
+import { appendFile, mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
+import * as path2 from "path";
+
+// src/knowledge/worktree-identity.ts
+import { randomUUID } from "crypto";
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import * as path from "path";
+var WORKTREE_ID_FILENAME = "worktree-id.json";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function readValidatedId(raw) {
+  const parsed = JSON.parse(raw);
+  if (parsed && typeof parsed.worktree_id === "string" && UUID_RE.test(parsed.worktree_id)) {
+    return parsed.worktree_id;
+  }
+  return;
+}
+var _internals = {
+  readFile,
+  writeFile,
+  existsSync,
+  mkdir,
+  randomUUID
+};
+async function resolveWorktreeId(directory) {
+  const dir = path.normalize(path.resolve(directory, ".swarm"));
+  const idPath = path.join(dir, WORKTREE_ID_FILENAME);
+  let repairInvalidFile = false;
+  try {
+    if (_internals.existsSync(idPath)) {
+      const raw = await _internals.readFile(idPath, "utf-8");
+      const validated = readValidatedId(raw);
+      if (validated !== undefined) {
+        return validated;
+      }
+      repairInvalidFile = true;
+    }
+  } catch {}
+  const newId = _internals.randomUUID();
+  try {
+    await _internals.mkdir(dir, { recursive: true });
+    const record = {
+      worktree_id: newId,
+      created_at: new Date().toISOString()
+    };
+    const payload = `${JSON.stringify(record, null, 2)}
+`;
+    if (repairInvalidFile) {
+      await _internals.writeFile(idPath, payload, {
+        encoding: "utf-8",
+        flag: "w"
+      });
+    } else {
+      try {
+        await _internals.writeFile(idPath, payload, {
+          encoding: "utf-8",
+          flag: "wx"
+        });
+      } catch (err) {
+        if (err?.code === "EEXIST" || _internals.existsSync(idPath)) {
+          const raw = await _internals.readFile(idPath, "utf-8");
+          const validated = readValidatedId(raw);
+          if (validated !== undefined) {
+            return validated;
+          }
+        }
+        throw err;
+      }
+    }
+  } catch {}
+  return newId;
+}
+
+// src/knowledge/curation-policy.ts
+var DEFAULT_QUORUM = { minCohortEvidence: 3 };
+async function authorizeCuration(input, context, quorum = DEFAULT_QUORUM) {
+  const { directory, action, entryId } = input;
+  const proposal = {
+    entryId,
+    action,
+    reason: input.reason,
+    evidenceScope: input.evidenceScope,
+    proposedAt: new Date().toISOString(),
+    status: "pending"
+  };
+  const persistProposal = (p) => {
+    queueMicrotask(async () => {
+      try {
+        const storeDir = _internals2.resolveKnowledgeStoreDir(directory);
+        await mkdir2(storeDir, { recursive: true });
+        await appendFile(path2.join(storeDir, "curation-proposals.jsonl"), `${JSON.stringify(p)}
+`, "utf-8");
+      } catch {}
+    });
+  };
+  const linked = _internals2.isLinked(directory);
+  if (linked) {
+    const currentFp = _internals2.cohortConfigFingerprint(buildConfigFingerprintInput(context.config));
+    const cohortFp = await _internals2.readCohortConfigFingerprint(directory);
+    if (cohortFp !== null && currentFp !== cohortFp) {
+      persistProposal(proposal);
+      return {
+        authorized: false,
+        basis: "config-mismatch",
+        detail: `Cohort config fingerprint mismatch: this worktree (${currentFp}) differs ` + `from the cohort (${cohortFp}). Cohort members will curate with different ` + `semantics. Align knowledge config across linked worktrees before destructive ` + `curation.`,
+        proposal
+      };
+    }
+  }
+  const entry = context.entry;
+  if (!entry) {
+    persistProposal(proposal);
+    return {
+      authorized: false,
+      basis: "entry-not-found",
+      detail: `Entry ${entryId} not found in the store.`,
+      proposal
+    };
+  }
+  if (input.override?.actor === "manual-override" && input.override.reason) {
+    return {
+      authorized: true,
+      basis: "override",
+      detail: `Operator override: ${input.override.reason}`,
+      expectedRevision: entry.revision,
+      expectedContentHash: entry.content_hash
+    };
+  }
+  if (!linked) {
+    return {
+      authorized: true,
+      basis: "config-skipped-unlinked",
+      detail: `Worktree is not cohort-linked; local curation is permitted ` + `(no cross-worktree safety concern).`,
+      expectedRevision: entry.revision,
+      expectedContentHash: entry.content_hash
+    };
+  }
+  if (entry.producer == null) {
+    persistProposal(proposal);
+    return {
+      authorized: false,
+      basis: "protected-unknown-owner",
+      detail: `Entry ${entryId} has no producer provenance (legacy). Destructive ` + `action is protected by default; recorded as a proposal. An audited ` + `override is required to force it.`,
+      proposal
+    };
+  }
+  const actorWorktreeId = input.actorWorktreeId ?? await _internals2.resolveWorktreeId(directory);
+  if (entry.producer.worktree_id === actorWorktreeId) {
+    return {
+      authorized: true,
+      basis: "owner",
+      detail: `Acting worktree is the proven producer of entry ${entryId}; ` + `owner-scoped ${input.evidenceScope} evidence authorized.`,
+      expectedRevision: entry.revision,
+      expectedContentHash: entry.content_hash
+    };
+  }
+  if (input.evidenceScope === "local-session") {
+    persistProposal(proposal);
+    return {
+      authorized: false,
+      basis: "not-owner-local-evidence",
+      detail: `Entry ${entryId} is owned by worktree ${entry.producer.worktree_id}; ` + `the acting worktree (${actorWorktreeId}) has only local-session ` + `evidence. Absence of local evidence is not negative evidence; ` + `recorded as a proposal. Use cohort-wide evidence or an override.`,
+      proposal
+    };
+  }
+  if (input.evidenceScope === "cohort-wide") {
+    const events = await _internals2.readKnowledgeEvents(directory);
+    const NEGATIVE_EVENT_TYPES = new Set(["violated", "contradicted"]);
+    const entryEvents = events.filter((e) => ("type" in e) && NEGATIVE_EVENT_TYPES.has(e.type ?? "") && ("knowledge_id" in e) && e.knowledge_id === entryId);
+    const cohortEvidence = entryEvents.length;
+    if (cohortEvidence >= quorum.minCohortEvidence) {
+      return {
+        authorized: true,
+        basis: "quorum",
+        detail: `Cohort quorum met for entry ${entryId}: ${cohortEvidence} ` + `cohort-wide evidence events (\u2265 ${quorum.minCohortEvidence} required).`,
+        expectedRevision: entry.revision,
+        expectedContentHash: entry.content_hash
+      };
+    }
+    persistProposal(proposal);
+    return {
+      authorized: false,
+      basis: "quorum-insufficient",
+      detail: `Cohort quorum NOT met for entry ${entryId}: ${cohortEvidence} ` + `cohort-wide evidence events (< ${quorum.minCohortEvidence} required).`,
+      proposal
+    };
+  }
+  persistProposal(proposal);
+  return {
+    authorized: false,
+    basis: "not-owner-local-evidence",
+    detail: `Entry ${entryId} is owned by worktree ${entry.producer.worktree_id}; ` + `the acting worktree (${actorWorktreeId}) is not the producer and ` + `has not supplied cohort-wide quorum evidence.`,
+    proposal
+  };
+}
+function buildConfigFingerprintInput(config) {
+  return {
+    dedup_threshold: config.dedup_threshold,
+    scope_filter: config.scope_filter,
+    validation_enabled: config.validation_enabled,
+    evergreen_confidence: config.evergreen_confidence,
+    evergreen_utility: config.evergreen_utility,
+    low_utility_threshold: config.low_utility_threshold,
+    default_max_phases: config.default_max_phases,
+    todo_max_phases: config.todo_max_phases,
+    confidence_floor_action: config.confidence_floor_action,
+    contradiction_threshold_action: config.contradiction_threshold_action,
+    contradiction_quarantine_threshold: config.contradiction_quarantine_threshold,
+    schema_version: config.schema_version,
+    swarm_max_entries: config.swarm_max_entries,
+    retrieval: {
+      mmr_lambda: config.retrieval?.mmr_lambda,
+      cold_start_bonus: config.retrieval?.cold_start_bonus,
+      synonym_min_cooccurrence: config.retrieval?.synonym_min_cooccurrence
+    }
+  };
+}
+async function readCohortConfigFingerprint(directory) {
+  if (!_internals2.isLinked(directory))
+    return null;
+  const pointer = _internals2.readLinkPointer(directory);
+  if (!pointer?.linkId)
+    return null;
+  const linkDir = _internals2.resolveLinkDir(pointer.linkId);
+  const cohortConfigPath = path2.join(linkDir, "cohort-config.json");
+  try {
+    const raw = await _internals2.readFile(cohortConfigPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.fingerprint === "string" ? parsed.fingerprint : null;
+  } catch {
+    return null;
+  }
+}
+var _internals2 = {
+  resolveWorktreeId,
+  readKnowledgeEvents,
+  cohortConfigFingerprint,
+  readCohortConfigFingerprint,
+  readFile: readFile2,
+  isLinked,
+  readLinkPointer,
+  resolveLinkDir,
+  resolveKnowledgeStoreDir
+};
+
+export { authorizeCuration, buildConfigFingerprintInput, readCohortConfigFingerprint, _internals2 as _internals };

package/dist/cli/{index-42cx6g2h.js → index-76kvm9z5.js}

@@ -4,7 +4,7 @@ import {
 } from "./index-q2rrv0cy.js";
 import {
   require_proper_lockfile
-} from "./index-vvk2g744.js";
+} from "./index-7g4c7s5r.js";
 import {
   __toESM
 } from "./index-a76rekgs.js";

package/dist/cli/{index-r2ysfdet.js → index-78b192v7.js}

@@ -2,21 +2,21 @@
 import {
   ALLOWED_SKILL_PATH_PREFIXES,
   validateSkillPath
-} from "./index-pjhfe7c3.js";
-import {
-  effectiveRetrievalOutcomes,
-  readKnowledgeCounterRollups
-} from "./index-5hze8ztj.js";
+} from "./index-3366gs26.js";
 import {
   computeOutcomeSignal,
   readKnowledge,
   resolveHiveKnowledgePath,
   resolveSwarmKnowledgePath,
   transactKnowledge
-} from "./index-qx5z58a7.js";
+} from "./index-rywkdacj.js";
+import {
+  effectiveRetrievalOutcomes,
+  readKnowledgeCounterRollups
+} from "./index-nhgw7de8.js";
 import {
   isActiveStatus
-} from "./index-bfwt3abw.js";
+} from "./index-4rhcth7a.js";
 import {
   advisoryWarn
 } from "./index-ye3fndsw.js";

package/dist/cli/{index-vwvkpg0d.js → index-816rkp4y.js}

@@ -1,104 +1,15 @@
 // @bun
+import {
+  validateSpecContent
+} from "./index-gnp9x6se.js";
 import {
   advisoryWarn
 } from "./index-ye3fndsw.js";
-import {
-  exports_external
-} from "./index-293f68mj.js";
 
 // src/sdd/effective-spec.ts
 import { createHash } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
-
-// src/config/spec-schema.ts
-var ObligationSchema = exports_external.enum(["MUST", "SHALL", "SHOULD", "MAY"]);
-var SpecRequirementSchema = exports_external.object({
-  id: exports_external.string().regex(/^FR-(?!000)\d{3}$/, "Requirement ID must match FR-### pattern (e.g., FR-001)"),
-  obligation: ObligationSchema,
-  text: exports_external.string().min(1)
-});
-var SpecScenarioSchema = exports_external.object({
-  name: exports_external.string().min(1),
-  given: exports_external.array(exports_external.string()).optional().default([]),
-  when: exports_external.array(exports_external.string()).min(1, 'Scenario must have at least one "when" clause'),
-  thenClauses: exports_external.array(exports_external.string()).min(1, 'Scenario must have at least one "then" clause')
-});
-var SpecSectionSchema = exports_external.object({
-  name: exports_external.string().min(1),
-  requirements: exports_external.array(SpecRequirementSchema).default([])
-});
-var SwarmSpecSchema = exports_external.object({
-  title: exports_external.string().min(1),
-  purpose: exports_external.string().min(1),
-  sections: exports_external.array(SpecSectionSchema).min(1, "Spec must have at least one section")
-});
-var SpecDeltaSchema = exports_external.object({
-  added: exports_external.array(SpecRequirementSchema).default([]),
-  modified: exports_external.array(SpecRequirementSchema).default([]),
-  removed: exports_external.array(SpecRequirementSchema).default([])
-});
-var DeltaSpecSchema = exports_external.union([
-  SwarmSpecSchema,
-  SpecDeltaSchema
-]);
-var FENCED_BLOCK_PATTERN = /```[\s\S]*?```/g;
-var INLINE_CODE_PATTERN = /`[^`]*`/g;
-var FR_ID_PATTERN = /\bFR-\d{3}\b/g;
-var OBLIGATION_PATTERN = /\b(MUST|SHALL|SHOULD|MAY)\b/g;
-var SECTION_HEADER_PATTERN = /^##\s+.+$/gm;
-function stripCodeBlocks(content) {
-  return content.replace(FENCED_BLOCK_PATTERN, "").replace(INLINE_CODE_PATTERN, "");
-}
-function getLineNumber(content, position) {
-  const prefix = content.substring(0, position);
-  return (prefix.match(/\n/g) || []).length + 1;
-}
-function validateSpecContent(content) {
-  const issues = [];
-  if (!content || content.trim().length === 0) {
-    return { valid: false, issues: [{ line: 1, message: "Content is empty" }] };
-  }
-  const strippedContent = stripCodeBlocks(content);
-  const frMatches = strippedContent.match(FR_ID_PATTERN);
-  if (!frMatches || frMatches.length === 0) {
-    issues.push({
-      line: 1,
-      message: "No FR-### requirement IDs found in spec content"
-    });
-  }
-  const obligationMatches = strippedContent.match(OBLIGATION_PATTERN);
-  if (!obligationMatches || obligationMatches.length === 0) {
-    issues.push({
-      line: 1,
-      message: "No obligation keywords (MUST, SHALL, SHOULD, MAY) found in spec content"
-    });
-  }
-  const sectionMatches = strippedContent.match(SECTION_HEADER_PATTERN);
-  if (!sectionMatches || sectionMatches.length === 0) {
-    issues.push({
-      line: 1,
-      message: "No section headers (## Section Name) found in spec content"
-    });
-  }
-  const idMatches = strippedContent.matchAll(/\bFR-(\d{3})\b/g);
-  for (const idMatch of idMatches) {
-    const num = parseInt(idMatch[1], 10);
-    if (num === 0) {
-      const pos = idMatch.index;
-      issues.push({
-        line: getLineNumber(strippedContent, pos),
-        message: `Invalid FR-ID "${idMatch[0]}" \u2014 number must be 001-999`
-      });
-    }
-  }
-  return {
-    valid: issues.length === 0,
-    issues
-  };
-}
-
-// src/sdd/effective-spec.ts
 var SWARM_SPEC_REL = path.join(".swarm", "spec.md");
 var OPENSPEC_ROOT = "openspec";
 var SPECKIT_MARKER = ".specify";

package/dist/cli/index-89s4mhmw.js

@@ -0,0 +1,6 @@
+// @bun
+import {
+  require_proper_lockfile
+} from "./index-7g4c7s5r.js";
+import"./index-a76rekgs.js";
+export default require_proper_lockfile();