opencode-swarm 7.139.5 → 7.139.7

package/dist/cli/{index-6nzmp937.js → index-brh827g0.js}

@@ -3,7 +3,10 @@ import {
   EvaluationRunV1Schema,
   GateAuditResultV1Schema,
   getProtectedEvaluationRunIds
-} from "./index-nrx08gcr.js";
+} from "./index-yyyk63kk.js";
+import {
+  loadDatabaseCtor
+} from "./index-134d35c1.js";
 import {
   readEffectiveSpecSync
 } from "./index-9ss2m4rs.js";
@@ -13,6 +16,7 @@ import {
   computeCurrentPlanHash,
   computePlanHash,
   derivePlanId,
+  derivePlanIdentityHash,
   getLatestLedgerSeq,
   initLedger,
   ledgerExists,
@@ -22,7 +26,7 @@ import {
   replayFromLedgerWithStatus,
   takeSnapshotEvent,
   takeSnapshotWithRetry
-} from "./index-6rxgb5r9.js";
+} from "./index-kbfsp07d.js";
 import {
   getWorktreeMergeFailure
 } from "./index-b8zgtz81.js";
@@ -35,7 +39,7 @@ import {
   readTaskEvidence,
   readTaskEvidenceRaw,
   sanitizeTaskId
-} from "./index-5z2xps64.js";
+} from "./index-n0pja0qs.js";
 import {
   _internals,
   buildDefaultPolicy,
@@ -49,8 +53,9 @@ import {
 } from "./index-ed5ykebp.js";
 import {
   assertProjectRoot,
+  tryAcquireLock,
   withEvidenceLock
-} from "./index-s0qc4gj6.js";
+} from "./index-hfvxhk4z.js";
 import {
   bunHash,
   bunWrite,
@@ -63,7 +68,7 @@ import {
 } from "./index-gprxjmm7.js";
 import {
   PlanSchema
-} from "./index-1kz6da87.js";
+} from "./index-d181x9zr.js";
 import {
   criticalWarn,
   error,
@@ -72,7 +77,7 @@ import {
 } from "./index-zgwm4ryv.js";
 import {
   emit
-} from "./index-rsrx77fg.js";
+} from "./index-ry0hgg3m.js";
 import {
   ZodError,
   init_zod
@@ -972,9 +977,9 @@ var init_executor = __esm(() => {
 import {
   closeSync,
   copyFileSync,
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   fsyncSync,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   openSync,
   readdirSync,
   renameSync as renameSync2,
@@ -984,6 +989,342 @@ import {
 import * as fsPromises from "fs/promises";
 import * as path8 from "path";
 
+// src/db/task-checkpoint-receipt.ts
+import { createHash } from "crypto";
+
+// src/db/project-db.ts
+import { existsSync, mkdirSync } from "fs";
+import { join, resolve } from "path";
+var MIGRATIONS = [
+  {
+    version: 1,
+    name: "create_project_constraints",
+    sql: `CREATE TABLE project_constraints (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			constraint_type TEXT NOT NULL,
+			content TEXT NOT NULL,
+			created_at TEXT NOT NULL DEFAULT (datetime('now'))
+		)`
+  },
+  {
+    version: 2,
+    name: "create_qa_gate_profile",
+    sql: `CREATE TABLE qa_gate_profile (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			plan_id TEXT NOT NULL UNIQUE,
+			created_at TEXT NOT NULL DEFAULT (datetime('now')),
+			project_type TEXT,
+			gates TEXT NOT NULL DEFAULT '{}',
+			locked_at TEXT,
+			locked_by_snapshot_seq INTEGER
+		)`
+  },
+  {
+    version: 3,
+    name: "create_qa_gate_profile_immutability_trigger",
+    sql: `CREATE TRIGGER IF NOT EXISTS trg_qa_gate_profile_no_update_after_lock
+			BEFORE UPDATE ON qa_gate_profile
+			WHEN OLD.locked_at IS NOT NULL
+			BEGIN
+				SELECT RAISE(ABORT, 'qa_gate_profile row is locked and cannot be modified after critic approval');
+			END`
+  },
+  {
+    version: 4,
+    name: "add_qa_gate_profile_raw_swarm",
+    sql: "ALTER TABLE qa_gate_profile ADD COLUMN raw_swarm TEXT"
+  },
+  {
+    version: 5,
+    name: "add_qa_gate_profile_raw_title",
+    sql: "ALTER TABLE qa_gate_profile ADD COLUMN raw_title TEXT"
+  },
+  {
+    version: 6,
+    name: "add_qa_gate_profile_identity_hash",
+    sql: "ALTER TABLE qa_gate_profile ADD COLUMN identity_hash TEXT"
+  },
+  {
+    version: 7,
+    name: "create_qa_gate_profile_identity_hash_index",
+    sql: `CREATE UNIQUE INDEX IF NOT EXISTS idx_qa_gate_profile_identity_hash
+			ON qa_gate_profile(identity_hash)
+			WHERE identity_hash IS NOT NULL`
+  },
+  {
+    version: 8,
+    name: "create_qa_gate_profile_identity",
+    sql: `CREATE TABLE qa_gate_profile_identity (
+			identity_hash TEXT PRIMARY KEY,
+			profile_id INTEGER NOT NULL UNIQUE REFERENCES qa_gate_profile(id) ON DELETE CASCADE,
+			raw_swarm TEXT NOT NULL,
+			raw_title TEXT NOT NULL,
+			readable_plan_id TEXT NOT NULL
+		)`
+  },
+  {
+    version: 9,
+    name: "create_qa_gate_profile_identity_readable_plan_index",
+    sql: `CREATE INDEX idx_qa_gate_profile_identity_readable_plan_id
+			ON qa_gate_profile_identity(readable_plan_id)`
+  },
+  {
+    version: 10,
+    name: "backfill_qa_gate_profile_identity_from_legacy_columns",
+    sql: `INSERT INTO qa_gate_profile_identity (
+				identity_hash,
+				profile_id,
+				raw_swarm,
+				raw_title,
+				readable_plan_id
+			)
+			SELECT
+				identity_hash,
+				id,
+				raw_swarm,
+				raw_title,
+				plan_id
+			FROM qa_gate_profile
+			WHERE identity_hash IS NOT NULL
+				AND raw_swarm IS NOT NULL
+				AND raw_title IS NOT NULL
+				AND NOT EXISTS (
+					SELECT 1
+					FROM qa_gate_profile_identity AS qi
+					WHERE qi.profile_id = qa_gate_profile.id
+				)`
+  },
+  {
+    version: 11,
+    name: "create_task_checkpoint_receipt",
+    sql: `CREATE TABLE task_checkpoint_receipt (
+			plan_identity_hash TEXT NOT NULL,
+			task_id TEXT NOT NULL,
+			label TEXT NOT NULL,
+			state TEXT NOT NULL CHECK(state IN ('pending', 'committed', 'logged')),
+			sha TEXT,
+			created_at TEXT NOT NULL DEFAULT (datetime('now')),
+			updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+			PRIMARY KEY(plan_identity_hash, task_id)
+		)`
+  },
+  {
+    version: 12,
+    name: "add_task_checkpoint_receipt_completion_generation",
+    sql: `ALTER TABLE task_checkpoint_receipt
+			ADD COLUMN generation INTEGER NOT NULL DEFAULT 1;
+		ALTER TABLE task_checkpoint_receipt
+			ADD COLUMN completion_active INTEGER NOT NULL DEFAULT 1
+			CHECK(completion_active IN (0, 1))`
+  },
+  {
+    version: 13,
+    name: "bind_task_checkpoint_receipt_to_completion_ledger_seq",
+    sql: `ALTER TABLE task_checkpoint_receipt
+			ADD COLUMN completion_ledger_seq INTEGER
+			CHECK(completion_ledger_seq IS NULL OR completion_ledger_seq >= 0)`
+  }
+];
+var _projectDbs = new Map;
+function runProjectMigrations(db) {
+  db.run(`CREATE TABLE IF NOT EXISTS schema_migrations (
+		version INTEGER PRIMARY KEY,
+		name TEXT NOT NULL,
+		applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+	)`);
+  const row = db.query("SELECT MAX(version) as version FROM schema_migrations").get();
+  const currentVersion = row?.version ?? 0;
+  for (const migration of MIGRATIONS) {
+    if (migration.version <= currentVersion)
+      continue;
+    const apply = db.transaction(() => {
+      db.run(migration.sql);
+      db.run("INSERT INTO schema_migrations (version, name) VALUES (?, ?)", [
+        migration.version,
+        migration.name
+      ]);
+    });
+    apply();
+  }
+}
+function projectDbPath(directory) {
+  return join(resolve(directory), ".swarm", "swarm.db");
+}
+function projectDbExists(directory) {
+  return existsSync(projectDbPath(directory));
+}
+function getProjectDb(directory) {
+  const key = resolve(directory);
+  const existing = _projectDbs.get(key);
+  if (existing)
+    return existing;
+  const swarmDir = join(key, ".swarm");
+  mkdirSync(swarmDir, { recursive: true });
+  const Db = loadDatabaseCtor();
+  const db = new Db(join(swarmDir, "swarm.db"));
+  db.run("PRAGMA journal_mode = WAL;");
+  db.run("PRAGMA synchronous = NORMAL;");
+  db.run("PRAGMA busy_timeout = 5000;");
+  db.run("PRAGMA foreign_keys = ON;");
+  runProjectMigrations(db);
+  _projectDbs.set(key, db);
+  return db;
+}
+function closeProjectDb(directory) {
+  const key = resolve(directory);
+  const db = _projectDbs.get(key);
+  if (db) {
+    db.close();
+    _projectDbs.delete(key);
+  }
+}
+
+// src/db/task-checkpoint-receipt.ts
+var TASK_COMPLETION_HASH_LENGTH = 16;
+function taskReceiptLabelSuffix(planIdentityHash, taskId, generation) {
+  return createHash("sha256").update(JSON.stringify(generation === 1 ? [planIdentityHash, taskId] : [planIdentityHash, taskId, generation]), "utf8").digest("hex").slice(0, TASK_COMPLETION_HASH_LENGTH);
+}
+function scrubTaskIdForCheckpointLabel(taskId) {
+  const scrubbed = taskId.replace(/[^a-zA-Z0-9._-]/g, "_");
+  return scrubbed.length > 32 ? scrubbed.slice(0, 32) : scrubbed;
+}
+function buildTaskCompletionDescriptor(planIdentityHash, taskId, generation) {
+  if (!Number.isSafeInteger(generation) || generation < 1) {
+    throw new Error(`Invalid task checkpoint generation: ${generation}`);
+  }
+  const suffix = taskReceiptLabelSuffix(planIdentityHash, taskId, generation);
+  const safeTaskId = scrubTaskIdForCheckpointLabel(taskId) || "task";
+  return {
+    planIdentityHash,
+    taskId,
+    generation,
+    label: `task-${safeTaskId}-complete-${suffix}`,
+    subject: generation === 1 ? `checkpoint(task-complete ${suffix} plan ${planIdentityHash}): ${safeTaskId}` : `checkpoint(task-complete ${suffix} gen ${generation} plan ${planIdentityHash}): ${safeTaskId}`
+  };
+}
+function readTaskCheckpointReceipt(directory, planIdentityHash, taskId) {
+  if (!projectDbExists(directory))
+    return null;
+  return getProjectDb(directory).query("SELECT * FROM task_checkpoint_receipt WHERE plan_identity_hash = ? AND task_id = ?").get(planIdentityHash, taskId) ?? null;
+}
+function ensureTaskCheckpointReceipt(directory, planIdentityHash, taskId, completionLedgerSeq) {
+  if (!Number.isSafeInteger(completionLedgerSeq) || completionLedgerSeq < 0) {
+    throw new Error(`Invalid task checkpoint completion ledger seq: ${completionLedgerSeq}`);
+  }
+  const db = getProjectDb(directory);
+  const initial = buildTaskCompletionDescriptor(planIdentityHash, taskId, 1);
+  db.transaction(() => {
+    db.run(`INSERT OR IGNORE INTO task_checkpoint_receipt
+				(plan_identity_hash, task_id, label, state, sha, generation,
+				 completion_active, completion_ledger_seq)
+			 VALUES (?, ?, ?, 'pending', NULL, 1, 1, ?)`, [planIdentityHash, taskId, initial.label, completionLedgerSeq]);
+    const row2 = db.query("SELECT * FROM task_checkpoint_receipt WHERE plan_identity_hash = ? AND task_id = ?").get(planIdentityHash, taskId);
+    if (!row2)
+      return;
+    if (row2.completion_ledger_seq === null) {
+      db.run(`UPDATE task_checkpoint_receipt
+				 SET completion_ledger_seq = ?, completion_active = 1,
+					updated_at = datetime('now')
+				 WHERE plan_identity_hash = ? AND task_id = ?
+					AND completion_ledger_seq IS NULL`, [completionLedgerSeq, planIdentityHash, taskId]);
+      return;
+    }
+    if (row2.completion_ledger_seq !== completionLedgerSeq) {
+      const nextGeneration = row2.generation + 1;
+      const descriptor = buildTaskCompletionDescriptor(planIdentityHash, taskId, nextGeneration);
+      db.run(`UPDATE task_checkpoint_receipt
+				 SET label = ?, state = 'pending', sha = NULL, generation = ?,
+					completion_active = 1, completion_ledger_seq = ?,
+					updated_at = datetime('now')
+				 WHERE plan_identity_hash = ? AND task_id = ?
+					AND completion_ledger_seq = ?`, [
+        descriptor.label,
+        nextGeneration,
+        completionLedgerSeq,
+        planIdentityHash,
+        taskId,
+        row2.completion_ledger_seq
+      ]);
+      return;
+    }
+    if (row2.completion_active === 0) {
+      db.run(`UPDATE task_checkpoint_receipt
+				 SET completion_active = 1, updated_at = datetime('now')
+				 WHERE plan_identity_hash = ? AND task_id = ?
+					AND completion_ledger_seq = ? AND completion_active = 0`, [planIdentityHash, taskId, completionLedgerSeq]);
+    }
+  })();
+  const row = readTaskCheckpointReceipt(directory, planIdentityHash, taskId);
+  if (!row) {
+    throw new Error(`Failed to create or read task checkpoint receipt for ${taskId}`);
+  }
+  return row;
+}
+function activateTaskCheckpointReceipt(directory, planIdentityHash, taskId) {
+  if (!projectDbExists(directory))
+    return null;
+  const db = getProjectDb(directory);
+  db.transaction(() => {
+    const row = db.query("SELECT * FROM task_checkpoint_receipt WHERE plan_identity_hash = ? AND task_id = ?").get(planIdentityHash, taskId);
+    if (!row || row.completion_active === 1)
+      return;
+    const descriptor = buildTaskCompletionDescriptor(planIdentityHash, taskId, row.generation);
+    db.run(`UPDATE task_checkpoint_receipt
+			 SET label = ?, state = 'pending', sha = NULL, completion_active = 1,
+				updated_at = datetime('now')
+			 WHERE plan_identity_hash = ? AND task_id = ? AND completion_active = 0`, [descriptor.label, planIdentityHash, taskId]);
+  })();
+  return readTaskCheckpointReceipt(directory, planIdentityHash, taskId);
+}
+function advanceTaskCheckpointReceiptGeneration(directory, planIdentityHash, taskId) {
+  if (!projectDbExists(directory))
+    return null;
+  const db = getProjectDb(directory);
+  db.transaction(() => {
+    const row = db.query("SELECT * FROM task_checkpoint_receipt WHERE plan_identity_hash = ? AND task_id = ?").get(planIdentityHash, taskId);
+    if (!row || row.completion_active === 0)
+      return;
+    const nextGeneration = row.generation + 1;
+    const descriptor = buildTaskCompletionDescriptor(planIdentityHash, taskId, nextGeneration);
+    db.run(`UPDATE task_checkpoint_receipt
+			 SET label = ?, state = 'pending', sha = NULL, generation = ?,
+				completion_active = 0, completion_ledger_seq = NULL,
+				updated_at = datetime('now')
+			 WHERE plan_identity_hash = ? AND task_id = ? AND completion_active = 1`, [descriptor.label, nextGeneration, planIdentityHash, taskId]);
+  })();
+  return readTaskCheckpointReceipt(directory, planIdentityHash, taskId);
+}
+function repairTaskCheckpointReceiptForCompletion(directory, planIdentityHash, taskId) {
+  if (!projectDbExists(directory))
+    return null;
+  const current = readTaskCheckpointReceipt(directory, planIdentityHash, taskId);
+  if (!current)
+    return null;
+  if (current.completion_active === 0) {
+    return activateTaskCheckpointReceipt(directory, planIdentityHash, taskId);
+  }
+  advanceTaskCheckpointReceiptGeneration(directory, planIdentityHash, taskId);
+  return activateTaskCheckpointReceipt(directory, planIdentityHash, taskId);
+}
+function updateTaskCheckpointReceipt(directory, descriptor, state, sha) {
+  const db = getProjectDb(directory);
+  db.run(`UPDATE task_checkpoint_receipt
+		 SET state = ?, sha = ?, updated_at = datetime('now')
+		 WHERE plan_identity_hash = ? AND task_id = ?
+			AND generation = ? AND completion_active = 1`, [
+    state,
+    sha,
+    descriptor.planIdentityHash,
+    descriptor.taskId,
+    descriptor.generation
+  ]);
+  const row = readTaskCheckpointReceipt(directory, descriptor.planIdentityHash, descriptor.taskId);
+  if (!row || row.generation !== descriptor.generation || row.completion_active !== 1) {
+    throw new Error(`Task checkpoint receipt generation changed for ${descriptor.taskId}`);
+  }
+  return row;
+}
+
 // src/git/branch.ts
 init_executor();
 import * as child_process from "child_process";
@@ -1292,7 +1633,7 @@ async function resetToRemoteBranch(cwd, options) {
     let lastError;
     for (let retry = 0;retry < 4; retry++) {
       if (retry > 0 && process.platform === "win32") {
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        await new Promise((resolve2) => setTimeout(resolve2, 500));
       }
       try {
         gitExec(["reset", "--hard", targetBranch], cwd);
@@ -1502,7 +1843,7 @@ async function resetToMainAfterMerge(cwd, options) {
       let discardSucceeded = false;
       for (let retry = 0;retry < 4; retry++) {
         if (retry > 0 && process.platform === "win32") {
-          await new Promise((resolve) => setTimeout(resolve, 500));
+          await new Promise((resolve2) => setTimeout(resolve2, 500));
         }
         try {
           _internals5.gitExec(["checkout", "--", "."], cwd);
@@ -2094,7 +2435,7 @@ var _internals7 = {
   gitHeadSha: (cwd) => {
     return _internals5.gitExec(["rev-parse", "HEAD"], cwd).trim();
   },
-  sleep: (ms) => new Promise((resolve3) => setTimeout(resolve3, ms)),
+  sleep: (ms) => new Promise((resolve4) => setTimeout(resolve4, ms)),
   hasExistingTaskCommit: (cwd, taskId) => {
     const safeId = scrubTaskIdForGitSubject(taskId);
     const escaped = safeId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -2257,14 +2598,14 @@ function readTaskScopes(directory, taskId) {
 }
 
 // src/utils/spec-hash.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import * as fsSync2 from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 async function computeSpecHash(directory) {
   const spec = _internals8.readEffectiveSpecSync(directory);
   if (!spec)
     return null;
-  return createHash2("sha256").update(spec.content, "utf-8").digest("hex");
+  return createHash3("sha256").update(spec.content, "utf-8").digest("hex");
 }
 async function isSpecStale(directory, plan) {
   const currentHash = await _internals8.computeSpecHash(directory);
@@ -2288,7 +2629,7 @@ async function isSpecStale(directory, plan) {
   return { stale: false };
 }
 function isObligationPreserving(directory) {
-  const snapshotPath = join6(directory, ".swarm", "spec-snapshot.md");
+  const snapshotPath = join7(directory, ".swarm", "spec-snapshot.md");
   try {
     let recordedContent;
     try {
@@ -2334,7 +2675,7 @@ var _internals8 = {
   readEffectiveSpecSync
 };
 function computeSpecDiff(directory) {
-  const snapshotPath = join6(directory, ".swarm", "spec-snapshot.md");
+  const snapshotPath = join7(directory, ".swarm", "spec-snapshot.md");
   let recordedContent;
   try {
     const snapshotSize = fsSync2.statSync(snapshotPath).size;
@@ -2538,7 +2879,7 @@ async function retryCasWithBackoff(directory, eventInput, options) {
         expectedHashPrefix: currentExpected.slice(0, 8),
         delayMs
       });
-      await new Promise((resolve4) => setTimeout(resolve4, delayMs));
+      await new Promise((resolve5) => setTimeout(resolve5, delayMs));
       if (options.verifyValid) {
         const stillValid = await options.verifyValid();
         if (!stillValid)
@@ -2616,6 +2957,14 @@ function computePlanContentHash(plan) {
     swarm: plan.swarm,
     current_phase: plan.current_phase,
     migration_status: plan.migration_status,
+    execution_profile: plan.execution_profile ? {
+      parallelization_enabled: plan.execution_profile.parallelization_enabled,
+      max_concurrent_tasks: plan.execution_profile.max_concurrent_tasks,
+      council_parallel: plan.execution_profile.council_parallel,
+      locked: plan.execution_profile.locked,
+      auto_proceed: plan.execution_profile.auto_proceed,
+      commit_after_each_completed_task: plan.execution_profile.commit_after_each_completed_task === true ? true : undefined
+    } : undefined,
     phases: plan.phases.map((phase) => ({
       id: phase.id,
       name: phase.name,
@@ -2947,6 +3296,23 @@ async function savePlan(directory, plan, options) {
     throw new Error(`Invalid directory: directory must be a non-empty string`);
   }
   assertProjectRoot(directory);
+  if (!options?.planLockAlreadyHeld) {
+    const lockResult = await tryAcquireLock(directory, "plan.json", "plan-manager", `save-plan-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+    if (!lockResult.acquired) {
+      throw new PlanConcurrentModificationError(`Plan write blocked: plan.json is locked by ${lockResult.existing?.agent ?? "another agent"} (task: ${lockResult.existing?.taskId ?? "unknown"})`);
+    }
+    try {
+      await savePlan(directory, plan, {
+        ...options,
+        planLockAlreadyHeld: true
+      });
+      return;
+    } finally {
+      if (lockResult.lock._release) {
+        await lockResult.lock._release().catch(() => {});
+      }
+    }
+  }
   const validated = PlanSchema.parse(plan);
   if (options?.preserveCompletedStatuses !== false) {
     try {
@@ -2991,7 +3357,7 @@ async function savePlan(directory, plan, options) {
       const oldLedgerPath = path8.join(swarmDir2, "plan-ledger.jsonl");
       const oldLedgerBackupPath = path8.join(swarmDir2, `plan-ledger.backup-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
       let backupExists = false;
-      if (existsSync3(oldLedgerPath)) {
+      if (existsSync4(oldLedgerPath)) {
         try {
           renameSync2(oldLedgerPath, oldLedgerBackupPath);
           backupExists = true;
@@ -3008,11 +3374,11 @@ async function savePlan(directory, plan, options) {
           const errorMessage2 = String(initErr);
           if (errorMessage2.includes("already initialized")) {
             try {
-              if (existsSync3(oldLedgerBackupPath))
+              if (existsSync4(oldLedgerBackupPath))
                 unlinkSync2(oldLedgerBackupPath);
             } catch {}
           } else {
-            if (existsSync3(oldLedgerBackupPath)) {
+            if (existsSync4(oldLedgerBackupPath)) {
               try {
                 renameSync2(oldLedgerBackupPath, oldLedgerPath);
               } catch {
@@ -3034,13 +3400,13 @@ async function savePlan(directory, plan, options) {
         } 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))
+            if (existsSync4(oldLedgerBackupPath))
               unlinkSync2(oldLedgerBackupPath);
           } catch {}
         }
       } else if (!initSucceeded && backupExists) {
         try {
-          if (existsSync3(oldLedgerBackupPath))
+          if (existsSync4(oldLedgerBackupPath))
             unlinkSync2(oldLedgerBackupPath);
         } catch {}
       }
@@ -3257,6 +3623,37 @@ ${markdown}`;
     });
     await bunWrite(markerPath, marker);
   } catch {}
+  if (currentPlan) {
+    try {
+      const oldIdentityHash = derivePlanIdentityHash(currentPlan);
+      const newIdentityHash = derivePlanIdentityHash(projectedPlan);
+      if (oldIdentityHash === newIdentityHash) {
+        const oldStatuses = new Map;
+        for (const phase of currentPlan.phases) {
+          for (const task of phase.tasks)
+            oldStatuses.set(task.id, task.status);
+        }
+        const newStatuses = new Map;
+        for (const phase of projectedPlan.phases) {
+          for (const task of phase.tasks)
+            newStatuses.set(task.id, task.status);
+        }
+        for (const [taskId, oldStatus] of oldStatuses) {
+          const newStatus = newStatuses.get(taskId);
+          if (oldStatus === "completed" && newStatus !== "completed") {
+            advanceTaskCheckpointReceiptGeneration(directory, oldIdentityHash, taskId);
+          }
+        }
+        for (const [taskId, newStatus] of newStatuses) {
+          if (newStatus === "completed" && oldStatuses.get(taskId) !== "completed") {
+            repairTaskCheckpointReceiptForCompletion(directory, newIdentityHash, taskId);
+          }
+        }
+      }
+    } catch (receiptError) {
+      warn(`[savePlan] task checkpoint receipt lifecycle sync failed (plan remains authoritative): ${receiptError instanceof Error ? receiptError.message : String(receiptError)}`);
+    }
+  }
 }
 async function rebuildPlan(directory, plan, options) {
   assertProjectRoot(directory);
@@ -3266,7 +3663,7 @@ async function rebuildPlan(directory, plan, options) {
   const swarmDir = path8.join(directory, ".swarm");
   const planPath = path8.join(swarmDir, "plan.json");
   const mdPath = path8.join(swarmDir, "plan.md");
-  mkdirSync3(swarmDir, { recursive: true });
+  mkdirSync4(swarmDir, { recursive: true });
   const tempPlanPath = path8.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   {
     const fd = openSync(tempPlanPath, "w");
@@ -3423,6 +3820,24 @@ function derivePlanMarkdown(plan) {
 Swarm: ${plan.swarm}
 Phase: ${currentPhase} [${phaseStatus}] | Updated: ${now}
 `;
+  if (plan.execution_profile) {
+    const profile = plan.execution_profile;
+    markdown += `
+## Execution Profile
+`;
+    markdown += `- Parallelization: ${profile.parallelization_enabled ? "enabled" : "disabled"}
+`;
+    markdown += `- Max Concurrent Tasks: ${profile.max_concurrent_tasks}
+`;
+    markdown += `- Council Parallel: ${profile.council_parallel ? "yes" : "no"}
+`;
+    markdown += `- Locked: ${profile.locked ? "yes" : "no"}
+`;
+    markdown += `- Auto Proceed: ${profile.auto_proceed ? "yes" : "no"}
+`;
+    markdown += `- Commit After Each Completed Task: ${profile.commit_after_each_completed_task ? "yes" : "no"}
+`;
+  }
   const sortedPhases = [...plan.phases].sort((a, b) => a.id - b.id);
   for (const phase of sortedPhases) {
     const phaseStatusText = statusMap[phase.status] || "PENDING";
@@ -3683,7 +4098,7 @@ function migrateLegacyPlan(planContent, swarmId) {
 // src/evidence/manager.ts
 init_zod();
 import {
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync2,
   realpathSync,
   renameSync as renameSync3,
@@ -3880,7 +4295,7 @@ async function atomicRenameWithRetry(src, dst, renameFn = fsp.rename) {
         throw err;
       }
       if (attempt < RENAME_MAX_ATTEMPTS - 1) {
-        await new Promise((resolve4) => setTimeout(resolve4, RENAME_BACKOFF_MS));
+        await new Promise((resolve5) => setTimeout(resolve5, RENAME_BACKOFF_MS));
       }
     }
   }
@@ -4164,7 +4579,7 @@ async function saveEvidence(directory, taskId, evidence, abortSignal) {
     if (bundleJson.length > EVIDENCE_MAX_JSON_BYTES) {
       throw new Error(`Evidence bundle size (${bundleJson.length} bytes) exceeds maximum (${EVIDENCE_MAX_JSON_BYTES} bytes)`);
     }
-    mkdirSync4(evidenceDir, { recursive: true });
+    mkdirSync5(evidenceDir, { recursive: true });
     const tempPath = path10.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
@@ -4552,4 +4967,4 @@ function mergeDurableGateEntriesFromEvidence(taskId, entries, evidence) {
   return merged;
 }
 
-export { getExecutor, init_executor, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, getGitRepositoryStatus, isGitRepo, getDefaultBaseBranch, resetToRemoteBranch, resetToMainAfterMerge, containsPathTraversal, containsControlChars, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, normalizePath, pathsConflict, isGlobalFile, isProtectedPath, readTaskScopes, computeSpecHash, loadPlanJsonOnly, loadPlan, savePlan, closePlanTerminalState, derivePlanMarkdown, isValidEvidenceType, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };
+export { projectDbExists, getProjectDb, closeProjectDb, buildTaskCompletionDescriptor, ensureTaskCheckpointReceipt, updateTaskCheckpointReceipt, getExecutor, init_executor, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, getGitRepositoryStatus, isGitRepo, getDefaultBaseBranch, resetToRemoteBranch, resetToMainAfterMerge, containsPathTraversal, containsControlChars, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, normalizePath, pathsConflict, isGlobalFile, isProtectedPath, readTaskScopes, computeSpecHash, loadPlanJsonOnly, loadPlan, savePlan, closePlanTerminalState, derivePlanMarkdown, isValidEvidenceType, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };