opencode-swarm 7.100.1 → 7.101.0

package/dist/cli/{evidence-summary-service-vgw9vw3n.js → evidence-summary-service-c4d1c2t3.js}

@@ -6,7 +6,7 @@ import {
   loadPlanJsonOnly,
   mergeDurableGateEntriesFromEvidence,
   readDurableGateEvidence
-} from "./index-3emh7rny.js";
+} from "./index-bnkd9ejn.js";
 import"./index-r8f89sm9.js";
 import"./index-9b7qp18e.js";
 import"./index-7ztmmqpt.js";

package/dist/cli/{guardrail-explain-z37rtfz4.js → guardrail-explain-ma84cj3s.js}

@@ -1,15 +1,15 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-4xqnktvr.js";
-import"./index-qvdxzjqt.js";
+} from "./index-wc8g49dp.js";
+import"./index-rmh6nqbp.js";
 import"./index-pj3a5fbt.js";
 import"./index-ydgy7vg5.js";
 import"./index-vwyjkzgs.js";
 import"./index-f7nma02k.js";
 import"./index-rpb763g8.js";
 import"./index-m0qshbr6.js";
-import"./index-3emh7rny.js";
+import"./index-bnkd9ejn.js";
 import"./index-adz3nk9b.js";
 import"./index-v4fcn4tr.js";
 import"./index-r8f89sm9.js";

package/dist/cli/{index-3emh7rny.js → index-bnkd9ejn.js}

