opencode-swarm 7.82.2 → 7.84.0

package/dist/cli/index-red8fm8p.js

@@ -0,0 +1,2914 @@
+// @bun
+import {
+  isValidTaskId,
+  readTaskEvidence,
+  readTaskEvidenceRaw,
+  sanitizeTaskId
+} from "./index-e7h9bb6v.js";
+import {
+  readSwarmFileAsync,
+  validateSwarmPath
+} from "./index-ckntc5gf.js";
+import {
+  readCachedParsedFile
+} from "./index-jtqkh8jf.js";
+import {
+  warn
+} from "./index-yx44zd0p.js";
+import {
+  withEvidenceLock
+} from "./index-bcp79s17.js";
+import {
+  ZodError,
+  exports_external
+} from "./index-293f68mj.js";
+import {
+  bunHash,
+  bunWrite
+} from "./index-b9v501fr.js";
+import {
+  emit
+} from "./index-p0ye10nd.js";
+
+// src/plan/manager.ts
+import {
+  copyFileSync,
+  existsSync as existsSync3,
+  readdirSync as readdirSync2,
+  renameSync as renameSync3,
+  unlinkSync
+} from "fs";
+import * as fsPromises from "fs/promises";
+import * as path3 from "path";
+
+// src/config/plan-schema.ts
+var ExecutionProfileSchema = exports_external.object({
+  parallelization_enabled: exports_external.boolean().default(false),
+  max_concurrent_tasks: exports_external.number().int().min(1).max(64).default(10),
+  council_parallel: exports_external.boolean().default(true),
+  locked: exports_external.boolean().default(false),
+  auto_proceed: exports_external.boolean().default(false)
+});
+var TaskStatusSchema = exports_external.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "blocked",
+  "closed"
+]);
+var TaskSizeSchema = exports_external.enum(["small", "medium", "large"]);
+var PhaseStatusSchema = exports_external.enum([
+  "pending",
+  "in_progress",
+  "complete",
+  "completed",
+  "blocked",
+  "closed"
+]);
+var MigrationStatusSchema = exports_external.enum([
+  "native",
+  "migrated",
+  "migration_failed"
+]);
+var TaskSchema = exports_external.object({
+  id: exports_external.string(),
+  phase: exports_external.number().int().min(1),
+  status: TaskStatusSchema.default("pending"),
+  size: TaskSizeSchema.default("small"),
+  description: exports_external.string().min(1),
+  depends: exports_external.array(exports_external.string()).default([]),
+  acceptance: exports_external.string().optional(),
+  files_touched: exports_external.array(exports_external.string()).default([]),
+  evidence_path: exports_external.string().optional(),
+  blocked_reason: exports_external.string().optional()
+});
+var PhaseSchema = exports_external.object({
+  id: exports_external.number().int().min(1),
+  name: exports_external.string().min(1),
+  status: PhaseStatusSchema.default("pending"),
+  tasks: exports_external.array(TaskSchema).default([]),
+  type: exports_external.enum(["code", "non-code"]).optional(),
+  required_agents: exports_external.array(exports_external.string()).optional()
+});
+var PlanSchema = exports_external.object({
+  schema_version: exports_external.literal("1.0.0"),
+  title: exports_external.string().min(1),
+  swarm: exports_external.string().min(1),
+  current_phase: exports_external.number().int().min(1).optional(),
+  phases: exports_external.array(PhaseSchema).min(1),
+  migration_status: MigrationStatusSchema.optional(),
+  specMtime: exports_external.string().optional(),
+  specHash: exports_external.string().optional(),
+  execution_profile: ExecutionProfileSchema.optional()
+});
+
+// src/utils/spec-hash.ts
+import { createHash as createHash2 } from "crypto";
+
+// 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 MAX_SPEC_BYTES = 256 * 1024;
+var MAX_SOURCE_BYTES = 512 * 1024;
+var MAX_SPEC_FILES = 100;
+var MAX_WALK_DEPTH = 10;
+function toPosix(relPath) {
+  return relPath.split(path.sep).join("/");
+}
+function hash(content) {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function readTextBounded(absPath) {
+  const stat = fs.lstatSync(absPath);
+  if (!stat.isFile() || stat.size > MAX_SOURCE_BYTES) {
+    return null;
+  }
+  return fs.readFileSync(absPath, "utf-8");
+}
+function fileArtifact(root, absPath) {
+  try {
+    const stat = fs.lstatSync(absPath);
+    if (!stat.isFile() || stat.size > MAX_SOURCE_BYTES)
+      return null;
+    return {
+      relPath: toPosix(path.relative(root, absPath)),
+      bytes: stat.size,
+      mtimeMs: stat.mtimeMs
+    };
+  } catch {
+    return null;
+  }
+}
+function walkSpecFiles(root, startRel) {
+  const start = path.join(root, startRel);
+  if (!fs.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 = fs.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 = path.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 = path.join(root, OPENSPEC_ROOT, "changes");
+  if (!fs.existsSync(changesDir))
+    return [];
+  let entries;
+  try {
+    entries = fs.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 = path.join(OPENSPEC_ROOT, "changes", entry.name);
+    return {
+      id: entry.name,
+      proposal: fs.existsSync(path.join(root, rel, "proposal.md")),
+      design: fs.existsSync(path.join(root, rel, "design.md")),
+      tasks: fs.existsSync(path.join(root, rel, "tasks.md")),
+      specs: walkSpecFiles(root, path.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) {
+  for (let n = 1;n <= 999; n++) {
+    const id = `FR-${String(n).padStart(3, "0")}`;
+    if (!used.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) {
+  const id = req.id && !used.has(req.id) ? req.id : nextFrId(used, warnings);
+  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 loadSddStatusSync(directory) {
+  const root = path.resolve(directory);
+  const swSpecPath = path.join(root, SWARM_SPEC_REL);
+  const openSpecPath = path.join(root, OPENSPEC_ROOT);
+  const errors = [];
+  const warnings = [];
+  const swSpecExists = fs.existsSync(swSpecPath);
+  const openSpecExists = fs.existsSync(openSpecPath);
+  const currentSpecs = walkSpecFiles(root, path.join(OPENSPEC_ROOT, "specs"));
+  const changes = listOpenSpecChanges(root);
+  const effectiveSpec = readEffectiveSpecSync(root);
+  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 = path.resolve(directory);
+  const currentSpecs = walkSpecFiles(root, path.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 = path.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 = path.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) {
+  const root = path.resolve(directory);
+  const swSpecPath = path.join(root, SWARM_SPEC_REL);
+  try {
+    const stat = fs.lstatSync(swSpecPath);
+    if (stat.isFile() && stat.size <= MAX_SPEC_BYTES) {
+      const content = fs.readFileSync(swSpecPath, "utf-8");
+      return {
+        source: "swarm",
+        content,
+        hash: hash(content),
+        mtime: stat.mtime.toISOString(),
+        sourcePaths: [toPosix(SWARM_SPEC_REL)],
+        warnings: []
+      };
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return buildOpenSpecProjectionSync(root);
+}
+function writeProjectedSpecSync(directory, options = {}) {
+  const root = path.resolve(directory);
+  const projection = buildOpenSpecProjectionSync(root, {
+    changeId: options.changeId
+  });
+  const target = path.join(root, SWARM_SPEC_REL);
+  if (!projection || options.dryRun) {
+    return { written: false, projection, path: target };
+  }
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  let archivePath;
+  if (fs.existsSync(target)) {
+    const prior = fs.readFileSync(target, "utf-8");
+    if (prior !== projection.content) {
+      const archiveDir = path.join(root, ".swarm", "spec-archive");
+      fs.mkdirSync(archiveDir, { recursive: true });
+      const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+      archivePath = path.join(archiveDir, `sdd-projection-${stamp}.md`);
+      fs.writeFileSync(archivePath, prior, "utf-8");
+    }
+  }
+  const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(tmp, projection.content, "utf-8");
+  fs.renameSync(tmp, target);
+  return { written: true, projection, archivePath, path: target };
+}
+
+// src/utils/spec-hash.ts
+async function computeSpecHash(directory) {
+  const spec = _internals.readEffectiveSpecSync(directory);
+  if (!spec)
+    return null;
+  return createHash2("sha256").update(spec.content, "utf-8").digest("hex");
+}
+async function isSpecStale(directory, plan) {
+  const currentHash = await _internals.computeSpecHash(directory);
+  if (!plan.specHash) {
+    return { stale: false };
+  }
+  if (currentHash === null) {
+    return {
+      stale: true,
+      reason: "effective spec has been deleted",
+      currentHash: null
+    };
+  }
+  if (currentHash !== plan.specHash) {
+    return {
+      stale: true,
+      reason: "effective spec has been modified since plan was saved",
+      currentHash
+    };
+  }
+  return { stale: false };
+}
+var _internals = {
+  computeSpecHash,
+  isSpecStale,
+  readEffectiveSpecSync
+};
+
+// src/plan/ledger.ts
+import * as crypto from "crypto";
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/plan/utils.ts
+function derivePlanId(plan) {
+  return `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
+}
+
+// src/plan/ledger.ts
+var LEDGER_SCHEMA_VERSION = "1.1.0";
+var LEDGER_FILENAME = "plan-ledger.jsonl";
+var PLAN_JSON_FILENAME = "plan.json";
+
+class LedgerStaleWriterError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LedgerStaleWriterError";
+  }
+}
+function getLedgerPath(directory) {
+  return path2.join(directory, ".swarm", LEDGER_FILENAME);
+}
+function getPlanJsonPath(directory) {
+  return path2.join(directory, ".swarm", PLAN_JSON_FILENAME);
+}
+function computePlanHash(plan) {
+  const normalized = {
+    schema_version: plan.schema_version,
+    title: plan.title,
+    swarm: plan.swarm,
+    current_phase: plan.current_phase,
+    migration_status: plan.migration_status,
+    execution_profile: plan.execution_profile,
+    phases: plan.phases.map((phase) => ({
+      id: phase.id,
+      name: phase.name,
+      status: phase.status,
+      required_agents: phase.required_agents ? [...phase.required_agents].sort() : undefined,
+      tasks: phase.tasks.map((task) => ({
+        id: task.id,
+        phase: task.phase,
+        status: task.status,
+        size: task.size,
+        description: task.description,
+        depends: [...task.depends].sort(),
+        acceptance: task.acceptance,
+        files_touched: [...task.files_touched].sort(),
+        evidence_path: task.evidence_path,
+        blocked_reason: task.blocked_reason
+      }))
+    }))
+  };
+  const jsonString = JSON.stringify(normalized);
+  return crypto.createHash("sha256").update(jsonString, "utf8").digest("hex");
+}
+function computeCurrentPlanHash(directory) {
+  const planPath = getPlanJsonPath(directory);
+  try {
+    const content = fs2.readFileSync(planPath, "utf8");
+    const plan = JSON.parse(content);
+    return computePlanHash(plan);
+  } catch {
+    return "";
+  }
+}
+async function ledgerExists(directory) {
+  const ledgerPath = getLedgerPath(directory);
+  return fs2.existsSync(ledgerPath);
+}
+async function getLatestLedgerSeq(directory) {
+  const ledgerPath = getLedgerPath(directory);
+  if (!fs2.existsSync(ledgerPath)) {
+    return 0;
+  }
+  try {
+    const content = fs2.readFileSync(ledgerPath, "utf8");
+    const lines = content.trim().split(`
+`).filter((line) => line.trim() !== "");
+    if (lines.length === 0) {
+      return 0;
+    }
+    let maxSeq = 0;
+    for (const line of lines) {
+      try {
+        const event = JSON.parse(line);
+        if (event.seq > maxSeq) {
+          maxSeq = event.seq;
+        }
+      } catch {}
+    }
+    return maxSeq;
+  } catch {
+    return 0;
+  }
+}
+async function readLedgerEvents(directory) {
+  const ledgerPath = getLedgerPath(directory);
+  if (!fs2.existsSync(ledgerPath)) {
+    return [];
+  }
+  try {
+    const content = fs2.readFileSync(ledgerPath, "utf8");
+    const lines = content.trim().split(`
+`).filter((line) => line.trim() !== "");
+    const events = [];
+    let skippedCount = 0;
+    for (const line of lines) {
+      try {
+        const event = JSON.parse(line);
+        events.push(event);
+      } catch {
+        skippedCount++;
+      }
+    }
+    if (skippedCount > 0) {
+      console.warn(`[ledger] Skipped ${skippedCount} malformed line(s) in plan-ledger.jsonl`);
+    }
+    events.sort((a, b) => a.seq - b.seq);
+    return events;
+  } catch {
+    return [];
+  }
+}
+async function initLedger(directory, planId, initialPlanHash, initialPlan) {
+  const ledgerPath = getLedgerPath(directory);
+  const planJsonPath = getPlanJsonPath(directory);
+  if (fs2.existsSync(ledgerPath)) {
+    throw new Error("Ledger already initialized. Use appendLedgerEvent to add events.");
+  }
+  let planHashAfter = initialPlanHash ?? "";
+  let embeddedPlan = initialPlan;
+  if (!initialPlanHash) {
+    try {
+      if (fs2.existsSync(planJsonPath)) {
+        const content = fs2.readFileSync(planJsonPath, "utf8");
+        const plan = JSON.parse(content);
+        planHashAfter = computePlanHash(plan);
+        if (!embeddedPlan)
+          embeddedPlan = plan;
+      }
+    } catch {}
+  }
+  const payload = embeddedPlan ? { plan: embeddedPlan, payload_hash: planHashAfter } : undefined;
+  const event = {
+    seq: 1,
+    timestamp: new Date().toISOString(),
+    plan_id: planId,
+    event_type: "plan_created",
+    source: "initLedger",
+    plan_hash_before: "",
+    plan_hash_after: planHashAfter,
+    schema_version: LEDGER_SCHEMA_VERSION,
+    ...payload ? { payload } : {}
+  };
+  fs2.mkdirSync(path2.join(directory, ".swarm"), { recursive: true });
+  const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
+  const line = `${JSON.stringify(event)}
+`;
+  fs2.writeFileSync(tempPath, line, "utf8");
+  fs2.renameSync(tempPath, ledgerPath);
+}
+async function appendLedgerEvent(directory, eventInput, options) {
+  const ledgerPath = getLedgerPath(directory);
+  const latestSeq = await getLatestLedgerSeq(directory);
+  const nextSeq = latestSeq + 1;
+  const planHashBefore = computeCurrentPlanHash(directory);
+  if (options?.expectedSeq !== undefined && options.expectedSeq !== latestSeq) {
+    throw new LedgerStaleWriterError(`Stale writer: expected seq ${options.expectedSeq} but found ${latestSeq}`);
+  }
+  if (options?.expectedHash !== undefined && options.expectedHash !== planHashBefore) {
+    throw new LedgerStaleWriterError(`Stale writer: expected hash ${options.expectedHash} but found ${planHashBefore}`);
+  }
+  const planHashAfter = options?.planHashAfter ?? planHashBefore;
+  const event = {
+    ...eventInput,
+    seq: nextSeq,
+    timestamp: new Date().toISOString(),
+    plan_hash_before: planHashBefore,
+    plan_hash_after: planHashAfter,
+    schema_version: LEDGER_SCHEMA_VERSION
+  };
+  fs2.mkdirSync(path2.join(directory, ".swarm"), { recursive: true });
+  const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
+  const line = `${JSON.stringify(event)}
+`;
+  if (fs2.existsSync(ledgerPath)) {
+    const existingContent = fs2.readFileSync(ledgerPath, "utf8");
+    fs2.writeFileSync(tempPath, existingContent + line, "utf8");
+  } else {
+    throw new Error("Ledger not initialized. Call initLedger() first.");
+  }
+  fs2.renameSync(tempPath, ledgerPath);
+  return event;
+}
+async function takeSnapshotWithRetry(directory, plan, options) {
+  const MAX_RETRIES = 3;
+  const TOTAL_ATTEMPTS = 1 + MAX_RETRIES;
+  const telemetrySource = options?.source ?? "save_plan_tool";
+  const snapshotOptions = { planHashAfter: options?.planHashAfter };
+  let lastError;
+  for (let attempt = 1;attempt <= TOTAL_ATTEMPTS; attempt++) {
+    try {
+      await takeSnapshotEvent(directory, plan, snapshotOptions);
+      return;
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (attempt < TOTAL_ATTEMPTS) {
+        await new Promise((r) => setTimeout(r, 10 * 2 ** (attempt - 1)));
+      }
+    }
+  }
+  console.warn(`[takeSnapshotWithRetry] Snapshot failed after ${MAX_RETRIES} retries (${TOTAL_ATTEMPTS} attempts): ${lastError.message}`);
+  try {
+    emit("snapshot_failed", {
+      error: lastError.message,
+      retries: MAX_RETRIES,
+      source: telemetrySource
+    });
+  } catch {}
+}
+async function takeSnapshotEvent(directory, plan, options) {
+  const payloadHash = computePlanHash(plan);
+  const snapshotPayload = {
+    plan,
+    payload_hash: payloadHash
+  };
+  if (options?.approvalMetadata) {
+    snapshotPayload.approval = options.approvalMetadata;
+  }
+  const planId = derivePlanId(plan);
+  return appendLedgerEvent(directory, {
+    event_type: "snapshot",
+    source: options?.source ?? "takeSnapshotEvent",
+    plan_id: planId,
+    payload: snapshotPayload
+  }, { planHashAfter: options?.planHashAfter });
+}
+async function replayFromLedger(directory, _options) {
+  const { events, truncated, badSuffix } = await readLedgerEventsWithIntegrity(directory);
+  if (events.length === 0) {
+    return null;
+  }
+  if (truncated && badSuffix !== null) {
+    await quarantineLedgerSuffix(directory, badSuffix);
+  }
+  const targetPlanId = events[0].plan_id;
+  const relevantEvents = events.filter((e) => e.plan_id === targetPlanId);
+  {
+    const snapshotEvents = relevantEvents.filter((e) => e.event_type === "snapshot");
+    if (snapshotEvents.length > 0) {
+      const latestSnapshotEvent = snapshotEvents[snapshotEvents.length - 1];
+      const snapshotPayload = latestSnapshotEvent.payload;
+      let plan2 = snapshotPayload.plan;
+      const eventsAfterSnapshot = relevantEvents.filter((e) => e.seq > latestSnapshotEvent.seq);
+      for (const event of eventsAfterSnapshot) {
+        plan2 = applyEventToPlan(plan2, event);
+        if (plan2 === null) {
+          return null;
+        }
+      }
+      return plan2;
+    }
+  }
+  const createdEvent = relevantEvents.find((e) => e.event_type === "plan_created");
+  if (createdEvent?.payload && typeof createdEvent.payload === "object" && "plan" in createdEvent.payload) {
+    const parseResult = PlanSchema.safeParse(createdEvent.payload.plan);
+    if (parseResult.success) {
+      let plan2 = parseResult.data;
+      const eventsAfterCreated = relevantEvents.filter((e) => e.seq > createdEvent.seq);
+      for (const event of eventsAfterCreated) {
+        if (plan2 === null)
+          return null;
+        plan2 = applyEventToPlan(plan2, event);
+      }
+      return plan2;
+    }
+  }
+  const planJsonPath = getPlanJsonPath(directory);
+  if (!fs2.existsSync(planJsonPath)) {
+    return null;
+  }
+  let plan;
+  try {
+    const content = fs2.readFileSync(planJsonPath, "utf8");
+    plan = JSON.parse(content);
+  } catch {
+    return null;
+  }
+  for (const event of relevantEvents) {
+    if (plan === null) {
+      return null;
+    }
+    plan = applyEventToPlan(plan, event);
+  }
+  return plan;
+}
+function applyEventToPlan(plan, event) {
+  switch (event.event_type) {
+    case "plan_created":
+      if (event.payload && typeof event.payload === "object" && "plan" in event.payload) {
+        const parsed = PlanSchema.safeParse(event.payload.plan);
+        if (parsed.success)
+          return parsed.data;
+      }
+      return plan;
+    case "task_status_changed":
+      if (event.task_id && event.to_status) {
+        const parseResult = TaskStatusSchema.safeParse(event.to_status);
+        if (!parseResult.success) {
+          return plan;
+        }
+        for (const phase of plan.phases) {
+          const task = phase.tasks.find((t) => t.id === event.task_id);
+          if (task) {
+            task.status = parseResult.data;
+            break;
+          }
+        }
+      }
+      return plan;
+    case "phase_completed":
+      if (event.phase_id) {
+        const phase = plan.phases.find((p) => p.id === event.phase_id);
+        if (phase) {
+          phase.status = "complete";
+        }
+      }
+      return plan;
+    case "plan_exported":
+      return plan;
+    case "task_added":
+      return plan;
+    case "task_removed":
+      if (event.task_id) {
+        for (const phase of plan.phases) {
+          const idx = phase.tasks.findIndex((t) => t.id === event.task_id);
+          if (idx !== -1) {
+            phase.tasks.splice(idx, 1);
+            break;
+          }
+        }
+      }
+      return plan;
+    case "task_updated":
+      return plan;
+    case "plan_rebuilt":
+      return plan;
+    case "task_reordered":
+      return plan;
+    case "snapshot":
+      return plan;
+    case "plan_reset":
+      return null;
+    case "execution_profile_set": {
+      const rawProfile = event.payload?.execution_profile;
+      if (rawProfile !== undefined) {
+        const parsed = ExecutionProfileSchema.safeParse(rawProfile);
+        if (parsed.success) {
+          return { ...plan, execution_profile: parsed.data };
+        }
+      }
+      return plan;
+    }
+    case "execution_profile_locked": {
+      if (plan.execution_profile) {
+        return {
+          ...plan,
+          execution_profile: { ...plan.execution_profile, locked: true }
+        };
+      }
+      return plan;
+    }
+    default:
+      throw new Error(`applyEventToPlan: unhandled event type "${event.event_type}" at seq ${event.seq}`);
+  }
+}
+async function readLedgerEventsWithIntegrity(directory) {
+  const ledgerPath = getLedgerPath(directory);
+  if (!fs2.existsSync(ledgerPath)) {
+    return { events: [], truncated: false, badSuffix: null };
+  }
+  try {
+    const content = fs2.readFileSync(ledgerPath, "utf8");
+    const lines = content.split(`
+`);
+    const events = [];
+    let truncated = false;
+    let badSuffix = null;
+    for (let i = 0;i < lines.length; i++) {
+      const line = lines[i];
+      if (line.trim() === "") {
+        continue;
+      }
+      try {
+        const event = JSON.parse(line);
+        events.push(event);
+      } catch {
+        truncated = true;
+        badSuffix = lines.slice(i).join(`
+`);
+        break;
+      }
+    }
+    events.sort((a, b) => a.seq - b.seq);
+    return { events, truncated, badSuffix };
+  } catch {
+    return { events: [], truncated: false, badSuffix: null };
+  }
+}
+async function quarantineLedgerSuffix(directory, badSuffix) {
+  try {
+    const quarantinePath = path2.join(directory, ".swarm", "plan-ledger.quarantine");
+    fs2.writeFileSync(quarantinePath, badSuffix, "utf8");
+    console.warn(`[ledger] Corrupted suffix quarantined to ${path2.relative(directory, quarantinePath)}`);
+  } catch {}
+}
+async function loadLastApprovedPlan(directory, expectedPlanId) {
+  const events = await readLedgerEvents(directory);
+  if (events.length === 0) {
+    return null;
+  }
+  for (let i = events.length - 1;i >= 0; i--) {
+    const event = events[i];
+    if (event.event_type !== "snapshot")
+      continue;
+    if (event.source !== "critic_approved")
+      continue;
+    if (expectedPlanId !== undefined && event.plan_id !== expectedPlanId) {
+      continue;
+    }
+    const payload = event.payload;
+    if (!payload || typeof payload !== "object" || !payload.plan) {
+      continue;
+    }
+    if (expectedPlanId !== undefined) {
+      const payloadPlanId = derivePlanId(payload.plan);
+      if (payloadPlanId !== expectedPlanId) {
+        continue;
+      }
+    }
+    return {
+      plan: payload.plan,
+      seq: event.seq,
+      timestamp: event.timestamp,
+      approval: payload.approval,
+      payloadHash: payload.payload_hash
+    };
+  }
+  return null;
+}
+
+// src/plan/manager.ts
+class PlanConcurrentModificationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PlanConcurrentModificationError";
+  }
+}
+
+class PlanTaskRemovalNotAcknowledgedError extends Error {
+  missingTasks;
+  constructor(missingTasks) {
+    const idList = missingTasks.map((t) => `${t.id}(${t.status})`).join(", ");
+    super(`PLAN_TASK_REMOVAL_NOT_ACKNOWLEDGED: the following tasks were present in the prior plan but missing from the new save: ${idList}. Pass acknowledged_removals.ids covering all missing task IDs with a non-empty reason to proceed.`);
+    this.name = "PlanTaskRemovalNotAcknowledgedError";
+    this.missingTasks = missingTasks;
+  }
+}
+var startupLedgerCheckedWorkspaces = new Set;
+var recoveryMutexes = new Map;
+var PLAN_JSON_CACHE_NAMESPACE = "plan-json:validated:v1";
+var _internals2 = {
+  loadPlan,
+  loadPlanJsonOnly,
+  regeneratePlanMarkdown
+};
+var CAS_BACKOFF_START_MS = 5;
+var CAS_BACKOFF_CAP_MS = 250;
+var CAS_BACKOFF_JITTER = 0.25;
+var CAS_MAX_RETRIES = 3;
+async function retryCasWithBackoff(directory, eventInput, options) {
+  const maxRetries = options.maxRetries ?? CAS_MAX_RETRIES;
+  let currentExpected = options.expectedHash;
+  let attempt = 0;
+  while (true) {
+    try {
+      return await appendLedgerEvent(directory, eventInput, {
+        expectedHash: currentExpected,
+        planHashAfter: options.planHashAfter
+      });
+    } catch (error) {
+      if (!(error instanceof LedgerStaleWriterError) || attempt >= maxRetries) {
+        throw error;
+      }
+      attempt++;
+      const base = Math.min(CAS_BACKOFF_START_MS * 2 ** (attempt - 1), CAS_BACKOFF_CAP_MS);
+      const jitter = base * CAS_BACKOFF_JITTER * (Math.random() * 2 - 1);
+      const delayMs = Math.max(1, Math.round(base + jitter));
+      emit("plan_ledger_cas_retry", {
+        attempt,
+        expectedHashPrefix: currentExpected.slice(0, 8),
+        delayMs
+      });
+      await new Promise((resolve3) => setTimeout(resolve3, delayMs));
+      if (options.verifyValid) {
+        const stillValid = await options.verifyValid();
+        if (!stillValid)
+          return null;
+      }
+      currentExpected = computeCurrentPlanHash(directory);
+    }
+  }
+}
+async function loadPlanJsonOnly(directory) {
+  try {
+    return await parsePlanJsonCached(directory);
+  } catch (error) {
+    warn(`Plan validation failed for .swarm/plan.json: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return null;
+}
+function compareTaskIds(a, b) {
+  const partsA = a.split(".").map((n) => parseInt(n, 10));
+  const partsB = b.split(".").map((n) => parseInt(n, 10));
+  const maxLen = Math.max(partsA.length, partsB.length);
+  for (let i = 0;i < maxLen; i++) {
+    const numA = partsA[i] ?? 0;
+    const numB = partsB[i] ?? 0;
+    if (numA !== numB) {
+      return numA - numB;
+    }
+  }
+  return 0;
+}
+async function getLatestLedgerHash(directory) {
+  try {
+    const events = await readLedgerEvents(directory);
+    if (events.length === 0)
+      return "";
+    const lastEvent = events[events.length - 1];
+    return lastEvent.plan_hash_after;
+  } catch {
+    return "";
+  }
+}
+async function parsePlanJsonCached(directory) {
+  const planJsonPath = path3.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");
+    }
+    const parsed = JSON.parse(planJsonContent);
+    return PlanSchema.parse(parsed);
+  });
+}
+function computePlanContentHash(plan) {
+  const content = {
+    schema_version: plan.schema_version,
+    title: plan.title,
+    swarm: plan.swarm,
+    current_phase: plan.current_phase,
+    migration_status: plan.migration_status,
+    phases: plan.phases.map((phase) => ({
+      id: phase.id,
+      name: phase.name,
+      status: phase.status,
+      tasks: phase.tasks.map((task) => ({
+        id: task.id,
+        phase: task.phase,
+        status: task.status,
+        size: task.size,
+        description: task.description,
+        depends: [...task.depends].sort(compareTaskIds),
+        acceptance: task.acceptance,
+        files_touched: [...task.files_touched].sort(),
+        evidence_path: task.evidence_path,
+        blocked_reason: task.blocked_reason
+      })).sort((a, b) => compareTaskIds(a.id, b.id))
+    })).sort((a, b) => a.id - b.id)
+  };
+  const jsonString = JSON.stringify(content);
+  return bunHash(jsonString).toString(36);
+}
+function extractPlanHashFromMarkdown(markdown) {
+  const match = markdown.match(/<!--\s*PLAN_HASH:\s*(\S+)\s*-->/);
+  return match ? match[1] : null;
+}
+async function isPlanMdInSync(directory, plan) {
+  const planMdContent = await readSwarmFileAsync(directory, "plan.md");
+  if (planMdContent === null) {
+    return false;
+  }
+  const expectedHash = computePlanContentHash(plan);
+  const existingHash = extractPlanHashFromMarkdown(planMdContent);
+  if (existingHash === expectedHash) {
+    return true;
+  }
+  const expectedMarkdown = derivePlanMarkdown(plan);
+  const normalizedExpected = expectedMarkdown.trim();
+  const normalizedActual = planMdContent.trim();
+  if (normalizedActual === normalizedExpected) {
+    return true;
+  }
+  return normalizedActual.includes(normalizedExpected) || normalizedExpected.includes(normalizedActual.replace(/^#.*$/gm, "").trim());
+}
+async function regeneratePlanMarkdown(directory, plan) {
+  const swarmDir = path3.resolve(directory, ".swarm");
+  const contentHash = computePlanContentHash(plan);
+  const markdown = derivePlanMarkdown(plan);
+  const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
+${markdown}`;
+  const mdPath = path3.join(swarmDir, "plan.md");
+  const mdTempPath = path3.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  try {
+    await bunWrite(mdTempPath, markdownWithHash);
+    renameSync3(mdTempPath, mdPath);
+  } finally {
+    try {
+      unlinkSync(mdTempPath);
+    } catch {}
+  }
+}
+async function loadPlan(directory) {
+  const planJsonContent = await readSwarmFileAsync(directory, "plan.json");
+  if (planJsonContent !== null) {
+    if (planJsonContent.includes("\x00") || planJsonContent.includes("\uFFFD")) {
+      warn("Plan rejected: .swarm/plan.json contains null bytes or invalid encoding");
+    } else {
+      try {
+        const validated = await parsePlanJsonCached(directory);
+        if (validated === null) {
+          warn("[loadPlan] plan.json disappeared during cached parse. Falling back to plan.md migration or ledger recovery.");
+        } else {
+          const inSync = await isPlanMdInSync(directory, validated);
+          if (!inSync) {
+            try {
+              await _internals2.regeneratePlanMarkdown(directory, validated);
+            } catch (regenError) {
+              warn(`Failed to regenerate plan.md: ${regenError instanceof Error ? regenError.message : String(regenError)}. Proceeding with plan.json only.`);
+            }
+          }
+          if (await ledgerExists(directory)) {
+            const planHash = computePlanHash(validated);
+            const ledgerHash = await getLatestLedgerHash(directory);
+            const resolvedWorkspace = path3.resolve(directory);
+            if (!startupLedgerCheckedWorkspaces.has(resolvedWorkspace)) {
+              startupLedgerCheckedWorkspaces.add(resolvedWorkspace);
+              if (ledgerHash !== "" && planHash !== ledgerHash) {
+                const currentPlanId = derivePlanId(validated);
+                const ledgerEvents = await readLedgerEvents(directory);
+                const firstEvent = ledgerEvents.length > 0 ? ledgerEvents[0] : null;
+                if (firstEvent && firstEvent.plan_id !== currentPlanId) {
+                  warn(`[loadPlan] Ledger identity mismatch (ledger: ${firstEvent.plan_id}, plan: ${currentPlanId}) \u2014 skipping ledger rebuild (migration detected). Use /swarm reset-session to reinitialize the ledger.`);
+                } else {
+                  warn("[loadPlan] plan.json is stale (hash mismatch with ledger) \u2014 rebuilding from ledger. If this recurs, run /swarm reset-session to clear stale session state.");
+                  try {
+                    const rebuilt = await replayFromLedger(directory);
+                    if (rebuilt) {
+                      await rebuildPlan(directory, rebuilt, {
+                        reason: "ledger_hash_mismatch_recovery"
+                      });
+                      warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at .swarm/SWARM_PLAN.md if it exists.");
+                      return rebuilt;
+                    }
+                  } catch (replayError) {
+                    try {
+                      const approved = await loadLastApprovedPlan(directory, currentPlanId);
+                      if (approved) {
+                        await rebuildPlan(directory, approved.plan, {
+                          reason: "approved_snapshot_fallback"
+                        });
+                        try {
+                          await takeSnapshotEvent(directory, approved.plan, {
+                            source: "recovery_from_approved_snapshot",
+                            approvalMetadata: approved.approval
+                          });
+                        } catch (healError) {
+                          warn(`[loadPlan] Recovery-heal snapshot append failed: ${healError instanceof Error ? healError.message : String(healError)}. Next loadPlan may re-enter recovery path.`);
+                        }
+                        const approvedPhase = approved.approval && typeof approved.approval === "object" && "phase" in approved.approval ? approved.approval.phase : undefined;
+                        warn(`[loadPlan] Ledger replay failed (${replayError instanceof Error ? replayError.message : String(replayError)}) \u2014 recovered from critic-approved snapshot seq=${approved.seq} (approval phase=${approvedPhase ?? "unknown"}, timestamp=${approved.timestamp}). This may roll the plan back to an earlier phase \u2014 verify before continuing.`);
+                        return approved.plan;
+                      }
+                    } catch {}
+                    warn(`[loadPlan] Ledger replay failed during hash-mismatch rebuild: ${replayError instanceof Error ? replayError.message : String(replayError)}. Returning stale plan.json. To recover: check .swarm/SWARM_PLAN.md for a checkpoint, or run /swarm reset-session.`);
+                  }
+                }
+              }
+            } else if (ledgerHash !== "" && planHash !== ledgerHash) {
+              if (process.env.DEBUG_SWARM) {
+                console.warn(`[loadPlan] Ledger hash mismatch during active session for ${resolvedWorkspace} \u2014 skipping rebuild (startup check already performed).`);
+              }
+            }
+          }
+          if (validated.specHash) {
+            const staleResult = await isSpecStale(directory, validated);
+            if (staleResult.stale) {
+              const runtimePlan = validated;
+              runtimePlan._specStale = true;
+              runtimePlan._specStaleReason = staleResult.reason;
+              try {
+                const specStalenessPath = path3.join(directory, ".swarm", "spec-staleness.json");
+                await fsPromises.writeFile(specStalenessPath, JSON.stringify({
+                  type: "spec_stale_detected",
+                  timestamp: new Date().toISOString(),
+                  phase: validated.current_phase ?? 1,
+                  specHash_plan: validated.specHash,
+                  specHash_current: staleResult.currentHash ?? null,
+                  reason: staleResult.reason,
+                  planTitle: validated.title
+                }, null, 2), "utf-8");
+              } catch {}
+              try {
+                const eventsPath = path3.join(directory, ".swarm", "events.jsonl");
+                const event = {
+                  type: "spec_stale_detected",
+                  timestamp: new Date().toISOString(),
+                  phase: validated.current_phase ?? 1,
+                  specHash_plan: validated.specHash,
+                  specHash_current: staleResult.currentHash ?? null,
+                  reason: staleResult.reason ?? "unknown",
+                  planTitle: validated.title
+                };
+                await fsPromises.appendFile(eventsPath, `${JSON.stringify(event)}
+`, "utf-8");
+              } catch {}
+            }
+          }
+          return validated;
+        }
+      } catch (error) {
+        warn(`[loadPlan] plan.json validation failed: ${error instanceof Error ? error.message : String(error)}. Attempting rebuild from ledger. If rebuild fails, check .swarm/SWARM_PLAN.md for a checkpoint.`);
+        let rawPlanId = null;
+        try {
+          const rawParsed = JSON.parse(planJsonContent);
+          if (typeof rawParsed?.swarm === "string" && typeof rawParsed?.title === "string") {
+            rawPlanId = derivePlanId(rawParsed);
+          }
+        } catch {}
+        if (await ledgerExists(directory)) {
+          const ledgerEventsForCatch = await readLedgerEvents(directory);
+          const catchFirstEvent = ledgerEventsForCatch.length > 0 ? ledgerEventsForCatch[0] : null;
+          const identityMatch = rawPlanId === null || catchFirstEvent === null || catchFirstEvent.plan_id === rawPlanId;
+          if (!identityMatch) {
+            warn(`[loadPlan] Ledger identity mismatch in validation-failure path (ledger: ${catchFirstEvent?.plan_id}, plan: ${rawPlanId}) \u2014 skipping ledger rebuild (migration detected).`);
+          } else if (catchFirstEvent !== null && rawPlanId !== null) {
+            const rebuilt = await replayFromLedger(directory);
+            if (rebuilt) {
+              await rebuildPlan(directory, rebuilt, {
+                reason: "validation_failure_recovery"
+              });
+              warn("[loadPlan] Rebuilt plan from ledger after validation failure. Projection was stale.");
+              return rebuilt;
+            }
+          }
+        }
+        const planMdContent2 = await readSwarmFileAsync(directory, "plan.md");
+        if (planMdContent2 !== null) {
+          const migrated = migrateLegacyPlan(planMdContent2);
+          const { removedCount } = await savePlanWithAutoAcknowledgedRemovals(directory, migrated, "load_plan_migration_from_md", "migrate legacy plan.md to plan.json");
+          if (removedCount > 0) {
+            migrated._midLoadRemovals = {
+              count: removedCount,
+              source: "load_plan_migration_from_md"
+            };
+          }
+          return migrated;
+        }
+      }
+    }
+  }
+  const planMdContent = await readSwarmFileAsync(directory, "plan.md");
+  if (planMdContent !== null) {
+    const migrated = migrateLegacyPlan(planMdContent);
+    await savePlan(directory, migrated);
+    return migrated;
+  }
+  if (await ledgerExists(directory)) {
+    const resolvedDir = path3.resolve(directory);
+    const existingMutex = recoveryMutexes.get(resolvedDir);
+    if (existingMutex) {
+      await existingMutex;
+      const postRecoveryPlan = await _internals2.loadPlanJsonOnly(directory);
+      if (postRecoveryPlan)
+        return postRecoveryPlan;
+    }
+    let resolveRecovery;
+    const mutex = new Promise((r) => {
+      resolveRecovery = r;
+    });
+    recoveryMutexes.set(resolvedDir, mutex);
+    try {
+      const rebuilt = await replayFromLedger(directory);
+      if (rebuilt) {
+        const { removedCount } = await savePlanWithAutoAcknowledgedRemovals(directory, rebuilt, "load_plan_rebuild_from_ledger", "rebuild plan from ledger replay");
+        if (removedCount > 0) {
+          rebuilt._midLoadRemovals = {
+            count: removedCount,
+            source: "load_plan_rebuild_from_ledger"
+          };
+        }
+        return rebuilt;
+      }
+      try {
+        const anchorEvents = await readLedgerEvents(directory);
+        if (anchorEvents.length === 0) {
+          warn("[loadPlan] Ledger present but no events readable \u2014 refusing approved-snapshot recovery (cannot verify plan identity).");
+          return null;
+        }
+        const expectedPlanId = anchorEvents[0].plan_id;
+        const approved = await loadLastApprovedPlan(directory, expectedPlanId);
+        if (approved) {
+          const approvedPhase = approved.approval && typeof approved.approval === "object" && "phase" in approved.approval ? approved.approval.phase : undefined;
+          warn(`[loadPlan] Ledger replay returned no plan \u2014 recovered from critic-approved snapshot seq=${approved.seq} timestamp=${approved.timestamp} (approval phase=${approvedPhase ?? "unknown"}). This may roll the plan back to an earlier phase \u2014 verify before continuing.`);
+          const { removedCount: snapshotRemovedCount } = await savePlanWithAutoAcknowledgedRemovals(directory, approved.plan, "load_plan_recovery_from_approved_snapshot", "restore from critic-approved snapshot");
+          if (snapshotRemovedCount > 0) {
+            approved.plan._midLoadRemovals = {
+              count: snapshotRemovedCount,
+              source: "load_plan_recovery_from_approved_snapshot"
+            };
+          }
+          try {
+            await takeSnapshotEvent(directory, approved.plan, {
+              source: "recovery_from_approved_snapshot",
+              approvalMetadata: approved.approval
+            });
+          } catch (healError) {
+            warn(`[loadPlan] Recovery-heal snapshot append failed: ${healError instanceof Error ? healError.message : String(healError)}. Next loadPlan may re-enter recovery path.`);
+          }
+          return approved.plan;
+        }
+      } catch (recoveryError) {
+        warn(`[loadPlan] Approved-snapshot recovery failed: ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`);
+      }
+    } finally {
+      resolveRecovery();
+      recoveryMutexes.delete(resolvedDir);
+    }
+  }
+  return null;
+}
+async function savePlanWithAutoAcknowledgedRemovals(directory, plan, source, reason, options) {
+  const existing = await _internals2.loadPlanJsonOnly(directory);
+  const newIds = new Set;
+  for (const phase of plan.phases) {
+    for (const task of phase.tasks)
+      newIds.add(task.id);
+  }
+  const removedIds = [];
+  if (existing) {
+    for (const phase of existing.phases) {
+      for (const task of phase.tasks) {
+        if (!newIds.has(task.id))
+          removedIds.push(task.id);
+      }
+    }
+  }
+  await savePlan(directory, plan, {
+    ...options ?? {},
+    acknowledged_removals: { ids: removedIds, reason, source }
+  });
+  return { removedCount: removedIds.length };
+}
+async function savePlan(directory, plan, options) {
+  if (directory === null || directory === undefined || typeof directory !== "string" || directory.trim().length === 0) {
+    throw new Error(`Invalid directory: directory must be a non-empty string`);
+  }
+  const validated = PlanSchema.parse(plan);
+  if (options?.preserveCompletedStatuses !== false) {
+    try {
+      const currentPlan2 = await _internals2.loadPlanJsonOnly(directory);
+      if (currentPlan2) {
+        const completedTaskIds = new Set;
+        for (const phase of currentPlan2.phases) {
+          for (const task of phase.tasks) {
+            if (task.status === "completed")
+              completedTaskIds.add(task.id);
+          }
+        }
+        if (completedTaskIds.size > 0) {
+          for (const phase of validated.phases) {
+            for (const task of phase.tasks) {
+              if (completedTaskIds.has(task.id) && task.status !== "completed") {
+                task.status = "completed";
+              }
+            }
+          }
+        }
+      }
+    } catch {}
+  }
+  for (const phase of validated.phases) {
+    const tasks = phase.tasks;
+    if (tasks.length > 0 && tasks.every((t) => t.status === "completed")) {
+      phase.status = "complete";
+    } else if (tasks.some((t) => t.status === "in_progress")) {
+      phase.status = "in_progress";
+    } else if (tasks.some((t) => t.status === "blocked")) {
+      phase.status = "blocked";
+    } else {
+      phase.status = "pending";
+    }
+  }
+  const currentPlan = await _internals2.loadPlanJsonOnly(directory);
+  const planId = derivePlanId(validated);
+  const planHashForInit = computePlanHash(validated);
+  if (!await ledgerExists(directory)) {
+    try {
+      await initLedger(directory, planId, planHashForInit, validated);
+    } catch (initErr) {
+      const msg = initErr instanceof Error ? initErr.message : String(initErr);
+      if (!/already initialized/i.test(msg)) {
+        throw initErr;
+      }
+    }
+  } else {
+    const existingEvents = await readLedgerEvents(directory);
+    if (existingEvents.length > 0 && existingEvents[0].plan_id !== planId) {
+      const swarmDir2 = path3.resolve(directory, ".swarm");
+      const oldLedgerPath = path3.join(swarmDir2, "plan-ledger.jsonl");
+      const oldLedgerBackupPath = path3.join(swarmDir2, `plan-ledger.backup-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
+      let backupExists = false;
+      if (existsSync3(oldLedgerPath)) {
+        try {
+          renameSync3(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.`);
+        }
+      }
+      let initSucceeded = false;
+      if (backupExists) {
+        try {
+          await initLedger(directory, planId, planHashForInit, validated);
+          initSucceeded = true;
+        } catch (initErr) {
+          const errorMessage = String(initErr);
+          if (errorMessage.includes("already initialized")) {
+            try {
+              if (existsSync3(oldLedgerBackupPath))
+                unlinkSync(oldLedgerBackupPath);
+            } catch {}
+          } else {
+            if (existsSync3(oldLedgerBackupPath)) {
+              try {
+                renameSync3(oldLedgerBackupPath, oldLedgerPath);
+              } catch {
+                copyFileSync(oldLedgerBackupPath, oldLedgerPath);
+                try {
+                  unlinkSync(oldLedgerBackupPath);
+                } catch {}
+              }
+            }
+            throw initErr;
+          }
+        }
+      }
+      if (initSucceeded && backupExists) {
+        const archivePath = path3.join(swarmDir2, `plan-ledger.archived-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
+        try {
+          renameSync3(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 (existsSync3(oldLedgerBackupPath))
+              unlinkSync(oldLedgerBackupPath);
+          } catch {}
+        }
+      } else if (!initSucceeded && backupExists) {
+        try {
+          if (existsSync3(oldLedgerBackupPath))
+            unlinkSync(oldLedgerBackupPath);
+        } catch {}
+      }
+      const MAX_ARCHIVED_SIBLINGS = 5;
+      try {
+        const allFiles = readdirSync2(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 {
+              unlinkSync(path3.join(swarmDir2, file));
+            } catch {}
+          }
+        }
+      } catch {}
+    }
+  }
+  const currentHash = computeCurrentPlanHash(directory);
+  const hashAfter = computePlanHash(validated);
+  if (currentPlan) {
+    const oldTaskMap = new Map;
+    for (const phase of currentPlan.phases) {
+      for (const task of phase.tasks) {
+        oldTaskMap.set(task.id, { phase: task.phase, status: task.status });
+      }
+    }
+    const newTaskIds = new Set;
+    for (const phase of validated.phases) {
+      for (const task of phase.tasks)
+        newTaskIds.add(task.id);
+    }
+    const missingTasks = [];
+    for (const [id, info] of oldTaskMap.entries()) {
+      if (!newTaskIds.has(id)) {
+        missingTasks.push({ id, phase: info.phase, status: info.status });
+      }
+    }
+    const ack = options?.acknowledged_removals;
+    if (missingTasks.length > 0) {
+      if (!ack) {
+        throw new PlanTaskRemovalNotAcknowledgedError(missingTasks);
+      }
+      if (typeof ack.reason !== "string" || ack.reason.trim().length === 0) {
+        throw new Error("PLAN_ACKNOWLEDGED_REMOVAL_INVALID: acknowledged_removals.reason must be a non-empty string.");
+      }
+      if (typeof ack.source !== "string" || ack.source.trim().length === 0) {
+        throw new Error("PLAN_ACKNOWLEDGED_REMOVAL_INVALID: acknowledged_removals.source must be a non-empty string.");
+      }
+      const ackSet = new Set(ack.ids);
+      const missingIdsSet = new Set(missingTasks.map((t) => t.id));
+      const unacked = missingTasks.filter((t) => !ackSet.has(t.id));
+      if (unacked.length > 0) {
+        throw new PlanTaskRemovalNotAcknowledgedError(unacked);
+      }
+      for (const id of ack.ids) {
+        if (!missingIdsSet.has(id)) {
+          throw new Error(`PLAN_ACKNOWLEDGED_REMOVAL_INVALID: acknowledged_removals contains "${id}" but that task is not missing from the plan.`);
+        }
+      }
+      try {
+        for (const missing of missingTasks) {
+          const eventInput = {
+            plan_id: derivePlanId(validated),
+            event_type: "task_removed",
+            task_id: missing.id,
+            phase_id: missing.phase,
+            from_status: missing.status,
+            source: ack.source,
+            payload: { reason: ack.reason, source: ack.source }
+          };
+          const capturedTaskId = missing.id;
+          await retryCasWithBackoff(directory, eventInput, {
+            expectedHash: currentHash,
+            planHashAfter: hashAfter,
+            verifyValid: async () => {
+              const onDisk = await _internals2.loadPlanJsonOnly(directory);
+              if (!onDisk)
+                return true;
+              for (const p of onDisk.phases) {
+                if (p.tasks.some((x) => x.id === capturedTaskId))
+                  return true;
+              }
+              return false;
+            }
+          });
+        }
+      } catch (error) {
+        if (error instanceof LedgerStaleWriterError) {
+          throw new PlanConcurrentModificationError(`Concurrent plan modification detected after retries: ${error.message}. Please retry the operation.`);
+        }
+        throw error;
+      }
+    }
+    try {
+      for (const phase of validated.phases) {
+        for (const task of phase.tasks) {
+          const oldTask = oldTaskMap.get(task.id);
+          if (oldTask && oldTask.status !== task.status) {
+            const eventInput = {
+              plan_id: derivePlanId(validated),
+              event_type: "task_status_changed",
+              task_id: task.id,
+              phase_id: phase.id,
+              from_status: oldTask.status,
+              to_status: task.status,
+              source: "savePlan"
+            };
+            const capturedFromStatus = oldTask.status;
+            const capturedTaskId = task.id;
+            await retryCasWithBackoff(directory, eventInput, {
+              expectedHash: currentHash,
+              planHashAfter: hashAfter,
+              verifyValid: async () => {
+                const onDisk = await _internals2.loadPlanJsonOnly(directory);
+                if (!onDisk)
+                  return true;
+                for (const p of onDisk.phases) {
+                  const t = p.tasks.find((x) => x.id === capturedTaskId);
+                  if (t) {
+                    return t.status === capturedFromStatus;
+                  }
+                }
+                return false;
+              }
+            });
+          }
+        }
+      }
+    } catch (error) {
+      if (error instanceof LedgerStaleWriterError) {
+        throw new PlanConcurrentModificationError(`Concurrent plan modification detected after retries: ${error.message}. Please retry the operation.`);
+      }
+      throw error;
+    }
+  }
+  const SNAPSHOT_INTERVAL = 50;
+  const latestSeq = await getLatestLedgerSeq(directory);
+  if (latestSeq > 0 && latestSeq % SNAPSHOT_INTERVAL === 0) {
+    await takeSnapshotWithRetry(directory, validated, {
+      planHashAfter: hashAfter,
+      source: "savePlan_manager"
+    });
+  }
+  const swarmDir = path3.resolve(directory, ".swarm");
+  const planPath = path3.join(swarmDir, "plan.json");
+  const tempPath = path3.join(swarmDir, `plan.json.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  try {
+    await bunWrite(tempPath, JSON.stringify(validated, null, 2));
+    renameSync3(tempPath, planPath);
+  } finally {
+    try {
+      unlinkSync(tempPath);
+    } catch {}
+  }
+  try {
+    const markerPath = path3.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),
+      in_progress: true
+    });
+    await bunWrite(markerPath, inProgressMarker);
+  } catch {}
+  try {
+    const contentHash = computePlanContentHash(validated);
+    const markdown = derivePlanMarkdown(validated);
+    const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
+${markdown}`;
+    const mdPath = path3.join(swarmDir, "plan.md");
+    const mdTempPath = path3.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    try {
+      await bunWrite(mdTempPath, markdownWithHash);
+      renameSync3(mdTempPath, mdPath);
+    } finally {
+      try {
+        unlinkSync(mdTempPath);
+      } catch {}
+    }
+  } catch (mdError) {
+    const message = mdError instanceof Error ? mdError.message : String(mdError);
+    warn(`[savePlan] plan.md write failed (non-fatal, plan.json is authoritative): ${message}`);
+    try {
+      emit("plan_md_write_failed", {
+        directory,
+        error: message,
+        timestamp: new Date().toISOString()
+      });
+    } catch {}
+  }
+  try {
+    const markerPath = path3.join(swarmDir, ".plan-write-marker");
+    const tasksCount = validated.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,
+      tasks_count: tasksCount,
+      in_progress: false
+    });
+    await bunWrite(markerPath, marker);
+  } catch {}
+}
+async function rebuildPlan(directory, plan, options) {
+  const targetPlan = plan ?? await replayFromLedger(directory);
+  if (!targetPlan)
+    return null;
+  const swarmDir = path3.join(directory, ".swarm");
+  const planPath = path3.join(swarmDir, "plan.json");
+  const mdPath = path3.join(swarmDir, "plan.md");
+  const tempPlanPath = path3.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  await bunWrite(tempPlanPath, JSON.stringify(targetPlan, null, 2));
+  renameSync3(tempPlanPath, planPath);
+  try {
+    const markerPath = path3.join(swarmDir, ".plan-write-marker");
+    const inProgressMarker = JSON.stringify({
+      source: "plan_manager",
+      timestamp: new Date().toISOString(),
+      phases_count: targetPlan.phases.length,
+      tasks_count: targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0),
+      in_progress: true
+    });
+    await bunWrite(markerPath, inProgressMarker);
+  } catch {}
+  try {
+    const contentHash = computePlanContentHash(targetPlan);
+    const markdown = derivePlanMarkdown(targetPlan);
+    const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
+${markdown}`;
+    const tempMdPath = path3.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    await bunWrite(tempMdPath, markdownWithHash);
+    renameSync3(tempMdPath, mdPath);
+  } finally {
+    try {
+      const markerPath = path3.join(swarmDir, ".plan-write-marker");
+      const tasksCount = targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
+      const marker = JSON.stringify({
+        source: "plan_manager",
+        timestamp: new Date().toISOString(),
+        phases_count: targetPlan.phases.length,
+        tasks_count: tasksCount,
+        in_progress: false
+      });
+      await bunWrite(markerPath, marker);
+    } catch {}
+  }
+  try {
+    const planId = derivePlanId(targetPlan);
+    const planHashAfter = computePlanHash(targetPlan);
+    await appendLedgerEvent(directory, {
+      event_type: "plan_rebuilt",
+      source: "rebuildPlan",
+      plan_id: planId,
+      payload: {
+        reason: options?.reason ?? "ledger_replay_recovery",
+        phases_count: targetPlan.phases.length,
+        tasks_count: targetPlan.phases.reduce((sum, p) => sum + p.tasks.length, 0)
+      }
+    }, { planHashAfter });
+  } catch {}
+  return targetPlan;
+}
+async function closePlanTerminalState(directory, plan, options) {
+  const planId = derivePlanId(plan);
+  const validated = PlanSchema.parse(plan);
+  const hashAfter = computePlanHash(validated);
+  for (const taskId of options.closedTaskIds) {
+    let taskPhaseId;
+    for (const phase of validated.phases) {
+      if (phase.tasks.some((t) => t.id === taskId)) {
+        taskPhaseId = phase.id;
+        break;
+      }
+    }
+    const fromStatus = options.originalStatuses?.get(taskId) ?? "in_progress";
+    await appendLedgerEvent(directory, {
+      plan_id: planId,
+      event_type: "task_status_changed",
+      task_id: taskId,
+      phase_id: taskPhaseId,
+      from_status: fromStatus,
+      to_status: "closed",
+      source: "close_terminal"
+    }, { planHashAfter: hashAfter });
+  }
+  for (const phaseId of options.closedPhaseIds) {
+    await appendLedgerEvent(directory, {
+      plan_id: planId,
+      event_type: "phase_completed",
+      phase_id: phaseId,
+      source: "close_terminal"
+    }, { planHashAfter: hashAfter });
+  }
+  await takeSnapshotEvent(directory, validated, {
+    planHashAfter: hashAfter,
+    source: "close_terminal"
+  });
+  const swarmDir = path3.join(directory, ".swarm");
+  const planPath = path3.join(swarmDir, "plan.json");
+  const tempPlanPath = path3.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  await bunWrite(tempPlanPath, JSON.stringify(validated, null, 2));
+  renameSync3(tempPlanPath, planPath);
+  try {
+    const markerPath = path3.join(swarmDir, ".plan-write-marker");
+    const inProgressMarker = JSON.stringify({
+      source: "plan_manager_close",
+      timestamp: new Date().toISOString(),
+      phases_count: validated.phases.length,
+      tasks_count: validated.phases.reduce((sum, phase) => sum + phase.tasks.length, 0),
+      in_progress: true
+    });
+    await bunWrite(markerPath, inProgressMarker);
+  } catch {}
+  try {
+    const mdPath = path3.join(swarmDir, "plan.md");
+    const contentHash = computePlanContentHash(validated);
+    const markdown = derivePlanMarkdown(validated);
+    const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
+${markdown}`;
+    const mdTempPath = path3.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    await bunWrite(mdTempPath, markdownWithHash);
+    renameSync3(mdTempPath, mdPath);
+  } finally {
+    try {
+      const markerPath = path3.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",
+        timestamp: new Date().toISOString(),
+        phases_count: validated.phases.length,
+        tasks_count: tasksCount,
+        in_progress: false
+      });
+      await bunWrite(markerPath, marker);
+    } catch {}
+  }
+}
+function derivePlanMarkdown(plan) {
+  const statusMap = {
+    pending: "PENDING",
+    in_progress: "IN PROGRESS",
+    complete: "COMPLETE",
+    completed: "COMPLETE",
+    blocked: "BLOCKED",
+    closed: "CLOSED"
+  };
+  const now = new Date().toISOString();
+  const currentPhase = plan.current_phase ?? 1;
+  const phaseStatus = statusMap[plan.phases[currentPhase - 1]?.status] || "PENDING";
+  let markdown = `# ${plan.title}
+Swarm: ${plan.swarm}
+Phase: ${currentPhase} [${phaseStatus}] | Updated: ${now}
+`;
+  const sortedPhases = [...plan.phases].sort((a, b) => a.id - b.id);
+  for (const phase of sortedPhases) {
+    const phaseStatusText = statusMap[phase.status] || "PENDING";
+    markdown += `
+## Phase ${phase.id}: ${phase.name} [${phaseStatusText}]
+`;
+    const sortedTasks = [...phase.tasks].sort((a, b) => compareTaskIds(a.id, b.id));
+    let currentTaskMarked = false;
+    for (const task of sortedTasks) {
+      let taskLine = "";
+      let suffix = "";
+      if (task.status === "completed") {
+        taskLine = `- [x] ${task.id}: ${task.description}`;
+      } else if (task.status === "blocked") {
+        taskLine = `- [BLOCKED] ${task.id}: ${task.description}`;
+        if (task.blocked_reason) {
+          taskLine += ` - ${task.blocked_reason}`;
+        }
+      } else {
+        taskLine = `- [ ] ${task.id}: ${task.description}`;
+      }
+      taskLine += ` [${task.size.toUpperCase()}]`;
+      if (task.depends.length > 0) {
+        const sortedDepends = [...task.depends].sort();
+        suffix += ` (depends: ${sortedDepends.join(", ")})`;
+      }
+      if (phase.id === plan.current_phase && task.status === "in_progress" && !currentTaskMarked) {
+        suffix += " \u2190 CURRENT";
+        currentTaskMarked = true;
+      }
+      markdown += `${taskLine}${suffix}
+`;
+    }
+  }
+  const phaseSections = markdown.split(`
+## `);
+  if (phaseSections.length > 1) {
+    const header = phaseSections[0];
+    const phases = phaseSections.slice(1).map((p) => `## ${p}`);
+    markdown = `${header}
+---
+${phases.join(`
+---
+`)}`;
+  }
+  return `${markdown.trim()}
+`;
+}
+function migrateLegacyPlan(planContent, swarmId) {
+  const lines = planContent.split(`
+`);
+  let title = "Untitled Plan";
+  let swarm = swarmId || "default-swarm";
+  let currentPhaseNum = 1;
+  const phases = [];
+  let currentPhase = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("# ") && title === "Untitled Plan") {
+      title = trimmed.substring(2).trim();
+      continue;
+    }
+    if (trimmed.startsWith("Swarm:")) {
+      swarm = trimmed.substring(6).trim();
+      continue;
+    }
+    if (trimmed.startsWith("Phase:")) {
+      const match = trimmed.match(/Phase:\s*(\d+)/i);
+      if (match) {
+        currentPhaseNum = parseInt(match[1], 10);
+      }
+      continue;
+    }
+    const phaseMatch = trimmed.match(/^#{2,3}\s*Phase\s+(\d+)(?::\s*([^[]+))?\s*(?:\[([^\]]+)\])?/i);
+    if (phaseMatch) {
+      if (currentPhase !== null) {
+        phases.push(currentPhase);
+      }
+      const phaseId = parseInt(phaseMatch[1], 10);
+      const phaseName = phaseMatch[2]?.trim() || `Phase ${phaseId}`;
+      const statusText = phaseMatch[3]?.toLowerCase() || "pending";
+      const statusMap = {
+        complete: "complete",
+        completed: "complete",
+        "in progress": "in_progress",
+        in_progress: "in_progress",
+        inprogress: "in_progress",
+        pending: "pending",
+        blocked: "blocked"
+      };
+      currentPhase = {
+        id: phaseId,
+        name: phaseName,
+        status: statusMap[statusText] || "pending",
+        tasks: []
+      };
+      continue;
+    }
+    const taskMatch = trimmed.match(/^-\s*\[([^\]]+)\]\s+(\d+\.\d+):\s*(.+?)(?:\s*\[(\w+)\])?(?:\s*-\s*(.+))?$/i);
+    if (taskMatch && currentPhase !== null) {
+      const checkbox = taskMatch[1].toLowerCase();
+      const taskId = taskMatch[2];
+      let description = taskMatch[3].trim();
+      const sizeText = taskMatch[4]?.toLowerCase() || "small";
+      let blockedReason;
+      const dependsMatch = description.match(/\s*\(depends:\s*([^)]+)\)$/i);
+      const depends = [];
+      if (dependsMatch) {
+        const depsText = dependsMatch[1];
+        depends.push(...depsText.split(",").map((d) => d.trim()));
+        description = description.substring(0, dependsMatch.index).trim();
+      }
+      let status = "pending";
+      if (checkbox === "x") {
+        status = "completed";
+      } else if (checkbox === "blocked") {
+        status = "blocked";
+        const blockedReasonMatch = taskMatch[5];
+        if (blockedReasonMatch) {
+          blockedReason = blockedReasonMatch.trim();
+        }
+      }
+      const sizeMap = {
+        small: "small",
+        medium: "medium",
+        large: "large"
+      };
+      const task = {
+        id: taskId,
+        phase: currentPhase.id,
+        status,
+        size: sizeMap[sizeText] || "small",
+        description,
+        depends,
+        acceptance: undefined,
+        files_touched: [],
+        evidence_path: undefined,
+        blocked_reason: blockedReason
+      };
+      currentPhase.tasks.push(task);
+    }
+    const numberedTaskMatch = trimmed.match(/^(\d+)\.\s+(.+?)(?:\s*\[(\w+)\])?$/);
+    if (numberedTaskMatch && currentPhase !== null) {
+      const taskId = `${currentPhase.id}.${currentPhase.tasks.length + 1}`;
+      let description = numberedTaskMatch[2].trim();
+      const sizeText = numberedTaskMatch[3]?.toLowerCase() || "small";
+      const dependsMatch = description.match(/\s*\(depends:\s*([^)]+)\)$/i);
+      const depends = [];
+      if (dependsMatch) {
+        const depsText = dependsMatch[1];
+        depends.push(...depsText.split(",").map((d) => d.trim()));
+        description = description.substring(0, dependsMatch.index).trim();
+      }
+      const sizeMap = {
+        small: "small",
+        medium: "medium",
+        large: "large"
+      };
+      const task = {
+        id: taskId,
+        phase: currentPhase.id,
+        status: "pending",
+        size: sizeMap[sizeText] || "small",
+        description,
+        depends,
+        acceptance: undefined,
+        files_touched: [],
+        evidence_path: undefined,
+        blocked_reason: undefined
+      };
+      currentPhase.tasks.push(task);
+    }
+    const noPrefixTaskMatch = trimmed.match(/^-\s*\[([^\]]+)\]\s+(?!\d+\.\d+:)(.+?)(?:\s*\[(\w+)\])?(?:\s*-\s*(.+))?$/i);
+    if (noPrefixTaskMatch && currentPhase !== null) {
+      const checkbox = noPrefixTaskMatch[1].toLowerCase();
+      const taskId = `${currentPhase.id}.${currentPhase.tasks.length + 1}`;
+      let description = noPrefixTaskMatch[2].trim();
+      const sizeText = noPrefixTaskMatch[3]?.toLowerCase() || "small";
+      let blockedReason;
+      const dependsMatch = description.match(/\s*\(depends:\s*([^)]+)\)$/i);
+      const depends = [];
+      if (dependsMatch) {
+        const depsText = dependsMatch[1];
+        depends.push(...depsText.split(",").map((d) => d.trim()));
+        description = description.substring(0, dependsMatch.index).trim();
+      }
+      let status = "pending";
+      if (checkbox === "x") {
+        status = "completed";
+      } else if (checkbox === "blocked") {
+        status = "blocked";
+        const blockedReasonMatch = noPrefixTaskMatch[4];
+        if (blockedReasonMatch) {
+          blockedReason = blockedReasonMatch.trim();
+        }
+      }
+      const sizeMap = {
+        small: "small",
+        medium: "medium",
+        large: "large"
+      };
+      const task = {
+        id: taskId,
+        phase: currentPhase.id,
+        status,
+        size: sizeMap[sizeText] || "small",
+        description,
+        depends,
+        acceptance: undefined,
+        files_touched: [],
+        evidence_path: undefined,
+        blocked_reason: blockedReason
+      };
+      currentPhase.tasks.push(task);
+    }
+  }
+  if (currentPhase !== null) {
+    phases.push(currentPhase);
+  }
+  let migrationStatus = "migrated";
+  if (phases.length === 0) {
+    console.warn(`migrateLegacyPlan: 0 phases parsed from ${lines.length} lines. First 3 lines: ${lines.slice(0, 3).join(" | ")}`);
+    migrationStatus = "migration_failed";
+    phases.push({
+      id: 1,
+      name: "Migration Failed",
+      status: "blocked",
+      tasks: [
+        {
+          id: "1.1",
+          phase: 1,
+          status: "blocked",
+          size: "large",
+          description: "Review and restructure plan manually",
+          depends: [],
+          files_touched: [],
+          blocked_reason: "Legacy plan could not be parsed automatically"
+        }
+      ]
+    });
+  }
+  phases.sort((a, b) => a.id - b.id);
+  const plan = {
+    schema_version: "1.0.0",
+    title,
+    swarm,
+    current_phase: currentPhaseNum,
+    phases,
+    migration_status: migrationStatus
+  };
+  return plan;
+}
+
+// src/evidence/manager.ts
+import {
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync3,
+  realpathSync,
+  rmSync,
+  statSync
+} from "fs";
+import * as fs3 from "fs/promises";
+import * as path4 from "path";
+
+// src/config/evidence-schema.ts
+var EVIDENCE_MAX_JSON_BYTES = 500 * 1024;
+var EVIDENCE_MAX_PATCH_BYTES = 5 * 1024 * 1024;
+var EVIDENCE_MAX_TASK_BYTES = 20 * 1024 * 1024;
+var EvidenceTypeSchema = exports_external.enum([
+  "review",
+  "test",
+  "diff",
+  "approval",
+  "note",
+  "retrospective",
+  "syntax",
+  "placeholder",
+  "sast",
+  "sbom",
+  "build",
+  "quality_budget",
+  "secretscan",
+  "mutation-gate",
+  "drift-verification",
+  "hallucination-verification"
+]);
+var EvidenceVerdictSchema = exports_external.enum([
+  "pass",
+  "fail",
+  "warn",
+  "skip",
+  "approved",
+  "rejected",
+  "info"
+]);
+var BaseEvidenceSchema = exports_external.object({
+  task_id: exports_external.string().min(1),
+  type: EvidenceTypeSchema,
+  timestamp: exports_external.string().datetime(),
+  agent: exports_external.string().min(1),
+  verdict: EvidenceVerdictSchema,
+  summary: exports_external.string().min(1),
+  metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+});
+var ReviewEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("review"),
+  risk: exports_external.enum(["low", "medium", "high", "critical"]),
+  issues: exports_external.array(exports_external.object({
+    severity: exports_external.enum(["error", "warning", "info"]),
+    message: exports_external.string().min(1),
+    file: exports_external.string().optional(),
+    line: exports_external.number().int().optional()
+  })).default([])
+});
+var TestEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("test"),
+  tests_passed: exports_external.number().int().min(0),
+  tests_failed: exports_external.number().int().min(0),
+  test_file: exports_external.string().optional(),
+  failures: exports_external.array(exports_external.object({
+    name: exports_external.string().min(1),
+    message: exports_external.string().min(1)
+  })).default([])
+});
+var DiffEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("diff"),
+  files_changed: exports_external.array(exports_external.string()).default([]),
+  additions: exports_external.number().int().min(0).default(0),
+  deletions: exports_external.number().int().min(0).default(0),
+  patch_path: exports_external.string().optional()
+});
+var ApprovalEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("approval")
+});
+var NoteEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("note")
+});
+var RetrospectiveEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("retrospective"),
+  phase_number: exports_external.number().int().min(1).max(99),
+  total_tool_calls: exports_external.number().int().min(0).max(9999),
+  coder_revisions: exports_external.number().int().min(0).max(999),
+  reviewer_rejections: exports_external.number().int().min(0).max(999),
+  loop_detections: exports_external.number().int().min(0).max(9999).optional(),
+  circuit_breaker_trips: exports_external.number().int().min(0).max(9999).optional(),
+  test_failures: exports_external.number().int().min(0).max(9999),
+  security_findings: exports_external.number().int().min(0).max(999),
+  integration_issues: exports_external.number().int().min(0).max(999),
+  task_count: exports_external.number().int().min(1).max(9999),
+  task_complexity: exports_external.enum(["trivial", "simple", "moderate", "complex"]),
+  top_rejection_reasons: exports_external.array(exports_external.string()).default([]),
+  lessons_learned: exports_external.array(exports_external.string()).max(5).default([]),
+  user_directives: exports_external.array(exports_external.object({
+    directive: exports_external.string().min(1),
+    category: exports_external.enum([
+      "tooling",
+      "code_style",
+      "architecture",
+      "process",
+      "other"
+    ]),
+    scope: exports_external.enum(["session", "project", "global"])
+  })).default([]),
+  approaches_tried: exports_external.array(exports_external.object({
+    approach: exports_external.string().min(1),
+    result: exports_external.enum(["success", "failure", "partial"]),
+    abandoned_reason: exports_external.string().optional()
+  })).max(10).default([]),
+  error_taxonomy: exports_external.array(exports_external.enum([
+    "planning_error",
+    "interface_mismatch",
+    "logic_error",
+    "scope_creep",
+    "gate_evasion"
+  ])).default([])
+});
+var SyntaxEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("syntax"),
+  files_checked: exports_external.number().int(),
+  files_failed: exports_external.number().int(),
+  skipped_count: exports_external.number().int().default(0),
+  files: exports_external.array(exports_external.object({
+    path: exports_external.string(),
+    language: exports_external.string(),
+    ok: exports_external.boolean(),
+    errors: exports_external.array(exports_external.object({
+      line: exports_external.number().int(),
+      column: exports_external.number().int(),
+      message: exports_external.string()
+    })).default([]),
+    skipped_reason: exports_external.string().optional()
+  })).default([])
+});
+var PlaceholderEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("placeholder"),
+  findings: exports_external.array(exports_external.object({
+    path: exports_external.string(),
+    line: exports_external.number().int(),
+    kind: exports_external.enum(["comment", "string", "function_body", "other"]),
+    excerpt: exports_external.string(),
+    rule_id: exports_external.string()
+  })).default([]),
+  files_scanned: exports_external.number().int(),
+  files_with_findings: exports_external.number().int(),
+  findings_count: exports_external.number().int()
+});
+var SastFindingSchema = exports_external.object({
+  rule_id: exports_external.string(),
+  severity: exports_external.enum(["critical", "high", "medium", "low"]),
+  message: exports_external.string(),
+  location: exports_external.object({
+    file: exports_external.string(),
+    line: exports_external.number().int(),
+    column: exports_external.number().int().optional()
+  }),
+  remediation: exports_external.string().optional()
+});
+var SastEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("sast"),
+  findings: exports_external.array(SastFindingSchema).default([]),
+  engine: exports_external.enum(["tier_a", "tier_a+tier_b"]),
+  files_scanned: exports_external.number().int(),
+  findings_count: exports_external.number().int(),
+  findings_by_severity: exports_external.object({
+    critical: exports_external.number().int(),
+    high: exports_external.number().int(),
+    medium: exports_external.number().int(),
+    low: exports_external.number().int()
+  }),
+  new_findings: exports_external.array(SastFindingSchema).optional(),
+  pre_existing_findings: exports_external.array(SastFindingSchema).optional(),
+  baseline_used: exports_external.boolean().optional()
+});
+var SbomEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("sbom"),
+  components: exports_external.array(exports_external.object({
+    name: exports_external.string(),
+    version: exports_external.string(),
+    type: exports_external.enum(["library", "framework", "application"]),
+    purl: exports_external.string().optional(),
+    license: exports_external.string().optional()
+  })).default([]),
+  metadata: exports_external.object({
+    timestamp: exports_external.string().datetime(),
+    tool: exports_external.string(),
+    tool_version: exports_external.string()
+  }),
+  files: exports_external.array(exports_external.string()),
+  components_count: exports_external.number().int(),
+  output_path: exports_external.string()
+});
+var BuildEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("build"),
+  runs: exports_external.array(exports_external.object({
+    kind: exports_external.enum(["build", "typecheck", "test"]),
+    command: exports_external.string(),
+    cwd: exports_external.string(),
+    exit_code: exports_external.number().int(),
+    duration_ms: exports_external.number().int(),
+    stdout_tail: exports_external.string(),
+    stderr_tail: exports_external.string()
+  })).default([]),
+  files_scanned: exports_external.number().int(),
+  runs_count: exports_external.number().int(),
+  failed_count: exports_external.number().int(),
+  skipped_reason: exports_external.string().optional()
+});
+var QualityBudgetEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("quality_budget"),
+  metrics: exports_external.object({
+    complexity_delta: exports_external.number(),
+    public_api_delta: exports_external.number(),
+    duplication_ratio: exports_external.number(),
+    test_to_code_ratio: exports_external.number()
+  }),
+  thresholds: exports_external.object({
+    max_complexity_delta: exports_external.number(),
+    max_public_api_delta: exports_external.number(),
+    max_duplication_ratio: exports_external.number(),
+    min_test_to_code_ratio: exports_external.number()
+  }),
+  violations: exports_external.array(exports_external.object({
+    type: exports_external.enum(["complexity", "api", "duplication", "test_ratio"]),
+    message: exports_external.string(),
+    severity: exports_external.enum(["error", "warning"]),
+    files: exports_external.array(exports_external.string())
+  })).default([]),
+  files_analyzed: exports_external.array(exports_external.string())
+});
+var SecretscanEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("secretscan"),
+  findings_count: exports_external.number().int().min(0).default(0),
+  scan_directory: exports_external.string().optional(),
+  files_scanned: exports_external.number().int().min(0).default(0),
+  skipped_files: exports_external.number().int().min(0).default(0)
+});
+var GateEvidenceBaseSchema = exports_external.object({
+  task_id: exports_external.string().optional(),
+  agent: exports_external.string().optional(),
+  timestamp: exports_external.string().datetime(),
+  summary: exports_external.string().min(1),
+  metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+});
+var MutationGateEvidenceSchema = GateEvidenceBaseSchema.extend({
+  type: exports_external.literal("mutation-gate"),
+  verdict: exports_external.enum(["pass", "warn", "fail", "skip"]),
+  killRate: exports_external.number().min(0).max(1).optional(),
+  adjustedKillRate: exports_external.number().min(0).max(1).optional(),
+  survivedMutants: exports_external.string().optional()
+});
+var DriftVerificationEvidenceSchema = GateEvidenceBaseSchema.extend({
+  type: exports_external.literal("drift-verification"),
+  verdict: exports_external.enum(["approved", "rejected"]),
+  requirementCoverage: exports_external.string().optional()
+});
+var HallucinationVerificationEvidenceSchema = GateEvidenceBaseSchema.extend({
+  type: exports_external.literal("hallucination-verification"),
+  verdict: exports_external.enum(["approved", "rejected"]),
+  findings: exports_external.string().optional()
+});
+var EvidenceSchema = exports_external.discriminatedUnion("type", [
+  ReviewEvidenceSchema,
+  TestEvidenceSchema,
+  DiffEvidenceSchema,
+  ApprovalEvidenceSchema,
+  NoteEvidenceSchema,
+  RetrospectiveEvidenceSchema,
+  SyntaxEvidenceSchema,
+  PlaceholderEvidenceSchema,
+  SastEvidenceSchema,
+  SbomEvidenceSchema,
+  BuildEvidenceSchema,
+  QualityBudgetEvidenceSchema,
+  SecretscanEvidenceSchema,
+  MutationGateEvidenceSchema,
+  DriftVerificationEvidenceSchema,
+  HallucinationVerificationEvidenceSchema
+]);
+var EvidenceBundleSchema = exports_external.object({
+  schema_version: exports_external.literal("1.0.0"),
+  task_id: exports_external.string().min(1),
+  entries: exports_external.array(EvidenceSchema).default([]),
+  created_at: exports_external.string().datetime(),
+  updated_at: exports_external.string().datetime()
+});
+
+// src/evidence/manager.ts
+var VALID_EVIDENCE_TYPES = [
+  "review",
+  "test",
+  "diff",
+  "approval",
+  "note",
+  "retrospective",
+  "syntax",
+  "placeholder",
+  "sast",
+  "sbom",
+  "build",
+  "quality_budget",
+  "secretscan"
+];
+function isValidEvidenceType(type) {
+  return VALID_EVIDENCE_TYPES.includes(type);
+}
+var sanitizeTaskId2 = sanitizeTaskId;
+var MAX_DEPTH = 20;
+var PROJECT_INDICATORS = [
+  "package.json",
+  ".git",
+  ".opencode",
+  "Cargo.toml",
+  "go.mod",
+  "pyproject.toml",
+  "Gemfile",
+  "composer.json",
+  "pom.xml",
+  "build.gradle",
+  "CMakeLists.txt"
+];
+function validateProjectRoot(directory) {
+  let resolved;
+  try {
+    resolved = realpathSync(directory);
+  } catch {
+    warn(`[evidence] Cannot canonicalize directory "${directory}" \u2014 failing closed`);
+    throw new Error(`Cannot verify project root for "${directory}" \u2014 directory may not exist or is inaccessible`);
+  }
+  let current = resolved;
+  let depth = 0;
+  while (true) {
+    if (depth >= MAX_DEPTH)
+      break;
+    depth++;
+    const parent = path4.dirname(current);
+    if (parent === current)
+      break;
+    const parentSwarm = path4.join(parent, ".swarm");
+    try {
+      if (statSync(parentSwarm).isDirectory()) {
+        let hasProjectIndicator = false;
+        for (const indicator of PROJECT_INDICATORS) {
+          try {
+            const indicatorStat = statSync(path4.join(parent, indicator));
+            if (indicatorStat.isFile() || indicatorStat.isDirectory()) {
+              hasProjectIndicator = true;
+              break;
+            }
+          } catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT") {} else {
+              hasProjectIndicator = true;
+              break;
+            }
+          }
+        }
+        if (hasProjectIndicator) {
+          warn(`[evidence] Rejecting write to subdirectory "${resolved}" \u2014 parent "${parent}" already contains .swarm/`);
+          throw new Error(`Cannot write evidence in "${resolved}" \u2014 parent directory "${parent}" already contains a .swarm/ folder. Evidence must be written to the project root.`);
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith("Cannot write evidence")) {
+        throw error;
+      }
+    }
+    current = parent;
+  }
+}
+async function saveEvidence(directory, taskId, evidence) {
+  _internals3.validateProjectRoot(directory);
+  const sanitizedTaskId = sanitizeTaskId2(taskId);
+  const relativePath = path4.join("evidence", sanitizedTaskId, "evidence.json");
+  validateSwarmPath(directory, relativePath);
+  return withEvidenceLock(directory, relativePath, "evidence-manager", sanitizedTaskId, async () => {
+    const evidencePath = validateSwarmPath(directory, relativePath);
+    const evidenceDir = path4.dirname(evidencePath);
+    let bundle;
+    const existingContent = await readSwarmFileAsync(directory, relativePath);
+    if (existingContent !== null) {
+      try {
+        const parsed = JSON.parse(existingContent);
+        bundle = EvidenceBundleSchema.parse(parsed);
+      } catch (error) {
+        warn(`Existing evidence bundle invalid for task ${sanitizedTaskId}, creating new: ${error instanceof Error ? error.message : String(error)}`);
+        const now = new Date().toISOString();
+        bundle = {
+          schema_version: "1.0.0",
+          task_id: sanitizedTaskId,
+          entries: [],
+          created_at: now,
+          updated_at: now
+        };
+      }
+    } else {
+      const now = new Date().toISOString();
+      bundle = {
+        schema_version: "1.0.0",
+        task_id: sanitizedTaskId,
+        entries: [],
+        created_at: now,
+        updated_at: now
+      };
+    }
+    const MAX_BUNDLE_ENTRIES = 100;
+    let entries = [...bundle.entries, evidence];
+    if (entries.length > MAX_BUNDLE_ENTRIES) {
+      entries = entries.slice(entries.length - MAX_BUNDLE_ENTRIES);
+    }
+    const updatedBundle = {
+      ...bundle,
+      entries,
+      updated_at: new Date().toISOString()
+    };
+    const bundleJson = JSON.stringify(updatedBundle);
+    if (bundleJson.length > EVIDENCE_MAX_JSON_BYTES) {
+      throw new Error(`Evidence bundle size (${bundleJson.length} bytes) exceeds maximum (${EVIDENCE_MAX_JSON_BYTES} bytes)`);
+    }
+    mkdirSync3(evidenceDir, { recursive: true });
+    const tempPath = path4.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+    try {
+      await bunWrite(tempPath, bundleJson);
+      await fs3.rename(tempPath, evidencePath);
+    } catch (error) {
+      try {
+        rmSync(tempPath, { force: true });
+      } catch {}
+      throw error;
+    }
+    return updatedBundle;
+  });
+}
+function isFlatRetrospective(parsed) {
+  return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) && parsed.type === "retrospective" && !parsed.schema_version;
+}
+var LEGACY_TASK_COMPLEXITY_MAP = {
+  low: "simple",
+  medium: "moderate",
+  high: "complex"
+};
+function remapLegacyTaskComplexity(entry) {
+  const taskComplexity = entry.task_complexity;
+  if (typeof taskComplexity === "string" && taskComplexity in LEGACY_TASK_COMPLEXITY_MAP) {
+    return {
+      ...entry,
+      task_complexity: LEGACY_TASK_COMPLEXITY_MAP[taskComplexity]
+    };
+  }
+  return entry;
+}
+function wrapFlatRetrospective(flatEntry, taskId) {
+  const now = new Date().toISOString();
+  const remappedEntry = remapLegacyTaskComplexity(flatEntry);
+  return {
+    schema_version: "1.0.0",
+    task_id: remappedEntry.task_id ?? taskId,
+    created_at: remappedEntry.timestamp ?? now,
+    updated_at: remappedEntry.timestamp ?? now,
+    entries: [remappedEntry]
+  };
+}
+async function loadEvidence(directory, taskId) {
+  const sanitizedTaskId = sanitizeTaskId2(taskId);
+  const relativePath = path4.join("evidence", sanitizedTaskId, "evidence.json");
+  if (relativePath.length > 4096) {
+    return { status: "not_found" };
+  }
+  const evidencePath = validateSwarmPath(directory, relativePath);
+  const content = await readSwarmFileAsync(directory, relativePath);
+  if (content === null) {
+    return { status: "not_found" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return { status: "invalid_schema", errors: ["Invalid JSON"] };
+  }
+  if (isFlatRetrospective(parsed)) {
+    const wrappedBundle = _internals3.wrapFlatRetrospective(parsed, sanitizedTaskId);
+    try {
+      const validated = EvidenceBundleSchema.parse(wrappedBundle);
+      try {
+        await withEvidenceLock(directory, relativePath, "evidence-loader", sanitizedTaskId, async () => {
+          const evidenceDir = path4.dirname(evidencePath);
+          const bundleJson = JSON.stringify(validated);
+          const tempPath = path4.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+          try {
+            await bunWrite(tempPath, bundleJson);
+            await fs3.rename(tempPath, evidencePath);
+          } catch (writeError) {
+            try {
+              rmSync(tempPath, { force: true });
+            } catch {}
+            warn(`Failed to persist repaired flat retrospective for task ${sanitizedTaskId}: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
+          }
+        });
+      } catch (lockErr) {
+        warn(`Evidence lock failed during flat-retrospective write-back for task ${sanitizedTaskId}: ${lockErr instanceof Error ? lockErr.message : String(lockErr)}`);
+      }
+      return { status: "found", bundle: validated };
+    } catch (error) {
+      warn(`Wrapped flat retrospective failed validation for task ${sanitizedTaskId}: ${error instanceof Error ? error.message : String(error)}`);
+      const errors = error instanceof ZodError ? error.issues.map((e) => `${e.path.join(".")}: ${e.message}`) : [error instanceof Error ? error.message : String(error)];
+      return { status: "invalid_schema", errors };
+    }
+  }
+  try {
+    const validated = EvidenceBundleSchema.parse(parsed);
+    return { status: "found", bundle: validated };
+  } catch (error) {
+    warn(`Evidence bundle validation failed for task ${sanitizedTaskId}: ${error instanceof Error ? error.message : String(error)}`);
+    const errors = error instanceof ZodError ? error.issues.map((e) => `${e.path.join(".")}: ${e.message}`) : [error instanceof Error ? error.message : String(error)];
+    return { status: "invalid_schema", errors };
+  }
+}
+async function listEvidenceTaskIds(directory) {
+  const evidenceBasePath = validateSwarmPath(directory, "evidence");
+  try {
+    statSync(evidenceBasePath);
+  } catch {
+    return [];
+  }
+  let entries;
+  try {
+    entries = readdirSync3(evidenceBasePath);
+  } catch {
+    return [];
+  }
+  const taskIds = [];
+  for (const entry of entries) {
+    const entryPath = path4.join(evidenceBasePath, entry);
+    try {
+      const stats = statSync(entryPath);
+      if (!stats.isDirectory()) {
+        continue;
+      }
+      sanitizeTaskId2(entry);
+      taskIds.push(entry);
+    } catch (error) {
+      if (error instanceof Error && !error.message.startsWith("Invalid task ID")) {
+        warn(`Error reading evidence entry '${entry}': ${error.message}`);
+      }
+    }
+  }
+  return taskIds.sort();
+}
+async function deleteEvidence(directory, taskId) {
+  const sanitizedTaskId = sanitizeTaskId2(taskId);
+  const relativePath = path4.join("evidence", sanitizedTaskId);
+  const evidenceDir = validateSwarmPath(directory, relativePath);
+  try {
+    statSync(evidenceDir);
+  } catch {
+    return false;
+  }
+  try {
+    rmSync(evidenceDir, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    warn(`Failed to delete evidence for task ${sanitizedTaskId}: ${error instanceof Error ? error.message : String(error)}`);
+    return false;
+  }
+}
+async function checkRequirementCoverage(phase, directory) {
+  const relativePath = path4.join("evidence", `req-coverage-phase-${phase}.json`);
+  const absolutePath = path4.resolve(directory, ".swarm", relativePath);
+  try {
+    await fs3.access(absolutePath);
+    return { exists: true, path: absolutePath };
+  } catch {
+    return { exists: false, path: absolutePath };
+  }
+}
+async function archiveEvidence(directory, maxAgeDays, maxBundles) {
+  const taskIds = await _internals3.listEvidenceTaskIds(directory);
+  const cutoffDate = new Date;
+  cutoffDate.setDate(cutoffDate.getDate() - maxAgeDays);
+  const cutoffIso = cutoffDate.toISOString();
+  const archived = [];
+  const remainingBundles = [];
+  for (const taskId of taskIds) {
+    const result = await _internals3.loadEvidence(directory, taskId);
+    if (result.status !== "found") {
+      continue;
+    }
+    if (result.bundle.updated_at < cutoffIso) {
+      const deleted = await deleteEvidence(directory, taskId);
+      if (deleted) {
+        archived.push(taskId);
+      }
+    } else {
+      remainingBundles.push({
+        taskId,
+        updatedAt: result.bundle.updated_at
+      });
+    }
+  }
+  if (maxBundles !== undefined && remainingBundles.length > maxBundles) {
+    remainingBundles.sort((a, b) => a.updatedAt.localeCompare(b.updatedAt));
+    const toDelete = remainingBundles.length - maxBundles;
+    for (let i = 0;i < toDelete; i++) {
+      const deleted = await deleteEvidence(directory, remainingBundles[i].taskId);
+      if (deleted) {
+        archived.push(remainingBundles[i].taskId);
+      }
+    }
+  }
+  return archived;
+}
+var _internals3 = {
+  wrapFlatRetrospective,
+  loadEvidence,
+  listEvidenceTaskIds,
+  validateProjectRoot
+};
+
+// src/evidence/gate-bridge.ts
+var GATE_EVIDENCE_TYPE_BY_GATE = {
+  reviewer: "review",
+  test_engineer: "test"
+};
+async function readDurableGateEvidence(directory, taskId) {
+  try {
+    return await readTaskEvidence(directory, taskId);
+  } catch {
+    return null;
+  }
+}
+function getDurableGateEvidenceStatus(evidence) {
+  if (!evidence?.gates || typeof evidence.gates !== "object") {
+    return {
+      isComplete: false,
+      missingGates: [],
+      evidenceExists: evidence != null,
+      invalid: false
+    };
+  }
+  if (!Array.isArray(evidence.required_gates) || evidence.required_gates.length === 0) {
+    return {
+      isComplete: false,
+      missingGates: ["required_gates"],
+      evidenceExists: true,
+      invalid: false
+    };
+  }
+  const missingGates = evidence.required_gates.filter((gate) => evidence.gates[gate] == null);
+  return {
+    isComplete: missingGates.length === 0,
+    missingGates,
+    evidenceExists: true,
+    invalid: false
+  };
+}
+async function getDurableGateEvidenceStatusForTask(directory, taskId) {
+  if (!isValidTaskId(taskId)) {
+    return {
+      isComplete: false,
+      missingGates: [],
+      evidenceExists: false,
+      invalid: false
+    };
+  }
+  try {
+    return getDurableGateEvidenceStatus(readTaskEvidenceRaw(directory, taskId));
+  } catch {
+    return {
+      isComplete: false,
+      missingGates: ["invalid_gate_evidence"],
+      evidenceExists: true,
+      invalid: true
+    };
+  }
+}
+function gateEvidenceToEntry(taskId, gate, type, evidence) {
+  const gateRecord = evidence.gates[gate];
+  if (!gateRecord) {
+    return null;
+  }
+  const base = {
+    task_id: taskId,
+    timestamp: gateRecord.timestamp,
+    agent: gateRecord.agent || gate,
+    verdict: "pass",
+    summary: `Gate evidence recorded by ${gate}`,
+    metadata: { source: "durable_gate_evidence", gate }
+  };
+  if (type === "review") {
+    return {
+      ...base,
+      type,
+      risk: "low",
+      issues: []
+    };
+  }
+  if (type === "approval") {
+    return {
+      ...base,
+      type
+    };
+  }
+  return {
+    ...base,
+    type,
+    tests_passed: 0,
+    tests_failed: 0,
+    failures: []
+  };
+}
+function mergeDurableGateEntriesFromEvidence(taskId, entries, evidence) {
+  if (!evidence?.gates) {
+    return entries;
+  }
+  const merged = [...entries];
+  for (const gate of Object.keys(evidence.gates).sort()) {
+    const type = GATE_EVIDENCE_TYPE_BY_GATE[gate] ?? "approval";
+    if ((type === "review" || type === "test") && merged.some((entry2) => entry2.type === type)) {
+      continue;
+    }
+    const entry = gateEvidenceToEntry(taskId, gate, type, evidence);
+    if (entry) {
+      merged.push(entry);
+    }
+  }
+  return merged;
+}
+
+export { PlanSchema, 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 };