opencode-swarm 6.61.0 → 6.63.0

package/dist/index.js

@@ -75,7 +75,8 @@ var init_tool_names = __esm(() => {
     "search",
     "batch_symbols",
     "suggest_patch",
-    "req_coverage"
+    "req_coverage",
+    "get_approved_plan"
   ];
   TOOL_NAME_SET = new Set(TOOL_NAMES);
 });
@@ -307,7 +308,8 @@ var init_constants = __esm(() => {
       "retrieve_summary",
       "symbols",
       "knowledge_recall",
-      "req_coverage"
+      "req_coverage",
+      "get_approved_plan"
     ],
     critic_oversight: [
       "complexity_hotspots",
@@ -391,7 +393,8 @@ var init_constants = __esm(() => {
     search: "Workspace-scoped ripgrep-style text search with structured JSON output. Supports literal and regex modes, glob filtering, and result limits. NOTE: This is text search, not structural AST search \u2014 use symbols and imports tools for structural queries.",
     batch_symbols: "Batched symbol extraction across multiple files. Returns per-file symbol summaries with isolated error handling.",
     suggest_patch: "Reviewer-safe structured patch suggestion tool. Produces context-anchored patch artifacts without file modification. Returns structured diagnostics on context mismatch.",
-    lint_spec: "validate .swarm/spec.md format and required fields"
+    lint_spec: "validate .swarm/spec.md format and required fields",
+    get_approved_plan: "retrieve the last critic-approved immutable plan snapshot for baseline drift comparison"
   };
   for (const [agentName, tools] of Object.entries(AGENT_TOOL_MAP)) {
     const invalidTools = tools.filter((tool) => !TOOL_NAME_SET.has(tool));
@@ -15785,22 +15788,26 @@ async function readLedgerEvents(directory) {
     return [];
   }
 }
-async function initLedger(directory, planId, initialPlanHash) {
+async function initLedger(directory, planId, initialPlanHash, initialPlan) {
   const ledgerPath = getLedgerPath(directory);
   const planJsonPath = getPlanJsonPath(directory);
   if (fs3.existsSync(ledgerPath)) {
     throw new Error("Ledger already initialized. Use appendLedgerEvent to add events.");
   }
   let planHashAfter = initialPlanHash ?? "";
+  let embeddedPlan = initialPlan;
   if (!initialPlanHash) {
     try {
       if (fs3.existsSync(planJsonPath)) {
         const content = fs3.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(),
@@ -15809,7 +15816,8 @@ async function initLedger(directory, planId, initialPlanHash) {
     source: "initLedger",
     plan_hash_before: "",
     plan_hash_after: planHashAfter,
-    schema_version: LEDGER_SCHEMA_VERSION
+    schema_version: LEDGER_SCHEMA_VERSION,
+    ...payload ? { payload } : {}
   };
   fs3.mkdirSync(path3.join(directory, ".swarm"), { recursive: true });
   const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
@@ -15896,7 +15904,7 @@ async function takeSnapshotEvent(directory, plan, options) {
     payload: snapshotPayload
   }, { planHashAfter: options?.planHashAfter });
 }
-async function replayFromLedger(directory, options) {
+async function replayFromLedger(directory, _options) {
   const events = await readLedgerEvents(directory);
   if (events.length === 0) {
     return null;
@@ -15919,6 +15927,20 @@ async function replayFromLedger(directory, options) {
       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 (!fs3.existsSync(planJsonPath)) {
     return null;
@@ -15941,6 +15963,11 @@ async function replayFromLedger(directory, options) {
 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) {
@@ -16029,7 +16056,13 @@ var init_ledger = __esm(() => {
 });
 
 // src/plan/manager.ts
-import { copyFileSync, existsSync as existsSync3, renameSync as renameSync2, unlinkSync } from "fs";
+import {
+  copyFileSync,
+  existsSync as existsSync3,
+  readdirSync,
+  renameSync as renameSync2,
+  unlinkSync
+} from "fs";
 import * as fsPromises from "fs/promises";
 import * as path4 from "path";
 async function loadPlanJsonOnly(directory) {
@@ -16281,35 +16314,53 @@ async function loadPlan(directory) {
     return migrated;
   }
   if (await ledgerExists(directory)) {
-    const rebuilt = await replayFromLedger(directory);
-    if (rebuilt) {
-      await savePlan(directory, rebuilt);
-      return rebuilt;
-    }
+    const resolvedDir = path4.resolve(directory);
+    const existingMutex = recoveryMutexes.get(resolvedDir);
+    if (existingMutex) {
+      await existingMutex;
+      const postRecoveryPlan = await loadPlanJsonOnly(directory);
+      if (postRecoveryPlan)
+        return postRecoveryPlan;
+    }
+    let resolveRecovery;
+    const mutex = new Promise((r) => {
+      resolveRecovery = r;
+    });
+    recoveryMutexes.set(resolvedDir, mutex);
     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 rebuilt = await replayFromLedger(directory);
+      if (rebuilt) {
+        await savePlan(directory, rebuilt);
+        return rebuilt;
       }
-      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.`);
-        await savePlan(directory, approved.plan);
-        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.`);
+      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.`);
+          await savePlan(directory, approved.plan);
+          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;
         }
-        return approved.plan;
+      } catch (recoveryError) {
+        warn(`[loadPlan] Approved-snapshot recovery failed: ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`);
       }
-    } catch (recoveryError) {
-      warn(`[loadPlan] Approved-snapshot recovery failed: ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`);
+    } finally {
+      resolveRecovery();
+      recoveryMutexes.delete(resolvedDir);
     }
   }
   return null;
@@ -16358,7 +16409,7 @@ async function savePlan(directory, plan, options) {
   const planId = `${validated.swarm}-${validated.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
   const planHashForInit = computePlanHash(validated);
   if (!await ledgerExists(directory)) {
-    await initLedger(directory, planId, planHashForInit);
+    await initLedger(directory, planId, planHashForInit, validated);
   } else {
     const existingEvents = await readLedgerEvents(directory);
     if (existingEvents.length > 0 && existingEvents[0].plan_id !== planId) {
@@ -16377,7 +16428,7 @@ async function savePlan(directory, plan, options) {
       let initSucceeded = false;
       if (backupExists) {
         try {
-          await initLedger(directory, planId, planHashForInit);
+          await initLedger(directory, planId, planHashForInit, validated);
           initSucceeded = true;
         } catch (initErr) {
           const errorMessage = String(initErr);
@@ -16419,6 +16470,19 @@ async function savePlan(directory, plan, options) {
             unlinkSync(oldLedgerBackupPath);
         } catch {}
       }
+      const MAX_ARCHIVED_SIBLINGS = 5;
+      try {
+        const allFiles = readdirSync(swarmDir2);
+        const archivedSiblings = allFiles.filter((f) => f.startsWith("plan-ledger.archived-") && f.endsWith(".jsonl")).sort();
+        if (archivedSiblings.length > MAX_ARCHIVED_SIBLINGS) {
+          const toRemove = archivedSiblings.slice(0, archivedSiblings.length - MAX_ARCHIVED_SIBLINGS);
+          for (const file2 of toRemove) {
+            try {
+              unlinkSync(path4.join(swarmDir2, file2));
+            } catch {}
+          }
+        }
+      } catch {}
     }
   }
   const currentHash = computeCurrentPlanHash(directory);
@@ -16468,7 +16532,7 @@ async function savePlan(directory, plan, options) {
       }
     } catch (error49) {
       if (error49 instanceof LedgerStaleWriterError) {
-        throw new Error(`Concurrent plan modification detected after retries: ${error49.message}. Please retry the operation.`);
+        throw new PlanConcurrentModificationError(`Concurrent plan modification detected after retries: ${error49.message}. Please retry the operation.`);
       }
       throw error49;
     }
@@ -16478,7 +16542,11 @@ async function savePlan(directory, plan, options) {
   if (latestSeq > 0 && latestSeq % SNAPSHOT_INTERVAL === 0) {
     await takeSnapshotEvent(directory, validated, {
       planHashAfter: hashAfter
-    }).catch(() => {});
+    }).catch((err2) => {
+      if (process.env.DEBUG_SWARM) {
+        warn(`[savePlan] Periodic snapshot write failed (non-fatal): ${err2 instanceof Error ? err2.message : String(err2)}`);
+      }
+    });
   }
   const swarmDir = path4.resolve(directory, ".swarm");
   const planPath = path4.join(swarmDir, "plan.json");
@@ -16491,19 +16559,23 @@ async function savePlan(directory, plan, options) {
       unlinkSync(tempPath);
     } catch {}
   }
-  const contentHash = computePlanContentHash(validated);
-  const markdown = derivePlanMarkdown(validated);
-  const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
-${markdown}`;
-  const mdPath = path4.join(swarmDir, "plan.md");
-  const mdTempPath = path4.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
-    await Bun.write(mdTempPath, markdownWithHash);
-    renameSync2(mdTempPath, mdPath);
-  } finally {
+    const contentHash = computePlanContentHash(validated);
+    const markdown = derivePlanMarkdown(validated);
+    const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
+${markdown}`;
+    const mdPath = path4.join(swarmDir, "plan.md");
+    const mdTempPath = path4.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
-      unlinkSync(mdTempPath);
-    } catch {}
+      await Bun.write(mdTempPath, markdownWithHash);
+      renameSync2(mdTempPath, mdPath);
+    } finally {
+      try {
+        unlinkSync(mdTempPath);
+      } catch {}
+    }
+  } catch (mdError) {
+    warn(`[savePlan] plan.md write failed (non-fatal, plan.json is authoritative): ${mdError instanceof Error ? mdError.message : String(mdError)}`);
   }
   try {
     const markerPath = path4.join(swarmDir, ".plan-write-marker");
@@ -16548,11 +16620,6 @@ ${markdown}`;
   return targetPlan;
 }
 async function updateTaskStatus(directory, taskId, status) {
-  const plan = await loadPlan(directory);
-  if (plan === null) {
-    throw new Error(`Plan not found in directory: ${directory}`);
-  }
-  let taskFound = false;
   const derivePhaseStatusFromTasks = (tasks) => {
     if (tasks.length > 0 && tasks.every((task) => task.status === "completed")) {
       return "complete";
@@ -16565,26 +16632,44 @@ async function updateTaskStatus(directory, taskId, status) {
     }
     return "pending";
   };
-  const updatedPhases = plan.phases.map((phase) => {
-    const updatedTasks = phase.tasks.map((task) => {
-      if (task.id === taskId) {
-        taskFound = true;
-        return { ...task, status };
-      }
-      return task;
+  const MAX_OUTER_RETRIES = 1;
+  for (let attempt = 0;attempt <= MAX_OUTER_RETRIES; attempt++) {
+    const plan = await loadPlan(directory);
+    if (plan === null) {
+      throw new Error(`Plan not found in directory: ${directory}`);
+    }
+    let taskFound = false;
+    const updatedPhases = plan.phases.map((phase) => {
+      const updatedTasks = phase.tasks.map((task) => {
+        if (task.id === taskId) {
+          taskFound = true;
+          return { ...task, status };
+        }
+        return task;
+      });
+      return {
+        ...phase,
+        status: derivePhaseStatusFromTasks(updatedTasks),
+        tasks: updatedTasks
+      };
     });
-    return {
-      ...phase,
-      status: derivePhaseStatusFromTasks(updatedTasks),
-      tasks: updatedTasks
-    };
-  });
-  if (!taskFound) {
-    throw new Error(`Task not found: ${taskId}`);
+    if (!taskFound) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+    const updatedPlan = { ...plan, phases: updatedPhases };
+    try {
+      await savePlan(directory, updatedPlan, {
+        preserveCompletedStatuses: true
+      });
+      return updatedPlan;
+    } catch (error49) {
+      if (error49 instanceof PlanConcurrentModificationError && attempt < MAX_OUTER_RETRIES) {
+        continue;
+      }
+      throw error49;
+    }
   }
-  const updatedPlan = { ...plan, phases: updatedPhases };
-  await savePlan(directory, updatedPlan, { preserveCompletedStatuses: true });
-  return updatedPlan;
+  throw new Error("updateTaskStatus: unexpected loop exit");
 }
 function derivePlanMarkdown(plan) {
   const statusMap = {
@@ -16852,57 +16937,90 @@ function migrateLegacyPlan(planContent, swarmId) {
   };
   return plan;
 }
-var startupLedgerCheckedWorkspaces;
+var PlanConcurrentModificationError, startupLedgerCheckedWorkspaces, recoveryMutexes;
 var init_manager = __esm(() => {
   init_plan_schema();
   init_utils2();
   init_utils();
   init_spec_hash();
   init_ledger();
+  PlanConcurrentModificationError = class PlanConcurrentModificationError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "PlanConcurrentModificationError";
+    }
+  };
   startupLedgerCheckedWorkspaces = new Set;
+  recoveryMutexes = new Map;
 });
 
-// src/evidence/manager.ts
-import { mkdirSync as mkdirSync2, readdirSync, rmSync, statSync as statSync2 } from "fs";
-import * as fs4 from "fs/promises";
-import * as path5 from "path";
-function isValidEvidenceType(type) {
-  return VALID_EVIDENCE_TYPES.includes(type);
-}
-function isSecretscanEvidence(evidence) {
-  return evidence.type === "secretscan";
-}
-function sanitizeTaskId(taskId) {
+// src/validation/task-id.ts
+function checkUnsafeChars(taskId) {
   if (!taskId || taskId.length === 0) {
-    throw new Error("Invalid task ID: empty string");
+    return "Invalid task ID: empty string";
   }
   if (/\0/.test(taskId)) {
-    throw new Error("Invalid task ID: contains null bytes");
+    return "Invalid task ID: contains null bytes";
   }
   for (let i2 = 0;i2 < taskId.length; i2++) {
     if (taskId.charCodeAt(i2) < 32) {
-      throw new Error("Invalid task ID: contains control characters");
+      return "Invalid task ID: contains control characters";
     }
   }
-  if (taskId.includes("..") || taskId.includes("../") || taskId.includes("..\\")) {
-    throw new Error("Invalid task ID: path traversal detected");
+  if (taskId.includes("..") || taskId.includes("/") || taskId.includes("\\")) {
+    return "Invalid task ID: path traversal detected";
   }
-  if (TASK_ID_REGEX.test(taskId)) {
-    return taskId;
-  }
-  if (RETRO_TASK_ID_REGEX.test(taskId)) {
-    return taskId;
+  return;
+}
+function isStrictTaskId(taskId) {
+  if (!taskId)
+    return false;
+  const unsafeMsg = checkUnsafeChars(taskId);
+  if (unsafeMsg)
+    return false;
+  return STRICT_TASK_ID_PATTERN.test(taskId);
+}
+function assertStrictTaskId(taskId) {
+  if (!isStrictTaskId(taskId)) {
+    throw new Error(`Invalid taskId: "${taskId}". Must match N.M or N.M.P (e.g. "1.1", "1.2.3").`);
   }
-  if (INTERNAL_TOOL_ID_REGEX.test(taskId)) {
-    return taskId;
+}
+function sanitizeTaskId(taskId) {
+  const unsafeMsg = checkUnsafeChars(taskId);
+  if (unsafeMsg) {
+    throw new Error(unsafeMsg);
   }
-  if (GENERAL_TASK_ID_REGEX.test(taskId)) {
+  if (STRICT_TASK_ID_PATTERN.test(taskId) || RETRO_TASK_ID_REGEX.test(taskId) || INTERNAL_TOOL_ID_REGEX.test(taskId) || GENERAL_TASK_ID_REGEX.test(taskId)) {
     return taskId;
   }
   throw new Error(`Invalid task ID: must be alphanumeric (ASCII) with optional hyphens, underscores, or dots, got "${taskId}"`);
 }
+function validateTaskIdFormat(taskId) {
+  if (!STRICT_TASK_ID_PATTERN.test(taskId)) {
+    return `Invalid taskId "${taskId}". Must match pattern N.M or N.M.P (e.g., "1.1", "1.2.3")`;
+  }
+  return;
+}
+var STRICT_TASK_ID_PATTERN, RETRO_TASK_ID_REGEX, INTERNAL_TOOL_ID_REGEX, GENERAL_TASK_ID_REGEX;
+var init_task_id = __esm(() => {
+  STRICT_TASK_ID_PATTERN = /^\d+\.\d+(\.\d+)*$/;
+  RETRO_TASK_ID_REGEX = /^retro-\d+$/;
+  INTERNAL_TOOL_ID_REGEX = /^(?:sast_scan|quality_budget|syntax_check|placeholder_scan|sbom_generate|build|secretscan)$/;
+  GENERAL_TASK_ID_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+});
+
+// src/evidence/manager.ts
+import { mkdirSync as mkdirSync2, readdirSync as readdirSync2, rmSync, statSync as statSync2 } from "fs";
+import * as fs4 from "fs/promises";
+import * as path5 from "path";
+function isValidEvidenceType(type) {
+  return VALID_EVIDENCE_TYPES.includes(type);
+}
+function isSecretscanEvidence(evidence) {
+  return evidence.type === "secretscan";
+}
 async function saveEvidence(directory, taskId, evidence) {
-  const sanitizedTaskId = sanitizeTaskId(taskId);
+  const sanitizedTaskId = sanitizeTaskId2(taskId);
   const relativePath = path5.join("evidence", sanitizedTaskId, "evidence.json");
   const evidencePath = validateSwarmPath(directory, relativePath);
   const evidenceDir = path5.dirname(evidencePath);
@@ -16933,9 +17051,14 @@ async function saveEvidence(directory, taskId, evidence) {
       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: [...bundle.entries, evidence],
+    entries,
     updated_at: new Date().toISOString()
   };
   const bundleJson = JSON.stringify(updatedBundle);
@@ -16980,7 +17103,7 @@ function wrapFlatRetrospective(flatEntry, taskId) {
   };
 }
 async function loadEvidence(directory, taskId) {
-  const sanitizedTaskId = sanitizeTaskId(taskId);
+  const sanitizedTaskId = sanitizeTaskId2(taskId);
   const relativePath = path5.join("evidence", sanitizedTaskId, "evidence.json");
   const evidencePath = validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
@@ -17034,7 +17157,7 @@ async function listEvidenceTaskIds(directory) {
   }
   let entries;
   try {
-    entries = readdirSync(evidenceBasePath);
+    entries = readdirSync2(evidenceBasePath);
   } catch {
     return [];
   }
@@ -17046,7 +17169,7 @@ async function listEvidenceTaskIds(directory) {
       if (!stats.isDirectory()) {
         continue;
       }
-      sanitizeTaskId(entry);
+      sanitizeTaskId2(entry);
       taskIds.push(entry);
     } catch (error49) {
       if (error49 instanceof Error && !error49.message.startsWith("Invalid task ID")) {
@@ -17057,7 +17180,7 @@ async function listEvidenceTaskIds(directory) {
   return taskIds.sort();
 }
 async function deleteEvidence(directory, taskId) {
-  const sanitizedTaskId = sanitizeTaskId(taskId);
+  const sanitizedTaskId = sanitizeTaskId2(taskId);
   const relativePath = path5.join("evidence", sanitizedTaskId);
   const evidenceDir = validateSwarmPath(directory, relativePath);
   try {
@@ -17119,12 +17242,13 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles) {
   }
   return archived;
 }
-var VALID_EVIDENCE_TYPES, TASK_ID_REGEX, RETRO_TASK_ID_REGEX, INTERNAL_TOOL_ID_REGEX, GENERAL_TASK_ID_REGEX, LEGACY_TASK_COMPLEXITY_MAP;
+var VALID_EVIDENCE_TYPES, sanitizeTaskId2, LEGACY_TASK_COMPLEXITY_MAP;
 var init_manager2 = __esm(() => {
   init_zod();
   init_evidence_schema();
   init_utils2();
   init_utils();
+  init_task_id();
   VALID_EVIDENCE_TYPES = [
     "review",
     "test",
@@ -17140,10 +17264,7 @@ var init_manager2 = __esm(() => {
     "quality_budget",
     "secretscan"
   ];
-  TASK_ID_REGEX = /^\d+\.\d+(\.\d+)*$/;
-  RETRO_TASK_ID_REGEX = /^retro-\d+$/;
-  INTERNAL_TOOL_ID_REGEX = /^(?:sast_scan|quality_budget|syntax_check|placeholder_scan|sbom_generate|build|secretscan)$/;
-  GENERAL_TASK_ID_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+  sanitizeTaskId2 = sanitizeTaskId;
   LEGACY_TASK_COMPLEXITY_MAP = {
     low: "simple",
     medium: "moderate",
@@ -40849,22 +40970,10 @@ __export(exports_gate_evidence, {
 import { mkdirSync as mkdirSync12, readFileSync as readFileSync18, renameSync as renameSync10, unlinkSync as unlinkSync5 } from "fs";
 import * as path39 from "path";
 function isValidTaskId2(taskId) {
-  if (!taskId)
-    return false;
-  if (taskId.includes(".."))
-    return false;
-  if (taskId.includes("/"))
-    return false;
-  if (taskId.includes("\\"))
-    return false;
-  if (taskId.includes("\x00"))
-    return false;
-  return TASK_ID_PATTERN.test(taskId);
+  return isStrictTaskId(taskId);
 }
 function assertValidTaskId(taskId) {
-  if (!isValidTaskId2(taskId)) {
-    throw new Error(`Invalid taskId: "${taskId}". Must match N.M or N.M.P (e.g. "1.1", "1.2.3").`);
-  }
+  assertStrictTaskId(taskId);
 }
 function deriveRequiredGates(agentType) {
   switch (agentType) {
@@ -40897,6 +41006,7 @@ function getEvidenceDir(directory) {
   return path39.join(directory, ".swarm", "evidence");
 }
 function getEvidencePath(directory, taskId) {
+  assertValidTaskId(taskId);
   return path39.join(getEvidenceDir(directory), `${taskId}.json`);
 }
 function readExisting(evidencePath) {
@@ -40984,11 +41094,11 @@ async function hasPassedAllGates(directory, taskId) {
     return false;
   return evidence.required_gates.every((gate) => evidence.gates[gate] != null);
 }
-var DEFAULT_REQUIRED_GATES, TASK_ID_PATTERN;
+var DEFAULT_REQUIRED_GATES;
 var init_gate_evidence = __esm(() => {
   init_telemetry();
+  init_task_id();
   DEFAULT_REQUIRED_GATES = ["reviewer", "test_engineer"];
-  TASK_ID_PATTERN = /^\d+\.\d+(\.\d+)*$/;
 });
 
 // src/hooks/review-receipt.ts
@@ -47285,11 +47395,14 @@ async function executeWriteRetro(args2, directory) {
   try {
     const allTaskIds = await listEvidenceTaskIds(directory);
     const phaseTaskIds = allTaskIds.filter((id) => id.startsWith(`${phase}.`));
+    const sessionStart = args2.metadata && typeof args2.metadata.session_start === "string" ? args2.metadata.session_start : undefined;
     for (const phaseTaskId of phaseTaskIds) {
       const result = await loadEvidence(directory, phaseTaskId);
       if (result.status !== "found")
         continue;
       const bundle = result.bundle;
+      if (sessionStart && bundle.updated_at < sessionStart)
+        continue;
       for (const entry of bundle.entries) {
         const e = entry;
         if (e.type === "review" && e.verdict === "fail") {
@@ -47481,6 +47594,18 @@ async function handleCloseCommand(directory, args2) {
       }
     }
   }
+  let sessionStart;
+  {
+    let earliest = Infinity;
+    for (const [, session] of swarmState.agentSessions) {
+      if (session.lastAgentEventTime > 0 && session.lastAgentEventTime < earliest) {
+        earliest = session.lastAgentEventTime;
+      }
+    }
+    if (earliest < Infinity) {
+      sessionStart = new Date(earliest).toISOString();
+    }
+  }
   const wrotePhaseRetro = closedPhases.length > 0;
   if (!wrotePhaseRetro && !planExists) {
     try {
@@ -47496,7 +47621,10 @@ async function handleCloseCommand(directory, args2) {
         test_failures: 0,
         security_findings: 0,
         integration_issues: 0,
-        metadata: { session_scope: "plan_free" }
+        metadata: {
+          session_scope: "plan_free",
+          ...sessionStart ? { session_start: sessionStart } : {}
+        }
       }, directory);
       try {
         const parsed = JSON.parse(sessionRetroResult);
@@ -47553,7 +47681,8 @@ async function handleCloseCommand(directory, args2) {
     }
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const archiveDir = path14.join(swarmDir, "archive", `swarm-${timestamp}`);
+  const suffix = Math.random().toString(36).slice(2, 8);
+  const archiveDir = path14.join(swarmDir, "archive", `swarm-${timestamp}-${suffix}`);
   let archiveResult = "";
   let archivedFileCount = 0;
   const archivedActiveStateFiles = new Set;
@@ -47817,11 +47946,23 @@ async function handleCloseCommand(directory, args2) {
   if (pruneErrors.length > 0) {
     warnings.push(`Could not prune ${pruneErrors.length} branch(es) (unmerged or checked out): ${pruneErrors.join(", ")}`);
   }
-  const warningMsg = warnings.length > 0 ? `
+  const retroWarnings = warnings.filter((w) => w.includes("Retrospective write") || w.includes("retrospective write") || w.includes("Session retrospective"));
+  const otherWarnings = warnings.filter((w) => !w.includes("Retrospective write") && !w.includes("retrospective write") && !w.includes("Session retrospective"));
+  let warningMsg = "";
+  if (retroWarnings.length > 0) {
+    warningMsg += `
+
+**\u26A0 Retrospective evidence incomplete:**
+${retroWarnings.map((w) => `- ${w}`).join(`
+`)}`;
+  }
+  if (otherWarnings.length > 0) {
+    warningMsg += `
 
 **Warnings:**
-${warnings.map((w) => `- ${w}`).join(`
-`)}` : "";
+${otherWarnings.map((w) => `- ${w}`).join(`
+`)}`;
+  }
   if (planAlreadyDone) {
     return `\u2705 Session finalized. Plan was already in a terminal state \u2014 cleanup and archive applied.
 
@@ -49071,7 +49212,7 @@ init_manager2();
 init_utils2();
 init_manager();
 import * as child_process4 from "child_process";
-import { existsSync as existsSync8, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
+import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
 import path19 from "path";
 import { fileURLToPath } from "url";
 function validateTaskDag(plan) {
@@ -49274,7 +49415,7 @@ async function checkPlanSync(directory, plan) {
 }
 async function checkConfigBackups(directory) {
   try {
-    const files = readdirSync2(directory);
+    const files = readdirSync3(directory);
     const backupCount = files.filter((f) => /\.opencode-swarm\.yaml\.bak/.test(f)).length;
     if (backupCount <= 5) {
       return {
@@ -49740,7 +49881,7 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkCurator(directory));
   try {
     const evidenceDir = path19.join(directory, ".swarm", "evidence");
-    const snapshotFiles = existsSync8(evidenceDir) ? readdirSync2(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
+    const snapshotFiles = existsSync8(evidenceDir) ? readdirSync3(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
       checks5.push({
@@ -51972,7 +52113,7 @@ async function handleResetSessionCommand(directory, _args) {
 // src/summaries/manager.ts
 init_utils2();
 init_utils();
-import { mkdirSync as mkdirSync9, readdirSync as readdirSync8, renameSync as renameSync8, rmSync as rmSync3, statSync as statSync7 } from "fs";
+import { mkdirSync as mkdirSync9, readdirSync as readdirSync9, renameSync as renameSync8, rmSync as rmSync3, statSync as statSync7 } from "fs";
 import * as path31 from "path";
 var SUMMARY_ID_REGEX = /^S\d+$/;
 function sanitizeSummaryId(id) {
@@ -54910,6 +55051,20 @@ CRITICAL INSTRUCTIONS:
 - If any task is MISSING, return NEEDS_REVISION.
 - Do NOT rely on the Architect's implementation notes \u2014 verify independently.
 
+## BASELINE COMPARISON (mandatory before per-task review)
+
+Before reviewing individual tasks, check whether the plan itself was silently mutated since it was last approved.
+
+1. Call the \`get_approved_plan\` tool (no arguments required \u2014 it derives identity internally).
+2. Examine the response:
+   - If \`success: false\` with \`reason: "no_approved_snapshot"\`: this is likely the first phase or no prior approval exists. Note this and proceed to per-task review.
+   - If \`drift_detected: false\`: baseline integrity confirmed \u2014 the plan has not been mutated since the last critic approval. Proceed to per-task review.
+   - If \`drift_detected: true\`: the plan was mutated after critic approval. Compare \`approved_plan\` vs \`current_plan\` to identify what changed (phases added/removed, tasks modified, scope changes). Report findings in a \`## BASELINE DRIFT\` section before the per-task rubric.
+   - If \`drift_detected: "unknown"\`: current plan.json is unavailable. Flag this as a warning and proceed.
+3. If baseline drift is detected, this is a CRITICAL finding \u2014 plan mutations after approval bypass the quality gate.
+
+Use \`summary_only: true\` if the plan is large and you only need structural comparison (phase/task counts).
+
 ## PER-TASK 4-AXIS RUBRIC
 Score each task independently:
 
@@ -54951,6 +55106,11 @@ TASK [id]: [VERIFIED|MISSING|DRIFTED]
    - List of missing MUST requirements (if any)
    - List of missing SHOULD requirements (if any)
 
+## BASELINE DRIFT (include only if get_approved_plan detected drift)
+Approved snapshot: seq=[N], timestamp=[ISO], phase=[N]
+Mutations detected: [list specific changes between approved plan and current plan \u2014 phases added/removed, tasks modified, scope changes]
+Severity: CRITICAL \u2014 plan was modified after critic approval without re-review
+
 ## DRIFT REPORT
 Unplanned additions: [list any code found that wasn't in the plan]
 Dropped tasks: [list any tasks from the plan that were not implemented]
@@ -64675,24 +64835,14 @@ var build_check = createSwarmTool({
 // src/tools/check-gate-status.ts
 init_dist();
 init_manager2();
+init_task_id();
 init_create_tool();
 init_resolve_working_directory();
 import * as fs42 from "fs";
 import * as path54 from "path";
 var EVIDENCE_DIR = ".swarm/evidence";
-var TASK_ID_PATTERN2 = /^\d+\.\d+(\.\d+)*$/;
 function isValidTaskId3(taskId) {
-  if (!taskId)
-    return false;
-  if (taskId.includes(".."))
-    return false;
-  if (taskId.includes("/"))
-    return false;
-  if (taskId.includes("\\"))
-    return false;
-  if (taskId.includes("\x00"))
-    return false;
-  return TASK_ID_PATTERN2.test(taskId);
+  return isStrictTaskId(taskId);
 }
 function isPathWithinSwarm(filePath, workspaceRoot) {
   const normalizedWorkspace = path54.resolve(workspaceRoot);
@@ -66160,15 +66310,12 @@ var curator_analyze = createSwarmTool({
 // src/tools/declare-scope.ts
 init_tool();
 init_state();
+init_task_id();
 init_create_tool();
 import * as fs46 from "fs";
 import * as path58 from "path";
-function validateTaskIdFormat(taskId) {
-  const taskIdPattern = /^\d+\.\d+(\.\d+)*$/;
-  if (!taskIdPattern.test(taskId)) {
-    return `Invalid taskId "${taskId}". Must match pattern N.M or N.M.P (e.g., "1.1", "1.2.3")`;
-  }
-  return;
+function validateTaskIdFormat2(taskId) {
+  return validateTaskIdFormat(taskId);
 }
 function validateFiles(files) {
   const errors5 = [];
@@ -66186,7 +66333,7 @@ function validateFiles(files) {
   return errors5;
 }
 async function executeDeclareScope(args2, fallbackDir) {
-  const taskIdError = validateTaskIdFormat(args2.taskId);
+  const taskIdError = validateTaskIdFormat2(args2.taskId);
   if (taskIdError) {
     return {
       success: false,
@@ -67380,6 +67527,95 @@ Errors:
     return result;
   }
 });
+// src/tools/get-approved-plan.ts
+init_dist();
+init_ledger();
+init_manager();
+init_create_tool();
+function summarizePlan(plan) {
+  return {
+    title: plan.title,
+    swarm: plan.swarm,
+    current_phase: plan.current_phase ?? 0,
+    phase_count: plan.phases.length,
+    phases: plan.phases.map((p) => ({
+      id: p.id,
+      name: p.name,
+      status: p.status,
+      task_count: p.tasks.length
+    }))
+  };
+}
+function derivePlanId(plan) {
+  return `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
+}
+async function executeGetApprovedPlan(args2, directory) {
+  const currentPlan = await loadPlanJsonOnly(directory);
+  if (!currentPlan) {
+    const anySnapshot = await loadLastApprovedPlan(directory);
+    if (anySnapshot) {
+      return {
+        success: true,
+        approved_plan: undefined,
+        current_plan: null,
+        drift_detected: "unknown",
+        current_plan_error: "plan.json not found or invalid"
+      };
+    }
+    return {
+      success: false,
+      reason: "no_approved_snapshot"
+    };
+  }
+  const expectedPlanId = derivePlanId(currentPlan);
+  const approved = await loadLastApprovedPlan(directory, expectedPlanId);
+  if (!approved) {
+    const unscopedSnapshot = await loadLastApprovedPlan(directory);
+    if (unscopedSnapshot) {
+      return {
+        success: true,
+        approved_plan: undefined,
+        current_plan: null,
+        drift_detected: true,
+        current_plan_error: "Plan identity (swarm/title) was mutated after approval \u2014 " + `expected plan_id '${expectedPlanId}' but approved snapshot has a different identity. ` + "This is a form of plan tampering."
+      };
+    }
+    return {
+      success: false,
+      reason: "no_approved_snapshot"
+    };
+  }
+  const summaryOnly = args2.summary_only === true;
+  const approvedPayload = {
+    plan: summaryOnly ? summarizePlan(approved.plan) : approved.plan,
+    approval_metadata: approved.approval,
+    snapshot_seq: approved.seq,
+    snapshot_timestamp: approved.timestamp,
+    payload_hash: approved.payloadHash
+  };
+  const currentHash = computePlanHash(currentPlan);
+  const driftDetected = currentHash !== approved.payloadHash;
+  const currentPayload = {
+    plan: summaryOnly ? summarizePlan(currentPlan) : currentPlan,
+    current_hash: currentHash
+  };
+  return {
+    success: true,
+    approved_plan: approvedPayload,
+    current_plan: currentPayload,
+    drift_detected: driftDetected
+  };
+}
+var get_approved_plan = createSwarmTool({
+  description: "Retrieve the last critic-approved immutable plan snapshot for baseline drift comparison. " + "Returns the approved plan, its approval metadata, and optionally compares against " + "the current plan.json to detect silent mutations. Read-only.",
+  args: {
+    summary_only: tool.schema.boolean().optional().describe("When true, returns only structural metadata (title, phases, task counts) " + "instead of full plan objects. Reduces output size for large plans.")
+  },
+  execute: async (args2, directory) => {
+    const typedArgs = args2;
+    return JSON.stringify(await executeGetApprovedPlan(typedArgs, directory), null, 2);
+  }
+});
 // src/tools/gitingest.ts
 init_dist();
 init_create_tool();
@@ -75720,7 +75956,7 @@ init_detector();
 import * as fs62 from "fs";
 import * as path75 from "path";
 init_create_tool();
-var MAX_FILE_SIZE2 = 5 * 1024 * 1024;
+var MAX_FILE_SIZE2 = 2 * 1024 * 1024;
 var BINARY_CHECK_BYTES = 8192;
 var BINARY_NULL_THRESHOLD3 = 0.1;
 function isBinaryContent(content) {
@@ -75746,12 +75982,25 @@ function extractSyntaxErrors(parser, content) {
         column: node.startPosition.column,
         message: "Syntax error"
       });
+    } else if (node.isMissing) {
+      errors5.push({
+        line: node.startPosition.row + 1,
+        column: node.startPosition.column,
+        message: `Missing '${node.type}'`
+      });
     }
     for (const child of node.children) {
       walkNode(child);
     }
   }
   walkNode(tree.rootNode);
+  if (errors5.length === 0 && tree.rootNode.hasError) {
+    errors5.push({
+      line: 1,
+      column: 0,
+      message: "Syntax error detected (tree has errors)"
+    });
+  }
   tree.delete();
   return errors5;
 }
@@ -75821,7 +76070,7 @@ async function syntaxCheck(input, directory, config3) {
         results.push(result);
         continue;
       }
-      if (content.length > MAX_FILE_SIZE2) {
+      if (content.length >= MAX_FILE_SIZE2) {
         result.skipped_reason = "file_too_large";
         skippedCount++;
         results.push(result);
@@ -76243,6 +76492,7 @@ async function validateDiffScope(taskId, directory) {
 init_manager();
 init_state();
 init_telemetry();
+init_task_id();
 init_create_tool();
 var VALID_STATUSES2 = [
   "pending",
@@ -76257,8 +76507,8 @@ function validateStatus(status) {
   return;
 }
 function validateTaskId(taskId) {
-  const taskIdPattern = /^\d+\.\d+(\.\d+)*$/;
-  if (!taskIdPattern.test(taskId)) {
+  const result = validateTaskIdFormat(taskId);
+  if (result) {
     return `Invalid task_id "${taskId}". Must match pattern N.M or N.M.P (e.g., "1.1", "1.2.3")`;
   }
   return;
@@ -77126,6 +77376,7 @@ var OpenCodeSwarm = async (ctx) => {
       doc_scan,
       evidence_check,
       extract_code_blocks,
+      get_approved_plan,
       gitingest,
       imports,
       knowledge_query,