opencode-swarm 6.62.0 → 6.63.0

package/dist/index.js

@@ -15788,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(),
@@ -15812,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)}`;
@@ -15899,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;
@@ -15922,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;
@@ -15944,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) {
@@ -16032,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) {
@@ -16284,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;
@@ -16361,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) {
@@ -16380,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);
@@ -16422,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);
@@ -16471,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;
     }
@@ -16481,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");
@@ -16494,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");
@@ -16551,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";
@@ -16568,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 = {
@@ -16855,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 (TASK_ID_REGEX.test(taskId)) {
-    return taskId;
+  if (taskId.includes("..") || taskId.includes("/") || taskId.includes("\\")) {
+    return "Invalid task ID: path traversal detected";
   }
-  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);
@@ -16936,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);
@@ -16983,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);
@@ -17037,7 +17157,7 @@ async function listEvidenceTaskIds(directory) {
   }
   let entries;
   try {
-    entries = readdirSync(evidenceBasePath);
+    entries = readdirSync2(evidenceBasePath);
   } catch {
     return [];
   }
@@ -17049,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")) {
@@ -17060,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 {
@@ -17122,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",
@@ -17143,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",
@@ -40852,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) {
@@ -40900,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) {
@@ -40987,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
@@ -47288,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") {
@@ -47484,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 {
@@ -47499,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);
@@ -47556,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;
@@ -47820,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.
 
@@ -49074,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) {
@@ -49277,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 {
@@ -49743,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({
@@ -51975,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) {
@@ -64697,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);
@@ -66182,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 = [];
@@ -66208,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,
@@ -76367,6 +76492,7 @@ async function validateDiffScope(taskId, directory) {
 init_manager();
 init_state();
 init_telemetry();
+init_task_id();
 init_create_tool();
 var VALID_STATUSES2 = [
   "pending",
@@ -76381,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;