@@ -1181,10 +1181,16 @@ function validateSpecContent(content) {
 // src/sdd/effective-spec.ts
 var SWARM_SPEC_REL = path4.join(".swarm", "spec.md");
 var OPENSPEC_ROOT = "openspec";
+var SPECKIT_MARKER = ".specify";
+var SPECKIT_SPECS_DIR = "specs";
 var MAX_SPEC_BYTES = 256 * 1024;
 var MAX_SOURCE_BYTES = 512 * 1024;
 var MAX_SPEC_FILES = 100;
 var MAX_WALK_DEPTH = 10;
+var SPECKIT_REQUIRED_SECTIONS = [
+  "## Functional Requirements",
+  "## Success Criteria"
+];
 function toPosix(relPath) {
   return relPath.split(path4.sep).join("/");
 }
@@ -1192,11 +1198,20 @@ function hash(content) {
   return createHash("sha256").update(content, "utf-8").digest("hex");
 }
 function readTextBounded(absPath) {
-  const stat = fs4.lstatSync(absPath);
+  let stat;
+  try {
+    stat = fs4.lstatSync(absPath);
+  } catch {
+    return null;
+  }
   if (!stat.isFile() || stat.size > MAX_SOURCE_BYTES) {
     return null;
   }
-  return fs4.readFileSync(absPath, "utf-8");
+  try {
+    return fs4.readFileSync(absPath, "utf-8");
+  } catch {
+    return null;
+  }
 }
 function fileArtifact(root, absPath) {
   try {
@@ -1335,10 +1350,10 @@ function parseRequirements(content, sourceRel, defaultKind) {
   }
   return requirements;
 }
-function nextFrId(used, warnings) {
+function nextFrId(used, warnings, reserved) {
   for (let n = 1;n <= 999; n++) {
     const id = `FR-${String(n).padStart(3, "0")}`;
-    if (!used.has(id)) {
+    if (!used.has(id) && !reserved?.has(id)) {
       used.add(id);
       return id;
     }
@@ -1346,8 +1361,8 @@ function nextFrId(used, warnings) {
   warnings.push("More than 999 FR identifiers are required; reusing FR-999.");
   return "FR-999";
 }
-function renderRequirement(req, used, warnings) {
-  const id = req.id && !used.has(req.id) ? req.id : nextFrId(used, warnings);
+function renderRequirement(req, used, warnings, reserved) {
+  const id = req.id && !used.has(req.id) ? req.id : nextFrId(used, warnings, reserved);
   if (req.id && req.id !== id) {
     warnings.push(`Duplicate requirement id ${req.id} in ${req.sourceRel}; generated ${id}.`);
   }
@@ -1359,7 +1374,173 @@ function renderRequirement(req, used, warnings) {
   }
   return `- ${text} _(source: ${req.sourceRel})_`;
 }
-function loadSddStatusSync(directory) {
+function detectSpeckit(directory) {
+  const root = path4.resolve(directory);
+  const markerPath = path4.join(root, SPECKIT_MARKER);
+  const markerPresent = fs4.statSync(markerPath, { throwIfNoEntry: false })?.isDirectory() ?? false;
+  if (!markerPresent) {
+    return { markerPresent: false, features: [] };
+  }
+  const specsRoot = path4.join(root, SPECKIT_SPECS_DIR);
+  if (!fs4.existsSync(specsRoot)) {
+    return { markerPresent: true, features: [] };
+  }
+  let entries;
+  try {
+    entries = fs4.readdirSync(specsRoot, { withFileTypes: true });
+  } catch {
+    return { markerPresent: true, features: [] };
+  }
+  const featureDirs = entries.filter((entry) => typeof entry?.name === "string" && !entry.isSymbolicLink() && entry.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
+  const features = [];
+  for (const entry of featureDirs) {
+    if (features.length >= MAX_SPEC_FILES)
+      break;
+    const specAbs = path4.join(specsRoot, entry.name, "spec.md");
+    let stat;
+    try {
+      stat = fs4.lstatSync(specAbs);
+    } catch {
+      continue;
+    }
+    if (!stat.isFile() || stat.size > MAX_SOURCE_BYTES)
+      continue;
+    features.push({
+      featureId: entry.name,
+      specRelPath: toPosix(path4.relative(root, specAbs))
+    });
+  }
+  return { markerPresent: true, features };
+}
+function parseSpeckitRequirements(content, sourceRel) {
+  const requirements = [];
+  const lines = content.replace(/\r\n/g, `
+`).split(`
+`);
+  let inFrSection = false;
+  for (const line of lines) {
+    if (/^##\s+/.test(line)) {
+      inFrSection = /^##\s+Functional Requirements\s*$/i.test(line);
+      continue;
+    }
+    if (!inFrSection)
+      continue;
+    if (!/^\s*[-*]\s+/.test(line))
+      continue;
+    if (!/\b(MUST|SHALL|SHOULD|MAY)\b/i.test(line))
+      continue;
+    const text = line.trim().replace(/^\s*[-*]\s+/, "");
+    const explicit = line.match(/\b(FR-(?!000)\d{3})\b/);
+    if (explicit) {
+      requirements.push({
+        id: explicit[1].toUpperCase(),
+        kind: "CURRENT",
+        title: explicit[1].toUpperCase(),
+        text,
+        sourceRel
+      });
+      continue;
+    }
+    requirements.push({
+      id: null,
+      kind: "CURRENT",
+      title: text,
+      text,
+      sourceRel
+    });
+  }
+  return requirements;
+}
+function resolveSpeckitProjection(directory, options = {}) {
+  const root = path4.resolve(directory);
+  const detection = detectSpeckit(root);
+  if (!detection.markerPresent) {
+    return { kind: "not_speckit" };
+  }
+  if (detection.features.length === 0) {
+    return { kind: "empty" };
+  }
+  let selectedFeature;
+  if (options.feature) {
+    const found = detection.features.find((f) => f.featureId === options.feature);
+    if (!found) {
+      return {
+        kind: "unknown_feature",
+        feature: options.feature,
+        available: detection.features.map((f) => f.featureId)
+      };
+    }
+    selectedFeature = found;
+  } else if (detection.features.length === 1) {
+    selectedFeature = detection.features[0];
+  } else {
+    return {
+      kind: "ambiguous",
+      features: detection.features.map((f) => f.featureId)
+    };
+  }
+  const specAbs = path4.join(root, selectedFeature.specRelPath);
+  const content = readTextBounded(specAbs);
+  if (content === null) {
+    return { kind: "zero_requirements", feature: selectedFeature.featureId };
+  }
+  const warnings = [];
+  const usedIds = new Set;
+  const requirements = parseSpeckitRequirements(content, selectedFeature.specRelPath);
+  if (requirements.length === 0) {
+    return { kind: "zero_requirements", feature: selectedFeature.featureId };
+  }
+  const reservedIds = new Set;
+  for (const req of requirements) {
+    if (req.id)
+      reservedIds.add(req.id);
+  }
+  let mtimeMs = 0;
+  try {
+    mtimeMs = fs4.lstatSync(specAbs).mtimeMs;
+  } catch {}
+  const lines = [
+    "# Specification: Effective SDD Projection",
+    "",
+    "Generated from Spec-Kit feature artifacts. Update the source artifacts, then run `/swarm sdd project` to refresh this projection.",
+    "",
+    "## Source Artifacts",
+    `- ${selectedFeature.specRelPath}`,
+    "",
+    "## Functional Requirements"
+  ];
+  for (const req of requirements) {
+    lines.push(renderRequirement(req, usedIds, warnings, reservedIds));
+  }
+  const projected = `${lines.join(`
+`)}
+`;
+  if (projected.length > MAX_SPEC_BYTES) {
+    return {
+      kind: "too_large",
+      feature: selectedFeature.featureId,
+      bytes: projected.length
+    };
+  }
+  const validation = validateSpecContent(projected);
+  if (!validation.valid) {
+    warnings.push(...validation.issues.map((issue) => `Projection line ${issue.line}: ${issue.message}`));
+  }
+  const spec = {
+    source: "speckit_projection",
+    content: projected,
+    hash: hash(projected),
+    mtime: mtimeMs > 0 ? new Date(mtimeMs).toISOString() : null,
+    sourcePaths: [selectedFeature.specRelPath],
+    warnings
+  };
+  return { kind: "ok", spec, feature: selectedFeature.featureId };
+}
+function buildSpeckitProjectionSync(directory, options = {}) {
+  const resolution = resolveSpeckitProjection(directory, options);
+  return resolution.kind === "ok" ? resolution.spec : null;
+}
+function loadSddStatusSync(directory, opts) {
   const root = path4.resolve(directory);
   const swSpecPath = path4.join(root, SWARM_SPEC_REL);
   const openSpecPath = path4.join(root, OPENSPEC_ROOT);
@@ -1369,7 +1550,7 @@ function loadSddStatusSync(directory) {
   const openSpecExists = fs4.existsSync(openSpecPath);
   const currentSpecs = walkSpecFiles(root, path4.join(OPENSPEC_ROOT, "specs"));
   const changes = listOpenSpecChanges(root);
-  const effectiveSpec = readEffectiveSpecSync(root);
+  const effectiveSpec = readEffectiveSpecSync(root, opts);
   if (openSpecExists && currentSpecs.length === 0 && changes.length === 0) {
     errors.push("openspec/ exists but contains no specs or active changes.");
   }
@@ -1493,7 +1674,7 @@ function buildOpenSpecProjectionSync(directory, options = {}) {
     warnings
   };
 }
-function readEffectiveSpecSync(directory) {
+function readEffectiveSpecSync(directory, opts) {
   const root = path4.resolve(directory);
   const swSpecPath = path4.join(root, SWARM_SPEC_REL);
   try {
@@ -1514,13 +1695,35 @@ function readEffectiveSpecSync(directory) {
       throw error2;
     }
   }
-  return buildOpenSpecProjectionSync(root);
+  if (opts?.source) {
+    switch (opts.source) {
+      case "openspec":
+        return buildOpenSpecProjectionSync(root);
+      case "speckit":
+        return buildSpeckitProjectionSync(root, { feature: opts.feature });
+      case "swarm":
+        return null;
+    }
+  }
+  const speckitDetection = detectSpeckit(root);
+  if (!speckitDetection.markerPresent) {
+    return buildOpenSpecProjectionSync(root);
+  }
+  const speckitPresent = speckitDetection.features.length > 0;
+  if (!speckitPresent) {
+    return buildOpenSpecProjectionSync(root);
+  }
+  const openspecProjection = buildOpenSpecProjectionSync(root);
+  const openspecPresent = openspecProjection !== null;
+  if (openspecPresent) {
+    console.warn("[opencode-swarm] Multiple SDD sources detected (openspec and speckit). " + "Enforcement/projection is suppressed until you disambiguate. " + "Pass --source openspec or --source speckit to select a provider.");
+    return null;
+  }
+  return buildSpeckitProjectionSync(root, { feature: opts?.feature });
 }
 function writeProjectedSpecSync(directory, options = {}) {
   const root = path4.resolve(directory);
-  const projection = buildOpenSpecProjectionSync(root, {
-    changeId: options.changeId
-  });
+  const projection = options.source === "speckit" ? buildSpeckitProjectionSync(root, { feature: options.feature }) : buildOpenSpecProjectionSync(root, { changeId: options.changeId });
   const target = path4.join(root, SWARM_SPEC_REL);
   if (!projection || options.dryRun) {
     return { written: false, projection, path: target };
@@ -1542,6 +1745,59 @@ function writeProjectedSpecSync(directory, options = {}) {
   fs4.renameSync(tmp, target);
   return { written: true, projection, archivePath, path: target };
 }
+function validateSpeckit(directory, options = {}) {
+  const root = path4.resolve(directory);
+  const resolution = resolveSpeckitProjection(root, options);
+  const problems = [];
+  if (resolution.kind !== "ok" && resolution.kind !== "zero_requirements") {
+    return { resolution, problems };
+  }
+  if (resolution.kind === "zero_requirements") {
+    problems.push(`Feature '${resolution.feature}' contains no parsable functional requirements.`);
+  }
+  const detection = detectSpeckit(root);
+  const featureEntry = detection.features.find((f) => f.featureId === resolution.feature);
+  if (!featureEntry) {
+    return { resolution, problems };
+  }
+  const specAbs = path4.join(root, featureEntry.specRelPath);
+  let specContent = null;
+  try {
+    specContent = readTextBounded(specAbs);
+  } catch {}
+  if (specContent !== null) {
+    const specLines = specContent.replace(/\r\n/g, `
+`).split(`
+`);
+    for (const requiredHeader of SPECKIT_REQUIRED_SECTIONS) {
+      if (!specLines.some((line) => line.trimEnd() === requiredHeader)) {
+        problems.push(`Missing required spec.md section: ${requiredHeader}`);
+      }
+    }
+  }
+  const tasksAbs = path4.join(path4.dirname(specAbs), "tasks.md");
+  let tasksContent = null;
+  try {
+    tasksContent = readTextBounded(tasksAbs);
+  } catch {}
+  if (tasksContent !== null) {
+    const tasksLines = tasksContent.replace(/\r\n/g, `
+`).split(`
+`);
+    for (const line of tasksLines) {
+      const taskMatch = line.match(/^\s*-\s+\[[ xX]\]\s+(T\d+)/);
+      if (!taskMatch)
+        continue;
+      const taskId = taskMatch[1];
+      const hasStoryRef = /\[US\d+\]/i.test(line);
+      const hasReqRef = /\bFR-(?!000)\d{3}\b/i.test(line);
+      if (!hasStoryRef && !hasReqRef) {
+        problems.push(`Task ${taskId} has no spec/requirement reference.`);
+      }
+    }
+  }
+  return { resolution, problems };
+}
 
 // src/utils/spec-hash.ts
 async function computeSpecHash(directory) {
@@ -3196,7 +3452,7 @@ import {
   readdirSync as readdirSync3,
   realpathSync,
   rmSync,
-  statSync
+  statSync as statSync2
 } from "fs";
 import * as fs6 from "fs/promises";
 import * as path7 from "path";
@@ -3536,11 +3792,11 @@ function validateProjectRoot(directory) {
       break;
     const parentSwarm = path7.join(parent, ".swarm");
     try {
-      if (statSync(parentSwarm).isDirectory()) {
+      if (statSync2(parentSwarm).isDirectory()) {
         let hasProjectIndicator = false;
         for (const indicator of PROJECT_INDICATORS) {
           try {
-            const indicatorStat = statSync(path7.join(parent, indicator));
+            const indicatorStat = statSync2(path7.join(parent, indicator));
             if (indicatorStat.isFile() || indicatorStat.isDirectory()) {
               hasProjectIndicator = true;
               break;
@@ -3716,7 +3972,7 @@ async function loadEvidence(directory, taskId) {
 async function listEvidenceTaskIds(directory) {
   const evidenceBasePath = validateSwarmPath(directory, "evidence");
   try {
-    statSync(evidenceBasePath);
+    statSync2(evidenceBasePath);
   } catch {
     return [];
   }
@@ -3730,7 +3986,7 @@ async function listEvidenceTaskIds(directory) {
   for (const entry of entries) {
     const entryPath = path7.join(evidenceBasePath, entry);
     try {
-      const stats = statSync(entryPath);
+      const stats = statSync2(entryPath);
       if (!stats.isDirectory()) {
         continue;
       }
@@ -3749,7 +4005,7 @@ async function deleteEvidence(directory, taskId) {
   const relativePath = path7.join("evidence", sanitizedTaskId);
   const evidenceDir = validateSwarmPath(directory, relativePath);
   try {
-    statSync(evidenceDir);
+    statSync2(evidenceDir);
   } catch {
     return false;
   }
@@ -3928,4 +4184,4 @@ function mergeDurableGateEntriesFromEvidence(taskId, entries, evidence) {
   return merged;
 }
 
-export { PlanSchema, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, getGitRepositoryStatus, isGitRepo, resetToRemoteBranch, resetToMainAfterMerge, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, normalizePath, pathsConflict, isGlobalFile, isProtectedPath, readTaskScopes, loadSddStatusSync, buildOpenSpecProjectionSync, readEffectiveSpecSync, writeProjectedSpecSync, computeSpecHash, derivePlanId, computePlanHash, initLedger, appendLedgerEvent, loadPlanJsonOnly, loadPlan, savePlan, closePlanTerminalState, derivePlanMarkdown, RetrospectiveEvidenceSchema, isValidEvidenceType, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };
+export { PlanSchema, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, getGitRepositoryStatus, isGitRepo, resetToRemoteBranch, resetToMainAfterMerge, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, normalizePath, pathsConflict, isGlobalFile, isProtectedPath, readTaskScopes, detectSpeckit, resolveSpeckitProjection, loadSddStatusSync, buildOpenSpecProjectionSync, readEffectiveSpecSync, writeProjectedSpecSync, validateSpeckit, computeSpecHash, derivePlanId, computePlanHash, initLedger, appendLedgerEvent, loadPlanJsonOnly, loadPlan, savePlan, closePlanTerminalState, derivePlanMarkdown, RetrospectiveEvidenceSchema, isValidEvidenceType, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };

package/dist/cli/{index-bcr2a549.js → index-mz3j0me8.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-4xqnktvr.js";
+} from "./index-wc8g49dp.js";
 import {
   handleGuardrailLog
 } from "./index-5bstvpct.js";
@@ -79,7 +79,7 @@ import {
   handleWriteRetroCommand,
   normalizeSwarmCommandInput,
   resolveCommand
-} from "./index-qvdxzjqt.js";
+} from "./index-rmh6nqbp.js";
 import"./index-pj3a5fbt.js";
 import"./index-ydgy7vg5.js";
 import"./index-vwyjkzgs.js";
@@ -90,7 +90,7 @@ import {
   ORCHESTRATOR_NAME,
   stripKnownSwarmPrefix
 } from "./index-m0qshbr6.js";
-import"./index-3emh7rny.js";
+import"./index-bnkd9ejn.js";
 import"./index-adz3nk9b.js";
 import"./index-v4fcn4tr.js";
 import"./index-r8f89sm9.js";