opencode-swarm 7.107.0 → 7.107.2

package/dist/cli/{index-25pev4e7.js → index-f12bmedv.js}

@@ -1,4 +1,7 @@
 // @bun
+import {
+  readEffectiveSpecSync
+} from "./index-357p0baj.js";
 import {
   isValidTaskId,
   readTaskEvidence,
@@ -8,7 +11,7 @@ import {
 import {
   readSwarmFileAsync,
   validateSwarmPath
-} from "./index-7ztmmqpt.js";
+} from "./index-mpe0yk9s.js";
 import {
   readCachedParsedFile
 } from "./index-jtqkh8jf.js";
@@ -36,13 +39,13 @@ import {
 // src/plan/manager.ts
 import {
   copyFileSync,
-  existsSync as existsSync6,
-  readdirSync as readdirSync2,
-  renameSync as renameSync5,
+  existsSync as existsSync5,
+  readdirSync,
+  renameSync as renameSync4,
   unlinkSync as unlinkSync3
 } from "fs";
 import * as fsPromises from "fs/promises";
-import * as path6 from "path";
+import * as path5 from "path";
 
 // src/config/plan-schema.ts
 var ExecutionProfileSchema = exports_external.object({
@@ -1084,729 +1087,14 @@ function readTaskScopes(directory, taskId) {
 }
 
 // src/utils/spec-hash.ts
-import { createHash as createHash2 } from "crypto";
-import * as fsSync from "fs";
-import { join as join4 } from "path";
-
-// src/sdd/effective-spec.ts
 import { createHash } from "crypto";
-import * as fs4 from "fs";
-import * as path4 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 = 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("/");
-}
-function hash(content) {
-  return createHash("sha256").update(content, "utf-8").digest("hex");
-}
-function readTextBounded(absPath) {
-  let stat;
-  try {
-    stat = fs4.lstatSync(absPath);
-  } catch {
-    return null;
-  }
-  if (!stat.isFile() || stat.size > MAX_SOURCE_BYTES) {
-    return null;
-  }
-  try {
-    return fs4.readFileSync(absPath, "utf-8");
-  } catch {
-    return null;
-  }
-}
-function fileArtifact(root, absPath) {
-  try {
-    const stat = fs4.lstatSync(absPath);
-    if (!stat.isFile() || stat.size > MAX_SOURCE_BYTES)
-      return null;
-    return {
-      relPath: toPosix(path4.relative(root, absPath)),
-      bytes: stat.size,
-      mtimeMs: stat.mtimeMs
-    };
-  } catch {
-    return null;
-  }
-}
-function walkSpecFiles(root, startRel) {
-  const start = path4.join(root, startRel);
-  if (!fs4.existsSync(start))
-    return [];
-  const artifacts = [];
-  const stack = [
-    { abs: start, depth: 0 }
-  ];
-  while (stack.length > 0 && artifacts.length < MAX_SPEC_FILES) {
-    const item = stack.pop();
-    if (!item || item.depth > MAX_WALK_DEPTH)
-      continue;
-    let entries;
-    try {
-      entries = fs4.readdirSync(item.abs, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    const dirents = entries.filter((entry) => typeof entry?.name === "string");
-    for (const entry of dirents.sort((a, b) => b.name.localeCompare(a.name))) {
-      const abs = path4.join(item.abs, entry.name);
-      if (entry.isSymbolicLink())
-        continue;
-      if (entry.isDirectory()) {
-        stack.push({ abs, depth: item.depth + 1 });
-      } else if (entry.isFile() && entry.name === "spec.md") {
-        const artifact = fileArtifact(root, abs);
-        if (artifact)
-          artifacts.push(artifact);
-        if (artifacts.length >= MAX_SPEC_FILES)
-          break;
-      }
-    }
-  }
-  return artifacts.sort((a, b) => a.relPath.localeCompare(b.relPath));
-}
-function listOpenSpecChanges(root) {
-  const changesDir = path4.join(root, OPENSPEC_ROOT, "changes");
-  if (!fs4.existsSync(changesDir))
-    return [];
-  let entries;
-  try {
-    entries = fs4.readdirSync(changesDir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  return entries.filter((entry) => entry.isDirectory() && entry.name !== "archive").sort((a, b) => a.name.localeCompare(b.name)).map((entry) => {
-    const rel = path4.join(OPENSPEC_ROOT, "changes", entry.name);
-    return {
-      id: entry.name,
-      proposal: fs4.existsSync(path4.join(root, rel, "proposal.md")),
-      design: fs4.existsSync(path4.join(root, rel, "design.md")),
-      tasks: fs4.existsSync(path4.join(root, rel, "tasks.md")),
-      specs: walkSpecFiles(root, path4.join(rel, "specs"))
-    };
-  });
-}
-function detectKind(line, current) {
-  const upper = line.toUpperCase();
-  if (/^#{2,6}\s+ADDED\b/.test(upper))
-    return "ADDED";
-  if (/^#{2,6}\s+MODIFIED\b/.test(upper))
-    return "MODIFIED";
-  if (/^#{2,6}\s+REMOVED\b/.test(upper))
-    return "REMOVED";
-  return current;
-}
-function requirementTextFromBlock(title, block, kind) {
-  const joined = block.join(" ").replace(/\s+/g, " ").trim();
-  const obligation = joined.match(/\b(MUST|SHALL|SHOULD|MAY)\b/i)?.[1];
-  if (obligation)
-    return joined;
-  if (kind === "REMOVED") {
-    return `MAY remove or retire behavior for ${title}.`;
-  }
-  return `MUST satisfy OpenSpec requirement ${title}.`;
-}
-function parseRequirements(content, sourceRel, defaultKind) {
-  const requirements = [];
-  const lines = content.replace(/\r\n/g, `
-`).split(`
-`);
-  let kind = defaultKind;
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i];
-    kind = detectKind(line, kind);
-    const explicit = line.match(/\b(FR-(?!000)\d{3})\b/);
-    if (explicit && /\b(MUST|SHALL|SHOULD|MAY)\b/i.test(line)) {
-      requirements.push({
-        id: explicit[1].toUpperCase(),
-        kind,
-        title: explicit[1].toUpperCase(),
-        text: line.trim().replace(/^\s*[-*]\s*/, ""),
-        sourceRel
-      });
-      continue;
-    }
-    const openSpecReq = line.match(/^#{3,4}\s+Requirement:\s*(.+)$/i);
-    if (!openSpecReq)
-      continue;
-    const title = openSpecReq[1].trim();
-    const block = [];
-    for (let j = i + 1;j < lines.length; j++) {
-      if (/^##\s+/.test(lines[j]))
-        break;
-      if (/^#{3,4}\s+Requirement:/i.test(lines[j]))
-        break;
-      const trimmed = lines[j].trim();
-      if (trimmed)
-        block.push(trimmed);
-    }
-    const id = block.join(`
-`).match(/\b(FR-(?!000)\d{3})\b/)?.[1] ?? null;
-    requirements.push({
-      id: id?.toUpperCase() ?? null,
-      kind,
-      title,
-      text: requirementTextFromBlock(title, block, kind),
-      sourceRel
-    });
-  }
-  return requirements;
-}
-function nextFrId(used, warnings, reserved) {
-  for (let n = 1;n <= 999; n++) {
-    const id = `FR-${String(n).padStart(3, "0")}`;
-    if (!used.has(id) && !reserved?.has(id)) {
-      used.add(id);
-      return id;
-    }
-  }
-  warnings.push("More than 999 FR identifiers are required; reusing FR-999.");
-  return "FR-999";
-}
-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}.`);
-  }
-  if (req.id === id)
-    used.add(id);
-  let text = req.text;
-  if (!text.includes(id)) {
-    text = `${id}: ${text}`;
-  }
-  return `- ${text} _(source: ${req.sourceRel})_`;
-}
-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);
-  const errors = [];
-  const warnings = [];
-  const swSpecExists = fs4.existsSync(swSpecPath);
-  const openSpecExists = fs4.existsSync(openSpecPath);
-  const currentSpecs = walkSpecFiles(root, path4.join(OPENSPEC_ROOT, "specs"));
-  const changes = listOpenSpecChanges(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.");
-  }
-  for (const change of changes) {
-    if (!change.proposal) {
-      warnings.push(`Change ${change.id} is missing proposal.md.`);
-    }
-    if (!change.tasks) {
-      warnings.push(`Change ${change.id} is missing tasks.md; tasks remain proposal input, not plan state.`);
-    }
-    if (change.specs.length === 0) {
-      errors.push(`Change ${change.id} has no specs/**/spec.md delta files.`);
-    }
-  }
-  return {
-    provider: effectiveSpec?.source ?? "none",
-    swSpecExists,
-    openSpecExists,
-    currentSpecs,
-    changes,
-    effectiveSpec,
-    errors,
-    warnings
-  };
-}
-function buildOpenSpecProjectionSync(directory, options = {}) {
-  const root = path4.resolve(directory);
-  const currentSpecs = walkSpecFiles(root, path4.join(OPENSPEC_ROOT, "specs"));
-  const allChanges = listOpenSpecChanges(root);
-  const changes = options.changeId ? allChanges.filter((change) => change.id === options.changeId) : allChanges;
-  const sourcePaths = [];
-  const warnings = [];
-  const usedIds = new Set;
-  const currentRequirements = [];
-  const changeRequirements = new Map;
-  let parsedRequirementCount = 0;
-  let mtimeMs = 0;
-  if (options.changeId && changes.length === 0)
-    return null;
-  if (currentSpecs.length === 0 && changes.length === 0)
-    return null;
-  for (const artifact of currentSpecs) {
-    const abs = path4.join(root, artifact.relPath);
-    const content2 = readTextBounded(abs);
-    if (content2 === null) {
-      warnings.push(`Skipped unreadable or oversized spec ${artifact.relPath}.`);
-      continue;
-    }
-    sourcePaths.push(artifact.relPath);
-    mtimeMs = Math.max(mtimeMs, artifact.mtimeMs);
-    const parsed = parseRequirements(content2, artifact.relPath, "CURRENT");
-    currentRequirements.push(...parsed);
-    parsedRequirementCount += parsed.length;
-  }
-  for (const change of changes) {
-    const reqs = [];
-    for (const artifact of change.specs) {
-      const abs = path4.join(root, artifact.relPath);
-      const content2 = readTextBounded(abs);
-      if (content2 === null) {
-        warnings.push(`Skipped unreadable or oversized spec ${artifact.relPath}.`);
-        continue;
-      }
-      sourcePaths.push(artifact.relPath);
-      mtimeMs = Math.max(mtimeMs, artifact.mtimeMs);
-      const parsed = parseRequirements(content2, artifact.relPath, "ADDED");
-      reqs.push(...parsed);
-      parsedRequirementCount += parsed.length;
-    }
-    changeRequirements.set(change.id, reqs);
-  }
-  if (sourcePaths.length > 0 && parsedRequirementCount === 0) {
-    return null;
-  }
-  const lines = [
-    "# Specification: Effective SDD Projection",
-    "",
-    "Generated from OpenSpec-compatible artifacts. Update the source artifacts, then run `/swarm sdd project` to refresh this projection.",
-    "",
-    "## Source Artifacts",
-    ...sourcePaths.map((rel) => `- ${rel}`),
-    "",
-    "## Current Requirements"
-  ];
-  if (currentRequirements.length === 0) {
-    lines.push("- No current OpenSpec requirements found in source artifacts.");
-    warnings.push("No current requirements found; projection includes an advisory note only.");
-  } else {
-    for (const req of currentRequirements) {
-      lines.push(renderRequirement(req, usedIds, warnings));
-    }
-  }
-  for (const [changeId, reqs] of changeRequirements.entries()) {
-    lines.push("", `## Pending Change: ${changeId}`);
-    if (reqs.length === 0) {
-      lines.push(`- ${nextFrId(usedIds, warnings)} SHOULD add OpenSpec delta requirements for change ${changeId}.`);
-      warnings.push(`Change ${changeId} contains no parsable requirements.`);
-      continue;
-    }
-    for (const req of reqs) {
-      lines.push(renderRequirement(req, usedIds, warnings));
-    }
-  }
-  const content = `${lines.join(`
-`)}
-`;
-  if (content.length > MAX_SPEC_BYTES) {
-    warnings.push(`Projected spec exceeds ${MAX_SPEC_BYTES} bytes; refusing to use projection.`);
-    return null;
-  }
-  const validation = validateSpecContent(content);
-  if (!validation.valid) {
-    warnings.push(...validation.issues.map((issue) => `Projection line ${issue.line}: ${issue.message}`));
-  }
-  return {
-    source: "openspec_projection",
-    content,
-    hash: hash(content),
-    mtime: mtimeMs > 0 ? new Date(mtimeMs).toISOString() : null,
-    sourcePaths,
-    warnings
-  };
-}
-function readEffectiveSpecSync(directory, opts) {
-  const root = path4.resolve(directory);
-  const swSpecPath = path4.join(root, SWARM_SPEC_REL);
-  try {
-    const stat = fs4.lstatSync(swSpecPath);
-    if (stat.isFile() && stat.size <= MAX_SPEC_BYTES) {
-      const content = fs4.readFileSync(swSpecPath, "utf-8");
-      return {
-        source: "swarm",
-        content,
-        hash: hash(content),
-        mtime: stat.mtime.toISOString(),
-        sourcePaths: [toPosix(SWARM_SPEC_REL)],
-        warnings: []
-      };
-    }
-  } catch (error2) {
-    if (error2.code !== "ENOENT") {
-      throw error2;
-    }
-  }
-  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 = 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 };
-  }
-  fs4.mkdirSync(path4.dirname(target), { recursive: true });
-  let archivePath;
-  if (fs4.existsSync(target)) {
-    const prior = fs4.readFileSync(target, "utf-8");
-    if (prior !== projection.content) {
-      const archiveDir = path4.join(root, ".swarm", "spec-archive");
-      fs4.mkdirSync(archiveDir, { recursive: true });
-      const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-      archivePath = path4.join(archiveDir, `sdd-projection-${stamp}.md`);
-      fs4.writeFileSync(archivePath, prior, "utf-8");
-    }
-  }
-  const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
-  fs4.writeFileSync(tmp, projection.content, "utf-8");
-  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
+import * as fsSync from "fs";
+import { join as join3 } from "path";
 async function computeSpecHash(directory) {
   const spec = _internals3.readEffectiveSpecSync(directory);
   if (!spec)
     return null;
-  return createHash2("sha256").update(spec.content, "utf-8").digest("hex");
+  return createHash("sha256").update(spec.content, "utf-8").digest("hex");
 }
 async function isSpecStale(directory, plan) {
   const currentHash = await _internals3.computeSpecHash(directory);
@@ -1830,7 +1118,7 @@ async function isSpecStale(directory, plan) {
   return { stale: false };
 }
 function isObligationPreserving(directory) {
-  const snapshotPath = join4(directory, ".swarm", "spec-snapshot.md");
+  const snapshotPath = join3(directory, ".swarm", "spec-snapshot.md");
   try {
     let recordedContent;
     try {
@@ -1876,7 +1164,7 @@ var _internals3 = {
   readEffectiveSpecSync
 };
 function computeSpecDiff(directory) {
-  const snapshotPath = join4(directory, ".swarm", "spec-snapshot.md");
+  const snapshotPath = join3(directory, ".swarm", "spec-snapshot.md");
   let recordedContent;
   try {
     const snapshotSize = fsSync.statSync(snapshotPath).size;
@@ -1963,8 +1251,8 @@ function computeLcsDiff(oldLines, newLines) {
 
 // src/plan/ledger.ts
 import * as crypto from "crypto";
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 
 // src/plan/utils.ts
 function derivePlanId(plan) {
@@ -1974,7 +1262,7 @@ function derivePlanId(plan) {
 // src/plan/ledger.ts
 var LEDGER_SCHEMA_VERSION = "1.1.0";
 var LEDGER_FILENAME = "plan-ledger.jsonl";
-var LEDGER_LOCK_PATH = path5.join(".swarm", LEDGER_FILENAME);
+var LEDGER_LOCK_PATH = path4.join(".swarm", LEDGER_FILENAME);
 var PLAN_JSON_FILENAME = "plan.json";
 
 class LedgerStaleWriterError extends Error {
@@ -1984,10 +1272,10 @@ class LedgerStaleWriterError extends Error {
   }
 }
 function getLedgerPath(directory) {
-  return path5.join(directory, ".swarm", LEDGER_FILENAME);
+  return path4.join(directory, ".swarm", LEDGER_FILENAME);
 }
 function getPlanJsonPath(directory) {
-  return path5.join(directory, ".swarm", PLAN_JSON_FILENAME);
+  return path4.join(directory, ".swarm", PLAN_JSON_FILENAME);
 }
 function computePlanHash(plan) {
   const normalized = {
@@ -2022,7 +1310,7 @@ function computePlanHash(plan) {
 function computeCurrentPlanHash(directory) {
   const planPath = getPlanJsonPath(directory);
   try {
-    const content = fs5.readFileSync(planPath, "utf8");
+    const content = fs4.readFileSync(planPath, "utf8");
     const plan = JSON.parse(content);
     return computePlanHash(plan);
   } catch {
@@ -2031,15 +1319,15 @@ function computeCurrentPlanHash(directory) {
 }
 async function ledgerExists(directory) {
   const ledgerPath = getLedgerPath(directory);
-  return fs5.existsSync(ledgerPath);
+  return fs4.existsSync(ledgerPath);
 }
 async function getLatestLedgerSeq(directory) {
   const ledgerPath = getLedgerPath(directory);
-  if (!fs5.existsSync(ledgerPath)) {
+  if (!fs4.existsSync(ledgerPath)) {
     return 0;
   }
   try {
-    const content = fs5.readFileSync(ledgerPath, "utf8");
+    const content = fs4.readFileSync(ledgerPath, "utf8");
     const lines = content.trim().split(`
 `).filter((line) => line.trim() !== "");
     if (lines.length === 0) {
@@ -2061,11 +1349,11 @@ async function getLatestLedgerSeq(directory) {
 }
 async function readLedgerEvents(directory) {
   const ledgerPath = getLedgerPath(directory);
-  if (!fs5.existsSync(ledgerPath)) {
+  if (!fs4.existsSync(ledgerPath)) {
     return [];
   }
   try {
-    const content = fs5.readFileSync(ledgerPath, "utf8");
+    const content = fs4.readFileSync(ledgerPath, "utf8");
     const lines = content.trim().split(`
 `).filter((line) => line.trim() !== "");
     const events = [];
@@ -2090,15 +1378,15 @@ async function readLedgerEvents(directory) {
 async function initLedger(directory, planId, initialPlanHash, initialPlan) {
   const ledgerPath = getLedgerPath(directory);
   const planJsonPath = getPlanJsonPath(directory);
-  if (fs5.existsSync(ledgerPath)) {
+  if (fs4.existsSync(ledgerPath)) {
     throw new Error("Ledger already initialized. Use appendLedgerEvent to add events.");
   }
   let planHashAfter = initialPlanHash ?? "";
   let embeddedPlan = initialPlan;
   if (!initialPlanHash) {
     try {
-      if (fs5.existsSync(planJsonPath)) {
-        const content = fs5.readFileSync(planJsonPath, "utf8");
+      if (fs4.existsSync(planJsonPath)) {
+        const content = fs4.readFileSync(planJsonPath, "utf8");
         const plan = JSON.parse(content);
         planHashAfter = computePlanHash(plan);
         if (!embeddedPlan)
@@ -2118,12 +1406,12 @@ async function initLedger(directory, planId, initialPlanHash, initialPlan) {
     schema_version: LEDGER_SCHEMA_VERSION,
     ...payload ? { payload } : {}
   };
-  fs5.mkdirSync(path5.join(directory, ".swarm"), { recursive: true });
+  fs4.mkdirSync(path4.join(directory, ".swarm"), { recursive: true });
   const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   const line = `${JSON.stringify(event)}
 `;
-  fs5.writeFileSync(tempPath, line, "utf8");
-  fs5.renameSync(tempPath, ledgerPath);
+  fs4.writeFileSync(tempPath, line, "utf8");
+  fs4.renameSync(tempPath, ledgerPath);
 }
 async function appendLedgerEvent(directory, eventInput, options) {
   return withEvidenceLock(directory, LEDGER_LOCK_PATH, "plan-ledger", "append-ledger-event", async () => {
@@ -2146,17 +1434,17 @@ async function appendLedgerEvent(directory, eventInput, options) {
       plan_hash_after: planHashAfter,
       schema_version: LEDGER_SCHEMA_VERSION
     };
-    fs5.mkdirSync(path5.join(directory, ".swarm"), { recursive: true });
+    fs4.mkdirSync(path4.join(directory, ".swarm"), { recursive: true });
     const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
     const line = `${JSON.stringify(event)}
 `;
-    if (fs5.existsSync(ledgerPath)) {
-      const existingContent = fs5.readFileSync(ledgerPath, "utf8");
-      fs5.writeFileSync(tempPath, existingContent + line, "utf8");
+    if (fs4.existsSync(ledgerPath)) {
+      const existingContent = fs4.readFileSync(ledgerPath, "utf8");
+      fs4.writeFileSync(tempPath, existingContent + line, "utf8");
     } else {
       throw new Error("Ledger not initialized. Call initLedger() first.");
     }
-    fs5.renameSync(tempPath, ledgerPath);
+    fs4.renameSync(tempPath, ledgerPath);
     return event;
   });
 }
@@ -2244,12 +1532,12 @@ async function replayFromLedger(directory, _options) {
     }
   }
   const planJsonPath = getPlanJsonPath(directory);
-  if (!fs5.existsSync(planJsonPath)) {
+  if (!fs4.existsSync(planJsonPath)) {
     return null;
   }
   let plan;
   try {
-    const content = fs5.readFileSync(planJsonPath, "utf8");
+    const content = fs4.readFileSync(planJsonPath, "utf8");
     plan = JSON.parse(content);
   } catch {
     return null;
@@ -2344,11 +1632,11 @@ function applyEventToPlan(plan, event) {
 }
 async function readLedgerEventsWithIntegrity(directory) {
   const ledgerPath = getLedgerPath(directory);
-  if (!fs5.existsSync(ledgerPath)) {
+  if (!fs4.existsSync(ledgerPath)) {
     return { events: [], truncated: false, badSuffix: null };
   }
   try {
-    const content = fs5.readFileSync(ledgerPath, "utf8");
+    const content = fs4.readFileSync(ledgerPath, "utf8");
     const lines = content.split(`
 `);
     const events = [];
@@ -2377,9 +1665,9 @@ async function readLedgerEventsWithIntegrity(directory) {
 }
 async function quarantineLedgerSuffix(directory, badSuffix) {
   try {
-    const quarantinePath = path5.join(directory, ".swarm", "plan-ledger.quarantine");
-    fs5.writeFileSync(quarantinePath, badSuffix, "utf8");
-    console.warn(`[ledger] Corrupted suffix quarantined to ${path5.relative(directory, quarantinePath)}`);
+    const quarantinePath = path4.join(directory, ".swarm", "plan-ledger.quarantine");
+    fs4.writeFileSync(quarantinePath, badSuffix, "utf8");
+    console.warn(`[ledger] Corrupted suffix quarantined to ${path4.relative(directory, quarantinePath)}`);
   } catch {}
 }
 async function loadLastApprovedPlan(directory, expectedPlanId) {
@@ -2475,7 +1763,7 @@ async function retryCasWithBackoff(directory, eventInput, options) {
         expectedHashPrefix: currentExpected.slice(0, 8),
         delayMs
       });
-      await new Promise((resolve4) => setTimeout(resolve4, delayMs));
+      await new Promise((resolve3) => setTimeout(resolve3, delayMs));
       if (options.verifyValid) {
         const stillValid = await options.verifyValid();
         if (!stillValid)
@@ -2518,7 +1806,7 @@ async function getLatestLedgerHash(directory) {
   }
 }
 async function surfaceLedgerStaleIfPersisted(directory, plan) {
-  const resolvedWorkspace = path6.resolve(directory);
+  const resolvedWorkspace = path5.resolve(directory);
   if (!ledgerStaleWorkspaces.has(resolvedWorkspace)) {
     return plan;
   }
@@ -2537,7 +1825,7 @@ async function surfaceLedgerStaleIfPersisted(directory, plan) {
   return plan;
 }
 async function parsePlanJsonCached(directory) {
-  const planJsonPath = path6.resolve(directory, ".swarm", "plan.json");
+  const planJsonPath = path5.resolve(directory, ".swarm", "plan.json");
   return readCachedParsedFile(planJsonPath, PLAN_JSON_CACHE_NAMESPACE, () => readSwarmFileAsync(directory, "plan.json"), (planJsonContent) => {
     if (planJsonContent.includes("\x00") || planJsonContent.includes("\uFFFD")) {
       throw new Error("Plan rejected: .swarm/plan.json contains null bytes or invalid encoding");
@@ -2597,16 +1885,16 @@ async function isPlanMdInSync(directory, plan, cache) {
   return false;
 }
 async function regeneratePlanMarkdown(directory, plan) {
-  const swarmDir = path6.resolve(directory, ".swarm");
+  const swarmDir = path5.resolve(directory, ".swarm");
   const contentHash = computePlanContentHash(plan);
   const markdown = derivePlanMarkdown(plan);
   const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-  const mdPath = path6.join(swarmDir, "plan.md");
-  const mdTempPath = path6.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const mdPath = path5.join(swarmDir, "plan.md");
+  const mdTempPath = path5.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await bunWrite(mdTempPath, markdownWithHash);
-    renameSync5(mdTempPath, mdPath);
+    renameSync4(mdTempPath, mdPath);
   } finally {
     try {
       unlinkSync3(mdTempPath);
@@ -2635,7 +1923,7 @@ async function loadPlan(directory, cache) {
           if (await ledgerExists(directory)) {
             const planHash = computePlanHash(validated);
             const ledgerHash = await getLatestLedgerHash(directory);
-            const resolvedWorkspace = path6.resolve(directory);
+            const resolvedWorkspace = path5.resolve(directory);
             if (!startupLedgerCheckedWorkspaces.has(resolvedWorkspace)) {
               startupLedgerCheckedWorkspaces.add(resolvedWorkspace);
               if (ledgerHash !== "" && planHash !== ledgerHash) {
@@ -2701,7 +1989,7 @@ async function loadPlan(directory, cache) {
               if (!preserving) {
                 try {
                   const diffInfo = computeSpecDiff(directory);
-                  const specStalenessPath = path6.join(directory, ".swarm", "spec-staleness.json");
+                  const specStalenessPath = path5.join(directory, ".swarm", "spec-staleness.json");
                   await fsPromises.writeFile(specStalenessPath, JSON.stringify({
                     type: "spec_stale_detected",
                     timestamp: new Date().toISOString(),
@@ -2715,7 +2003,7 @@ async function loadPlan(directory, cache) {
                   }, null, 2), "utf-8");
                 } catch {}
                 try {
-                  const eventsPath = path6.join(directory, ".swarm", "events.jsonl");
+                  const eventsPath = path5.join(directory, ".swarm", "events.jsonl");
                   const event = {
                     type: "spec_stale_detected",
                     timestamp: new Date().toISOString(),
@@ -2781,7 +2069,7 @@ async function loadPlan(directory, cache) {
     return migrated;
   }
   if (await ledgerExists(directory)) {
-    const resolvedDir = path6.resolve(directory);
+    const resolvedDir = path5.resolve(directory);
     const existingMutex = recoveryMutexes.get(resolvedDir);
     if (existingMutex) {
       await existingMutex;
@@ -2921,13 +2209,13 @@ async function savePlan(directory, plan, options) {
   } else {
     const existingEvents = await readLedgerEvents(directory);
     if (existingEvents.length > 0 && existingEvents[0].plan_id !== planId) {
-      const swarmDir2 = path6.resolve(directory, ".swarm");
-      const oldLedgerPath = path6.join(swarmDir2, "plan-ledger.jsonl");
-      const oldLedgerBackupPath = path6.join(swarmDir2, `plan-ledger.backup-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
+      const swarmDir2 = path5.resolve(directory, ".swarm");
+      const oldLedgerPath = path5.join(swarmDir2, "plan-ledger.jsonl");
+      const oldLedgerBackupPath = path5.join(swarmDir2, `plan-ledger.backup-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
       let backupExists = false;
-      if (existsSync6(oldLedgerPath)) {
+      if (existsSync5(oldLedgerPath)) {
         try {
-          renameSync5(oldLedgerPath, oldLedgerBackupPath);
+          renameSync4(oldLedgerPath, oldLedgerBackupPath);
           backupExists = true;
         } catch (renameErr) {
           throw new Error(`[savePlan] Cannot reinitialize ledger: could not move old ledger aside (rename failed: ${renameErr instanceof Error ? renameErr.message : String(renameErr)}). The existing ledger has plan_id="${existingEvents[0].plan_id}" which does not match the current plan="${planId}". To proceed, close any programs that may have the ledger file open, or run /swarm reset-session to clear the ledger.`);
@@ -2942,13 +2230,13 @@ async function savePlan(directory, plan, options) {
           const errorMessage2 = String(initErr);
           if (errorMessage2.includes("already initialized")) {
             try {
-              if (existsSync6(oldLedgerBackupPath))
+              if (existsSync5(oldLedgerBackupPath))
                 unlinkSync3(oldLedgerBackupPath);
             } catch {}
           } else {
-            if (existsSync6(oldLedgerBackupPath)) {
+            if (existsSync5(oldLedgerBackupPath)) {
               try {
-                renameSync5(oldLedgerBackupPath, oldLedgerPath);
+                renameSync4(oldLedgerBackupPath, oldLedgerPath);
               } catch {
                 copyFileSync(oldLedgerBackupPath, oldLedgerPath);
                 try {
@@ -2961,32 +2249,32 @@ async function savePlan(directory, plan, options) {
         }
       }
       if (initSucceeded && backupExists) {
-        const archivePath = path6.join(swarmDir2, `plan-ledger.archived-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
+        const archivePath = path5.join(swarmDir2, `plan-ledger.archived-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
         try {
-          renameSync5(oldLedgerBackupPath, archivePath);
+          renameSync4(oldLedgerBackupPath, archivePath);
           warn(`[savePlan] Ledger identity mismatch (was "${existingEvents[0].plan_id}", now "${planId}") \u2014 archived old ledger to ${archivePath} and reinitializing.`);
         } catch (renameErr) {
           warn(`[savePlan] Could not archive old ledger (rename failed: ${renameErr instanceof Error ? renameErr.message : String(renameErr)}). Old ledger may still exist at ${oldLedgerBackupPath}.`);
           try {
-            if (existsSync6(oldLedgerBackupPath))
+            if (existsSync5(oldLedgerBackupPath))
               unlinkSync3(oldLedgerBackupPath);
           } catch {}
         }
       } else if (!initSucceeded && backupExists) {
         try {
-          if (existsSync6(oldLedgerBackupPath))
+          if (existsSync5(oldLedgerBackupPath))
             unlinkSync3(oldLedgerBackupPath);
         } catch {}
       }
       const MAX_ARCHIVED_SIBLINGS = 5;
       try {
-        const allFiles = readdirSync2(swarmDir2);
+        const allFiles = readdirSync(swarmDir2);
         const archivedSiblings = allFiles.filter((f) => f.startsWith("plan-ledger.archived-") && f.endsWith(".jsonl")).sort();
         if (archivedSiblings.length > MAX_ARCHIVED_SIBLINGS) {
           const toRemove = archivedSiblings.slice(0, archivedSiblings.length - MAX_ARCHIVED_SIBLINGS);
           for (const file of toRemove) {
             try {
-              unlinkSync3(path6.join(swarmDir2, file));
+              unlinkSync3(path5.join(swarmDir2, file));
             } catch {}
           }
         }
@@ -3111,46 +2399,47 @@ async function savePlan(directory, plan, options) {
       throw error2;
     }
   }
+  const projectedPlan = await replayFromLedger(directory) ?? validated;
   const SNAPSHOT_INTERVAL = 50;
   const latestSeq = await getLatestLedgerSeq(directory);
   if (latestSeq > 0 && latestSeq % SNAPSHOT_INTERVAL === 0) {
-    await takeSnapshotWithRetry(directory, validated, {
-      planHashAfter: hashAfter,
+    await takeSnapshotWithRetry(directory, projectedPlan, {
+      planHashAfter: computePlanHash(projectedPlan),
       source: "savePlan_manager"
     });
   }
-  const swarmDir = path6.resolve(directory, ".swarm");
-  const planPath = path6.join(swarmDir, "plan.json");
-  const tempPath = path6.join(swarmDir, `plan.json.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path5.resolve(directory, ".swarm");
+  const planPath = path5.join(swarmDir, "plan.json");
+  const tempPath = path5.join(swarmDir, `plan.json.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
-    await bunWrite(tempPath, JSON.stringify(validated, null, 2));
-    renameSync5(tempPath, planPath);
+    await bunWrite(tempPath, JSON.stringify(projectedPlan, null, 2));
+    renameSync4(tempPath, planPath);
   } finally {
     try {
       unlinkSync3(tempPath);
     } catch {}
   }
   try {
-    const markerPath = path6.join(swarmDir, ".plan-write-marker");
+    const markerPath = path5.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager",
       timestamp: new Date().toISOString(),
-      phases_count: validated.phases.length,
-      tasks_count: validated.phases.reduce((sum, p) => sum + p.tasks.length, 0),
+      phases_count: projectedPlan.phases.length,
+      tasks_count: projectedPlan.phases.reduce((sum, p) => sum + p.tasks.length, 0),
       in_progress: true
     });
     await bunWrite(markerPath, inProgressMarker);
   } catch {}
   try {
-    const contentHash = computePlanContentHash(validated);
-    const markdown = derivePlanMarkdown(validated);
+    const contentHash = computePlanContentHash(projectedPlan);
+    const markdown = derivePlanMarkdown(projectedPlan);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const mdPath = path6.join(swarmDir, "plan.md");
-    const mdTempPath = path6.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const mdPath = path5.join(swarmDir, "plan.md");
+    const mdTempPath = path5.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
       await bunWrite(mdTempPath, markdownWithHash);
-      renameSync5(mdTempPath, mdPath);
+      renameSync4(mdTempPath, mdPath);
     } finally {
       try {
         unlinkSync3(mdTempPath);
@@ -3168,12 +2457,12 @@ ${markdown}`;
     } catch {}
   }
   try {
-    const markerPath = path6.join(swarmDir, ".plan-write-marker");
-    const tasksCount = validated.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
+    const markerPath = path5.join(swarmDir, ".plan-write-marker");
+    const tasksCount = projectedPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
     const marker = JSON.stringify({
       source: "plan_manager",
       timestamp: new Date().toISOString(),
-      phases_count: validated.phases.length,
+      phases_count: projectedPlan.phases.length,
       tasks_count: tasksCount,
       in_progress: false
     });
@@ -3184,14 +2473,14 @@ async function rebuildPlan(directory, plan, options) {
   const targetPlan = plan ?? await replayFromLedger(directory);
   if (!targetPlan)
     return null;
-  const swarmDir = path6.join(directory, ".swarm");
-  const planPath = path6.join(swarmDir, "plan.json");
-  const mdPath = path6.join(swarmDir, "plan.md");
-  const tempPlanPath = path6.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path5.join(directory, ".swarm");
+  const planPath = path5.join(swarmDir, "plan.json");
+  const mdPath = path5.join(swarmDir, "plan.md");
+  const tempPlanPath = path5.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   await bunWrite(tempPlanPath, JSON.stringify(targetPlan, null, 2));
-  renameSync5(tempPlanPath, planPath);
+  renameSync4(tempPlanPath, planPath);
   try {
-    const markerPath = path6.join(swarmDir, ".plan-write-marker");
+    const markerPath = path5.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager",
       timestamp: new Date().toISOString(),
@@ -3206,12 +2495,12 @@ async function rebuildPlan(directory, plan, options) {
     const markdown = derivePlanMarkdown(targetPlan);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const tempMdPath = path6.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const tempMdPath = path5.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     await bunWrite(tempMdPath, markdownWithHash);
-    renameSync5(tempMdPath, mdPath);
+    renameSync4(tempMdPath, mdPath);
   } finally {
     try {
-      const markerPath = path6.join(swarmDir, ".plan-write-marker");
+      const markerPath = path5.join(swarmDir, ".plan-write-marker");
       const tasksCount = targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
       const marker = JSON.stringify({
         source: "plan_manager",
@@ -3274,13 +2563,13 @@ async function closePlanTerminalState(directory, plan, options) {
     planHashAfter: hashAfter,
     source: "close_terminal"
   });
-  const swarmDir = path6.join(directory, ".swarm");
-  const planPath = path6.join(swarmDir, "plan.json");
-  const tempPlanPath = path6.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path5.join(directory, ".swarm");
+  const planPath = path5.join(swarmDir, "plan.json");
+  const tempPlanPath = path5.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   await bunWrite(tempPlanPath, JSON.stringify(validated, null, 2));
-  renameSync5(tempPlanPath, planPath);
+  renameSync4(tempPlanPath, planPath);
   try {
-    const markerPath = path6.join(swarmDir, ".plan-write-marker");
+    const markerPath = path5.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager_close",
       timestamp: new Date().toISOString(),
@@ -3291,17 +2580,17 @@ async function closePlanTerminalState(directory, plan, options) {
     await bunWrite(markerPath, inProgressMarker);
   } catch {}
   try {
-    const mdPath = path6.join(swarmDir, "plan.md");
+    const mdPath = path5.join(swarmDir, "plan.md");
     const contentHash = computePlanContentHash(validated);
     const markdown = derivePlanMarkdown(validated);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const mdTempPath = path6.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const mdTempPath = path5.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     await bunWrite(mdTempPath, markdownWithHash);
-    renameSync5(mdTempPath, mdPath);
+    renameSync4(mdTempPath, mdPath);
   } finally {
     try {
-      const markerPath = path6.join(swarmDir, ".plan-write-marker");
+      const markerPath = path5.join(swarmDir, ".plan-write-marker");
       const tasksCount = validated.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
       const marker = JSON.stringify({
         source: "plan_manager_close",
@@ -3585,14 +2874,14 @@ function migrateLegacyPlan(planContent, swarmId) {
 
 // src/evidence/manager.ts
 import {
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync3,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync2,
   realpathSync,
   rmSync,
-  statSync as statSync3
+  statSync as statSync2
 } from "fs";
-import * as fs6 from "fs/promises";
-import * as path7 from "path";
+import * as fs5 from "fs/promises";
+import * as path6 from "path";
 
 // src/config/evidence-schema.ts
 var EVIDENCE_MAX_JSON_BYTES = 500 * 1024;
@@ -3924,16 +3213,16 @@ function validateProjectRoot(directory) {
     if (depth >= MAX_DEPTH)
       break;
     depth++;
-    const parent = path7.dirname(current);
+    const parent = path6.dirname(current);
     if (parent === current)
       break;
-    const parentSwarm = path7.join(parent, ".swarm");
+    const parentSwarm = path6.join(parent, ".swarm");
     try {
-      if (statSync3(parentSwarm).isDirectory()) {
+      if (statSync2(parentSwarm).isDirectory()) {
         let hasProjectIndicator = false;
         for (const indicator of PROJECT_INDICATORS) {
           try {
-            const indicatorStat = statSync3(path7.join(parent, indicator));
+            const indicatorStat = statSync2(path6.join(parent, indicator));
             if (indicatorStat.isFile() || indicatorStat.isDirectory()) {
               hasProjectIndicator = true;
               break;
@@ -3961,12 +3250,12 @@ function validateProjectRoot(directory) {
 async function saveEvidence(directory, taskId, evidence) {
   _internals5.validateProjectRoot(directory);
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path7.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path6.join("evidence", sanitizedTaskId, "evidence.json");
   validateSwarmPath(directory, relativePath);
   _internals5.validateEvidence(evidence);
   return withEvidenceLock(directory, relativePath, "evidence-manager", sanitizedTaskId, async () => {
     const evidencePath = validateSwarmPath(directory, relativePath);
-    const evidenceDir = path7.dirname(evidencePath);
+    const evidenceDir = path6.dirname(evidencePath);
     let bundle;
     const existingContent = await readSwarmFileAsync(directory, relativePath);
     if (existingContent !== null) {
@@ -4008,11 +3297,11 @@ async function saveEvidence(directory, taskId, evidence) {
     if (bundleJson.length > EVIDENCE_MAX_JSON_BYTES) {
       throw new Error(`Evidence bundle size (${bundleJson.length} bytes) exceeds maximum (${EVIDENCE_MAX_JSON_BYTES} bytes)`);
     }
-    mkdirSync5(evidenceDir, { recursive: true });
-    const tempPath = path7.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+    mkdirSync4(evidenceDir, { recursive: true });
+    const tempPath = path6.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
-      await fs6.rename(tempPath, evidencePath);
+      await fs5.rename(tempPath, evidencePath);
     } catch (error2) {
       try {
         rmSync(tempPath, { force: true });
@@ -4053,7 +3342,7 @@ function wrapFlatRetrospective(flatEntry, taskId) {
 }
 async function loadEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path7.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path6.join("evidence", sanitizedTaskId, "evidence.json");
   if (relativePath.length > 4096) {
     return { status: "not_found" };
   }
@@ -4074,12 +3363,12 @@ async function loadEvidence(directory, taskId) {
       const validated = EvidenceBundleSchema.parse(wrappedBundle);
       try {
         await withEvidenceLock(directory, relativePath, "evidence-loader", sanitizedTaskId, async () => {
-          const evidenceDir = path7.dirname(evidencePath);
+          const evidenceDir = path6.dirname(evidencePath);
           const bundleJson = JSON.stringify(validated);
-          const tempPath = path7.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+          const tempPath = path6.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
           try {
             await bunWrite(tempPath, bundleJson);
-            await fs6.rename(tempPath, evidencePath);
+            await fs5.rename(tempPath, evidencePath);
           } catch (writeError) {
             try {
               rmSync(tempPath, { force: true });
@@ -4109,21 +3398,21 @@ async function loadEvidence(directory, taskId) {
 async function listEvidenceTaskIds(directory) {
   const evidenceBasePath = validateSwarmPath(directory, "evidence");
   try {
-    statSync3(evidenceBasePath);
+    statSync2(evidenceBasePath);
   } catch {
     return [];
   }
   let entries;
   try {
-    entries = readdirSync3(evidenceBasePath);
+    entries = readdirSync2(evidenceBasePath);
   } catch {
     return [];
   }
   const taskIds = [];
   for (const entry of entries) {
-    const entryPath = path7.join(evidenceBasePath, entry);
+    const entryPath = path6.join(evidenceBasePath, entry);
     try {
-      const stats = statSync3(entryPath);
+      const stats = statSync2(entryPath);
       if (!stats.isDirectory()) {
         continue;
       }
@@ -4139,10 +3428,10 @@ async function listEvidenceTaskIds(directory) {
 }
 async function deleteEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path7.join("evidence", sanitizedTaskId);
+  const relativePath = path6.join("evidence", sanitizedTaskId);
   const evidenceDir = validateSwarmPath(directory, relativePath);
   try {
-    statSync3(evidenceDir);
+    statSync2(evidenceDir);
   } catch {
     return false;
   }
@@ -4155,10 +3444,10 @@ async function deleteEvidence(directory, taskId) {
   }
 }
 async function checkRequirementCoverage(phase, directory) {
-  const relativePath = path7.join("evidence", `req-coverage-phase-${phase}.json`);
-  const absolutePath = path7.resolve(directory, ".swarm", relativePath);
+  const relativePath = path6.join("evidence", `req-coverage-phase-${phase}.json`);
+  const absolutePath = path6.resolve(directory, ".swarm", relativePath);
   try {
-    await fs6.access(absolutePath);
+    await fs5.access(absolutePath);
     return { exists: true, path: absolutePath };
   } catch {
     return { exists: false, path: absolutePath };
@@ -4322,4 +3611,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, 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 };
+export { PlanSchema, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, getGitRepositoryStatus, isGitRepo, resetToRemoteBranch, resetToMainAfterMerge, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, normalizePath, pathsConflict, isGlobalFile, isProtectedPath, readTaskScopes, 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 };