@runfusion/fusion 0.27.0 → 0.27.1

package/dist/extension.js

@@ -64,6 +64,7 @@ var init_settings_schema = __esm({
       ntfyEnabled: false,
       ntfyTopic: void 0,
       ntfyBaseUrl: void 0,
+      ntfyAccessToken: void 0,
       ntfyEvents: [
         "in-review",
         "merged",
@@ -247,6 +248,7 @@ var init_settings_schema = __esm({
       worktreeRebaseLocalBase: true,
       mergeConflictStrategy: "smart-prefer-main",
       workflowStepTimeoutMs: 36e4,
+      workflowRevisionForkOnScopeMismatch: true,
       strictScopeEnforcement: false,
       buildRetryCount: 0,
       verificationFixRetries: 3,
@@ -3357,9 +3359,9 @@ var init_sqlite_adapter = __esm({
 
 // ../core/src/db.ts
 import { isAbsolute, join as join2 } from "node:path";
-import { mkdirSync, existsSync } from "node:fs";
+import { mkdirSync, existsSync, statSync } from "node:fs";
 import { spawnSync } from "node:child_process";
-import { randomUUID } from "node:crypto";
+import { createHash as createHash2, randomUUID } from "node:crypto";
 function toJson(value) {
   if (value === void 0 || value === null) return "[]";
   if (Array.isArray(value) && value.length === 0) return "[]";
@@ -3379,6 +3381,15 @@ function fromJson(json) {
     return void 0;
   }
 }
+function isSqliteLockError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /SQLITE_(?:BUSY|LOCKED)|database is locked|database table is locked/i.test(message);
+}
+function sleepSync(ms) {
+  if (ms <= 0) return;
+  const signal = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(signal, 0, 0, ms);
+}
 function probeFts5(db) {
   if (process.env.FUSION_DISABLE_FTS5 === "1" || process.env.FUSION_DISABLE_FTS5 === "true") {
     return false;
@@ -3478,15 +3489,28 @@ function getSchemaCompatibilityTableSchemas() {
   }
   return tables;
 }
+function canonicalizeSchemaTables(tables) {
+  return Object.fromEntries(
+    [...tables.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([tableName, columns]) => [
+      tableName,
+      Object.fromEntries(
+        [...columns.entries()].sort(([left], [right]) => left.localeCompare(right))
+      )
+    ])
+  );
+}
 function createDatabase(fusionDir, options) {
   return new Database(fusionDir, options);
 }
-var SCHEMA_VERSION, SCHEMA_SQL, TABLE_LEVEL_CONSTRAINT_PREFIXES, SCHEMA_TABLE_SCHEMAS, MIGRATION_ONLY_TABLE_SCHEMAS, Database;
+var DEFAULT_SQLITE_BUSY_TIMEOUT_MS, DEFAULT_SQLITE_LOCK_RECOVERY_WINDOW_MS, DEFAULT_SQLITE_LOCK_RECOVERY_DELAY_MS, SCHEMA_VERSION, SCHEMA_SQL, TABLE_LEVEL_CONSTRAINT_PREFIXES, SCHEMA_TABLE_SCHEMAS, MIGRATION_ONLY_TABLE_SCHEMAS, SCHEMA_COMPAT_FINGERPRINT, Database;
 var init_db = __esm({
   "../core/src/db.ts"() {
     "use strict";
     init_sqlite_adapter();
     init_types();
+    DEFAULT_SQLITE_BUSY_TIMEOUT_MS = 5e3;
+    DEFAULT_SQLITE_LOCK_RECOVERY_WINDOW_MS = 1e3;
+    DEFAULT_SQLITE_LOCK_RECOVERY_DELAY_MS = 50;
     SCHEMA_VERSION = 72;
     SCHEMA_SQL = `
 -- Tasks table with JSON columns for nested data
@@ -3578,6 +3602,9 @@ CREATE TABLE IF NOT EXISTS tasks (
 );
 
 -- Config table (single row with project settings)
+-- nextId is a deprecated legacy allocator counter retained read-only for one
+-- release so older databases/config consumers can still load it during the
+-- distributed_task_id_state transition.
 CREATE TABLE IF NOT EXISTS config (
   id INTEGER PRIMARY KEY CHECK (id = 1),
   nextId INTEGER DEFAULT 1,
@@ -4352,6 +4379,20 @@ CREATE INDEX IF NOT EXISTS idxTodoItemsSortOrder ON todo_items(listId, sortOrder
         createdAt: "TEXT NOT NULL"
       }
     };
+    SCHEMA_COMPAT_FINGERPRINT = createHash2("sha1").update(
+      JSON.stringify({
+        schemaVersion: SCHEMA_VERSION,
+        schemaSqlTables: canonicalizeSchemaTables(SCHEMA_TABLE_SCHEMAS),
+        migrationOnlyTableSchemas: Object.fromEntries(
+          Object.entries(MIGRATION_ONLY_TABLE_SCHEMAS).sort(([left], [right]) => left.localeCompare(right)).map(([tableName, columns]) => [
+            tableName,
+            Object.fromEntries(
+              Object.entries(columns).sort(([left], [right]) => left.localeCompare(right))
+            )
+          ])
+        )
+      })
+    ).digest("hex");
     Database = class _Database {
       static sharedIntegrityChecks = /* @__PURE__ */ new Map();
       db;
@@ -4369,10 +4410,16 @@ CREATE INDEX IF NOT EXISTS idxTodoItemsSortOrder ON todo_items(listId, sortOrder
       _fts5Available;
       integrityCheckScheduled = false;
       closed = false;
+      busyTimeoutMs;
+      lockRecoveryWindowMs;
+      lockRecoveryDelayMs;
       constructor(fusionDir, options) {
         const inMemory = options?.inMemory === true;
         this.inMemory = inMemory;
         this.dbPath = inMemory ? ":memory:" : join2(fusionDir, "fusion.db");
+        this.busyTimeoutMs = Math.max(0, options?.busyTimeoutMs ?? DEFAULT_SQLITE_BUSY_TIMEOUT_MS);
+        this.lockRecoveryWindowMs = Math.max(0, options?.lockRecoveryWindowMs ?? DEFAULT_SQLITE_LOCK_RECOVERY_WINDOW_MS);
+        this.lockRecoveryDelayMs = Math.max(1, options?.lockRecoveryDelayMs ?? DEFAULT_SQLITE_LOCK_RECOVERY_DELAY_MS);
         if (!inMemory && !isAbsolute(fusionDir)) {
           throw new Error(`[fusion] Database constructor requires an absolute fusionDir path, got: ${fusionDir}`);
         }
@@ -4392,13 +4439,13 @@ This means a caller passed a .fusion directory where a project root was expected
           throw new Error(`Failed to open Fusion database at ${this.dbPath}: ${message}`);
         }
         if (!inMemory) {
-          this.db.exec("PRAGMA busy_timeout = 5000");
+          this.db.exec(`PRAGMA busy_timeout = ${this.busyTimeoutMs}`);
           this.db.exec("PRAGMA journal_mode = WAL");
           this.db.exec("PRAGMA synchronous = NORMAL");
           this.db.exec("PRAGMA wal_autocheckpoint = 100");
           this.db.exec("PRAGMA journal_size_limit = 4194304");
         } else {
-          this.db.exec("PRAGMA busy_timeout = 5000");
+          this.db.exec(`PRAGMA busy_timeout = ${this.busyTimeoutMs}`);
         }
         this.db.exec("PRAGMA foreign_keys = ON");
         this._fts5Available = probeFts5(this.db);
@@ -4509,6 +4556,44 @@ This means a caller passed a .fusion directory where a project root was expected
         });
         return rebuilt.status === 0;
       }
+      /**
+       * Run WAL truncation + VACUUM and report compaction stats.
+       *
+       * In-memory databases no-op and return zeroed stats. Disk-backed databases
+       * sample file size before/after compaction, run `wal_checkpoint(TRUNCATE)`,
+       * and then run `VACUUM` while the connection is in EXCLUSIVE locking mode to
+       * prevent concurrent writes from other connections during maintenance.
+       */
+      vacuum() {
+        if (this.inMemory) {
+          return { beforeBytes: 0, afterBytes: 0, durationMs: 0 };
+        }
+        const beforeBytes = existsSync(this.dbPath) ? statSync(this.dbPath).size : 0;
+        const startedAt = Date.now();
+        this.db.exec("PRAGMA locking_mode=EXCLUSIVE");
+        try {
+          try {
+            this.walCheckpoint("TRUNCATE");
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Database vacuum maintenance failed during WAL checkpoint (dbPath=${this.dbPath}): ${message}`);
+          }
+          try {
+            this.db.exec("VACUUM");
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Database vacuum maintenance failed during VACUUM (dbPath=${this.dbPath}): ${message}`);
+          }
+          const afterBytes = existsSync(this.dbPath) ? statSync(this.dbPath).size : 0;
+          return {
+            beforeBytes,
+            afterBytes,
+            durationMs: Date.now() - startedAt
+          };
+        } finally {
+          this.db.exec("PRAGMA locking_mode=NORMAL");
+        }
+      }
       /**
        * Initialize the database: create tables if they don't exist
        * and seed meta values.
@@ -4523,10 +4608,20 @@ This means a caller passed a .fusion directory where a project root was expected
           `INSERT OR IGNORE INTO __meta (key, value) VALUES ('lastModified', '${Date.now()}')`
         );
         this.migrate();
-        this.ensureSchemaCompatibility();
-        this.ensureRoutinesSchemaCompatibility();
-        this.ensureInsightRunsSchemaCompatibility();
-        this.ensureEvalTaskResultsSchemaCompatibility();
+        const schemaCompatFingerprint = this.getMetaValue("schemaCompatFingerprint");
+        const skipColumnReconciliation = schemaCompatFingerprint === SCHEMA_COMPAT_FINGERPRINT;
+        const tableColumnsCache = skipColumnReconciliation ? void 0 : /* @__PURE__ */ new Map();
+        const compatibilityOptions = {
+          tableColumnsCache,
+          skipColumnReconciliation
+        };
+        this.ensureSchemaCompatibility(compatibilityOptions);
+        this.ensureRoutinesSchemaCompatibility(compatibilityOptions);
+        this.ensureInsightRunsSchemaCompatibility(compatibilityOptions);
+        this.ensureEvalTaskResultsSchemaCompatibility(compatibilityOptions);
+        if (!skipColumnReconciliation) {
+          this.setMetaValue("schemaCompatFingerprint", SCHEMA_COMPAT_FINGERPRINT);
+        }
         const configNow = (/* @__PURE__ */ new Date()).toISOString();
         this.db.exec(
           `INSERT OR IGNORE INTO config (id, nextId, nextWorkflowStepId, settings, workflowSteps, updatedAt) VALUES (1, 1, 1, '${JSON.stringify(DEFAULT_PROJECT_SETTINGS)}', '[]', '${configNow}')`
@@ -4544,20 +4639,27 @@ This means a caller passed a .fusion directory where a project root was expected
        * re-run even if a previous migration partially applied.
        */
       /**
-       * Applies unconditional column reconciliation for all known project DB tables.
+       * Reconciles additive columns for every known project DB table unless the
+       * persisted `schemaCompatFingerprint` already matches SCHEMA_COMPAT_FINGERPRINT.
        *
-       * FN-3879 introduced a tasks checkout-column self-heal, FN-3898 formalized it,
-       * and FN-3887 generalized the guardrail so migration-version drift no longer
-       * determines whether additive columns exist. Invariant: every column declared
-       * in SCHEMA_SQL or MIGRATION_ONLY_TABLE_SCHEMAS exists on any live table after
-       * this method returns, regardless of the persisted schemaVersion.
+       * The fingerprint is invalidated automatically by SCHEMA_VERSION changes and by
+       * edits to the canonicalized column declarations from SCHEMA_SQL or
+       * MIGRATION_ONLY_TABLE_SCHEMAS. When it is absent or stale, this method runs the
+       * full FN-3879/FN-3887/FN-3898 safety pass so every declared column exists on
+       * every live table after init() returns.
        */
-      ensureSchemaCompatibility() {
+      ensureSchemaCompatibility(options = {}) {
+        if (options.skipColumnReconciliation) {
+          return;
+        }
         const knownTableSchemas = getSchemaCompatibilityTableSchemas();
+        const tableColumnsCache = options.tableColumnsCache;
         for (const [tableName, columns] of knownTableSchemas) {
           if (!this.hasTable(tableName)) continue;
+          const cachedColumns = this.getTableColumns(tableName, true, tableColumnsCache);
           for (const [columnName, columnDefinition] of columns) {
-            this.addColumnIfMissing(tableName, columnName, columnDefinition);
+            if (cachedColumns.has(columnName)) continue;
+            this.addColumnIfMissingCached(tableName, columnName, columnDefinition, tableColumnsCache);
           }
         }
       }
@@ -4568,10 +4670,14 @@ This means a caller passed a .fusion directory where a project root was expected
        * agent IDs from earlier table definitions. `RoutineStore.rowToRoutine()` and
        * backup routine sync expect a safe string value, so normalize to ''.
        */
-      ensureRoutinesSchemaCompatibility() {
+      ensureRoutinesSchemaCompatibility(options = {}) {
         if (!this.hasTable("routines")) {
           return;
         }
+        if (!options.skipColumnReconciliation) {
+          this.addColumnIfMissingCached("routines", "agentId", "TEXT DEFAULT ''", options.tableColumnsCache);
+          this.addColumnIfMissingCached("routines", "scope", "TEXT DEFAULT 'project'", options.tableColumnsCache);
+        }
         this.db.exec("UPDATE routines SET agentId = '' WHERE agentId IS NULL");
         this.db.exec("UPDATE routines SET scope = 'project' WHERE scope IS NULL OR TRIM(scope) = ''");
         this.db.exec("CREATE INDEX IF NOT EXISTS idxRoutinesNextRunAt ON routines(nextRunAt)");
@@ -4585,13 +4691,17 @@ This means a caller passed a .fusion directory where a project root was expected
        * remains focused on index creation that should run after the generic column
        * backfill pass.
        */
-      ensureInsightRunsSchemaCompatibility() {
+      ensureInsightRunsSchemaCompatibility(options = {}) {
         if (!this.hasTable("project_insight_runs")) {
           return;
         }
+        if (!options.skipColumnReconciliation) {
+          this.addColumnIfMissingCached("project_insight_runs", "lifecycle", "TEXT", options.tableColumnsCache);
+          this.addColumnIfMissingCached("project_insight_runs", "cancelledAt", "TEXT", options.tableColumnsCache);
+        }
         this.db.exec(`CREATE INDEX IF NOT EXISTS idxInsightRunsProjectTriggerStatus ON project_insight_runs(projectId, trigger, status)`);
       }
-      ensureEvalTaskResultsSchemaCompatibility() {
+      ensureEvalTaskResultsSchemaCompatibility(_options = {}) {
         if (!this.hasTable("eval_task_results")) {
           return;
         }
@@ -5933,12 +6043,26 @@ This means a caller passed a .fusion directory where a project root was expected
         const lower = message.toLowerCase();
         return lower.includes("corruption found reading blob") || lower.includes("database disk image is malformed") || lower.includes("fts5") && lower.includes("corrupt");
       }
+      /**
+       * Read the declared columns for a table.
+       */
+      getTableColumns(table, useCache = false, cache) {
+        if (useCache && cache?.has(table)) {
+          return cache.get(table) ?? /* @__PURE__ */ new Set();
+        }
+        const columns = new Set(
+          this.db.prepare(`PRAGMA table_info(${table})`).all().map((column) => column.name)
+        );
+        if (useCache && cache) {
+          cache.set(table, columns);
+        }
+        return columns;
+      }
       /**
        * Check whether a table has a given column.
        */
       hasColumn(table, column) {
-        const cols = this.db.prepare(`PRAGMA table_info(${table})`).all();
-        return cols.some((c) => c.name === column);
+        return this.getTableColumns(table).has(column);
       }
       /**
        * Add a column to a table if it does not already exist.
@@ -5948,6 +6072,20 @@ This means a caller passed a .fusion directory where a project root was expected
           this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
         }
       }
+      /**
+       * Add a column using a per-init table-info cache when available.
+       */
+      addColumnIfMissingCached(table, column, definition, cache) {
+        const columns = this.getTableColumns(table, Boolean(cache), cache);
+        if (columns.has(column)) {
+          return;
+        }
+        this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+        columns.add(column);
+        if (cache) {
+          cache.set(table, columns);
+        }
+      }
       /**
        * Normalize legacy steering comments into the unified comments field exactly once.
        *
@@ -6048,25 +6186,67 @@ This means a caller passed a .fusion directory where a project root was expected
         this.integrityCheckPending = false;
         this.db.close();
       }
+      runWithLockRecovery(action, fn) {
+        const deadline = Date.now() + this.lockRecoveryWindowMs;
+        let attempt = 0;
+        while (true) {
+          try {
+            fn();
+            return;
+          } catch (error) {
+            if (!isSqliteLockError(error)) {
+              throw error;
+            }
+            if (Date.now() >= deadline) {
+              throw new Error(
+                `SQLite ${action} failed after ${attempt + 1} attempt${attempt === 0 ? "" : "s"}: ${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+            const remainingMs = Math.max(0, deadline - Date.now());
+            const delayMs = Math.min(this.lockRecoveryDelayMs * Math.max(1, attempt + 1), remainingMs);
+            sleepSync(delayMs);
+            attempt += 1;
+          }
+        }
+      }
       /**
        * Execute a function inside a SQLite transaction.
        * Supports nested calls via SAVEPOINTs.
        * If the function throws, the transaction/savepoint is rolled back.
        * If the function returns normally, the transaction/savepoint is committed.
+       *
+       * Outermost transactions default to `BEGIN` (DEFERRED) so read-only callers
+       * avoid taking a writer lock until they actually mutate state.
+       * Use `transactionImmediate()` for write-heavy paths that should acquire the
+       * RESERVED lock before user code runs and fail/retry before the callback executes.
        */
-      transaction(fn) {
+      transaction(fn, options) {
         const depth = this.transactionDepth++;
         const isOutermost = depth === 0;
         const savepointName = `sp_${depth}`;
-        if (isOutermost) {
-          this.db.exec("BEGIN");
-        } else {
-          this.db.exec(`SAVEPOINT ${savepointName}`);
+        const mode = options?.mode ?? "deferred";
+        try {
+          if (isOutermost) {
+            if (mode === "immediate") {
+              this.runWithLockRecovery("BEGIN IMMEDIATE", () => {
+                this.db.exec("BEGIN IMMEDIATE");
+              });
+            } else {
+              this.db.exec("BEGIN");
+            }
+          } else {
+            this.db.exec(`SAVEPOINT ${savepointName}`);
+          }
+        } catch (error) {
+          this.transactionDepth--;
+          throw error;
         }
         try {
           const result = fn();
           if (isOutermost) {
-            this.db.exec("COMMIT");
+            this.runWithLockRecovery("COMMIT", () => {
+              this.db.exec("COMMIT");
+            });
           } else {
             this.db.exec(`RELEASE ${savepointName}`);
           }
@@ -6083,6 +6263,9 @@ This means a caller passed a .fusion directory where a project root was expected
           this.transactionDepth--;
         }
       }
+      transactionImmediate(fn) {
+        return this.transaction(fn, { mode: "immediate" });
+      }
       /**
        * Execute plugin-provided schema initialization hooks.
        *
@@ -6118,14 +6301,24 @@ This means a caller passed a .fusion directory where a project root was expected
       exec(sql) {
         this.db.exec(sql);
       }
+      getMetaValue(key) {
+        const row = this.db.prepare("SELECT value FROM __meta WHERE key = ?").get(key);
+        return row?.value;
+      }
+      /**
+       * Persist a __meta value idempotently.
+       */
+      setMetaValue(key, value) {
+        this.db.prepare("INSERT OR REPLACE INTO __meta (key, value) VALUES (?, ?)").run(key, value);
+      }
       /**
        * Get the last modification timestamp (epoch ms).
        * Returns 0 if the value is not set.
        */
       getLastModified() {
-        const row = this.db.prepare("SELECT value FROM __meta WHERE key = 'lastModified'").get();
-        if (!row) return 0;
-        return parseInt(row.value, 10) || 0;
+        const value = this.getMetaValue("lastModified");
+        if (!value) return 0;
+        return parseInt(value, 10) || 0;
       }
       /**
        * Update the last modification timestamp to the current time.
@@ -6144,9 +6337,9 @@ This means a caller passed a .fusion directory where a project root was expected
        * Get the schema version number.
        */
       getSchemaVersion() {
-        const row = this.db.prepare("SELECT value FROM __meta WHERE key = 'schemaVersion'").get();
-        if (!row) return 0;
-        return parseInt(row.value, 10) || 0;
+        const value = this.getMetaValue("schemaVersion");
+        if (!value) return 0;
+        return parseInt(value, 10) || 0;
       }
       /**
        * Get the database file path.
@@ -6162,7 +6355,7 @@ This means a caller passed a .fusion directory where a project root was expected
 import { mkdir, readFile, writeFile, readdir, unlink, rename, access, appendFile } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
 import { basename, dirname, join as join3, resolve as resolve2 } from "node:path";
-import { randomUUID as randomUUID2, randomBytes, createHash as createHash2 } from "node:crypto";
+import { randomUUID as randomUUID2, randomBytes, createHash as createHash3 } from "node:crypto";
 import { EventEmitter } from "node:events";
 function resolveCreationRuntimeConfig(incoming, metadata) {
   const isEphemeral = isEphemeralAgent({ metadata });
@@ -7328,7 +7521,7 @@ var init_agent_store = __esm({
             throw new Error(`Agent ${agentId} not found`);
           }
           const token = randomBytes(32).toString("hex");
-          const tokenHash = createHash2("sha256").update(token).digest("hex");
+          const tokenHash = createHash3("sha256").update(token).digest("hex");
           const createdAt = (/* @__PURE__ */ new Date()).toISOString();
           const label = options?.label?.trim();
           const key = {
@@ -9484,10 +9677,10 @@ END;
           mkdirSync3(fusionDir, { recursive: true });
         }
         this.db = new DatabaseSync(inMemory ? ":memory:" : join6(fusionDir, "archive.db"));
+        this.db.exec("PRAGMA busy_timeout = 5000");
         if (!inMemory) {
           this.db.exec("PRAGMA journal_mode = WAL");
         }
-        this.db.exec("PRAGMA busy_timeout = 5000");
         this._fts5Available = probeFts5(this.db);
       }
       /** True when this SQLite build has FTS5. See db.ts#probeFts5. */
@@ -13162,9 +13355,15 @@ CREATE INDEX IF NOT EXISTS idxMeshWriteQueueReplay ON meshWriteQueue(targetNodeI
       globalDir;
       /** Tracks transaction nesting depth for savepoint-based nested transactions. */
       transactionDepth = 0;
-      constructor(globalDir) {
+      busyTimeoutMs;
+      lockRecoveryWindowMs;
+      lockRecoveryDelayMs;
+      constructor(globalDir, options) {
         this.globalDir = resolveGlobalDir(globalDir);
         this.dbPath = join8(this.globalDir, "fusion-central.db");
+        this.busyTimeoutMs = Math.max(0, options?.busyTimeoutMs ?? 5e3);
+        this.lockRecoveryWindowMs = Math.max(0, options?.lockRecoveryWindowMs ?? 1e3);
+        this.lockRecoveryDelayMs = Math.max(1, options?.lockRecoveryDelayMs ?? 50);
         if (!existsSync6(this.globalDir)) {
           mkdirSync4(this.globalDir, { recursive: true });
         }
@@ -13174,8 +13373,8 @@ CREATE INDEX IF NOT EXISTS idxMeshWriteQueueReplay ON meshWriteQueue(targetNodeI
           const message = error instanceof Error ? error.message : String(error);
           throw new Error(`Failed to open Fusion central database at ${this.dbPath}: ${message}`);
         }
+        this.db.exec(`PRAGMA busy_timeout = ${this.busyTimeoutMs}`);
         this.db.exec("PRAGMA journal_mode = WAL");
-        this.db.exec("PRAGMA busy_timeout = 5000");
         this.db.exec("PRAGMA foreign_keys = ON");
       }
       /**
@@ -13281,6 +13480,29 @@ CREATE INDEX IF NOT EXISTS idxMeshWriteQueueReplay ON meshWriteQueue(targetNodeI
       close() {
         this.db.close();
       }
+      runWithLockRecovery(action, fn) {
+        const deadline = Date.now() + this.lockRecoveryWindowMs;
+        let attempt = 0;
+        while (true) {
+          try {
+            fn();
+            return;
+          } catch (error) {
+            if (!isSqliteLockError(error)) {
+              throw error;
+            }
+            if (Date.now() >= deadline) {
+              throw new Error(
+                `SQLite ${action} failed after ${attempt + 1} attempt${attempt === 0 ? "" : "s"}: ${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+            const remainingMs = Math.max(0, deadline - Date.now());
+            const delayMs = Math.min(this.lockRecoveryDelayMs * Math.max(1, attempt + 1), remainingMs);
+            sleepSync(delayMs);
+            attempt += 1;
+          }
+        }
+      }
       /**
        * Execute a function inside a SQLite transaction.
        * Supports nested calls via SAVEPOINTs.
@@ -13291,15 +13513,24 @@ CREATE INDEX IF NOT EXISTS idxMeshWriteQueueReplay ON meshWriteQueue(targetNodeI
         const depth = this.transactionDepth++;
         const isOutermost = depth === 0;
         const savepointName = `sp_${depth}`;
-        if (isOutermost) {
-          this.db.exec("BEGIN");
-        } else {
-          this.db.exec(`SAVEPOINT ${savepointName}`);
+        try {
+          if (isOutermost) {
+            this.runWithLockRecovery("BEGIN IMMEDIATE", () => {
+              this.db.exec("BEGIN IMMEDIATE");
+            });
+          } else {
+            this.db.exec(`SAVEPOINT ${savepointName}`);
+          }
+        } catch (error) {
+          this.transactionDepth--;
+          throw error;
         }
         try {
           const result = fn();
           if (isOutermost) {
-            this.db.exec("COMMIT");
+            this.runWithLockRecovery("COMMIT", () => {
+              this.db.exec("COMMIT");
+            });
           } else {
             this.db.exec(`RELEASE ${savepointName}`);
           }
@@ -19920,8 +20151,8 @@ var init_system_metrics = __esm({
 
 // ../core/src/central-core.ts
 import { EventEmitter as EventEmitter11 } from "node:events";
-import { createHash as createHash3, randomUUID as randomUUID9 } from "node:crypto";
-import { existsSync as existsSync7, statSync } from "node:fs";
+import { createHash as createHash4, randomUUID as randomUUID9 } from "node:crypto";
+import { existsSync as existsSync7, statSync as statSync2 } from "node:fs";
 import { mkdir as mkdir4 } from "node:fs/promises";
 import { isAbsolute as isAbsolute2, join as join11, basename as basename2, resolve as resolve5 } from "node:path";
 var CentralCore;
@@ -20030,7 +20261,7 @@ var init_central_core = __esm({
         if (!existsSync7(input.path)) {
           throw new Error(`Project path does not exist: ${input.path}`);
         }
-        if (!statSync(input.path).isDirectory()) {
+        if (!statSync2(input.path).isDirectory()) {
           throw new Error(`Project path must be a directory: ${input.path}`);
         }
         const existingByPath = await this.getProjectByPath(input.path);
@@ -21769,7 +22000,7 @@ var init_central_core = __esm({
         const dbPath = this.db.getPath();
         let dbSizeBytes = 0;
         try {
-          dbSizeBytes = statSync(dbPath).size;
+          dbSizeBytes = statSync2(dbPath).size;
         } catch {
         }
         return { projectCount, totalTasksCompleted, dbSizeBytes };
@@ -21987,10 +22218,10 @@ var init_central_core = __esm({
        */
       async generateProjectName(projectPath) {
         try {
-          const { execFile: execFile8 } = await import("node:child_process");
-          const { promisify: promisify14 } = await import("node:util");
-          const execFileAsync6 = promisify14(execFile8);
-          const { stdout } = await execFileAsync6(
+          const { execFile: execFile9 } = await import("node:child_process");
+          const { promisify: promisify15 } = await import("node:util");
+          const execFileAsync7 = promisify15(execFile9);
+          const { stdout } = await execFileAsync7(
             "git",
             ["remote", "get-url", "origin"],
             { cwd: projectPath, timeout: 5e3 }
@@ -22292,7 +22523,7 @@ var init_central_core = __esm({
           exportedAt: snapshot.exportedAt,
           version: 1
         };
-        const checksum = createHash3("sha256").update(JSON.stringify(payloadWithoutChecksum)).digest("hex");
+        const checksum = createHash4("sha256").update(JSON.stringify(payloadWithoutChecksum)).digest("hex");
         return this.applyRemoteSettings({ ...payloadWithoutChecksum, checksum });
       }
       getAuthMaterialSnapshot(providerAuth) {
@@ -22335,7 +22566,7 @@ var init_central_core = __esm({
           exportedAt,
           version: 1
         };
-        const checksum = createHash3("sha256").update(JSON.stringify(payloadWithoutChecksum)).digest("hex");
+        const checksum = createHash4("sha256").update(JSON.stringify(payloadWithoutChecksum)).digest("hex");
         return {
           ...payloadWithoutChecksum,
           checksum
@@ -22370,7 +22601,7 @@ var init_central_core = __esm({
           exportedAt: payload.exportedAt,
           version: payload.version
         };
-        const computedChecksum = createHash3("sha256").update(JSON.stringify(payloadWithoutChecksum)).digest("hex");
+        const computedChecksum = createHash4("sha256").update(JSON.stringify(payloadWithoutChecksum)).digest("hex");
         if (computedChecksum !== payload.checksum) {
           return {
             success: false,
@@ -22492,13 +22723,13 @@ var init_central_core = __esm({
 });
 
 // ../core/src/sqlite-validation.ts
-import { existsSync as existsSync8, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync8, statSync as statSync3 } from "node:fs";
 function isValidSqliteDatabaseFile(dbPath) {
   if (!existsSync8(dbPath)) {
     return false;
   }
   try {
-    if (!statSync2(dbPath).isFile()) {
+    if (!statSync3(dbPath).isFile()) {
       return false;
     }
   } catch {
@@ -22691,10 +22922,10 @@ var init_migration = __esm({
           return basename3(projectPath);
         }
         try {
-          const { execFile: execFile8 } = await import("node:child_process");
-          const { promisify: promisify14 } = await import("node:util");
-          const execFileAsync6 = promisify14(execFile8);
-          const { stdout } = await execFileAsync6(
+          const { execFile: execFile9 } = await import("node:child_process");
+          const { promisify: promisify15 } = await import("node:util");
+          const execFileAsync7 = promisify15(execFile9);
+          const { stdout } = await execFileAsync7(
             "git",
             ["remote", "get-url", "origin"],
             { cwd: projectPath, timeout: 1e3 }
@@ -32967,7 +33198,7 @@ var init_memory_dreams = __esm({
 import { readFile as readFile6, writeFile as writeFile5, mkdir as mkdir6, access as access3, constants, readdir as readdir4, stat as stat2 } from "node:fs/promises";
 import { existsSync as existsSync11 } from "node:fs";
 import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute4, join as join15, normalize as normalize2, relative, resolve as resolve7, sep as sep3 } from "node:path";
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function shouldSkipBackgroundQmdRefresh() {
   return (process.env.VITEST === "true" || process.env.NODE_ENV === "test") && process.env.FUSION_ENABLE_QMD_REFRESH_IN_TESTS !== "1";
 }
@@ -32983,7 +33214,7 @@ function memoryDreamsPath(rootDir) {
 function qmdMemoryCollectionName(rootDir) {
   const absoluteRoot = resolve7(rootDir);
   const slug = basename4(absoluteRoot).toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "project";
-  const hash = createHash4("sha1").update(absoluteRoot).digest("hex").slice(0, 12);
+  const hash = createHash5("sha1").update(absoluteRoot).digest("hex").slice(0, 12);
   return `${QMD_COLLECTION_PREFIX}-${slug}-${hash}`;
 }
 function buildQmdSearchArgs(rootDir, options) {
@@ -33019,7 +33250,7 @@ function buildQmdRefreshCommands(rootDir) {
 function qmdAgentMemoryCollectionName(rootDir, agentId) {
   const absoluteRoot = resolve7(rootDir);
   const safeAgentId = agentId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
-  const hash = createHash4("sha1").update(`${absoluteRoot}:${agentId}`).digest("hex").slice(0, 12);
+  const hash = createHash5("sha1").update(`${absoluteRoot}:${agentId}`).digest("hex").slice(0, 12);
   return `fusion-agent-memory-${safeAgentId.toLowerCase()}-${hash}`;
 }
 function dailyMemoryPath(rootDir, date = /* @__PURE__ */ new Date()) {
@@ -33423,13 +33654,13 @@ async function searchWithQmd(rootDir, options) {
   const command = "qmd";
   const limit = Math.max(1, Math.min(options.limit ?? 5, 20));
   try {
-    const { execFile: execFile8 } = await import("node:child_process");
-    const { promisify: promisify14 } = await import("node:util");
-    const execFileAsync6 = promisify14(execFile8);
-    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync6);
+    const { execFile: execFile9 } = await import("node:child_process");
+    const { promisify: promisify15 } = await import("node:util");
+    const execFileAsync7 = promisify15(execFile9);
+    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync7);
     scheduleQmdProjectMemoryRefresh(rootDir);
     const args = buildQmdSearchArgs(rootDir, options);
-    const { stdout } = await execFileAsync6(command, args, {
+    const { stdout } = await execFileAsync7(command, args, {
       cwd: rootDir,
       timeout: 4e3,
       maxBuffer: 1024 * 1024
@@ -33454,12 +33685,12 @@ async function searchWithQmd(rootDir, options) {
     return [];
   }
 }
-async function ensureQmdProjectMemoryCollection(rootDir, execFileAsync6) {
+async function ensureQmdProjectMemoryCollection(rootDir, execFileAsync7) {
   const collectionName = qmdMemoryCollectionName(rootDir);
   const memoryDir = memoryWorkspacePath(rootDir);
   await mkdir6(memoryDir, { recursive: true });
   try {
-    await execFileAsync6("qmd", buildQmdCollectionAddArgs(rootDir), {
+    await execFileAsync7("qmd", buildQmdCollectionAddArgs(rootDir), {
       cwd: rootDir,
       timeout: 4e3,
       maxBuffer: 512 * 1024
@@ -33475,9 +33706,9 @@ ${stderr}`)) {
   return collectionName;
 }
 async function getDefaultExecFileAsync() {
-  const { execFile: execFile8 } = await import("node:child_process");
-  const { promisify: promisify14 } = await import("node:util");
-  return promisify14(execFile8);
+  const { execFile: execFile9 } = await import("node:child_process");
+  const { promisify: promisify15 } = await import("node:util");
+  return promisify15(execFile9);
 }
 async function refreshQmdProjectMemoryIndex(rootDir, options) {
   const key = resolve7(rootDir);
@@ -33492,14 +33723,14 @@ async function refreshQmdProjectMemoryIndex(rootDir, options) {
     }
   }
   const promise = (async () => {
-    const execFileAsync6 = options?.execFileAsync ?? await getDefaultExecFileAsync();
-    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync6);
-    await execFileAsync6("qmd", ["update"], {
+    const execFileAsync7 = options?.execFileAsync ?? await getDefaultExecFileAsync();
+    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync7);
+    await execFileAsync7("qmd", ["update"], {
       cwd: rootDir,
       timeout: 3e4,
       maxBuffer: 1024 * 1024
     });
-    await execFileAsync6("qmd", ["embed"], {
+    await execFileAsync7("qmd", ["embed"], {
       cwd: rootDir,
       timeout: 12e4,
       maxBuffer: 1024 * 1024
@@ -33535,12 +33766,12 @@ async function refreshQmdAgentMemoryIndex(rootDir, agentId, options) {
     }
   }
   const promise = (async () => {
-    const execFileAsync6 = options?.execFileAsync ?? await getDefaultExecFileAsync();
+    const execFileAsync7 = options?.execFileAsync ?? await getDefaultExecFileAsync();
     const { agentMemoryWorkspacePath: agentMemoryWorkspacePath2 } = await Promise.resolve().then(() => (init_memory_dreams(), memory_dreams_exports));
     const workspacePath = agentMemoryWorkspacePath2(rootDir, agentId);
     await mkdir6(workspacePath, { recursive: true });
     try {
-      await execFileAsync6("qmd", ["collection", "add", workspacePath, "--name", qmdAgentMemoryCollectionName(rootDir, agentId), "--mask", "**/*.md"], {
+      await execFileAsync7("qmd", ["collection", "add", workspacePath, "--name", qmdAgentMemoryCollectionName(rootDir, agentId), "--mask", "**/*.md"], {
         cwd: rootDir,
         timeout: 4e3,
         maxBuffer: 512 * 1024
@@ -33553,8 +33784,8 @@ ${stderr}`)) {
         throw err;
       }
     }
-    await execFileAsync6("qmd", ["update"], { cwd: rootDir, timeout: 3e4, maxBuffer: 1024 * 1024 });
-    await execFileAsync6("qmd", ["embed"], { cwd: rootDir, timeout: 12e4, maxBuffer: 1024 * 1024 });
+    await execFileAsync7("qmd", ["update"], { cwd: rootDir, timeout: 3e4, maxBuffer: 1024 * 1024 });
+    await execFileAsync7("qmd", ["embed"], { cwd: rootDir, timeout: 12e4, maxBuffer: 1024 * 1024 });
   })();
   qmdAgentRefreshState.set(key, { lastStartedAt: now, inFlight: promise });
   try {
@@ -33575,8 +33806,8 @@ function scheduleQmdAgentMemoryRefresh(rootDir, agentId) {
 }
 async function isQmdAvailable() {
   try {
-    const execFileAsync6 = await getDefaultExecFileAsync();
-    await execFileAsync6("qmd", ["--help"], {
+    const execFileAsync7 = await getDefaultExecFileAsync();
+    await execFileAsync7("qmd", ["--help"], {
       timeout: 3e3,
       maxBuffer: 128 * 1024
     });
@@ -33586,12 +33817,12 @@ async function isQmdAvailable() {
   }
 }
 async function installQmd(options) {
-  const execFileAsync6 = options?.execFileAsync ?? await getDefaultExecFileAsync();
+  const execFileAsync7 = options?.execFileAsync ?? await getDefaultExecFileAsync();
   const [command, ...args] = QMD_INSTALL_COMMAND.split(" ");
   if (!command || args.length === 0) {
     throw new MemoryBackendError("BACKEND_UNAVAILABLE", "qmd install command is not configured", "qmd");
   }
-  await execFileAsync6(command, args, {
+  await execFileAsync7(command, args, {
     timeout: 12e4,
     maxBuffer: 1024 * 1024
   });
@@ -34892,6 +35123,135 @@ function resolveLocalNodeId(nodes, fallback = "local") {
   const localNode = nodes?.find((node) => node.type === "local");
   return localNode?.id ?? fallback;
 }
+function parseTaskId(taskId) {
+  const match = taskId.trim().toUpperCase().match(TASK_ID_PATTERN);
+  if (!match) {
+    return null;
+  }
+  const sequence = Number.parseInt(match[2], 10);
+  if (!Number.isFinite(sequence)) {
+    return null;
+  }
+  return { prefix: match[1], sequence };
+}
+function getConfiguredPrefixAndLegacyNextId(db) {
+  try {
+    const row = db.prepare("SELECT nextId, settings FROM config WHERE id = 1").get();
+    if (!row) {
+      return { prefix: "KB", nextId: null };
+    }
+    const settings = row.settings ? JSON.parse(row.settings) : null;
+    return {
+      prefix: (settings?.taskPrefix ?? "KB").trim().toUpperCase(),
+      nextId: typeof row.nextId === "number" ? row.nextId : null
+    };
+  } catch {
+    return { prefix: "KB", nextId: null };
+  }
+}
+function getKnownPrefixes(db) {
+  const prefixes = /* @__PURE__ */ new Set();
+  const configured = getConfiguredPrefixAndLegacyNextId(db).prefix;
+  if (configured) {
+    prefixes.add(configured);
+  }
+  const addFromQuery = (sql, mapper) => {
+    try {
+      const rows = db.prepare(sql).all();
+      for (const row of rows) {
+        const prefix = mapper(row)?.trim().toUpperCase();
+        if (prefix) {
+          prefixes.add(prefix);
+        }
+      }
+    } catch {
+    }
+  };
+  addFromQuery("SELECT prefix FROM distributed_task_id_state", (row) => row.prefix);
+  addFromQuery("SELECT prefix FROM distributed_task_id_reservations", (row) => row.prefix);
+  addFromQuery("SELECT id FROM tasks", (row) => parseTaskId(String(row.id ?? ""))?.prefix);
+  addFromQuery("SELECT id FROM archivedTasks", (row) => parseTaskId(String(row.id ?? ""))?.prefix);
+  return prefixes;
+}
+function getMaxTaskSequenceFromTable(db, table, prefix) {
+  try {
+    const rows = db.prepare(`SELECT id FROM ${table} WHERE id LIKE ?`).all(`${prefix}-%`);
+    let maxSequence = 0;
+    for (const row of rows) {
+      const parsed = parseTaskId(row.id);
+      if (parsed?.prefix === prefix && parsed.sequence > maxSequence) {
+        maxSequence = parsed.sequence;
+      }
+    }
+    return maxSequence;
+  } catch {
+    return 0;
+  }
+}
+function getMaxReservationSequence(db, prefix) {
+  try {
+    const row = db.prepare("SELECT MAX(sequence) AS maxSeq FROM distributed_task_id_reservations WHERE prefix = ?").get(prefix);
+    return typeof row?.maxSeq === "number" ? row.maxSeq : 0;
+  } catch {
+    return 0;
+  }
+}
+function getNextSequenceFloor(db, prefix) {
+  const configured = getConfiguredPrefixAndLegacyNextId(db);
+  let nextSequence = 1;
+  if (configured.prefix === prefix && configured.nextId && configured.nextId > nextSequence) {
+    nextSequence = configured.nextId;
+  }
+  const taskHighWaterMark = getMaxTaskSequenceFromTable(db, "tasks", prefix) + 1;
+  const archivedHighWaterMark = getMaxTaskSequenceFromTable(db, "archivedTasks", prefix) + 1;
+  const reservationHighWaterMark = getMaxReservationSequence(db, prefix) + 1;
+  nextSequence = Math.max(nextSequence, taskHighWaterMark, archivedHighWaterMark, reservationHighWaterMark);
+  return nextSequence;
+}
+function ensureStateRow(db, prefix) {
+  const nowIso3 = (/* @__PURE__ */ new Date()).toISOString();
+  const nextSequence = getNextSequenceFloor(db, prefix);
+  db.prepare(
+    `INSERT OR IGNORE INTO distributed_task_id_state (
+      prefix, nextSequence, committedClusterTaskCount, lastCommittedTaskId, updatedAt
+    ) VALUES (?, ?, 0, NULL, ?)`
+  ).run(prefix, nextSequence, nowIso3);
+  db.prepare(
+    `UPDATE distributed_task_id_state
+     SET nextSequence = MAX(nextSequence, ?),
+         updatedAt = ?
+     WHERE prefix = ?`
+  ).run(nextSequence, nowIso3, prefix);
+}
+function reconcileTaskIdState(db) {
+  const nowIso3 = (/* @__PURE__ */ new Date()).toISOString();
+  return db.transaction(() => {
+    const reconciled = [];
+    for (const prefix of getKnownPrefixes(db)) {
+      const nextSequence = getNextSequenceFloor(db, prefix);
+      db.prepare(
+        `INSERT OR IGNORE INTO distributed_task_id_state (
+          prefix, nextSequence, committedClusterTaskCount, lastCommittedTaskId, updatedAt
+        ) VALUES (?, ?, 0, NULL, ?)`
+      ).run(prefix, nextSequence, nowIso3);
+      const before = db.prepare("SELECT nextSequence FROM distributed_task_id_state WHERE prefix = ?").get(prefix);
+      db.prepare(
+        `UPDATE distributed_task_id_state
+         SET nextSequence = MAX(nextSequence, ?),
+             updatedAt = ?
+         WHERE prefix = ?`
+      ).run(nextSequence, nowIso3, prefix);
+      const after = db.prepare("SELECT nextSequence FROM distributed_task_id_state WHERE prefix = ?").get(prefix);
+      if (!before || !after || after.nextSequence !== before.nextSequence) {
+        reconciled.push(prefix);
+      }
+    }
+    if (reconciled.length > 0) {
+      db.bumpLastModified();
+    }
+    return reconciled;
+  });
+}
 function formatDistributedTaskId(prefix, sequence) {
   const normalizedPrefix = prefix.trim().toUpperCase();
   if (!normalizedPrefix) {
@@ -34934,48 +35294,6 @@ function createDistributedTaskIdAllocator(db) {
     };
     return existsInTable("tasks") || existsInTable("archivedTasks");
   };
-  const ensureStateRow = (prefix) => {
-    let seedSequence = 1;
-    try {
-      const configRow = db.prepare("SELECT nextId, settings FROM config WHERE id = 1").get();
-      if (configRow) {
-        const settings = configRow.settings ? JSON.parse(configRow.settings) : null;
-        const configuredPrefix = (settings?.taskPrefix ?? "KB").trim().toUpperCase();
-        if (configuredPrefix === prefix && typeof configRow.nextId === "number" && configRow.nextId > seedSequence) {
-          seedSequence = configRow.nextId;
-        }
-      }
-    } catch {
-    }
-    const idPattern = `${prefix}-%`;
-    const probeTable = (table) => {
-      try {
-        const row = db.prepare(
-          `SELECT MAX(CAST(substr(id, ${prefix.length + 2}) AS INTEGER)) AS maxSeq
-             FROM ${table}
-             WHERE id LIKE ? AND substr(id, ${prefix.length + 2}) GLOB '[0-9]*'`
-        ).get(idPattern);
-        if (row && typeof row.maxSeq === "number" && row.maxSeq + 1 > seedSequence) {
-          seedSequence = row.maxSeq + 1;
-        }
-      } catch {
-      }
-    };
-    probeTable("tasks");
-    probeTable("archivedTasks");
-    const nowIso3 = (/* @__PURE__ */ new Date()).toISOString();
-    db.prepare(
-      `INSERT OR IGNORE INTO distributed_task_id_state (
-        prefix, nextSequence, committedClusterTaskCount, lastCommittedTaskId, updatedAt
-      ) VALUES (?, ?, 0, NULL, ?)`
-    ).run(prefix, seedSequence, nowIso3);
-    db.prepare(
-      `UPDATE distributed_task_id_state
-       SET nextSequence = MAX(nextSequence, ?),
-           updatedAt = ?
-       WHERE prefix = ?`
-    ).run(seedSequence, nowIso3, prefix);
-  };
   return {
     formatDistributedTaskId,
     reserveDistributedTaskId: async (input) => withLock(async () => {
@@ -34989,7 +35307,7 @@ function createDistributedTaskIdAllocator(db) {
         if (!prefix) {
           throw new DistributedTaskIdError("prefix is required", "invalid_prefix");
         }
-        ensureStateRow(prefix);
+        ensureStateRow(db, prefix);
         const state = db.prepare(
           "SELECT nextSequence, committedClusterTaskCount FROM distributed_task_id_state WHERE prefix = ?"
         ).get(prefix);
@@ -35043,7 +35361,7 @@ function createDistributedTaskIdAllocator(db) {
              SET status = 'committed', committedAt = ?, updatedAt = ?
              WHERE reservationId = ?`
         ).run(nowIso3, nowIso3, row.reservationId);
-        ensureStateRow(row.prefix);
+        ensureStateRow(db, row.prefix);
         db.prepare(
           `UPDATE distributed_task_id_state
              SET committedClusterTaskCount = committedClusterTaskCount + 1,
@@ -35089,7 +35407,7 @@ function createDistributedTaskIdAllocator(db) {
                WHERE reservationId = ?`
           ).run(input.reason, nowIso3, nowIso3, row.reservationId);
         }
-        ensureStateRow(row.prefix);
+        ensureStateRow(db, row.prefix);
         const state = db.prepare(
           "SELECT committedClusterTaskCount FROM distributed_task_id_state WHERE prefix = ?"
         ).get(row.prefix);
@@ -35111,7 +35429,7 @@ function createDistributedTaskIdAllocator(db) {
         if (!prefix) {
           throw new DistributedTaskIdError("prefix is required", "invalid_prefix");
         }
-        ensureStateRow(prefix);
+        ensureStateRow(db, prefix);
         const row = db.prepare(
           `SELECT nextSequence, committedClusterTaskCount, lastCommittedTaskId
                FROM distributed_task_id_state
@@ -35136,11 +35454,12 @@ function createDistributedTaskIdAllocator(db) {
     })
   };
 }
-var DEFAULT_RESERVATION_TTL_MS, DistributedTaskIdError;
+var DEFAULT_RESERVATION_TTL_MS, TASK_ID_PATTERN, DistributedTaskIdError;
 var init_distributed_task_id = __esm({
   "../core/src/distributed-task-id.ts"() {
     "use strict";
     DEFAULT_RESERVATION_TTL_MS = 15 * 60 * 1e3;
+    TASK_ID_PATTERN = /^([A-Z][A-Z0-9]*)-(\d+)$/;
     DistributedTaskIdError = class extends Error {
       constructor(message, code) {
         super(message);
@@ -35435,6 +35754,8 @@ var init_store = __esm({
       worktreeAllocationLock = Promise.resolve();
       /** Promise chain for serializing config.json read-modify-write cycles */
       configLock = Promise.resolve();
+      /** Startup/open guard for distributed_task_id_state reconciliation. */
+      taskIdStateReconciled = false;
       /** Cached workflow steps — invalidated on create/update/delete */
       workflowStepsCache = null;
       /** Plugin-contributed workflow step templates injected by engine runtime. */
@@ -35501,6 +35822,7 @@ var init_store = __esm({
             throw error;
           }
           this._db = db;
+          this.reconcileDistributedTaskIdStateOnOpen();
           if (detectLegacyData(this.fusionDir)) {
           }
         }
@@ -35520,6 +35842,13 @@ var init_store = __esm({
         }
         return this._archiveDb;
       }
+      reconcileDistributedTaskIdStateOnOpen() {
+        if (this.taskIdStateReconciled) {
+          return;
+        }
+        reconcileTaskIdState(this.db);
+        this.taskIdStateReconciled = true;
+      }
       async init() {
         await mkdir7(this.tasksDir, { recursive: true });
         if (!this._db) {
@@ -35532,15 +35861,18 @@ var init_store = __esm({
           }
           this._db = db;
         }
+        this.reconcileDistributedTaskIdStateOnOpen();
         if (detectLegacyData(this.fusionDir)) {
           await migrateFromLegacy(this.fusionDir, this._db);
         }
         await this.migrateActiveArchivedTasksToArchiveDb();
         await this.importLegacyAgentLogsOnce();
+        this.taskIdStateReconciled = false;
+        this.reconcileDistributedTaskIdStateOnOpen();
         if (!existsSync13(this.configPath)) {
           const config = await this.readConfig();
           try {
-            await writeFile6(this.configPath, JSON.stringify(config, null, 2));
+            await writeFile6(this.configPath, this.serializeConfigForDisk(config));
           } catch (err) {
             storeLog.warn("Backward-compat config.json sync failed during init", {
               phase: "init:config-sync",
@@ -36129,117 +36461,8 @@ ${outcome}`;
     `;
         return [...columns, limitedLog].join(", ");
       }
-      /**
-       * Upsert a task to the database. Used by create and update operations.
-       */
-      upsertTask(task) {
-        this.db.prepare(`
-      INSERT INTO tasks (
-        id, lineageId, title, description, priority, "column", status, size, reviewLevel, currentStep,
-        worktree, blockedBy, paused, baseBranch, branch, executionStartBranch, baseCommitSha, modelPresetId, modelProvider,
-        modelId, validatorModelProvider, validatorModelId, planningModelProvider, planningModelId, mergeRetries,
-        workflowStepRetries, stuckKillCount, postReviewFixCount, recoveryRetryCount, taskDoneRetryCount, verificationFailureCount, mergeConflictBounceCount, nextRecoveryAt, error,
-        summary, thinkingLevel, executionMode, tokenUsageInputTokens, tokenUsageOutputTokens, tokenUsageCachedTokens,
-        tokenUsageTotalTokens, tokenUsageFirstUsedAt, tokenUsageLastUsedAt, createdAt, updatedAt, columnMovedAt,
-        executionStartedAt, executionCompletedAt,
-        dependencies, steps, log, attachments, steeringComments,
-        comments, review, reviewState, workflowStepResults, prInfo, issueInfo, githubTracking,
-        sourceIssueProvider, sourceIssueRepository, sourceIssueExternalIssueId, sourceIssueNumber, sourceIssueUrl,
-        mergeDetails, breakIntoSubtasks, enabledWorkflowSteps, modifiedFiles, missionId, sliceId, assignedAgentId, pausedByAgentId, assigneeUserId, nodeId, effectiveNodeId, effectiveNodeSource, sourceType, sourceAgentId, sourceRunId, sourceSessionId, sourceMessageId, sourceParentTaskId, sourceMetadata, checkedOutBy, checkedOutAt, checkoutNodeId, checkoutRunId, checkoutLeaseRenewedAt, checkoutLeaseEpoch
-      ) VALUES (
-        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
-      )
-      ON CONFLICT(id) DO UPDATE SET
-        lineageId = excluded.lineageId,
-        title = excluded.title,
-        description = excluded.description,
-        priority = excluded.priority,
-        "column" = excluded."column",
-        status = excluded.status,
-        size = excluded.size,
-        reviewLevel = excluded.reviewLevel,
-        currentStep = excluded.currentStep,
-        worktree = excluded.worktree,
-        blockedBy = excluded.blockedBy,
-        paused = excluded.paused,
-        baseBranch = excluded.baseBranch,
-        branch = excluded.branch,
-        executionStartBranch = excluded.executionStartBranch,
-        baseCommitSha = excluded.baseCommitSha,
-        modelPresetId = excluded.modelPresetId,
-        modelProvider = excluded.modelProvider,
-        modelId = excluded.modelId,
-        validatorModelProvider = excluded.validatorModelProvider,
-        validatorModelId = excluded.validatorModelId,
-        planningModelProvider = excluded.planningModelProvider,
-        planningModelId = excluded.planningModelId,
-        mergeRetries = excluded.mergeRetries,
-        workflowStepRetries = excluded.workflowStepRetries,
-        stuckKillCount = excluded.stuckKillCount,
-        postReviewFixCount = excluded.postReviewFixCount,
-        recoveryRetryCount = excluded.recoveryRetryCount,
-        taskDoneRetryCount = excluded.taskDoneRetryCount,
-        verificationFailureCount = excluded.verificationFailureCount,
-        mergeConflictBounceCount = excluded.mergeConflictBounceCount,
-        nextRecoveryAt = excluded.nextRecoveryAt,
-        error = excluded.error,
-        summary = excluded.summary,
-        thinkingLevel = excluded.thinkingLevel,
-        executionMode = excluded.executionMode,
-        tokenUsageInputTokens = excluded.tokenUsageInputTokens,
-        tokenUsageOutputTokens = excluded.tokenUsageOutputTokens,
-        tokenUsageCachedTokens = excluded.tokenUsageCachedTokens,
-        tokenUsageTotalTokens = excluded.tokenUsageTotalTokens,
-        tokenUsageFirstUsedAt = excluded.tokenUsageFirstUsedAt,
-        tokenUsageLastUsedAt = excluded.tokenUsageLastUsedAt,
-        createdAt = excluded.createdAt,
-        updatedAt = excluded.updatedAt,
-        columnMovedAt = excluded.columnMovedAt,
-        executionStartedAt = excluded.executionStartedAt,
-        executionCompletedAt = excluded.executionCompletedAt,
-        dependencies = excluded.dependencies,
-        steps = excluded.steps,
-        log = excluded.log,
-        attachments = excluded.attachments,
-        steeringComments = excluded.steeringComments,
-        comments = excluded.comments,
-        review = excluded.review,
-        reviewState = excluded.reviewState,
-        workflowStepResults = excluded.workflowStepResults,
-        prInfo = excluded.prInfo,
-        issueInfo = excluded.issueInfo,
-        githubTracking = excluded.githubTracking,
-        sourceIssueProvider = excluded.sourceIssueProvider,
-        sourceIssueRepository = excluded.sourceIssueRepository,
-        sourceIssueExternalIssueId = excluded.sourceIssueExternalIssueId,
-        sourceIssueNumber = excluded.sourceIssueNumber,
-        sourceIssueUrl = excluded.sourceIssueUrl,
-        mergeDetails = excluded.mergeDetails,
-        breakIntoSubtasks = excluded.breakIntoSubtasks,
-        enabledWorkflowSteps = excluded.enabledWorkflowSteps,
-        modifiedFiles = excluded.modifiedFiles,
-        missionId = excluded.missionId,
-        sliceId = excluded.sliceId,
-        assignedAgentId = excluded.assignedAgentId,
-        pausedByAgentId = excluded.pausedByAgentId,
-        assigneeUserId = excluded.assigneeUserId,
-        nodeId = excluded.nodeId,
-        effectiveNodeId = excluded.effectiveNodeId,
-        effectiveNodeSource = excluded.effectiveNodeSource,
-        sourceType = excluded.sourceType,
-        sourceAgentId = excluded.sourceAgentId,
-        sourceRunId = excluded.sourceRunId,
-        sourceSessionId = excluded.sourceSessionId,
-        sourceMessageId = excluded.sourceMessageId,
-        sourceParentTaskId = excluded.sourceParentTaskId,
-        sourceMetadata = excluded.sourceMetadata,
-        checkedOutBy = excluded.checkedOutBy,
-        checkedOutAt = excluded.checkedOutAt,
-        checkoutNodeId = excluded.checkoutNodeId,
-        checkoutRunId = excluded.checkoutRunId,
-        checkoutLeaseRenewedAt = excluded.checkoutLeaseRenewedAt,
-        checkoutLeaseEpoch = excluded.checkoutLeaseEpoch
-    `).run(
+      getTaskPersistValues(task) {
+        return [
           task.id,
           task.lineageId ?? generateTaskLineageId(),
           task.title ?? null,
@@ -36330,9 +36553,193 @@ ${outcome}`;
           task.checkoutRunId ?? null,
           task.checkoutLeaseRenewedAt ?? null,
           task.checkoutLeaseEpoch ?? 0
-        );
+        ];
+      }
+      /**
+       * Insert a brand-new task row. Create paths must use this so SQLite raises on
+       * duplicate IDs instead of silently rewriting the existing row.
+       */
+      insertTask(task) {
+        this.db.prepare(`
+      INSERT INTO tasks (
+        id, lineageId, title, description, priority, "column", status, size, reviewLevel, currentStep,
+        worktree, blockedBy, paused, baseBranch, branch, executionStartBranch, baseCommitSha, modelPresetId, modelProvider,
+        modelId, validatorModelProvider, validatorModelId, planningModelProvider, planningModelId, mergeRetries,
+        workflowStepRetries, stuckKillCount, postReviewFixCount, recoveryRetryCount, taskDoneRetryCount, verificationFailureCount, mergeConflictBounceCount, nextRecoveryAt, error,
+        summary, thinkingLevel, executionMode, tokenUsageInputTokens, tokenUsageOutputTokens, tokenUsageCachedTokens,
+        tokenUsageTotalTokens, tokenUsageFirstUsedAt, tokenUsageLastUsedAt, createdAt, updatedAt, columnMovedAt,
+        executionStartedAt, executionCompletedAt,
+        dependencies, steps, log, attachments, steeringComments,
+        comments, review, reviewState, workflowStepResults, prInfo, issueInfo, githubTracking,
+        sourceIssueProvider, sourceIssueRepository, sourceIssueExternalIssueId, sourceIssueNumber, sourceIssueUrl,
+        mergeDetails, breakIntoSubtasks, enabledWorkflowSteps, modifiedFiles, missionId, sliceId, assignedAgentId, pausedByAgentId, assigneeUserId, nodeId, effectiveNodeId, effectiveNodeSource, sourceType, sourceAgentId, sourceRunId, sourceSessionId, sourceMessageId, sourceParentTaskId, sourceMetadata, checkedOutBy, checkedOutAt, checkoutNodeId, checkoutRunId, checkoutLeaseRenewedAt, checkoutLeaseEpoch
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+      )
+    `).run(...this.getTaskPersistValues(task));
         this.db.bumpLastModified();
       }
+      /**
+       * Upsert a task to the database. Update paths intentionally retain ON CONFLICT
+       * semantics; create paths must use insertTask() instead.
+       */
+      upsertTask(task) {
+        this.db.prepare(`
+      INSERT INTO tasks (
+        id, lineageId, title, description, priority, "column", status, size, reviewLevel, currentStep,
+        worktree, blockedBy, paused, baseBranch, branch, executionStartBranch, baseCommitSha, modelPresetId, modelProvider,
+        modelId, validatorModelProvider, validatorModelId, planningModelProvider, planningModelId, mergeRetries,
+        workflowStepRetries, stuckKillCount, postReviewFixCount, recoveryRetryCount, taskDoneRetryCount, verificationFailureCount, mergeConflictBounceCount, nextRecoveryAt, error,
+        summary, thinkingLevel, executionMode, tokenUsageInputTokens, tokenUsageOutputTokens, tokenUsageCachedTokens,
+        tokenUsageTotalTokens, tokenUsageFirstUsedAt, tokenUsageLastUsedAt, createdAt, updatedAt, columnMovedAt,
+        executionStartedAt, executionCompletedAt,
+        dependencies, steps, log, attachments, steeringComments,
+        comments, review, reviewState, workflowStepResults, prInfo, issueInfo, githubTracking,
+        sourceIssueProvider, sourceIssueRepository, sourceIssueExternalIssueId, sourceIssueNumber, sourceIssueUrl,
+        mergeDetails, breakIntoSubtasks, enabledWorkflowSteps, modifiedFiles, missionId, sliceId, assignedAgentId, pausedByAgentId, assigneeUserId, nodeId, effectiveNodeId, effectiveNodeSource, sourceType, sourceAgentId, sourceRunId, sourceSessionId, sourceMessageId, sourceParentTaskId, sourceMetadata, checkedOutBy, checkedOutAt, checkoutNodeId, checkoutRunId, checkoutLeaseRenewedAt, checkoutLeaseEpoch
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+      )
+      ON CONFLICT(id) DO UPDATE SET
+        lineageId = excluded.lineageId,
+        title = excluded.title,
+        description = excluded.description,
+        priority = excluded.priority,
+        "column" = excluded."column",
+        status = excluded.status,
+        size = excluded.size,
+        reviewLevel = excluded.reviewLevel,
+        currentStep = excluded.currentStep,
+        worktree = excluded.worktree,
+        blockedBy = excluded.blockedBy,
+        paused = excluded.paused,
+        baseBranch = excluded.baseBranch,
+        branch = excluded.branch,
+        executionStartBranch = excluded.executionStartBranch,
+        baseCommitSha = excluded.baseCommitSha,
+        modelPresetId = excluded.modelPresetId,
+        modelProvider = excluded.modelProvider,
+        modelId = excluded.modelId,
+        validatorModelProvider = excluded.validatorModelProvider,
+        validatorModelId = excluded.validatorModelId,
+        planningModelProvider = excluded.planningModelProvider,
+        planningModelId = excluded.planningModelId,
+        mergeRetries = excluded.mergeRetries,
+        workflowStepRetries = excluded.workflowStepRetries,
+        stuckKillCount = excluded.stuckKillCount,
+        postReviewFixCount = excluded.postReviewFixCount,
+        recoveryRetryCount = excluded.recoveryRetryCount,
+        taskDoneRetryCount = excluded.taskDoneRetryCount,
+        verificationFailureCount = excluded.verificationFailureCount,
+        mergeConflictBounceCount = excluded.mergeConflictBounceCount,
+        nextRecoveryAt = excluded.nextRecoveryAt,
+        error = excluded.error,
+        summary = excluded.summary,
+        thinkingLevel = excluded.thinkingLevel,
+        executionMode = excluded.executionMode,
+        tokenUsageInputTokens = excluded.tokenUsageInputTokens,
+        tokenUsageOutputTokens = excluded.tokenUsageOutputTokens,
+        tokenUsageCachedTokens = excluded.tokenUsageCachedTokens,
+        tokenUsageTotalTokens = excluded.tokenUsageTotalTokens,
+        tokenUsageFirstUsedAt = excluded.tokenUsageFirstUsedAt,
+        tokenUsageLastUsedAt = excluded.tokenUsageLastUsedAt,
+        createdAt = excluded.createdAt,
+        updatedAt = excluded.updatedAt,
+        columnMovedAt = excluded.columnMovedAt,
+        executionStartedAt = excluded.executionStartedAt,
+        executionCompletedAt = excluded.executionCompletedAt,
+        dependencies = excluded.dependencies,
+        steps = excluded.steps,
+        log = excluded.log,
+        attachments = excluded.attachments,
+        steeringComments = excluded.steeringComments,
+        comments = excluded.comments,
+        review = excluded.review,
+        reviewState = excluded.reviewState,
+        workflowStepResults = excluded.workflowStepResults,
+        prInfo = excluded.prInfo,
+        issueInfo = excluded.issueInfo,
+        githubTracking = excluded.githubTracking,
+        sourceIssueProvider = excluded.sourceIssueProvider,
+        sourceIssueRepository = excluded.sourceIssueRepository,
+        sourceIssueExternalIssueId = excluded.sourceIssueExternalIssueId,
+        sourceIssueNumber = excluded.sourceIssueNumber,
+        sourceIssueUrl = excluded.sourceIssueUrl,
+        mergeDetails = excluded.mergeDetails,
+        breakIntoSubtasks = excluded.breakIntoSubtasks,
+        enabledWorkflowSteps = excluded.enabledWorkflowSteps,
+        modifiedFiles = excluded.modifiedFiles,
+        missionId = excluded.missionId,
+        sliceId = excluded.sliceId,
+        assignedAgentId = excluded.assignedAgentId,
+        pausedByAgentId = excluded.pausedByAgentId,
+        assigneeUserId = excluded.assigneeUserId,
+        nodeId = excluded.nodeId,
+        effectiveNodeId = excluded.effectiveNodeId,
+        effectiveNodeSource = excluded.effectiveNodeSource,
+        sourceType = excluded.sourceType,
+        sourceAgentId = excluded.sourceAgentId,
+        sourceRunId = excluded.sourceRunId,
+        sourceSessionId = excluded.sourceSessionId,
+        sourceMessageId = excluded.sourceMessageId,
+        sourceParentTaskId = excluded.sourceParentTaskId,
+        sourceMetadata = excluded.sourceMetadata,
+        checkedOutBy = excluded.checkedOutBy,
+        checkedOutAt = excluded.checkedOutAt,
+        checkoutNodeId = excluded.checkoutNodeId,
+        checkoutRunId = excluded.checkoutRunId,
+        checkoutLeaseRenewedAt = excluded.checkoutLeaseRenewedAt,
+        checkoutLeaseEpoch = excluded.checkoutLeaseEpoch
+    `).run(...this.getTaskPersistValues(task));
+        this.db.bumpLastModified();
+      }
+      isTaskIdConflictError(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return /SQLITE_CONSTRAINT|UNIQUE constraint failed: tasks\.id|PRIMARY KEY constraint failed: tasks\.id/i.test(message);
+      }
+      logTaskCreateConflict(task, operation, error) {
+        storeLog.error("Refused colliding task create", {
+          phase: "task-create:id-conflict",
+          operation,
+          taskId: task.id,
+          column: task.column,
+          sourceType: task.sourceType,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      insertTaskWithFtsRecovery(task, operation) {
+        const normalizeConflict = (error) => {
+          this.logTaskCreateConflict(task, operation, error);
+          throw new Error(`Task ID already exists: ${task.id}`);
+        };
+        try {
+          this.insertTask(task);
+          return;
+        } catch (error) {
+          if (this.isTaskIdConflictError(error)) {
+            normalizeConflict(error);
+          }
+          if (!this.db.isFts5CorruptionError(error)) {
+            throw error;
+          }
+          console.warn(`[fusion:store] FTS5 corruption detected during insert for task ${task.id}; rebuilding index and retrying once`);
+          try {
+            this.db.rebuildFts5Index();
+          } catch (rebuildError) {
+            console.warn("[fusion:store] FTS5 rebuild failed; propagating original insert error", rebuildError);
+            throw error;
+          }
+          try {
+            this.insertTask(task);
+          } catch (retryError) {
+            if (this.isTaskIdConflictError(retryError)) {
+              normalizeConflict(retryError);
+            }
+            console.warn("[fusion:store] Insert retry after FTS5 rebuild failed; propagating original insert error", retryError);
+            throw error;
+          }
+        }
+      }
       upsertTaskWithFtsRecovery(task) {
         try {
           this.upsertTask(task);
@@ -36365,6 +36772,28 @@ ${outcome}`;
         if (!row) return void 0;
         return this.rowToTask(row);
       }
+      isTaskIdPresentInArchivedTasksTable(id) {
+        try {
+          const row = this.db.prepare("SELECT 1 as found FROM archivedTasks WHERE id = ? LIMIT 1").get(id);
+          return row?.found === 1;
+        } catch {
+          return false;
+        }
+      }
+      taskIdExistsAnywhere(id) {
+        if (this.readTaskFromDb(id)) {
+          return true;
+        }
+        if (this.isTaskIdPresentInArchivedTasksTable(id)) {
+          return true;
+        }
+        return this.archiveDb.get(id) !== void 0;
+      }
+      assertTaskIdAvailable(id) {
+        if (this.taskIdExistsAnywhere(id)) {
+          throw new Error(`Task ID already exists: ${id}`);
+        }
+      }
       isTaskArchived(id) {
         const row = this.db.prepare('SELECT "column" FROM tasks WHERE id = ?').get(id);
         if (row) {
@@ -36592,7 +37021,16 @@ ${outcome}`;
         await rename4(tmpPath, taskJsonPath);
       }
       /**
-       * Write a task to SQLite (primary store) and also write task.json to disk
+       * Write a brand-new task to SQLite (primary store) and also write task.json to disk
+       * for backward compatibility and debugging. Create paths must call this variant
+       * so duplicate IDs fail safely instead of overwriting existing rows.
+       */
+      async atomicCreateTaskJson(dir, task, operation) {
+        this.insertTaskWithFtsRecovery(task, operation);
+        await this.writeTaskJsonFile(dir, task);
+      }
+      /**
+       * Write an existing task to SQLite (primary store) and also write task.json to disk
        * for backward compatibility and debugging.
        */
       async atomicWriteTaskJson(dir, task) {
@@ -36608,7 +37046,7 @@ ${outcome}`;
        * @param auditInput - Optional audit event input to record atomically with the task write
        */
       async atomicWriteTaskJsonWithAudit(dir, task, auditInput) {
-        this.db.transaction(() => {
+        this.db.transactionImmediate(() => {
           this.upsertTaskWithFtsRecovery(task);
           if (auditInput) {
             const eventId = randomUUID13();
@@ -36886,6 +37324,10 @@ ${outcome}`;
           settings: fromJson(row.settings)
         };
       }
+      serializeConfigForDisk(config) {
+        const { nextId: _deprecatedNextId, ...configForDisk } = config;
+        return JSON.stringify(configForDisk, null, 2);
+      }
       async writeConfig(config, options) {
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const row = this.db.prepare("SELECT nextWorkflowStepId FROM config WHERE id = 1").get();
@@ -36893,10 +37335,14 @@ ${outcome}`;
         const legacyWorkflowSteps = config.workflowSteps;
         const workflowStepsJson = Array.isArray(legacyWorkflowSteps) ? JSON.stringify(legacyWorkflowSteps) : "[]";
         this.db.prepare(
-          `INSERT OR REPLACE INTO config (id, nextId, nextWorkflowStepId, settings, workflowSteps, updatedAt) 
-       VALUES (1, ?, ?, ?, ?, ?)`
+          `INSERT INTO config (id, nextWorkflowStepId, settings, workflowSteps, updatedAt)
+       VALUES (1, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         nextWorkflowStepId = excluded.nextWorkflowStepId,
+         settings = excluded.settings,
+         workflowSteps = excluded.workflowSteps,
+         updatedAt = excluded.updatedAt`
         ).run(
-          config.nextId || 1,
           nextWorkflowStepId,
           JSON.stringify(config.settings || {}),
           workflowStepsJson,
@@ -36905,7 +37351,7 @@ ${outcome}`;
         this.db.bumpLastModified();
         try {
           const tmpPath = this.configPath + ".tmp";
-          await writeFile6(tmpPath, JSON.stringify(config, null, 2));
+          await writeFile6(tmpPath, this.serializeConfigForDisk(config));
           await rename4(tmpPath, this.configPath);
         } catch (err) {
           storeLog.warn("Backward-compat config.json sync failed after config write", {
@@ -37152,9 +37598,7 @@ ${outcome}`;
         if (input.dependencies?.includes(id)) {
           throw new Error(`Task ${id} cannot depend on itself`);
         }
-        if (this.readTaskFromDb(id)) {
-          throw new Error(`Task ID already exists: ${id}`);
-        }
+        this.assertTaskIdAvailable(id);
         const title = input.title?.trim() || void 0;
         let resolvedWorkflowSteps = input.enabledWorkflowSteps?.length ? await this.resolveEnabledWorkflowSteps(input.enabledWorkflowSteps) : void 0;
         if (input.enabledWorkflowSteps === void 0 && options.applyDefaultWorkflowSteps !== false) {
@@ -37250,9 +37694,9 @@ ${outcome}`;
           createdAt: now,
           updatedAt: options?.updatedAt ?? now
         };
+        this.assertTaskIdAvailable(id);
         const dir = this.taskDir(id);
-        await mkdir7(dir, { recursive: true });
-        await this.atomicWriteTaskJson(dir, task);
+        await this.atomicCreateTaskJson(dir, task, "createTask");
         if (this.isWatching) this.taskCache.set(id, { ...task });
         const prompt = options?.promptOverride ?? (task.column === "triage" ? buildBootstrapPrompt(id, task.title, task.description) : this.generateSpecifiedPrompt(task));
         await mkdir7(dir, { recursive: true });
@@ -37291,9 +37735,9 @@ ${outcome}`;
               updatedAt: now,
               baseBranch: sourceTask.baseBranch
             };
+            this.assertTaskIdAvailable(newId);
             const newDir = this.taskDir(newId);
-            await mkdir7(newDir, { recursive: true });
-            await this.atomicWriteTaskJson(newDir, newTask);
+            await this.atomicCreateTaskJson(newDir, newTask, "duplicateTask");
             await mkdir7(newDir, { recursive: true });
             await writeFile6(join16(newDir, "PROMPT.md"), sourceTask.prompt);
             if (this.isWatching) this.taskCache.set(newId, { ...newTask });
@@ -37347,9 +37791,9 @@ Refines: ${id}`,
               updatedAt: now,
               attachments: sourceTask.attachments ? [...sourceTask.attachments] : void 0
             };
+            this.assertTaskIdAvailable(newId);
             const newDir = this.taskDir(newId);
-            await mkdir7(newDir, { recursive: true });
-            await this.atomicWriteTaskJson(newDir, newTask);
+            await this.atomicCreateTaskJson(newDir, newTask, "refineTask");
             const prompt = `# ${newTask.title}
 
 ${newTask.description}
@@ -37731,6 +38175,8 @@ ${newTask.description}
             task.status = void 0;
             task.error = void 0;
             task.blockedBy = void 0;
+            task.paused = void 0;
+            task.pausedByAgentId = void 0;
             const hasNonPendingStepProgress = task.steps.some((step) => step.status !== "pending");
             const preserveStepProgress = options?.preserveResumeState || options?.preserveProgress === true && hasNonPendingStepProgress;
             if (!options?.preserveWorktree) {
@@ -38402,21 +38848,23 @@ ${newTask.description}
           target: input.target,
           metadata: input.metadata
         };
-        this.db.prepare(`
-      INSERT INTO runAuditEvents (
-        id, timestamp, taskId, agentId, runId, domain, mutationType, target, metadata
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-          event.id,
-          event.timestamp,
-          event.taskId ?? null,
-          event.agentId,
-          event.runId,
-          event.domain,
-          event.mutationType,
-          event.target,
-          toJsonNullable(event.metadata)
-        );
+        this.db.transactionImmediate(() => {
+          this.db.prepare(`
+        INSERT INTO runAuditEvents (
+          id, timestamp, taskId, agentId, runId, domain, mutationType, target, metadata
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+            event.id,
+            event.timestamp,
+            event.taskId ?? null,
+            event.agentId,
+            event.runId,
+            event.domain,
+            event.mutationType,
+            event.target,
+            toJsonNullable(event.metadata)
+          );
+        });
         return event;
       }
       /**
@@ -40549,6 +40997,7 @@ ${stepsSection}`;
         if (this._db) {
           this._db.close();
           this._db = null;
+          this.taskIdStateReconciled = false;
         }
         if (this._archiveDb) {
           this._archiveDb.close();
@@ -40582,9 +41031,9 @@ ${stepsSection}`;
       }
       getDatabaseHealth() {
         return {
-          corruptionDetected: this.db.corruptionDetected,
-          integrityCheckPending: this.db.integrityCheckPending,
-          integrityCheckLastRunAt: this.db.integrityCheckLastRunAt
+          healthy: !this.db.corruptionDetected,
+          lastCheckedAt: this.db.integrityCheckLastRunAt ? new Date(this.db.integrityCheckLastRunAt) : null,
+          isRunning: this.db.integrityCheckPending
         };
       }
       getDistributedTaskIdAllocator() {
@@ -41098,7 +41547,7 @@ var init_daemon_token = __esm({
 });
 
 // ../core/src/pi-extensions.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync5, readdirSync, readFileSync as readFileSync3, statSync as statSync3, writeFileSync } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync5, readdirSync, readFileSync as readFileSync3, statSync as statSync4, writeFileSync } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { basename as basename5, isAbsolute as isAbsolute5, join as join17, relative as relative2, resolve as resolve8, sep as sep4, win32 } from "node:path";
 function getHomeDir3(home) {
@@ -41188,7 +41637,7 @@ function discoverExtensionsInDir(dir, cwd, home) {
         let isDirectory = entry.isDirectory();
         if (entry.isSymbolicLink()) {
           try {
-            isDirectory = statSync3(entryPath).isDirectory();
+            isDirectory = statSync4(entryPath).isDirectory();
           } catch {
             isDirectory = false;
           }
@@ -49064,11 +49513,11 @@ var require_extract_zip = __commonJS({
     var { createWriteStream, promises: fs2 } = __require("fs");
     var getStream = require_get_stream();
     var path2 = __require("path");
-    var { promisify: promisify14 } = __require("util");
+    var { promisify: promisify15 } = __require("util");
     var stream = __require("stream");
     var yauzl = require_yauzl();
-    var openZip = promisify14(yauzl.open);
-    var pipeline = promisify14(stream.pipeline);
+    var openZip = promisify15(yauzl.open);
+    var pipeline = promisify15(stream.pipeline);
     var Extractor = class {
       constructor(zipPath, opts) {
         this.zipPath = zipPath;
@@ -49150,7 +49599,7 @@ var require_extract_zip = __commonJS({
         await fs2.mkdir(destDir, mkdirOptions);
         if (isDir) return;
         debug("opening read stream", dest);
-        const readStream = await promisify14(this.zipfile.openReadStream.bind(this.zipfile))(entry);
+        const readStream = await promisify15(this.zipfile.openReadStream.bind(this.zipfile))(entry);
         if (symlink) {
           const link = await getStream(readStream);
           debug("creating symlink", link, dest);
@@ -56496,7 +56945,7 @@ var require_dist3 = __commonJS({
 });
 
 // ../core/src/agent-companies-parser.ts
-import { existsSync as existsSync19, mkdtempSync, readdirSync as readdirSync2, readFileSync as readFileSync5, rmSync, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync19, mkdtempSync, readdirSync as readdirSync2, readFileSync as readFileSync5, rmSync, statSync as statSync5 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { isAbsolute as isAbsolute7, join as join22, normalize as normalize3, resolve as resolve11 } from "node:path";
 function slugifyAgentReference(value) {
@@ -56772,7 +57221,7 @@ function parseCompanyDirectory(dirPath) {
   if (!existsSync19(resolvedPath)) {
     throw new AgentCompaniesParseError(`Company directory does not exist: ${resolvedPath}`);
   }
-  if (!statSync4(resolvedPath).isDirectory()) {
+  if (!statSync5(resolvedPath).isDirectory()) {
     throw new AgentCompaniesParseError(`Company path is not a directory: ${resolvedPath}`);
   }
   const companyPath = join22(resolvedPath, "COMPANY.md");
@@ -56811,12 +57260,12 @@ function resolveExtractionRoot(tempDir) {
   return tempDir;
 }
 async function extractTarArchive(archivePath, outputDir) {
-  const [{ execFile: execFile8 }, { promisify: promisify14 }] = await Promise.all([
+  const [{ execFile: execFile9 }, { promisify: promisify15 }] = await Promise.all([
     import("node:child_process"),
     import("node:util")
   ]);
-  const execFileAsync6 = promisify14(execFile8);
-  await execFileAsync6("tar", ["xzf", archivePath, "-C", outputDir]);
+  const execFileAsync7 = promisify15(execFile9);
+  await execFileAsync7("tar", ["xzf", archivePath, "-C", outputDir]);
 }
 function sanitizeCompanySubPath(subPath) {
   const trimmed = subPath.trim();
@@ -59369,15 +59818,15 @@ function evaluateAgentActionGate(params) {
   let resourceId;
   if (params.toolName === "bash") {
     const command = extractShellCommand(args);
-    const git = classifyGitCommand(command);
-    if (git?.write) {
+    const git2 = classifyGitCommand(command);
+    if (git2?.write) {
       category = "git_write";
-      operation = git.operation;
+      operation = git2.operation;
       resourceType = "git";
     } else {
       category = "command_execution";
-      operation = git?.operation ?? "shell command";
-      resourceType = git ? "git" : "command";
+      operation = git2?.operation ?? "shell command";
+      resourceType = git2 ? "git" : "command";
     }
   } else if (params.toolName === "write" || params.toolName === "edit") {
     category = "file_write_delete";
@@ -61236,6 +61685,71 @@ _... existing specification middle trimmed ..._
 
 ${tail}`;
 }
+function extractMarkdownSection(document2, headingName) {
+  const heading = `## ${headingName}`;
+  const start = document2.indexOf(heading);
+  if (start === -1) {
+    return "";
+  }
+  const afterHeading = start + heading.length;
+  const nextH2 = document2.indexOf("\n## ", afterHeading);
+  const nextH1 = document2.indexOf("\n# ", afterHeading);
+  const endCandidates = [nextH2, nextH1].filter((value) => value !== -1);
+  const end = endCandidates.length > 0 ? Math.min(...endCandidates) : document2.length;
+  return document2.slice(start, end).trim();
+}
+function compactTaskPromptStepsSection(section) {
+  const stepTitles = Array.from(section.matchAll(/^### Step \d+:.*$/gm), (match) => match[0].trim());
+  if (stepTitles.length === 0) {
+    return section.trim();
+  }
+  return [
+    "## Steps",
+    ...stepTitles,
+    "",
+    "_... step checklist details trimmed for context limits ..._"
+  ].join("\n").trim();
+}
+function truncateCompactedSection(section, maxChars, label) {
+  const trimmed = section.trim();
+  if (!trimmed || trimmed.length <= maxChars) {
+    return trimmed;
+  }
+  const marker = `_... ${label} trimmed for context limits ..._`;
+  const headBudget = Math.max(200, maxChars - marker.length - 2);
+  return [
+    `${trimmed.slice(0, headBudget).trimEnd()}\u2026`,
+    "",
+    marker
+  ].join("\n").trim();
+}
+function compactTaskPromptSectionBody(body) {
+  const trimmed = body.trim();
+  if (trimmed.length <= MAX_COMPACTED_TASK_PROMPT_CHARS) {
+    return trimmed;
+  }
+  const fencedMatch = /^```markdown\s*\n([\s\S]*?)\n```$/m.exec(trimmed);
+  const promptContent = fencedMatch ? fencedMatch[1].trim() : trimmed;
+  const firstSectionIndex = promptContent.indexOf("\n## ");
+  const preamble = (firstSectionIndex === -1 ? promptContent : promptContent.slice(0, firstSectionIndex)).trim();
+  const missionSection = extractMarkdownSection(promptContent, "Mission");
+  const dependenciesSection = extractMarkdownSection(promptContent, "Dependencies");
+  const fileScopeSection = extractMarkdownSection(promptContent, "File Scope");
+  const stepsSection = compactTaskPromptStepsSection(extractMarkdownSection(promptContent, "Steps"));
+  const compactedContent = [
+    truncateCompactedSection(preamble, 400, "task header"),
+    truncateCompactedSection(missionSection, 900, "mission"),
+    truncateCompactedSection(dependenciesSection, 500, "dependencies"),
+    truncateCompactedSection(fileScopeSection, 1e3, "file scope"),
+    truncateCompactedSection(stepsSection, 1200, "steps outline"),
+    "_... remaining PROMPT.md sections trimmed for context limits ..._"
+  ].filter(Boolean).join("\n\n").trim();
+  const narrowedContent = compactedContent.length <= MAX_COMPACTED_TASK_PROMPT_CHARS ? compactedContent : compactExistingSpecificationSectionBody(compactedContent);
+  const finalContent = fencedMatch ? `\`\`\`markdown
+${narrowedContent}
+\`\`\`` : narrowedContent;
+  return finalContent.length < trimmed.length ? finalContent : compactExistingSpecificationSectionBody(trimmed);
+}
 function compactUserCommentsSectionBody(body) {
   const trimmed = body.trim();
   if (trimmed.length <= MAX_COMPACTED_USER_COMMENTS_CHARS) {
@@ -61268,7 +61782,7 @@ function compactUserCommentsSectionBody(body) {
   ].join("\n").trim();
 }
 function compactLargePromptSections(prompt) {
-  const sectionPattern = /(^|\n)(## (?:Subtask Consideration|Subtask Breakdown Requested|Attachments|Existing Specification|User Comments)\n)([\s\S]*?)(?=\n## [^#]|\n# [^#]|$)/g;
+  const sectionPattern = /(^|\n)(## (?:Subtask Consideration|Subtask Breakdown Requested|Attachments|Existing Specification|Task PROMPT\.md|User Comments)\n)((?:\n*```markdown[\s\S]*?\n```|[\s\S]*?))(?=\n## [^#]|\n# [^#]|$)/g;
   let changed = false;
   const compactedPrompt = prompt.replace(sectionPattern, (match, prefix, heading, body) => {
     const headingName = heading.trim().replace(/^##\s+/, "");
@@ -61278,6 +61792,7 @@ function compactLargePromptSections(prompt) {
       "Subtask Breakdown Requested": MAX_COMPACTED_SUBTASK_GUIDANCE_CHARS,
       Attachments: MAX_COMPACTED_ATTACHMENTS_CHARS,
       "Existing Specification": MAX_COMPACTED_EXISTING_SPEC_CHARS,
+      "Task PROMPT.md": MAX_COMPACTED_TASK_PROMPT_CHARS,
       "User Comments": MAX_COMPACTED_USER_COMMENTS_CHARS
     };
     const maxChars = maxByHeading[headingName] ?? MAX_COMPACTED_PROMPT_MEMORY_CHARS;
@@ -61291,6 +61806,8 @@ function compactLargePromptSections(prompt) {
       compactedBody = compactAttachmentSectionBody(trimmedBody);
     } else if (headingName === "Existing Specification") {
       compactedBody = compactExistingSpecificationSectionBody(trimmedBody);
+    } else if (headingName === "Task PROMPT.md") {
+      compactedBody = compactTaskPromptSectionBody(trimmedBody);
     } else if (headingName === "User Comments") {
       compactedBody = compactUserCommentsSectionBody(trimmedBody);
     }
@@ -62315,7 +62832,7 @@ async function createFnAgent2(options) {
   });
   return { session: promptableSession, sessionFile: promptableSession.sessionFile };
 }
-var execAsync, hostExtensionPaths, FN_MEMORY_APPEND_TOOL_NAME, FUSION_SHUTDOWN_WRAP_FLAG, COMPACTION_FALLBACK_INSTRUCTIONS, MAX_COMPACTED_PROMPT_MEMORY_CHARS, MAX_COMPACTED_SUBTASK_GUIDANCE_CHARS, MAX_COMPACTED_ATTACHMENTS_CHARS, MAX_COMPACTED_EXISTING_SPEC_CHARS, MAX_COMPACTED_USER_COMMENTS_CHARS, GATE_BYPASS_TOOL_NAMES;
+var execAsync, hostExtensionPaths, FN_MEMORY_APPEND_TOOL_NAME, FUSION_SHUTDOWN_WRAP_FLAG, COMPACTION_FALLBACK_INSTRUCTIONS, MAX_COMPACTED_PROMPT_MEMORY_CHARS, MAX_COMPACTED_SUBTASK_GUIDANCE_CHARS, MAX_COMPACTED_ATTACHMENTS_CHARS, MAX_COMPACTED_EXISTING_SPEC_CHARS, MAX_COMPACTED_TASK_PROMPT_CHARS, MAX_COMPACTED_USER_COMMENTS_CHARS, GATE_BYPASS_TOOL_NAMES;
 var init_pi = __esm({
   "../engine/src/pi.ts"() {
     "use strict";
@@ -62341,6 +62858,7 @@ var init_pi = __esm({
     MAX_COMPACTED_SUBTASK_GUIDANCE_CHARS = 1200;
     MAX_COMPACTED_ATTACHMENTS_CHARS = 4e3;
     MAX_COMPACTED_EXISTING_SPEC_CHARS = 4e3;
+    MAX_COMPACTED_TASK_PROMPT_CHARS = MAX_COMPACTED_EXISTING_SPEC_CHARS;
     MAX_COMPACTED_USER_COMMENTS_CHARS = 2e3;
     GATE_BYPASS_TOOL_NAMES = /* @__PURE__ */ new Set([
       "fn_heartbeat_done",
@@ -63609,7 +64127,7 @@ var init_research_step_runner = __esm({
 // ../engine/src/agent-tools.ts
 import { appendFile as appendFile3, mkdir as mkdir12, readFile as readFile14, readdir as readdir8, stat as stat5, writeFile as writeFile11 } from "node:fs/promises";
 import { existsSync as existsSync24 } from "node:fs";
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { join as join30, relative as relative6, resolve as resolve16 } from "node:path";
 import { Type } from "@mariozechner/pi-ai";
 function sanitizeAgentMemoryId(agentId) {
@@ -63652,7 +64170,7 @@ async function readAgentMemoryWorkspaceLongTerm(rootDir, agentId) {
   }
 }
 function qmdAgentMemoryCollectionName2(rootDir, agentId) {
-  const hash = createHash5("sha1").update(`${rootDir}:${agentId}`).digest("hex").slice(0, 12);
+  const hash = createHash6("sha1").update(`${rootDir}:${agentId}`).digest("hex").slice(0, 12);
   return `fusion-agent-memory-${sanitizeAgentMemoryId(agentId).toLowerCase()}-${hash}`;
 }
 function buildQmdAgentMemoryCollectionAddArgs(rootDir, agentId) {
@@ -63781,11 +64299,11 @@ async function refreshAgentMemoryQmdIndex(rootDir, agentMemory) {
     return;
   }
   const promise = (async () => {
-    const { execFile: execFile8 } = await import("node:child_process");
-    const { promisify: promisify14 } = await import("node:util");
-    const execFileAsync6 = promisify14(execFile8);
+    const { execFile: execFile9 } = await import("node:child_process");
+    const { promisify: promisify15 } = await import("node:util");
+    const execFileAsync7 = promisify15(execFile9);
     try {
-      await execFileAsync6("qmd", buildQmdAgentMemoryCollectionAddArgs(rootDir, agentMemory.agentId), {
+      await execFileAsync7("qmd", buildQmdAgentMemoryCollectionAddArgs(rootDir, agentMemory.agentId), {
         cwd: rootDir,
         timeout: 4e3,
         maxBuffer: 512 * 1024
@@ -63798,8 +64316,8 @@ ${stderr}`)) {
         throw error;
       }
     }
-    await execFileAsync6("qmd", ["update"], { cwd: rootDir, timeout: 3e4, maxBuffer: 1024 * 1024 });
-    await execFileAsync6("qmd", ["embed"], { cwd: rootDir, timeout: 12e4, maxBuffer: 1024 * 1024 });
+    await execFileAsync7("qmd", ["update"], { cwd: rootDir, timeout: 3e4, maxBuffer: 1024 * 1024 });
+    await execFileAsync7("qmd", ["embed"], { cwd: rootDir, timeout: 12e4, maxBuffer: 1024 * 1024 });
   })();
   agentQmdRefreshState.set(key, { lastStartedAt: now, inFlight: promise });
   try {
@@ -63854,10 +64372,10 @@ async function searchAgentMemoryWithQmd(rootDir, agentMemory, query, limit) {
   }
   try {
     await refreshAgentMemoryQmdIndex(rootDir, agentMemory);
-    const { execFile: execFile8 } = await import("node:child_process");
-    const { promisify: promisify14 } = await import("node:util");
-    const execFileAsync6 = promisify14(execFile8);
-    const { stdout } = await execFileAsync6("qmd", buildQmdAgentMemorySearchArgs(rootDir, agentMemory.agentId, query, limit), {
+    const { execFile: execFile9 } = await import("node:child_process");
+    const { promisify: promisify15 } = await import("node:util");
+    const execFileAsync7 = promisify15(execFile9);
+    const { stdout } = await execFileAsync7("qmd", buildQmdAgentMemorySearchArgs(rootDir, agentMemory.agentId, query, limit), {
       cwd: rootDir,
       timeout: 4e3,
       maxBuffer: 1024 * 1024
@@ -63936,24 +64454,36 @@ function createTaskCreateTool(store, provenance, options) {
     description: "Create a new task for out-of-scope work discovered during execution. The task goes into triage where it will be specified by the AI. Optionally set dependencies (e.g., the new task depends on the current one, or the current task should wait for the new one).",
     parameters: taskCreateParams,
     execute: async (_id, params) => {
-      const task = await createAgentTask(store, {
-        description: params.description,
-        dependencies: params.dependencies,
-        column: "triage",
-        source: provenance ? {
-          sourceType: provenance.sourceType,
-          sourceAgentId: provenance.sourceAgentId,
-          sourceRunId: provenance.sourceRunId
-        } : void 0
-      }, options);
-      const deps = task.dependencies.length ? ` (depends on: ${task.dependencies.join(", ")})` : "";
-      return {
-        content: [{
-          type: "text",
-          text: `Created ${task.id}: ${params.description}${deps}`
-        }],
-        details: { taskId: task.id }
-      };
+      try {
+        const task = await createAgentTask(store, {
+          description: params.description,
+          dependencies: params.dependencies,
+          column: "triage",
+          priority: params.priority,
+          source: provenance ? {
+            sourceType: provenance.sourceType,
+            sourceAgentId: provenance.sourceAgentId,
+            sourceRunId: provenance.sourceRunId
+          } : void 0
+        }, options);
+        const deps = task.dependencies.length ? ` (depends on: ${task.dependencies.join(", ")})` : "";
+        return {
+          content: [{
+            type: "text",
+            text: `Created ${task.id}: ${params.description}${deps}`
+          }],
+          details: { taskId: task.id }
+        };
+      } catch (err) {
+        if (err instanceof Error && err.message.startsWith("Task ID already exists:")) {
+          return {
+            content: [{ type: "text", text: `ERROR: ${err.message}` }],
+            details: {},
+            isError: true
+          };
+        }
+        throw err;
+      }
     }
   };
 }
@@ -64864,24 +65394,35 @@ function createDelegateTaskTool(agentStore, taskStore, options) {
           details: {}
         };
       }
-      const task = await createAgentTask(taskStore, {
-        description: params.description,
-        dependencies: params.dependencies,
-        column: "todo",
-        assignedAgentId: params.agent_id,
-        source: {
-          sourceType: "api",
-          ...override ? { sourceMetadata: { executorRoleOverride: true } } : {}
+      try {
+        const task = await createAgentTask(taskStore, {
+          description: params.description,
+          dependencies: params.dependencies,
+          column: "todo",
+          assignedAgentId: params.agent_id,
+          source: {
+            sourceType: "api",
+            ...override ? { sourceMetadata: { executorRoleOverride: true } } : {}
+          }
+        }, options);
+        const deps = task.dependencies.length ? ` (depends on: ${task.dependencies.join(", ")})` : "";
+        return {
+          content: [{
+            type: "text",
+            text: `Delegated to ${agent.name} (${agent.id}): Created ${task.id}${deps}. The task will be picked up by ${agent.name} on their next heartbeat cycle.`
+          }],
+          details: { taskId: task.id, agentId: agent.id, agentName: agent.name }
+        };
+      } catch (err) {
+        if (err instanceof Error && err.message.startsWith("Task ID already exists:")) {
+          return {
+            content: [{ type: "text", text: `ERROR: ${err.message}` }],
+            details: {},
+            isError: true
+          };
         }
-      }, options);
-      const deps = task.dependencies.length ? ` (depends on: ${task.dependencies.join(", ")})` : "";
-      return {
-        content: [{
-          type: "text",
-          text: `Delegated to ${agent.name} (${agent.id}): Created ${task.id}${deps}. The task will be picked up by ${agent.name} on their next heartbeat cycle.`
-        }],
-        details: { taskId: task.id, agentId: agent.id, agentName: agent.name }
-      };
+        throw err;
+      }
     }
   };
 }
@@ -65221,7 +65762,7 @@ ${lines.join("\n")}`
     }
   };
 }
-var taskCreateParams, taskLogParams, taskDocumentWriteParams, taskDocumentReadParams, reflectOnPerformanceParams, readEvaluationsParams, updateIdentityParams, listAgentsParams, delegateTaskParams, getAgentConfigParams, updateAgentConfigParams, createAgentParams, deleteAgentParams, sendMessageParams, readMessagesParams, memorySearchParams, memoryGetParams, webFetchParams, researchRunParams, researchListParams, researchGetParams, researchCancelParams, memoryAppendParams, log10, MAX_INSTRUCTIONS_TEXT_LENGTH, MAX_MEMORY_LENGTH, MAX_SOUL_LENGTH, AGENT_MEMORY_ROOT3, AGENT_MEMORY_FILENAME2, AGENT_DREAMS_FILENAME2, agentQmdRefreshState, AGENT_QMD_REFRESH_INTERVAL_MS, DAILY_AGENT_MEMORY_RE2;
+var TASK_CREATE_PRIORITY_VALUES, taskCreateParams, taskLogParams, taskDocumentWriteParams, taskDocumentReadParams, reflectOnPerformanceParams, readEvaluationsParams, updateIdentityParams, listAgentsParams, delegateTaskParams, getAgentConfigParams, updateAgentConfigParams, createAgentParams, deleteAgentParams, sendMessageParams, readMessagesParams, memorySearchParams, memoryGetParams, webFetchParams, researchRunParams, researchListParams, researchGetParams, researchCancelParams, memoryAppendParams, log10, MAX_INSTRUCTIONS_TEXT_LENGTH, MAX_MEMORY_LENGTH, MAX_SOUL_LENGTH, AGENT_MEMORY_ROOT3, AGENT_MEMORY_FILENAME2, AGENT_DREAMS_FILENAME2, agentQmdRefreshState, AGENT_QMD_REFRESH_INTERVAL_MS, DAILY_AGENT_MEMORY_RE2;
 var init_agent_tools = __esm({
   "../engine/src/agent-tools.ts"() {
     "use strict";
@@ -65232,10 +65773,16 @@ var init_agent_tools = __esm({
     init_logger2();
     init_web_fetch();
     init_agent_action_gate();
+    TASK_CREATE_PRIORITY_VALUES = ["low", "normal", "high", "urgent"];
     taskCreateParams = Type.Object({
       description: Type.String({ description: "What needs to be done" }),
       dependencies: Type.Optional(
         Type.Array(Type.String(), { description: 'Task IDs this new task depends on (e.g. ["KB-001"])' })
+      ),
+      priority: Type.Optional(
+        Type.Union(TASK_CREATE_PRIORITY_VALUES.map((priority) => Type.Literal(priority)), {
+          description: "Task priority (low, normal, high, urgent)"
+        })
       )
     });
     taskLogParams = Type.Object({
@@ -66473,6 +67020,7 @@ var init_ntfy_provider = __esm({
         );
         const response = await sendNtfyNotificationWithResult({
           ntfyBaseUrl: this.config.ntfyBaseUrl,
+          ntfyAccessToken: this.config.ntfyAccessToken,
           topic: this.config.topic,
           title: content.title,
           message: content.message,
@@ -66777,7 +67325,7 @@ var init_notification_service = __esm({
       handleSettingsUpdated = async (data) => {
         const { settings, previous } = data;
         this.setNotificationsEnabledFromSettings(settings);
-        if (settings.ntfyEnabled !== previous.ntfyEnabled || settings.ntfyTopic !== previous.ntfyTopic || settings.ntfyBaseUrl !== previous.ntfyBaseUrl || settings.ntfyDashboardHost !== previous.ntfyDashboardHost || JSON.stringify(settings.ntfyEvents) !== JSON.stringify(previous.ntfyEvents)) {
+        if (settings.ntfyEnabled !== previous.ntfyEnabled || settings.ntfyTopic !== previous.ntfyTopic || settings.ntfyBaseUrl !== previous.ntfyBaseUrl || settings.ntfyAccessToken !== previous.ntfyAccessToken || settings.ntfyDashboardHost !== previous.ntfyDashboardHost || JSON.stringify(settings.ntfyEvents) !== JSON.stringify(previous.ntfyEvents)) {
           const wasEnabled = Boolean(previous.ntfyEnabled && previous.ntfyTopic);
           const isEnabled = Boolean(settings.ntfyEnabled && settings.ntfyTopic);
           await this.syncNtfyProvider(settings);
@@ -66789,6 +67337,8 @@ var init_notification_service = __esm({
             schedulerLog.log("NotificationService ntfy topic updated");
           } else if (settings.ntfyBaseUrl !== previous.ntfyBaseUrl) {
             schedulerLog.log("NotificationService ntfy base URL updated");
+          } else if (settings.ntfyAccessToken !== previous.ntfyAccessToken) {
+            schedulerLog.log("NotificationService ntfy access token updated");
           } else if (settings.ntfyDashboardHost !== previous.ntfyDashboardHost) {
             schedulerLog.log("NotificationService ntfy dashboard host updated");
           } else if (JSON.stringify(settings.ntfyEvents) !== JSON.stringify(previous.ntfyEvents)) {
@@ -66817,6 +67367,7 @@ var init_notification_service = __esm({
         await this.ntfyProvider.initialize?.({
           topic: settings.ntfyTopic,
           ntfyBaseUrl: settings.ntfyBaseUrl ?? this.options.ntfyBaseUrl,
+          ntfyAccessToken: settings.ntfyAccessToken,
           dashboardHost: settings.ntfyDashboardHost,
           events: settings.ntfyEvents ?? [...DEFAULT_NTFY_EVENTS],
           projectId: this.options.projectId
@@ -67023,6 +67574,7 @@ function buildNtfyClickUrl(options) {
 }
 async function sendNtfyNotificationWithResult({
   ntfyBaseUrl,
+  ntfyAccessToken,
   topic,
   title,
   message,
@@ -67039,6 +67591,10 @@ async function sendNtfyNotificationWithResult({
     if (clickUrl) {
       headers.Click = clickUrl;
     }
+    const trimmedToken = ntfyAccessToken?.trim();
+    if (trimmedToken) {
+      headers.Authorization = `Bearer ${trimmedToken}`;
+    }
     const resolvedBaseUrl = resolveNtfyBaseUrl(ntfyBaseUrl);
     const response = await fetch(`${resolvedBaseUrl}/${topic}`, {
       method: "POST",
@@ -67354,9 +67910,33 @@ async function reviewStep(cwd, taskId, stepNumber, stepName, reviewType, promptC
       this.reason = reason;
     }
   }
-  let session;
-  try {
-    ({ session } = await createResolvedAgentSession({
+  const activeSessions = /* @__PURE__ */ new Set();
+  let reviewText = "";
+  const endSession = (session2) => {
+    if (!activeSessions.delete(session2)) {
+      return;
+    }
+    session2.dispose();
+    options.onSessionEnded?.(session2);
+  };
+  const buildPauseUnavailableResult = async (reason) => {
+    reviewerLog.log(
+      `${taskId}: ${reviewType} review for Step ${stepNumber} aborted before spawn \u2014 ${reason} active`
+    );
+    if (options.store && options.taskId) {
+      await options.store.logEntry(
+        options.taskId,
+        `${reviewType} review aborted before spawn \u2014 ${reason} active`
+      ).catch(() => void 0);
+    }
+    return {
+      verdict: "UNAVAILABLE",
+      review: `${reason} active \u2014 reviewer not spawned. Stop calling fn_review_* and exit cleanly; the parent task will resume after unpause.`,
+      summary: `Skipped: ${reason}`
+    };
+  };
+  const createReviewerSession = async () => {
+    const { session: session2 } = await createResolvedAgentSession({
       sessionPurpose: "reviewer",
       runtimeHint: extractRuntimeHint(memoryAgent?.runtimeConfig),
       pluginRunner: options.pluginRunner,
@@ -67374,7 +67954,6 @@ async function reviewStep(cwd, taskId, stepNumber, stepName, reviewType, promptC
       fallbackProvider: validatorFallbackProvider,
       fallbackModelId: validatorFallbackModelId,
       defaultThinkingLevel: options.defaultThinkingLevel,
-      // Skill selection: use assigned agent skills if available, otherwise role fallback
       ...skillContext?.skillSelectionContext ? { skillSelection: skillContext.skillSelectionContext } : {},
       taskId: options.taskId,
       taskTitle: options.taskTitle,
@@ -67398,52 +67977,138 @@ async function reviewStep(cwd, taskId, stepNumber, stepName, reviewType, promptC
           throw new ReviewerPauseAbortError(reason);
         }
       }
-    }));
+    });
+    const reviewerModelDesc = describeModel(session2);
+    const reviewerModelMarker = `Reviewer using model: ${reviewerModelDesc}`;
+    reviewerLog.log(`${taskId}: reviewer using model ${reviewerModelDesc}`);
+    if (options.store && options.taskId) {
+      await options.store.logEntry(options.taskId, reviewerModelMarker);
+      await options.store.appendAgentLog(options.taskId, reviewerModelMarker, "text", void 0, "reviewer").catch(() => void 0);
+    }
+    activeSessions.add(session2);
+    options.onSessionCreated?.(session2);
+    session2.subscribe((event) => {
+      if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+        reviewText += event.assistantMessageEvent.delta;
+      }
+    });
+    return session2;
+  };
+  const runReviewPrompt = async (session2, prompt) => {
+    await promptWithFallback(session2, prompt);
+    checkSessionError(session2);
+  };
+  let session;
+  try {
+    session = await createReviewerSession();
   } catch (err) {
     if (err instanceof ReviewerPauseAbortError) {
-      reviewerLog.log(
-        `${taskId}: ${reviewType} review for Step ${stepNumber} aborted before spawn \u2014 ${err.reason} active`
-      );
-      if (options.store && options.taskId) {
-        await options.store.logEntry(
-          options.taskId,
-          `${reviewType} review aborted before spawn \u2014 ${err.reason} active`
-        ).catch(() => void 0);
-      }
-      return {
-        verdict: "UNAVAILABLE",
-        review: `${err.reason} active \u2014 reviewer not spawned. Stop calling fn_review_* and exit cleanly; the parent task will resume after unpause.`,
-        summary: `Skipped: ${err.reason}`
-      };
+      return buildPauseUnavailableResult(err.reason);
     }
     throw err;
   }
-  const reviewerModelDesc = describeModel(session);
-  const reviewerModelMarker = `Reviewer using model: ${reviewerModelDesc}`;
-  reviewerLog.log(`${taskId}: reviewer using model ${reviewerModelDesc}`);
-  if (options.store && options.taskId) {
-    await options.store.logEntry(options.taskId, reviewerModelMarker);
-    await options.store.appendAgentLog(options.taskId, reviewerModelMarker, "text", void 0, "reviewer").catch(() => void 0);
-  }
-  options.onSessionCreated?.(session);
-  let reviewText = "";
-  session.subscribe((event) => {
-    if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
-      reviewText += event.assistantMessageEvent.delta;
-    }
-  });
   try {
-    await promptWithFallback(session, request2);
-    checkSessionError(session);
+    try {
+      await runReviewPrompt(session, request2);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      if (!isContextLimitError(errorMessage)) {
+        throw err;
+      }
+      const retryLogMessage = reviewType === "code" ? "code review hit context limit \u2014 retrying with compacted request" : `${reviewType} review hit context limit \u2014 retrying with compacted request`;
+      reviewerLog.warn(`${taskId}: ${retryLogMessage}`);
+      if (options.store && options.taskId) {
+        await options.store.logEntry(options.taskId, retryLogMessage).catch(() => void 0);
+      }
+      reviewText = "";
+      const reducedRequest = buildReducedReviewRequest(
+        taskId,
+        stepNumber,
+        stepName,
+        reviewType,
+        promptContent,
+        cwd,
+        baseline
+      );
+      try {
+        await runReviewPrompt(session, reducedRequest);
+      } catch (retryErr) {
+        if (!isReviewerSessionReuseError(retryErr)) {
+          throw retryErr;
+        }
+        endSession(session);
+        try {
+          session = await createReviewerSession();
+        } catch (recreateErr) {
+          if (recreateErr instanceof ReviewerPauseAbortError) {
+            return buildPauseUnavailableResult(recreateErr.reason);
+          }
+          throw recreateErr;
+        }
+        await runReviewPrompt(session, reducedRequest);
+      }
+    }
   } finally {
-    if (agentLogger) await agentLogger.flush();
-    session.dispose();
-    options.onSessionEnded?.(session);
+    if (agentLogger) {
+      await agentLogger.flush();
+    }
+    for (const activeSession of [...activeSessions]) {
+      endSession(activeSession);
+    }
   }
   const verdict = extractVerdict(reviewText);
   const summary = extractSummary(reviewText);
   return { verdict, review: reviewText, summary };
 }
+function isReviewerSessionReuseError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /prompt is in progress|session (?:is )?(?:closed|disposed|ended)|conversation already active/i.test(message);
+}
+function extractPromptSection(promptContent, sectionName) {
+  const heading = `## ${sectionName}`;
+  const start = promptContent.indexOf(heading);
+  if (start === -1) {
+    return "";
+  }
+  const afterHeading = start + heading.length;
+  const nextH2 = promptContent.indexOf("\n## ", afterHeading);
+  const nextH1 = promptContent.indexOf("\n# ", afterHeading);
+  const endCandidates = [nextH2, nextH1].filter((value) => value !== -1);
+  const end = endCandidates.length > 0 ? Math.min(...endCandidates) : promptContent.length;
+  return promptContent.slice(start, end).trim();
+}
+function summarizePromptSteps(promptContent) {
+  const stepTitles = Array.from(promptContent.matchAll(/^### Step \d+:.*$/gm), (match) => match[0].trim());
+  if (stepTitles.length === 0) {
+    return "";
+  }
+  return ["## Steps", ...stepTitles].join("\n");
+}
+function buildReducedTaskPromptSummary(promptContent) {
+  const firstSectionIndex = promptContent.indexOf("\n## ");
+  const header = (firstSectionIndex === -1 ? promptContent : promptContent.slice(0, firstSectionIndex)).trim();
+  const sections = [
+    header,
+    extractPromptSection(promptContent, "Mission"),
+    extractPromptSection(promptContent, "Dependencies"),
+    extractPromptSection(promptContent, "File Scope"),
+    summarizePromptSteps(promptContent),
+    "_... additional PROMPT.md sections omitted after context-limit retry ..._"
+  ].filter(Boolean);
+  return sections.join("\n\n").trim();
+}
+function buildReducedReviewRequest(taskId, stepNumber, stepName, reviewType, promptContent, cwd, baseline) {
+  return buildReviewRequest(
+    taskId,
+    stepNumber,
+    stepName,
+    reviewType,
+    buildReducedTaskPromptSummary(promptContent),
+    cwd,
+    baseline,
+    void 0
+  );
+}
 function buildReviewRequest(taskId, stepNumber, stepName, reviewType, promptContent, cwd, baseline, userComments) {
   const parts = [
     `Review request for task ${taskId}, Step ${stepNumber}: ${stepName}`,
@@ -67568,6 +68233,7 @@ var init_reviewer = __esm({
     "use strict";
     init_src();
     init_pi();
+    init_context_limit_detector();
     init_agent_session_helpers();
     init_session_skill_context();
     init_agent_logger();
@@ -69544,11 +70210,17 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
         const taskGetParams = Type2.Object({
           id: Type2.String({ description: "Task ID (e.g. KB-001)" })
         });
+        const taskCreatePriorityValues = ["low", "normal", "high", "urgent"];
         const taskCreateParams3 = Type2.Object({
           title: Type2.Optional(Type2.String({ description: "Short child task title" })),
           description: Type2.String({ description: "Child task description/mission" }),
           dependencies: Type2.Optional(
             Type2.Array(Type2.String({ description: "Task ID dependency (e.g. KB-001)" }))
+          ),
+          priority: Type2.Optional(
+            Type2.Union(taskCreatePriorityValues.map((priority) => Type2.Literal(priority)), {
+              description: "Task priority (low, normal, high, urgent)"
+            })
           )
         });
         const taskList = {
@@ -69670,6 +70342,7 @@ Remove or replace these ids and call fn_task_create again.`
                 description: params.description,
                 dependencies: validDeps,
                 column: "triage",
+                priority: params.priority,
                 // Inherit parent's model settings if available
                 modelProvider: parentTask?.modelProvider,
                 modelId: parentTask?.modelId,
@@ -70485,11 +71158,146 @@ var init_run_audit = __esm({
   }
 });
 
-// ../engine/src/merger.ts
-import { execSync, exec as exec3, execFile as execFile3 } from "node:child_process";
+// ../engine/src/merger-squash-audit.ts
+import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
+async function auditSquashMerge({
+  rootDir,
+  squashSha,
+  lookback = DEFAULT_LOOKBACK
+}) {
+  const normalizedLookback = normalizeLookback(lookback);
+  const parentSha = await git(rootDir, ["rev-parse", `${squashSha}^`]);
+  const squashSubject = await git(rootDir, ["log", "-1", "--format=%s", squashSha]);
+  const branchSubjects = normalizeLines(await git(rootDir, ["log", "-1", "--format=%b", squashSha])).map((line) => line.replace(/^- /, "").trim()).filter(Boolean);
+  const recentMainCommits = await listRecentMainCommits(rootDir, parentSha, normalizedLookback);
+  const recentMainSubjects = recentMainCommits.map((entry) => entry.subject);
+  const duplicateSubjects = branchSubjects.filter((subject) => recentMainSubjects.includes(subject)).map((subject) => ({ type: "duplicate-subject", subject }));
+  const touchedFiles = normalizeLines(await git(rootDir, ["diff", "--name-only", parentSha, squashSha]));
+  const touchedFileOverlaps = [];
+  for (const file of touchedFiles) {
+    const overlappingCommits = [];
+    for (const commit of recentMainCommits) {
+      const touchedInCommit = await git(rootDir, ["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha, "--", file]);
+      if (normalizeLines(touchedInCommit).includes(file)) {
+        overlappingCommits.push({ sha: commit.shortSha, subject: commit.subject });
+      }
+    }
+    if (overlappingCommits.length > 0) {
+      touchedFileOverlaps.push({
+        type: "touched-file-overlap",
+        file,
+        recentMainCommits: overlappingCommits
+      });
+    }
+  }
+  const findings = [...duplicateSubjects, ...touchedFileOverlaps];
+  return {
+    squashSha,
+    parentSha,
+    squashSubject,
+    lookback: normalizedLookback,
+    branchSubjects,
+    recentMainSubjects,
+    duplicateSubjects,
+    touchedFiles,
+    touchedFileOverlaps,
+    findings,
+    issueCount: findings.length,
+    clean: findings.length === 0
+  };
+}
+function formatSquashAuditReport(findings) {
+  const lines = [
+    `Auditing squash: ${findings.squashSha} \u2014 ${findings.squashSubject}`,
+    `Parent (main before squash): ${findings.parentSha}`,
+    `Lookback window on main: ${findings.lookback} commits`,
+    "",
+    "=== Duplicate-cherry-pick risk ==="
+  ];
+  if (findings.duplicateSubjects.length === 0) {
+    lines.push("(none \u2014 no branch commit subjects match recent main commits)", "");
+  } else {
+    lines.push(
+      "WARN: branch contains commits whose subjects match recent main commits.",
+      "Auto-resolve may have picked the older side, dropping refinements.",
+      "Action: diff each main commit below against HEAD and confirm its",
+      "net contribution survived. Restore anything dropped as a follow-up.",
+      "",
+      ...findings.duplicateSubjects.map((entry) => `  - ${entry.subject}`),
+      ""
+    );
+  }
+  lines.push(`=== Touched-file overlap (${findings.touchedFiles.length} files in squash) ===`);
+  if (findings.touchedFileOverlaps.length === 0) {
+    lines.push("(none \u2014 squash touches files no recent main commit touched)", "");
+  } else {
+    lines.push(
+      "Files the squash touched that also have recent main activity.",
+      "Action: for each commit below, verify its changes still appear",
+      "in HEAD. Reapply any silently dropped changes on the same branch.",
+      ""
+    );
+    for (const overlap of findings.touchedFileOverlaps) {
+      lines.push(`  ${overlap.file}`);
+      for (const commit of overlap.recentMainCommits) {
+        lines.push(`    - ${commit.sha}  ${commit.subject}`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push(`Audit complete. ${findings.issueCount} item(s) for the calling agent to review.`);
+  return lines.join("\n");
+}
+async function git(rootDir, args) {
+  const { stdout } = await execFileAsync("git", args, {
+    cwd: rootDir,
+    encoding: "utf-8",
+    maxBuffer: GIT_OUTPUT_MAX_BUFFER
+  });
+  return stdout.trim();
+}
+function normalizeLines(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return [];
+  return trimmed.split("\n").map((line) => line.trim()).filter(Boolean);
+}
+async function listRecentMainCommits(rootDir, parentSha, lookback) {
+  const entries = normalizeLines(await git(rootDir, ["log", `--format=%H~%h~%s`, `-n`, String(lookback), parentSha]));
+  return entries.map((entry) => {
+    const [sha, shortSha, ...subjectParts] = entry.split("~");
+    const subject = subjectParts.join("~").trim();
+    if (!sha?.trim() || !shortSha?.trim() || !subject) {
+      return null;
+    }
+    return {
+      sha: sha.trim(),
+      shortSha: shortSha.trim(),
+      subject
+    };
+  }).filter((entry) => entry !== null);
+}
+function normalizeLookback(value) {
+  if (!Number.isFinite(value) || !value || value < 1) {
+    return DEFAULT_LOOKBACK;
+  }
+  return Math.trunc(value);
+}
+var execFileAsync, DEFAULT_LOOKBACK, GIT_OUTPUT_MAX_BUFFER;
+var init_merger_squash_audit = __esm({
+  "../engine/src/merger-squash-audit.ts"() {
+    "use strict";
+    execFileAsync = promisify4(execFile3);
+    DEFAULT_LOOKBACK = 30;
+    GIT_OUTPUT_MAX_BUFFER = 10 * 1024 * 1024;
+  }
+});
+
+// ../engine/src/merger.ts
+import { execSync, exec as exec3, execFile as execFile4 } from "node:child_process";
+import { promisify as promisify5 } from "node:util";
 import { existsSync as existsSync25, readFileSync as readFileSync11, writeFileSync as writeFileSync2, unlinkSync, renameSync as renameSync2 } from "node:fs";
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 import { join as join32 } from "node:path";
 import { hostname } from "node:os";
 import { Type as Type3 } from "typebox";
@@ -70558,7 +71366,7 @@ function computeLockfileHash(rootDir) {
     const p = join32(rootDir, name);
     if (existsSync25(p)) {
       try {
-        return createHash6("sha256").update(readFileSync11(p)).digest("hex");
+        return createHash7("sha256").update(readFileSync11(p)).digest("hex");
       } catch {
         return null;
       }
@@ -70616,8 +71424,8 @@ function commitOwnedByTask(taskId, subject, body) {
 async function findOwnedLandedCommitForTask(rootDir, task) {
   const tryHydrate = async (sha) => {
     try {
-      await execFileAsync("git", ["merge-base", "--is-ancestor", sha, "HEAD"], { cwd: rootDir });
-      const { stdout } = await execFileAsync("git", ["log", "-1", "--format=%H%x1f%s%x1f%b", sha], {
+      await execFileAsync2("git", ["merge-base", "--is-ancestor", sha, "HEAD"], { cwd: rootDir });
+      const { stdout } = await execFileAsync2("git", ["log", "-1", "--format=%H%x1f%s%x1f%b", sha], {
         cwd: rootDir,
         encoding: "utf-8"
       });
@@ -70625,7 +71433,7 @@ async function findOwnedLandedCommitForTask(rootDir, task) {
       if (!resolvedSha || !commitOwnedByTask(task.id, subject, body)) return null;
       const owned = { sha: resolvedSha, subject };
       try {
-        const { stdout: statsOut } = await execFileAsync("git", ["show", "--shortstat", "--format=", resolvedSha], {
+        const { stdout: statsOut } = await execFileAsync2("git", ["show", "--shortstat", "--format=", resolvedSha], {
           cwd: rootDir,
           encoding: "utf-8"
         });
@@ -70648,7 +71456,7 @@ async function findOwnedLandedCommitForTask(rootDir, task) {
   ];
   for (const args of searches) {
     try {
-      const { stdout } = await execFileAsync("git", args, { cwd: rootDir, encoding: "utf-8" });
+      const { stdout } = await execFileAsync2("git", args, { cwd: rootDir, encoding: "utf-8" });
       const first = stdout.trim().split("\n").find(Boolean);
       if (!first) continue;
       const [sha] = first.split("");
@@ -70711,15 +71519,15 @@ async function snapshotDirtyFiles(rootDir) {
   const paths = /* @__PURE__ */ new Set();
   try {
     const [unstagedOut, stagedOut, porcelainOut] = await Promise.all([
-      execFileAsync("git", ["diff", "-z", "--name-only"], { cwd: rootDir, encoding: "utf-8" }).then(
+      execFileAsync2("git", ["diff", "-z", "--name-only"], { cwd: rootDir, encoding: "utf-8" }).then(
         (r) => r.stdout,
         () => ""
       ),
-      execFileAsync("git", ["diff", "-z", "--cached", "--name-only"], { cwd: rootDir, encoding: "utf-8" }).then(
+      execFileAsync2("git", ["diff", "-z", "--cached", "--name-only"], { cwd: rootDir, encoding: "utf-8" }).then(
         (r) => r.stdout,
         () => ""
       ),
-      execFileAsync("git", ["status", "-z", "--porcelain"], { cwd: rootDir, encoding: "utf-8" }).then(
+      execFileAsync2("git", ["status", "-z", "--porcelain"], { cwd: rootDir, encoding: "utf-8" }).then(
         (r) => r.stdout,
         () => ""
       )
@@ -70744,18 +71552,18 @@ async function snapshotDirtyFiles(rootDir) {
 async function gitDirtyFingerprint(rootDir) {
   try {
     const [diffOut, statusOut] = await Promise.all([
-      execFileAsync("git", ["diff", "HEAD"], {
+      execFileAsync2("git", ["diff", "HEAD"], {
         cwd: rootDir,
         encoding: "utf-8",
         maxBuffer: 64 * 1024 * 1024
       }).then((r) => r.stdout, () => ""),
-      execFileAsync("git", ["status", "-z", "--porcelain"], { cwd: rootDir, encoding: "utf-8" }).then(
+      execFileAsync2("git", ["status", "-z", "--porcelain"], { cwd: rootDir, encoding: "utf-8" }).then(
         (r) => r.stdout,
         () => ""
       )
     ]);
     if (!diffOut && !statusOut) return "";
-    return createHash6("sha256").update(diffOut).update("\0").update(statusOut).digest("hex");
+    return createHash7("sha256").update(diffOut).update("\0").update(statusOut).digest("hex");
   } catch {
     return "";
   }
@@ -72434,7 +73242,7 @@ async function commitOrAmendMergeWithFixes(rootDir, taskId, branch, commitLog, i
       encoding: "utf-8"
     });
     const unstaged = new Set(unstagedOut.split("\n").map((l) => l.trim()).filter(Boolean));
-    const { stdout: porcelainOut } = await execFileAsync("git", ["status", "-z", "--porcelain"], {
+    const { stdout: porcelainOut } = await execFileAsync2("git", ["status", "-z", "--porcelain"], {
       cwd: rootDir,
       encoding: "utf-8"
     });
@@ -72455,7 +73263,7 @@ async function commitOrAmendMergeWithFixes(rootDir, taskId, branch, commitLog, i
       }
     }
     if (unstagedToStage.length > 0) {
-      await execFileAsync("git", ["add", "--", ...unstagedToStage], { cwd: rootDir });
+      await execFileAsync2("git", ["add", "--", ...unstagedToStage], { cwd: rootDir });
     }
     const untrackedToStage = [];
     for (const p of untracked) {
@@ -72468,7 +73276,7 @@ async function commitOrAmendMergeWithFixes(rootDir, taskId, branch, commitLog, i
       }
     }
     if (untrackedToStage.length > 0) {
-      await execFileAsync("git", ["add", "--", ...untrackedToStage], { cwd: rootDir });
+      await execFileAsync2("git", ["add", "--", ...untrackedToStage], { cwd: rootDir });
     }
     const cap = (arr, n = 20) => arr.length <= n ? arr.join(", ") : `${arr.slice(0, n).join(", ")} ... (+${arr.length - n} more)`;
     mergerLog.log(
@@ -72971,8 +73779,8 @@ async function classifyConflict(filePath, cwd) {
 }
 async function resolveWithOurs(filePath, cwd) {
   try {
-    await execFileAsync("git", ["checkout", "--ours", "--", filePath], { cwd });
-    await execFileAsync("git", ["add", "--", filePath], { cwd });
+    await execFileAsync2("git", ["checkout", "--ours", "--", filePath], { cwd });
+    await execFileAsync2("git", ["add", "--", filePath], { cwd });
     mergerLog.log(`Auto-resolved ${filePath} using --ours`);
   } catch (error) {
     throw new Error(`Failed to auto-resolve ${filePath} with ours: ${error}`);
@@ -72980,8 +73788,8 @@ async function resolveWithOurs(filePath, cwd) {
 }
 async function resolveWithTheirs(filePath, cwd) {
   try {
-    await execFileAsync("git", ["checkout", "--theirs", "--", filePath], { cwd });
-    await execFileAsync("git", ["add", "--", filePath], { cwd });
+    await execFileAsync2("git", ["checkout", "--theirs", "--", filePath], { cwd });
+    await execFileAsync2("git", ["add", "--", filePath], { cwd });
     mergerLog.log(`Auto-resolved ${filePath} using --theirs`);
   } catch (error) {
     throw new Error(`Failed to auto-resolve ${filePath} with theirs: ${error}`);
@@ -72989,7 +73797,7 @@ async function resolveWithTheirs(filePath, cwd) {
 }
 async function resolveTrivialWhitespace(filePath, cwd) {
   try {
-    await execFileAsync("git", ["add", "--", filePath], { cwd });
+    await execFileAsync2("git", ["add", "--", filePath], { cwd });
     mergerLog.log(`Auto-resolved ${filePath} (trivial whitespace)`);
   } catch (error) {
     throw new Error(`Failed to auto-resolve ${filePath} trivial conflict: ${error}`);
@@ -73183,6 +73991,43 @@ async function findWorktreeUser(store, worktreePath, excludeTaskId) {
 function quoteArg(value) {
   return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
 }
+function shouldRunPostSquashAudit(result, mergeWasEmpty, isEmptyCommit, commitSha) {
+  if (mergeWasEmpty || isEmptyCommit || !commitSha) {
+    return false;
+  }
+  return (result.autoResolvedCount ?? 0) > 0 || result.attemptsMade === 3;
+}
+function buildSquashAuditBlockingMessage(taskId, squashSha, findings) {
+  const riskParts = [];
+  if (findings.duplicateSubjects.length > 0) {
+    riskParts.push(`${findings.duplicateSubjects.length} duplicate-subject risk${findings.duplicateSubjects.length === 1 ? "" : "s"}`);
+  }
+  if (findings.touchedFileOverlaps.length > 0) {
+    riskParts.push(`${findings.touchedFileOverlaps.length} touched-file overlap risk${findings.touchedFileOverlaps.length === 1 ? "" : "s"}`);
+  }
+  const summary = riskParts.length > 0 ? riskParts.join(", ") : `${findings.issueCount} audit finding(s)`;
+  return `${taskId}: post-squash audit blocked auto-completion for ${squashSha.slice(0, 8)} (${summary})`;
+}
+function formatSquashAuditAgentLog(findings) {
+  const lines = [];
+  if (findings.duplicateSubjects.length > 0) {
+    lines.push("Duplicate-subject risks:");
+    for (const duplicate of findings.duplicateSubjects) {
+      lines.push(`- ${duplicate.subject}`);
+    }
+  }
+  if (findings.touchedFileOverlaps.length > 0) {
+    if (lines.length > 0) lines.push("");
+    lines.push("Touched-file overlap risks:");
+    for (const overlap of findings.touchedFileOverlaps) {
+      lines.push(`- ${overlap.file}`);
+      for (const commit of overlap.recentMainCommits) {
+        lines.push(`  - ${commit.sha} ${commit.subject}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
 async function resolveSafeCommitBody(opts) {
   const cleanLog = opts.commitLog.trim();
   if (cleanLog.length > 0) return cleanLog;
@@ -74514,6 +75359,26 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
       }
       const isEmptyCommit = filesChanged === 0;
       const recordedSha = isEmptyCommit || mergeWasEmpty ? void 0 : commitSha;
+      const auditSha = recordedSha;
+      if (auditSha && shouldRunPostSquashAudit(result, mergeWasEmpty, isEmptyCommit, auditSha)) {
+        const auditFindings = await auditSquashMerge({
+          rootDir,
+          squashSha: auditSha
+        });
+        if (!auditFindings.clean) {
+          const auditError = new SquashAuditError(taskId, auditSha, auditFindings);
+          await store.appendAgentLog(
+            taskId,
+            auditError.message,
+            "tool_error",
+            formatSquashAuditAgentLog(auditFindings),
+            "merger"
+          );
+          await store.updateTask(taskId, { status: null });
+          throw auditError;
+        }
+        await store.appendAgentLog(taskId, "post-squash audit clean", "text", void 0, "merger");
+      }
       if (isEmptyCommit) {
         mergerLog.warn(
           `${taskId}: local squash produced an empty commit (${commitSha?.slice(0, 8)}) \u2014 branch likely contained dupes of main. Skipping commitSha; recovery will backfill when real commit lands.`
@@ -74578,6 +75443,9 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
         "merger"
       );
     } catch (err) {
+      if (err instanceof SquashAuditError || err?.name === "SquashAuditError") {
+        throw err;
+      }
       mergerLog.warn(`${taskId}: failed to collect/store merge details: ${err.message}`);
     }
     try {
@@ -75813,7 +76681,7 @@ async function completeTask(store, taskId, result) {
   result.task = task;
   store.emit("task:merged", result);
 }
-var execAsync2, execFileAsync, LOCKFILE_PATTERNS, GENERATED_PATTERNS, DEPENDENCY_SYNC_TRIGGER_PATTERNS, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS, PULL_REBASE_TIMEOUT_MS, PUSH_TIMEOUT_MS, MERGE_COMMIT_LOG_MAX_CHARS, MERGE_DIFF_STAT_MAX_CHARS, INSTALL_MARKER_RELPATH, LOCKFILE_CANDIDATES, VerificationError, MergeAbortedError, VERIFICATION_EXTRA_ENV, AUTOSTASH_LABEL_PREFIX, AUTOSTASH_TIMESTAMP_RE, ACTIVE_MERGER_STATUS_FILENAME, FUSION_TASK_ID_TRAILER_KEY;
+var execAsync2, execFileAsync2, LOCKFILE_PATTERNS, GENERATED_PATTERNS, DEPENDENCY_SYNC_TRIGGER_PATTERNS, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS, PULL_REBASE_TIMEOUT_MS, PUSH_TIMEOUT_MS, MERGE_COMMIT_LOG_MAX_CHARS, MERGE_DIFF_STAT_MAX_CHARS, INSTALL_MARKER_RELPATH, LOCKFILE_CANDIDATES, VerificationError, MergeAbortedError, SquashAuditError, VERIFICATION_EXTRA_ENV, AUTOSTASH_LABEL_PREFIX, AUTOSTASH_TIMESTAMP_RE, ACTIVE_MERGER_STATUS_FILENAME, FUSION_TASK_ID_TRAILER_KEY;
 var init_merger = __esm({
   "../engine/src/merger.ts"() {
     "use strict";
@@ -75833,8 +76701,9 @@ var init_merger = __esm({
     init_agent_instructions();
     init_run_audit();
     init_agent_tools();
-    execAsync2 = promisify4(exec3);
-    execFileAsync = promisify4(execFile3);
+    init_merger_squash_audit();
+    execAsync2 = promisify5(exec3);
+    execFileAsync2 = promisify5(execFile4);
     LOCKFILE_PATTERNS = [
       "package-lock.json",
       "pnpm-lock.yaml",
@@ -75891,6 +76760,14 @@ var init_merger = __esm({
         this.name = "MergeAbortedError";
       }
     };
+    SquashAuditError = class extends Error {
+      constructor(taskId, squashSha, findings) {
+        super(buildSquashAuditBlockingMessage(taskId, squashSha, findings));
+        this.squashSha = squashSha;
+        this.findings = findings;
+        this.name = "SquashAuditError";
+      }
+    };
     VERIFICATION_EXTRA_ENV = Object.fromEntries(
       [
         ["FUSION_TEST_TOTAL_WORKERS", "8"],
@@ -76092,7 +76969,7 @@ __export(worktree_pool_exports, {
   scanOrphanedBranches: () => scanOrphanedBranches
 });
 import { exec as exec4 } from "node:child_process";
-import { promisify as promisify5 } from "node:util";
+import { promisify as promisify6 } from "node:util";
 import { existsSync as existsSync27, lstatSync, readdirSync as readdirSync4, rmSync as rmSync2 } from "node:fs";
 import { join as join34, relative as relative8, resolve as resolve18, isAbsolute as isAbsolute10 } from "node:path";
 function getExecStdout(result) {
@@ -76303,7 +77180,7 @@ var init_worktree_pool = __esm({
   "../engine/src/worktree-pool.ts"() {
     "use strict";
     init_logger2();
-    execAsync3 = promisify5(exec4);
+    execAsync3 = promisify6(exec4);
     WorktreePool = class {
       idle = /* @__PURE__ */ new Set();
       /**
@@ -76495,7 +77372,7 @@ var init_token_cap_detector = __esm({
 
 // ../engine/src/step-session-executor.ts
 import { exec as exec5 } from "node:child_process";
-import { promisify as promisify6 } from "node:util";
+import { promisify as promisify7 } from "node:util";
 import { existsSync as existsSync28 } from "node:fs";
 import { join as join35 } from "node:path";
 function parseStepFileScopes(prompt) {
@@ -76758,7 +77635,7 @@ var init_step_session_executor = __esm({
     init_context_limit_detector();
     init_usage_limit_detector();
     init_agent_tools();
-    execAsync4 = promisify6(exec5);
+    execAsync4 = promisify7(exec5);
     stepExecLog = createLogger2("step-session-executor");
     MAX_STEP_RETRIES = 3;
     RETRY_DELAYS_MS = [1e3, 5e3, 15e3];
@@ -77412,7 +78289,9 @@ async function hydrateWorktreeDb({
       ensureWorktreeSchema(worktreePath);
     }
     srcDb = new DatabaseSync(srcDbPath);
+    srcDb.exec("PRAGMA busy_timeout = 5000");
     dstDb = openWorktreeDbWithRecovery(dstDbPath, worktreePath);
+    dstDb.exec("PRAGMA busy_timeout = 5000");
     dstDb.exec("PRAGMA journal_mode = WAL");
     const srcTaskCols = getColumns(srcDb, "tasks");
     const dstTaskCols = getColumns(dstDb, "tasks");
@@ -77861,12 +78740,120 @@ var init_run_verification_tool = __esm({
 
 // ../engine/src/executor.ts
 import { exec as exec6 } from "node:child_process";
-import { promisify as promisify7 } from "node:util";
+import { promisify as promisify8 } from "node:util";
 import { delimiter, isAbsolute as isAbsolute12, join as join39, relative as relative9, resolve as resolvePath } from "node:path";
 import { existsSync as existsSync31 } from "node:fs";
 import { readFile as readFile17, writeFile as writeFile13 } from "node:fs/promises";
 import { Type as Type5 } from "@mariozechner/pi-ai";
 import { ModelRegistry as ModelRegistry2, SessionManager as SessionManager2 } from "@mariozechner/pi-coding-agent";
+function normalizeWorkflowScopePath(pathValue) {
+  return pathValue.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/").replace(/\/$/, "");
+}
+function stripTrailingPathPunctuation(pathValue) {
+  return pathValue.replace(/[),.:;!?]+$/g, "");
+}
+function extractReferencedPathsFromWorkflowFeedback(feedback) {
+  const extracted = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of feedback.matchAll(WORKFLOW_FEEDBACK_PATH_REGEX)) {
+    const candidate = stripTrailingPathPunctuation(match[1] ?? match[2] ?? "");
+    const normalized = normalizeWorkflowScopePath(candidate);
+    if (!normalized.includes("/") || !normalized) continue;
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    extracted.push(normalized);
+  }
+  return extracted;
+}
+function workflowPathMatchesDeclaredScope(filePath, scopePatterns) {
+  const normalizedPath = normalizeWorkflowScopePath(filePath);
+  for (const rawPattern of scopePatterns) {
+    const pattern = normalizeWorkflowScopePath(rawPattern);
+    if (!pattern) continue;
+    if (/\/\*+$/.test(pattern)) {
+      const directory = pattern.replace(/\/\*+$/, "");
+      if (normalizedPath === directory || normalizedPath.startsWith(`${directory}/`)) return true;
+      continue;
+    }
+    if (pattern.endsWith("/")) {
+      if (normalizedPath.startsWith(pattern)) return true;
+      continue;
+    }
+    if (normalizedPath === pattern) return true;
+  }
+  return false;
+}
+function partitionWorkflowRevisionFeedback(feedback, declaredFileScope) {
+  const trimmedFeedback = feedback.trim();
+  if (!trimmedFeedback || declaredFileScope.length === 0) {
+    return {
+      inScopeFeedback: trimmedFeedback,
+      outOfScopeFeedback: "",
+      inScopeSegments: trimmedFeedback ? [trimmedFeedback] : [],
+      outOfScopeSegments: [],
+      detectedPaths: extractReferencedPathsFromWorkflowFeedback(trimmedFeedback)
+    };
+  }
+  const segments = trimmedFeedback.split(/\n\s*\n/).map((segment) => segment.trim()).filter(Boolean);
+  const allDetectedPaths = extractReferencedPathsFromWorkflowFeedback(trimmedFeedback);
+  if (allDetectedPaths.length === 0) {
+    return {
+      inScopeFeedback: trimmedFeedback,
+      outOfScopeFeedback: "",
+      inScopeSegments: trimmedFeedback ? [trimmedFeedback] : [],
+      outOfScopeSegments: [],
+      detectedPaths: []
+    };
+  }
+  const inScopeSegments = [];
+  const outOfScopeSegments = [];
+  for (const segment of segments) {
+    const segmentPaths = extractReferencedPathsFromWorkflowFeedback(segment);
+    if (segmentPaths.length === 0) {
+      inScopeSegments.push(segment);
+      continue;
+    }
+    const hasOutOfScopePath = segmentPaths.some((path2) => !workflowPathMatchesDeclaredScope(path2, declaredFileScope));
+    if (hasOutOfScopePath) {
+      outOfScopeSegments.push(segment);
+    } else {
+      inScopeSegments.push(segment);
+    }
+  }
+  return {
+    inScopeFeedback: inScopeSegments.join("\n\n"),
+    outOfScopeFeedback: outOfScopeSegments.join("\n\n"),
+    inScopeSegments,
+    outOfScopeSegments,
+    detectedPaths: allDetectedPaths
+  };
+}
+function normalizeWorktreePath(pathValue) {
+  return resolvePath(pathValue).replace(/\\/g, "/").replace(/\/+$/, "");
+}
+async function extractPersistedSessionWorktreePath(sessionFile) {
+  try {
+    const content = await readFile17(sessionFile, "utf-8");
+    const matches = content.match(SESSION_WORKTREE_PATH_REGEX) ?? [];
+    if (matches.length === 0) return null;
+    const normalizedCounts = /* @__PURE__ */ new Map();
+    for (const match of matches) {
+      const normalized = normalizeWorktreePath(match);
+      normalizedCounts.set(normalized, (normalizedCounts.get(normalized) ?? 0) + 1);
+    }
+    let best = null;
+    for (const [path2, count] of normalizedCounts.entries()) {
+      if (!best || count > best.count) best = { path: path2, count };
+    }
+    return best?.path ?? null;
+  } catch {
+    return null;
+  }
+}
+function isSessionWorktreeCompatible(persistedWorktreePath, currentWorktreePath) {
+  if (!persistedWorktreePath) return true;
+  return persistedWorktreePath === normalizeWorktreePath(currentWorktreePath);
+}
 function truncateWorkflowScriptOutput2(output) {
   if (output.length <= WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2) return output;
   return `... output truncated to last ${WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2} characters ...
@@ -78146,7 +79133,7 @@ function detectReviewHandoffIntent(commentText) {
   ];
   return handoffPhrases.some((phrase) => text.includes(phrase));
 }
-var execAsync5, STEP_STATUSES, MAX_WORKFLOW_STEP_RETRIES, MAX_TASK_DONE_SESSION_RETRIES, MAX_TASK_DONE_REQUEUE_RETRIES, COMPLETED_TASK_WATCHDOG_MS, WORKFLOW_RERUN_WATCHDOG_MS, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2, NonRetryableWorktreeError, taskUpdateParams, taskAddDepParams, spawnAgentParams, reviewStepParams, EXECUTOR_SYSTEM_PROMPT, TaskExecutor;
+var execAsync5, STEP_STATUSES, MAX_WORKFLOW_STEP_RETRIES, MAX_TASK_DONE_SESSION_RETRIES, MAX_TASK_DONE_REQUEUE_RETRIES, COMPLETED_TASK_WATCHDOG_MS, WORKFLOW_RERUN_WATCHDOG_MS, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2, WORKFLOW_FEEDBACK_PATH_REGEX, NonRetryableWorktreeError, SESSION_WORKTREE_PATH_REGEX, taskUpdateParams, taskAddDepParams, spawnAgentParams, reviewStepParams, EXECUTOR_SYSTEM_PROMPT, TaskExecutor;
 var init_executor = __esm({
   "../engine/src/executor.ts"() {
     "use strict";
@@ -78183,7 +79170,7 @@ var init_executor = __esm({
     init_fallback_model_observer();
     init_agent_logger();
     init_agent_tools();
-    execAsync5 = promisify7(exec6);
+    execAsync5 = promisify8(exec6);
     STEP_STATUSES = ["pending", "in-progress", "done", "skipped"];
     MAX_WORKFLOW_STEP_RETRIES = 3;
     MAX_TASK_DONE_SESSION_RETRIES = 3;
@@ -78191,8 +79178,10 @@ var init_executor = __esm({
     COMPLETED_TASK_WATCHDOG_MS = 6e4;
     WORKFLOW_RERUN_WATCHDOG_MS = 15e3;
     WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2 = 4e3;
+    WORKFLOW_FEEDBACK_PATH_REGEX = /`([^`\n]+)`|(?<![A-Za-z0-9_.-])((?:\.\.?\/)?(?:@?[A-Za-z0-9._-]+\/)+[A-Za-z0-9._-]+(?:\.[A-Za-z0-9._-]+)?)/g;
     NonRetryableWorktreeError = class extends Error {
     };
+    SESSION_WORKTREE_PATH_REGEX = /([A-Za-z]:)?[^"'\s]*\.worktrees[\\/][^"'\s]+/g;
     taskUpdateParams = Type5.Object({
       step: Type5.Number({ description: "Step number (1-indexed)" }),
       status: Type5.Union(
@@ -80266,15 +81255,18 @@ ${summary}`,
                   }
                   if (!workflowResult.allPassed) {
                     if (workflowResult.revisionRequested) {
-                      await this.handleWorkflowRevisionRequest(task, worktreePath, workflowResult.feedback, workflowResult.stepName);
-                      return;
-                    }
-                    const retried = await this.handleWorkflowStepFailure(task, worktreePath, workflowResult.feedback, workflowResult.stepName || "Unknown");
-                    if (retried) {
+                      const rerunScheduled = await this.handleWorkflowRevisionRequest(task, worktreePath, workflowResult.feedback, workflowResult.stepName, settings);
+                      if (rerunScheduled) {
+                        return;
+                      }
+                    } else {
+                      const retried = await this.handleWorkflowStepFailure(task, worktreePath, workflowResult.feedback, workflowResult.stepName || "Unknown");
+                      if (retried) {
+                        return;
+                      }
+                      await this.sendTaskBackForFix(task, worktreePath, workflowResult.feedback, workflowResult.stepName || "Unknown", "Workflow step failed");
                       return;
                     }
-                    await this.sendTaskBackForFix(task, worktreePath, workflowResult.feedback, workflowResult.stepName || "Unknown", "Workflow step failed");
-                    return;
                   }
                 } else {
                   executorLog.log(`${task.id}: fast mode \u2014 skipping pre-merge workflow steps`);
@@ -80530,7 +81522,23 @@ ${summary}`,
             const executorFallbackProvider = settings.fallbackProvider;
             const executorFallbackModelId = settings.fallbackModelId;
             const executorThinkingLevel = detail.thinkingLevel ?? settings.defaultThinkingLevel;
-            const isResuming = !!task.sessionFile && existsSync31(task.sessionFile);
+            let isResuming = !!task.sessionFile && existsSync31(task.sessionFile);
+            if (isResuming) {
+              const persistedWorktreePath = await extractPersistedSessionWorktreePath(task.sessionFile);
+              if (!isSessionWorktreeCompatible(persistedWorktreePath, worktreePath)) {
+                executorLog.warn(
+                  `${task.id}: stale sessionFile worktree mismatch (session=${persistedWorktreePath}, task=${worktreePath}); starting fresh session`
+                );
+                await this.store.logEntry(
+                  task.id,
+                  `Detected stale persisted session metadata (worktree mismatch: ${persistedWorktreePath} vs ${worktreePath}) \u2014 discarded resume state and started fresh session`,
+                  void 0,
+                  this.currentRunContext
+                );
+                await this.store.updateTask(task.id, { sessionFile: null });
+                isResuming = false;
+              }
+            }
             const sessionManager = isResuming ? SessionManager2.open(task.sessionFile) : SessionManager2.create(worktreePath);
             executorLog.log(`${task.id}: creating agent session (provider=${executorProvider ?? "default"}, model=${executorModelId ?? "default"}, resuming=${isResuming})`);
             const executorInstructions = await this.resolveInstructionsForRole("executor");
@@ -80760,15 +81768,18 @@ ${summary}`,
                   }
                   if (!workflowResult.allPassed) {
                     if (workflowResult.revisionRequested) {
-                      await this.handleWorkflowRevisionRequest(task, worktreePath, workflowResult.feedback, workflowResult.stepName);
-                      return;
-                    }
-                    const retried = await this.handleWorkflowStepFailure(task, worktreePath, workflowResult.feedback, workflowResult.stepName || "Unknown");
-                    if (retried) {
+                      const rerunScheduled = await this.handleWorkflowRevisionRequest(task, worktreePath, workflowResult.feedback, workflowResult.stepName, settings);
+                      if (rerunScheduled) {
+                        return;
+                      }
+                    } else {
+                      const retried = await this.handleWorkflowStepFailure(task, worktreePath, workflowResult.feedback, workflowResult.stepName || "Unknown");
+                      if (retried) {
+                        return;
+                      }
+                      await this.sendTaskBackForFix(task, worktreePath, workflowResult.feedback, workflowResult.stepName || "Unknown", "Workflow step failed");
                       return;
                     }
-                    await this.sendTaskBackForFix(task, worktreePath, workflowResult.feedback, workflowResult.stepName || "Unknown", "Workflow step failed");
-                    return;
                   }
                 } else {
                   executorLog.log(`${task.id}: fast mode \u2014 skipping pre-merge workflow steps`);
@@ -80928,11 +81939,14 @@ ${summary}`,
                     }
                     if (!workflowResult.allPassed) {
                       if (workflowResult.revisionRequested) {
-                        await this.handleWorkflowRevisionRequest(task, worktreePath, workflowResult.feedback, workflowResult.stepName);
+                        const rerunScheduled = await this.handleWorkflowRevisionRequest(task, worktreePath, workflowResult.feedback, workflowResult.stepName, settings);
+                        if (rerunScheduled) {
+                          return;
+                        }
+                      } else {
+                        await this.sendTaskBackForFix(task, worktreePath, workflowResult.feedback, workflowResult.stepName || "Unknown", "Workflow step failed on retry");
                         return;
                       }
-                      await this.sendTaskBackForFix(task, worktreePath, workflowResult.feedback, workflowResult.stepName || "Unknown", "Workflow step failed on retry");
-                      return;
                     }
                   } else {
                     executorLog.log(`${task.id}: fast mode \u2014 skipping pre-merge workflow steps`);
@@ -81732,18 +82746,38 @@ Take a different approach. Do NOT repeat the rejected strategy. Re-read the step
        * the injected feedback from PROMPT.md and applies an in-place fix rather
        * than redoing any completed step.
        */
-      async handleWorkflowRevisionRequest(task, worktreePath, feedback, stepName) {
+      async handleWorkflowRevisionRequest(task, worktreePath, feedback, stepName, settings) {
         executorLog.log(`${task.id}: workflow revision requested by step "${stepName}"`);
         this.clearCompletedTaskWatchdog(task.id);
+        const shouldForkOnScopeMismatch = settings.workflowRevisionForkOnScopeMismatch !== false;
+        let inScopeFeedback = feedback.trim();
+        let outOfScopeFeedback = "";
+        let followUpTaskId;
+        if (shouldForkOnScopeMismatch) {
+          const declaredFileScope = await this.store.parseFileScopeFromPrompt(task.id).catch(() => []);
+          const partition = partitionWorkflowRevisionFeedback(feedback, declaredFileScope);
+          inScopeFeedback = partition.inScopeFeedback;
+          outOfScopeFeedback = partition.outOfScopeFeedback;
+          if (outOfScopeFeedback) {
+            const followUpTask = await this.createWorkflowRevisionFollowUpTask(task, stepName, outOfScopeFeedback);
+            followUpTaskId = followUpTask.id;
+          }
+        }
+        if (!inScopeFeedback) {
+          await this.store.logEntry(
+            task.id,
+            followUpTaskId ? `Workflow step "${stepName}" requested revision \u2014 feedback forked to follow-up ${followUpTaskId}; original task left unchanged` : `Workflow step "${stepName}" requested revision \u2014 no in-scope feedback detected`,
+            outOfScopeFeedback || feedback,
+            this.currentRunContext
+          );
+          return false;
+        }
         const updatedTask = await this.store.getTask(task.id);
         const reopen = await this.reopenLastStepForRevision(task.id, updatedTask);
         const reopenSummary = reopen ? `re-opening Step ${reopen.index + 1} ("${reopen.name}") for in-place fix` : "no step to re-open (none were completed)";
-        await this.store.logEntry(
-          task.id,
-          `Workflow step "${stepName}" requested revision \u2014 ${reopenSummary}`,
-          feedback
-        );
-        await this.injectWorkflowRevisionInstructions(task, feedback);
+        const logMessage = followUpTaskId ? `Workflow step "${stepName}" requested revision \u2014 split feedback: appended in-scope guidance and forked out-of-scope work to ${followUpTaskId}; ${reopenSummary}` : `Workflow step "${stepName}" requested revision \u2014 feedback appended to original task; ${reopenSummary}`;
+        await this.store.logEntry(task.id, logMessage, inScopeFeedback, this.currentRunContext);
+        await this.injectWorkflowRevisionInstructions(task, inScopeFeedback);
         await this.store.updateTask(task.id, {
           status: null,
           sessionFile: null
@@ -81754,6 +82788,35 @@ Take a different approach. Do NOT repeat the rejected strategy. Re-read the step
           worktreePath,
           `${task.id}: revision rerun scheduled \u2014 moved to todo then in-progress`
         );
+        return true;
+      }
+      async createWorkflowRevisionFollowUpTask(task, stepName, feedback) {
+        const title = `${task.id}: workflow follow-up from ${stepName}`;
+        const description = [
+          `Follow-up work forked from workflow revision feedback on ${task.id}.`,
+          "",
+          `Original task: ${task.id}${task.title ? ` \u2014 ${task.title}` : ""}`,
+          `Workflow step: ${stepName}`,
+          "",
+          "This feedback referenced files outside the original task's declared File Scope, so it was forked into a follow-up task instead of mutating the original PROMPT.md.",
+          "",
+          "## Out-of-Scope Workflow Revision Feedback",
+          "",
+          feedback
+        ].join("\n");
+        return this.store.createTask({
+          title,
+          description,
+          dependencies: [task.id],
+          source: {
+            sourceType: "workflow_step",
+            sourceParentTaskId: task.id,
+            sourceMetadata: {
+              workflowStepName: stepName,
+              routing: "scope-mismatch-fork"
+            }
+          }
+        });
       }
       /**
        * Re-open the last non-pending step so a revision/failure handler gives the
@@ -87050,7 +88113,7 @@ Follow this process:
 
 // ../engine/src/agent-heartbeat.ts
 import { Type as Type6 } from "@mariozechner/pi-ai";
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 function formatDuration(ms) {
   const totalMinutes = Math.floor(ms / 6e4);
   if (totalMinutes < 1) return "<1m";
@@ -87094,7 +88157,7 @@ function truncatePrompt(text, maxChars) {
 ... (truncated, ${text.length} chars)`;
 }
 function shortContentHash(value) {
-  return createHash7("sha256").update(value).digest("hex").slice(0, 8);
+  return createHash8("sha256").update(value).digest("hex").slice(0, 8);
 }
 function buildIdentitySnapshot(args) {
   const { agent, resolvedInstructions, workspaceMemory } = args;
@@ -88946,13 +90009,13 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
         });
       }
       async buildReportsHealthSection(agentId, agentStore) {
-        const getReports = agentStore.getAgentsByReportsTo;
-        if (typeof getReports !== "function") {
+        const storeWithReports = agentStore;
+        if (typeof storeWithReports.getAgentsByReportsTo !== "function") {
           return null;
         }
         let reports;
         try {
-          reports = await getReports(agentId);
+          reports = await storeWithReports.getAgentsByReportsTo(agentId);
         } catch (err) {
           heartbeatLog.warn(`Failed to load reports for ${agentId}: ${err instanceof Error ? err.message : String(err)}`);
           return null;
@@ -91347,7 +92410,7 @@ var init_cron_runner = __esm({
 
 // ../engine/src/routine-runner.ts
 import { exec as exec8 } from "node:child_process";
-import { promisify as promisify8 } from "node:util";
+import { promisify as promisify9 } from "node:util";
 function truncateOutput3(stdout, stderr) {
   let output = stdout;
   if (stderr) {
@@ -91369,7 +92432,7 @@ var init_routine_runner = __esm({
     init_logger2();
     init_shell_utils();
     log16 = createLogger2("routine-runner");
-    execAsync6 = promisify8(exec8);
+    execAsync6 = promisify9(exec8);
     DEFAULT_TIMEOUT_MS8 = 5 * 60 * 1e3;
     MAX_BUFFER2 = 1024 * 1024;
     MAX_OUTPUT_LENGTH2 = 10 * 1024;
@@ -92306,17 +93369,25 @@ function isMissingWorktreeSessionStartFailure(error) {
   if (typeof error !== "string") {
     return false;
   }
-  return error.includes("Refusing to start coding agent in missing worktree:");
+  return error.includes(MISSING_WORKTREE_SESSION_PREFIX);
+}
+function extractMissingWorktreePathFromSessionStartFailure(error) {
+  if (typeof error !== "string") return null;
+  const idx = error.indexOf(MISSING_WORKTREE_SESSION_PREFIX);
+  if (idx < 0) return null;
+  const pathPart = error.slice(idx + MISSING_WORKTREE_SESSION_PREFIX.length).trim();
+  return pathPart.length > 0 ? pathPart : null;
 }
 function isRecoverableMissingWorktreeReviewFailure(task) {
   return task.column === "in-review" && !task.paused && task.status === "failed" && isMissingWorktreeSessionStartFailure(task.error) && hasStepProgress(task);
 }
-var log17, RestartRecoveryCoordinator;
+var log17, MISSING_WORKTREE_SESSION_PREFIX, RestartRecoveryCoordinator;
 var init_restart_recovery_coordinator = __esm({
   "../engine/src/restart-recovery-coordinator.ts"() {
     "use strict";
     init_logger2();
     log17 = createLogger2("restart-recovery");
+    MISSING_WORKTREE_SESSION_PREFIX = "Refusing to start coding agent in missing worktree:";
     RestartRecoveryCoordinator = class {
       constructor(store, executor) {
         this.store = store;
@@ -92360,8 +93431,8 @@ var init_restart_recovery_coordinator = __esm({
 
 // ../engine/src/self-healing.ts
 import { exec as exec9, execSync as execSync2 } from "node:child_process";
-import { promisify as promisify9 } from "node:util";
-import { existsSync as existsSync33, readdirSync as readdirSync5, rmSync as rmSync3, statSync as statSync5 } from "node:fs";
+import { promisify as promisify10 } from "node:util";
+import { existsSync as existsSync33, readdirSync as readdirSync5, rmSync as rmSync3, statSync as statSync6 } from "node:fs";
 import { isAbsolute as isAbsolute14, join as join41, relative as relative10, resolve as resolve20 } from "node:path";
 function commitOwnedByTask2(taskId, lineageId, subject, body) {
   if (lineageId && body.includes(`Fusion-Task-Lineage: ${lineageId}`)) {
@@ -92454,7 +93525,7 @@ function isNoTaskDoneFailure2(task) {
 function hasStepProgress2(task) {
   return task.steps.some((step) => step.status !== "pending");
 }
-var log18, execAsync7, APPROVED_TRIAGE_RECOVERY_GRACE_MS, ORPHANED_EXECUTION_RECOVERY_GRACE_MS, ACTIVE_MERGE_STATUSES, NON_TERMINAL_STEP_STATUSES2, GHOST_REVIEW_PRESERVED_STATUSES, ORPHANED_WITH_WORKTREE_GRACE_MS, MAX_TASK_DONE_RETRIES, MAX_AUTO_MERGE_RETRIES, DEADLOCK_RECOVERY_COOLDOWN_MS, DEFAULT_STALE_MERGING_STATUS_MIN_AGE_MS, DURABLE_ERROR_RECOVERY_MAX_RETRIES, DURABLE_ERROR_RECOVERY_BASE_COOLDOWN_MS, DURABLE_ERROR_RECOVERY_MAX_COOLDOWN_MS, SelfHealingManager;
+var log18, execAsync7, APPROVED_TRIAGE_RECOVERY_GRACE_MS, ORPHANED_EXECUTION_RECOVERY_GRACE_MS, ACTIVE_MERGE_STATUSES, NON_TERMINAL_STEP_STATUSES2, GHOST_REVIEW_PRESERVED_STATUSES, ORPHANED_WITH_WORKTREE_GRACE_MS, MAX_TASK_DONE_RETRIES, MAX_AUTO_MERGE_RETRIES, MAX_STARVATION_DROPS, DEADLOCK_RECOVERY_COOLDOWN_MS, DEFAULT_STALE_MERGING_STATUS_MIN_AGE_MS, DURABLE_ERROR_RECOVERY_MAX_RETRIES, DURABLE_ERROR_RECOVERY_BASE_COOLDOWN_MS, DURABLE_ERROR_RECOVERY_MAX_COOLDOWN_MS, SelfHealingManager;
 var init_self_healing = __esm({
   "../engine/src/self-healing.ts"() {
     "use strict";
@@ -92464,7 +93535,7 @@ var init_self_healing = __esm({
     init_restart_recovery_coordinator();
     init_transient_error_detector();
     log18 = createLogger2("self-healing");
-    execAsync7 = promisify9(exec9);
+    execAsync7 = promisify10(exec9);
     APPROVED_TRIAGE_RECOVERY_GRACE_MS = 6e4;
     ORPHANED_EXECUTION_RECOVERY_GRACE_MS = 6e4;
     ACTIVE_MERGE_STATUSES = /* @__PURE__ */ new Set(["merging", "merging-pr", "merging-fix"]);
@@ -92480,6 +93551,7 @@ var init_self_healing = __esm({
     ORPHANED_WITH_WORKTREE_GRACE_MS = 3e5;
     MAX_TASK_DONE_RETRIES = 3;
     MAX_AUTO_MERGE_RETRIES = 3;
+    MAX_STARVATION_DROPS = 3;
     DEADLOCK_RECOVERY_COOLDOWN_MS = 15 * 6e4;
     DEFAULT_STALE_MERGING_STATUS_MIN_AGE_MS = 5 * 6e4;
     DURABLE_ERROR_RECOVERY_MAX_RETRIES = 5;
@@ -92502,6 +93574,7 @@ var init_self_healing = __esm({
       settingsListener = null;
       // ── Per-task deadlock recovery cooldown ─────────────────────────────
       deadlockRecoveryCooldown = /* @__PURE__ */ new Map();
+      mergeStarvationDrops = /* @__PURE__ */ new Map();
       // ── Lifecycle ───────────────────────────────────────────────────────
       start() {
         this.settingsListener = ({ settings, previous }) => {
@@ -93225,6 +94298,7 @@ var init_self_healing = __esm({
             try {
               log18.warn(`Clearing stale merge status for ${task.id}: ${previousStatus}`);
               await this.store.updateTask(task.id, { status: null });
+              this.options.clearMergeActive?.(task.id);
               await this.store.logEntry(
                 task.id,
                 `Auto-recovered: cleared stale '${previousStatus}' status (no active merger)`
@@ -93295,6 +94369,8 @@ var init_self_healing = __esm({
                 reason = `blocker ${blockerId} in-review + paused`;
               } else if (blocker.column === "in-review" && blocker.status === "failed" && (blocker.mergeRetries ?? 0) >= MAX_AUTO_MERGE_RETRIES) {
                 reason = `blocker ${blockerId} in-review + failed (mergeRetries ${blocker.mergeRetries ?? 0}/${MAX_AUTO_MERGE_RETRIES})`;
+              } else if (blocker.column === "in-review" && blocker.status === "failed" && isMissingWorktreeSessionStartFailure(blocker.error)) {
+                reason = `blocker ${blockerId} in-review + failed (missing-worktree session start)`;
               } else if (task.dependencies.length > 0 && !unresolvedDeps.includes(blockerId)) {
                 reason = `blocker ${blockerId} not among unresolved dependencies`;
               }
@@ -93404,7 +94480,7 @@ var init_self_healing = __esm({
           if (settings.globalPause || settings.enginePaused) return 0;
           const tasks = await this.store.listTasks({ column: "in-review", slim: true });
           const mergeable = tasks.filter(
-            (t) => t.column === "in-review" && !t.paused && // Exclude transient merge statuses. Active merges should be left alone;
+            (t) => t.column === "in-review" && !t.paused && t.status !== "failed" && // Exclude transient merge statuses. Active merges should be left alone;
             // stale ones are handled by recoverStaleMergingStatus().
             t.status !== "merging" && t.status !== "merging-pr" && Boolean(t.worktree) && t.mergeDetails?.mergeConfirmed !== true && t.mergeDetails?.noOpMerge !== true && !hasTerminalInvalidDoneTransition(t) && // Mirror ProjectEngine.canMergeTask retry gate. If retries are already
             // exhausted, re-enqueueing here is a no-op and each recovery log write
@@ -93413,6 +94489,13 @@ var init_self_healing = __esm({
             // in case updateTask(moveTask) is briefly out-of-order during recovery.
             (t.mergeRetries ?? 0) < MAX_AUTO_MERGE_RETRIES && getTaskMergeBlocker(t) === void 0
           );
+          const inReviewIds = new Set(tasks.map((task) => task.id));
+          const mergeableIds = new Set(mergeable.map((task) => task.id));
+          for (const taskId of [...this.mergeStarvationDrops.keys()]) {
+            if (!inReviewIds.has(taskId) || !mergeableIds.has(taskId)) {
+              this.mergeStarvationDrops.delete(taskId);
+            }
+          }
           if (mergeable.length === 0) return 0;
           log18.warn(`Found ${mergeable.length} mergeable review task(s) stuck in in-review`);
           const enqueueMerge = this.options.enqueueMerge;
@@ -93420,7 +94503,23 @@ var init_self_healing = __esm({
           for (const task of mergeable) {
             try {
               if (enqueueMerge) {
-                enqueueMerge(task.id);
+                const queued = enqueueMerge(task.id);
+                if (!queued) {
+                  const drops = (this.mergeStarvationDrops.get(task.id) ?? 0) + 1;
+                  this.mergeStarvationDrops.set(task.id, drops);
+                  log18.warn(
+                    `Auto-recovery enqueue dropped for ${task.id} (${drops}/${MAX_STARVATION_DROPS}); engine merge queue rejected re-enqueue`
+                  );
+                  if (drops >= MAX_STARVATION_DROPS) {
+                    const error = `Auto-merge starvation: ${MAX_STARVATION_DROPS} consecutive enqueue attempts were dropped by the engine merge queue; task requires manual intervention.`;
+                    await this.store.updateTask(task.id, { status: "failed", error });
+                    await this.store.logEntry(task.id, error);
+                    this.mergeStarvationDrops.delete(task.id);
+                    recovered++;
+                  }
+                  continue;
+                }
+                this.mergeStarvationDrops.delete(task.id);
               } else {
                 await this.store.mergeTask(task.id);
               }
@@ -94470,16 +95569,18 @@ var init_self_healing = __esm({
           for (const task of candidates) {
             try {
               const staleWorktree = task.worktree;
+              const missingWorktreePath = extractMissingWorktreePathFromSessionStartFailure(task.error);
+              const hasMismatchedLiveWorktree = typeof staleWorktree === "string" && staleWorktree.length > 0 && typeof missingWorktreePath === "string" && missingWorktreePath.length > 0 && resolve20(staleWorktree) !== resolve20(missingWorktreePath);
               await this.store.updateTask(task.id, {
                 status: null,
                 error: null,
-                worktree: null,
-                branch: null,
+                worktree: hasMismatchedLiveWorktree ? staleWorktree : null,
+                branch: hasMismatchedLiveWorktree ? task.branch ?? null : null,
                 sessionFile: null
               });
               await this.store.logEntry(
                 task.id,
-                `Auto-recovered: retry/verification session targeted missing worktree${staleWorktree ? ` (${staleWorktree})` : ""} \u2014 cleared stale session metadata and requeued to todo`
+                hasMismatchedLiveWorktree ? `Auto-recovered: stale resume referenced missing worktree (${missingWorktreePath}) while live task worktree is ${staleWorktree} \u2014 cleared stale session metadata and requeued to todo` : `Auto-recovered: retry/verification session targeted missing worktree${staleWorktree ? ` (${staleWorktree})` : ""} \u2014 cleared stale session metadata and requeued to todo`
               );
               await this.store.moveTask(task.id, "todo", { preserveProgress: true });
               recovered++;
@@ -94873,7 +95974,7 @@ var init_self_healing = __esm({
           if (idle.length === 0) return;
           const withMtime = idle.map((p) => {
             try {
-              return { path: p, mtime: statSync5(p).mtimeMs };
+              return { path: p, mtime: statSync6(p).mtimeMs };
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
               log18.warn(`Failed to read mtime for worktree ${p}: ${errorMessage} \u2014 defaulting mtime to 0`);
@@ -96088,6 +97189,7 @@ var init_in_process_runtime = __esm({
        * before `start()` via `setMergeEnqueuer`.
        */
       mergeEnqueuer;
+      clearMergeActive;
       activeMergeTaskIdProvider;
       /** Tracks whether startup recovery was intentionally deferred due to pause state. */
       startupRecoveryDeferred = false;
@@ -96485,7 +97587,8 @@ var init_in_process_runtime = __esm({
             recoverApprovedTriageTask: (task) => this.triageProcessor?.recoverApprovedTask(task) ?? Promise.resolve(false),
             getPlanningTaskIds: () => this.triageProcessor?.getProcessingTaskIds() ?? /* @__PURE__ */ new Set(),
             evictStaleTriageProcessing: () => this.triageProcessor?.evictStaleProcessing() ?? /* @__PURE__ */ new Set(),
-            enqueueMerge: this.mergeEnqueuer ? (taskId) => this.mergeEnqueuer?.(taskId) : void 0,
+            enqueueMerge: this.mergeEnqueuer ? (taskId) => this.mergeEnqueuer?.(taskId) ?? false : void 0,
+            clearMergeActive: this.clearMergeActive ? (taskId) => this.clearMergeActive?.(taskId) : void 0,
             getActiveMergeTaskId: () => this.activeMergeTaskIdProvider?.() ?? null,
             leaseManager: this.leaseManager,
             hasActiveAgentExecution: (agentId) => this.heartbeatMonitor?.getTrackedAgents().includes(agentId) ?? false,
@@ -96679,6 +97782,9 @@ var init_in_process_runtime = __esm({
       setMergeEnqueuer(enqueueMerge) {
         this.mergeEnqueuer = enqueueMerge;
       }
+      setMergeActiveClearer(clearMergeActive) {
+        this.clearMergeActive = clearMergeActive;
+      }
       setActiveMergeTaskIdProvider(getActiveMergeTaskId) {
         this.activeMergeTaskIdProvider = getActiveMergeTaskId;
       }
@@ -98783,8 +99889,8 @@ var init_provider_adapters = __esm({
 
 // ../engine/src/remote-access/tunnel-process-manager.ts
 import { EventEmitter as EventEmitter23 } from "node:events";
-import { exec as exec10, execFile as execFile4, spawn as spawn5 } from "node:child_process";
-import { promisify as promisify10 } from "node:util";
+import { exec as exec10, execFile as execFile5, spawn as spawn5 } from "node:child_process";
+import { promisify as promisify11 } from "node:util";
 function nowIso2() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -98824,7 +99930,7 @@ function toStateError(code, err) {
     at: nowIso2()
   };
 }
-var DEFAULT_MAX_LOG_ENTRIES, DEFAULT_STOP_TIMEOUT_MS2, execFileAsync2, execAsync8, LineBuffer, TunnelProcessManager;
+var DEFAULT_MAX_LOG_ENTRIES, DEFAULT_STOP_TIMEOUT_MS2, execFileAsync3, execAsync8, LineBuffer, TunnelProcessManager;
 var init_tunnel_process_manager = __esm({
   "../engine/src/remote-access/tunnel-process-manager.ts"() {
     "use strict";
@@ -98832,8 +99938,8 @@ var init_tunnel_process_manager = __esm({
     init_provider_adapters();
     DEFAULT_MAX_LOG_ENTRIES = 400;
     DEFAULT_STOP_TIMEOUT_MS2 = 5e3;
-    execFileAsync2 = promisify10(execFile4);
-    execAsync8 = promisify10(exec10);
+    execFileAsync3 = promisify11(execFile5);
+    execAsync8 = promisify11(exec10);
     LineBuffer = class {
       pending = "";
       push(chunk) {
@@ -98910,7 +100016,7 @@ var init_tunnel_process_manager = __esm({
           return null;
         }
         try {
-          const { stdout } = await execFileAsync2("tailscale", ["status", "--json"], { timeout: 3e3 });
+          const { stdout } = await execFileAsync3("tailscale", ["status", "--json"], { timeout: 3e3 });
           const data = JSON.parse(String(stdout));
           const dnsName = data.Self?.DNSName?.replace(/\.$/, "");
           if (!dnsName) {
@@ -98933,7 +100039,7 @@ var init_tunnel_process_manager = __esm({
         ];
         for (const resetCommand of resetCommands) {
           try {
-            await execFileAsync2(resetCommand.command, resetCommand.args, { timeout: 5e3 });
+            await execFileAsync3(resetCommand.command, resetCommand.args, { timeout: 5e3 });
             return;
           } catch {
           }
@@ -99232,8 +100338,8 @@ var init_tunnel_process_manager = __esm({
 });
 
 // ../engine/src/project-engine.ts
-import { execFile as execFile5 } from "node:child_process";
-import { promisify as promisify11 } from "node:util";
+import { execFile as execFile6 } from "node:child_process";
+import { promisify as promisify12 } from "node:util";
 function formatErrorDetails(error) {
   if (error instanceof Error) {
     return {
@@ -99248,7 +100354,7 @@ function isInvalidDoneTransitionError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return message.includes("Invalid transition:") && message.includes("\u2192 'done'");
 }
-var execFileAsync3, MERGE_HANDOFF_GRACE_MS, isRemoteActive, ProjectEngine;
+var execFileAsync4, MERGE_HANDOFF_GRACE_MS, isRemoteActive, ProjectEngine;
 var init_project_engine = __esm({
   "../engine/src/project-engine.ts"() {
     "use strict";
@@ -99266,7 +100372,7 @@ var init_project_engine = __esm({
     init_research_orchestrator();
     init_research_step_runner();
     init_tunnel_process_manager();
-    execFileAsync3 = promisify11(execFile5);
+    execFileAsync4 = promisify12(execFile6);
     MERGE_HANDOFF_GRACE_MS = 300;
     isRemoteActive = (ra) => ra?.activeProvider != null && (ra.providers[ra.activeProvider]?.enabled ?? false);
     ProjectEngine = class _ProjectEngine {
@@ -99285,7 +100391,10 @@ var init_project_engine = __esm({
             this.activeMergeTaskId = null;
           }
           this.mergeActive.delete(taskId);
-          this.internalEnqueueMerge(taskId);
+          return this.internalEnqueueMerge(taskId);
+        });
+        this.runtime.setMergeActiveClearer?.((taskId) => {
+          this.mergeActive.delete(taskId);
         });
       }
       runtime;
@@ -99320,6 +100429,7 @@ var init_project_engine = __esm({
       mergeAbortController = null;
       mergeRetryTimer = null;
       autostashSweepTimer = null;
+      mergeActiveReconcileTimer = null;
       /**
        * Pending manual merge resolvers — keyed by taskId.
        * When `onMerge` is called, the task is enqueued like auto-merge but a
@@ -99515,6 +100625,7 @@ ${detail}`
         this.wireAutostashOrphanRecovery(store);
         await this.startupMergeSweep(store);
         this.scheduleMergeRetry(store);
+        this.scheduleMergeActiveReconciliation(settings.maintenanceIntervalMs ?? 9e5);
         void this.runStaleAutostashSweep(store, "startup");
         this.scheduleStaleAutostashSweep(store);
         this.started = true;
@@ -99540,6 +100651,10 @@ ${detail}`
           clearTimeout(this.autostashSweepTimer);
           this.autostashSweepTimer = null;
         }
+        if (this.mergeActiveReconcileTimer) {
+          clearInterval(this.mergeActiveReconcileTimer);
+          this.mergeActiveReconcileTimer = null;
+        }
         this.mergeAbortController?.abort();
         this.mergeAbortController = null;
         this.activeMergeTaskId = null;
@@ -99761,7 +100876,7 @@ ${detail}`
        * an external `onMerge` callback (e.g. dashboard's createServer call).
        */
       enqueueMerge(taskId) {
-        this.internalEnqueueMerge(taskId);
+        return this.internalEnqueueMerge(taskId);
       }
       /**
        * Perform an AI-powered merge for a task, serialized through the merge queue.
@@ -99778,7 +100893,10 @@ ${detail}`
         }
         return new Promise((resolve24, reject) => {
           this.manualMergeResolvers.set(taskId, { resolve: resolve24, reject });
-          this.internalEnqueueMerge(taskId);
+          if (!this.internalEnqueueMerge(taskId)) {
+            this.manualMergeResolvers.delete(taskId);
+            reject(new Error(`Merge enqueue rejected for ${taskId}`));
+          }
         });
       }
       setRestoreDiagnostics(outcome, reason, provider, message) {
@@ -99956,7 +101074,7 @@ ${detail}`
       async checkExecutableAvailable(command) {
         const checker = process.platform === "win32" ? "where" : "which";
         try {
-          await execFileAsync3(checker, [command]);
+          await execFileAsync4(checker, [command]);
           return { available: true };
         } catch {
           return {
@@ -100045,15 +101163,17 @@ ${detail}`
         return void 0;
       }
       internalEnqueueMerge(taskId) {
-        if (this.shuttingDown) return;
+        if (this.shuttingDown) return false;
         if (this.mergeActive.has(taskId)) {
           const isActuallyLive = this.mergeQueue.includes(taskId) || this.activeMergeTaskId === taskId;
           if (!isActuallyLive) {
             runtimeLog.warn(
-              `internalEnqueueMerge(${taskId}): skipped \u2014 mergeActive entry is leaked (not queued, not active). reconcileStaleMergeActive() will clear it on the next sweep.`
+              `internalEnqueueMerge(${taskId}): skipped \u2014 mergeActive entry is leaked (not queued, not active). Reconciling stale entry and retrying enqueue now.`
             );
+            this.mergeActive.delete(taskId);
+          } else {
+            return false;
           }
-          return;
         }
         this.mergeActive.add(taskId);
         this.mergeQueue.push(taskId);
@@ -100062,6 +101182,7 @@ ${detail}`
             `Merge queue drain failed unexpectedly: ${err instanceof Error ? err.message : String(err)}`
           );
         });
+        return true;
       }
       /**
        * Filter a sweep's listTasks() result to merge-eligible tasks, sort by
@@ -100080,6 +101201,27 @@ ${detail}`
         }
         return eligible.length;
       }
+      reconcileStaleMergeActive() {
+        let cleared = 0;
+        for (const taskId of [...this.mergeActive]) {
+          if (taskId === this.activeMergeTaskId) continue;
+          if (this.mergeQueue.includes(taskId)) continue;
+          this.mergeActive.delete(taskId);
+          cleared++;
+        }
+        return cleared;
+      }
+      scheduleMergeActiveReconciliation(intervalMs) {
+        if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+          return;
+        }
+        this.mergeActiveReconcileTimer = setInterval(() => {
+          const cleared = this.reconcileStaleMergeActive();
+          if (cleared > 0) {
+            runtimeLog.warn(`Reconciled ${cleared} stale mergeActive entr${cleared === 1 ? "y" : "ies"}`);
+          }
+        }, intervalMs);
+      }
       async findActiveRecoveryFollowUp(store, parentTaskId, branch) {
         const tasks = await store.listTasks({ slim: true }).catch(() => []);
         const activeRecoveryTasks = tasks.filter(
@@ -100099,6 +101241,7 @@ ${detail}`
         if (this.mergeRunning) return;
         this.mergeRunning = true;
         try {
+          this.reconcileStaleMergeActive();
           const store = this.runtime.getTaskStore();
           const cwd = this.config.workingDirectory;
           while (this.mergeQueue.length > 0 && !this.shuttingDown) {
@@ -100878,6 +102021,21 @@ ${detail}`
         };
         store.on("settings:updated", onEngineUnpause);
         this.settingsHandlers.push(onEngineUnpause);
+        const onMaintenanceIntervalChange = ({
+          settings: s,
+          previous: prev
+        }) => {
+          if (s.maintenanceIntervalMs === prev.maintenanceIntervalMs) {
+            return;
+          }
+          if (this.mergeActiveReconcileTimer) {
+            clearInterval(this.mergeActiveReconcileTimer);
+            this.mergeActiveReconcileTimer = null;
+          }
+          this.scheduleMergeActiveReconciliation(s.maintenanceIntervalMs ?? 9e5);
+        };
+        store.on("settings:updated", onMaintenanceIntervalChange);
+        this.settingsHandlers.push(onMaintenanceIntervalChange);
         const onStuckTimeoutChange = async ({
           settings: s,
           previous: prev
@@ -101977,6 +103135,7 @@ __export(src_exports2, {
   applyAutostashBySha: () => applyAutostashBySha,
   applyUnavailableNodePolicy: () => applyUnavailableNodePolicy,
   assertSafeUrl: () => assertSafeUrl,
+  auditSquashMerge: () => auditSquashMerge,
   buildAgentChatPrompt: () => buildAgentChatPrompt,
   buildNtfyClickUrl: () => buildNtfyClickUrl,
   buildRuntimeResolutionContext: () => buildRuntimeResolutionContext,
@@ -102002,6 +103161,7 @@ __export(src_exports2, {
   extractRuntimeHint: () => extractRuntimeHint,
   extractRuntimeModel: () => extractRuntimeModel,
   fetchWebContent: () => fetchWebContent,
+  formatSquashAuditReport: () => formatSquashAuditReport,
   formatTaskIdentifier: () => formatTaskIdentifier,
   generateReservedWorktreeName: () => generateReservedWorktreeName,
   generateWorktreeName: () => generateWorktreeName,
@@ -102056,6 +103216,7 @@ var init_src2 = __esm({
     init_mission_autopilot();
     init_mission_execution_loop();
     init_merger();
+    init_merger_squash_audit();
     init_reviewer();
     init_pi();
     init_pi();
@@ -107101,13 +108262,13 @@ var init_github_poll = __esm({
 });
 
 // ../dashboard/src/routes/resolve-diff-base.ts
-import { execFile as execFile6 } from "node:child_process";
-import { promisify as promisify12 } from "node:util";
-var execFileAsync4;
+import { execFile as execFile7 } from "node:child_process";
+import { promisify as promisify13 } from "node:util";
+var execFileAsync5;
 var init_resolve_diff_base = __esm({
   "../dashboard/src/routes/resolve-diff-base.ts"() {
     "use strict";
-    execFileAsync4 = promisify12(execFile6);
+    execFileAsync5 = promisify13(execFile7);
   }
 });
 
@@ -112299,13 +113460,13 @@ var init_register_agents_projects_nodes = __esm({
 });
 
 // ../dashboard/src/exec-file.ts
-import { execFile as execFile7 } from "node:child_process";
-import { promisify as promisify13 } from "node:util";
-var execFileAsync5;
+import { execFile as execFile8 } from "node:child_process";
+import { promisify as promisify14 } from "node:util";
+var execFileAsync6;
 var init_exec_file = __esm({
   "../dashboard/src/exec-file.ts"() {
     "use strict";
-    execFileAsync5 = promisify13(execFile7);
+    execFileAsync6 = promisify14(execFile8);
   }
 });
 
@@ -117849,7 +119010,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes3, createHash: createHash8 } = __require("crypto");
+    var { randomBytes: randomBytes3, createHash: createHash9 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -118509,7 +119670,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash8("sha1").update(key + GUID).digest("base64");
+        const digest = createHash9("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -118876,7 +120037,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter32 = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash8 } = __require("crypto");
+    var { createHash: createHash9 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -119177,7 +120338,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash8("sha1").update(key + GUID).digest("base64");
+        const digest = createHash9("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -119607,7 +120768,7 @@ __export(task_exports, {
   runTaskUpdate: () => runTaskUpdate
 });
 import { createInterface as createInterface2 } from "node:readline/promises";
-import { watchFile, unwatchFile, statSync as statSync6, existsSync as existsSync35, readFileSync as readFileSync13 } from "node:fs";
+import { watchFile, unwatchFile, statSync as statSync7, existsSync as existsSync35, readFileSync as readFileSync13 } from "node:fs";
 import { basename as basename10, join as join46 } from "node:path";
 function getGitHubIssueUrl(sourceMetadata) {
   if (!sourceMetadata || typeof sourceMetadata !== "object") return void 0;
@@ -119929,7 +121090,7 @@ async function runTaskLogs(id, options = {}, projectName) {
     let lastPosition = 0;
     let lastSize = 0;
     try {
-      const stats = statSync6(logPath);
+      const stats = statSync7(logPath);
       lastSize = stats.size;
       lastPosition = lastSize;
     } catch {
@@ -119946,7 +121107,7 @@ async function runTaskLogs(id, options = {}, projectName) {
     watchFile(logPath, { interval: 1e3 }, () => {
       if (isShuttingDown) return;
       try {
-        const stats = statSync6(logPath);
+        const stats = statSync7(logPath);
         if (stats.size < lastPosition) {
           lastPosition = 0;
         }
@@ -121347,6 +122508,9 @@ function kbExtension(pi) {
         Type8.String({
           description: "Agent ID to assign this task to (e.g. 'agent-abc123')"
         })
+      ),
+      priority: Type8.Optional(
+        StringEnum([...TASK_PRIORITIES], { description: "Task priority (low, normal, high, urgent)" })
       )
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -121363,31 +122527,45 @@ function kbExtension(pi) {
           };
         }
       }
-      const task = await store.createTask({
-        description: params.description.trim(),
-        dependencies: params.depends,
-        assignedAgentId: normalizedAgentId === null ? void 0 : normalizedAgentId,
-        source: { sourceType: "api" }
-      });
-      const label = task.description.length > 80 ? task.description.slice(0, 80) + "\u2026" : task.description;
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Created ${task.id}: ${label}
+      try {
+        const task = await store.createTask({
+          description: params.description.trim(),
+          dependencies: params.depends,
+          assignedAgentId: normalizedAgentId === null ? void 0 : normalizedAgentId,
+          priority: params.priority,
+          source: { sourceType: "api" }
+        });
+        const label = task.description.length > 80 ? task.description.slice(0, 80) + "\u2026" : task.description;
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Created ${task.id}: ${label}
 Column: triage
 ` + (task.dependencies.length ? `Dependencies: ${task.dependencies.join(", ")}
 ` : "") + (task.assignedAgentId ? `Assigned to: ${task.assignedAgentId}
-` : "") + `Path: .fusion/tasks/${task.id}/`
+` : "") + `Priority: ${task.priority}
+Path: .fusion/tasks/${task.id}/`
+            }
+          ],
+          details: {
+            taskId: task.id,
+            column: task.column,
+            dependencies: task.dependencies,
+            assignedAgentId: task.assignedAgentId,
+            priority: task.priority
           }
-        ],
-        details: {
-          taskId: task.id,
-          column: task.column,
-          dependencies: task.dependencies,
-          assignedAgentId: task.assignedAgentId
+        };
+      } catch (error) {
+        if (error instanceof Error && error.message.startsWith("Task ID already exists:")) {
+          return {
+            content: [{ type: "text", text: `ERROR: ${error.message}` }],
+            isError: true,
+            details: { error: error.message }
+          };
         }
-      };
+        throw error;
+      }
     }
   });
   pi.registerTool({
@@ -123329,25 +124507,36 @@ ${lines.join("\n\n")}` }],
       const agentStore = new AgentStore2({ rootDir: getFusionDir(ctx.cwd) });
       await agentStore.init();
       const agent = await agentStore.getAgent(params.agent_id);
-      const store = await getStore2(ctx.cwd);
-      const task = await store.createTask({
-        description: params.description,
-        dependencies: params.dependencies,
-        column: "todo",
-        assignedAgentId: params.agent_id,
-        source: {
-          sourceType: "api",
-          ...params.override === true ? { sourceMetadata: { executorRoleOverride: true } } : {}
+      try {
+        const store = await getStore2(ctx.cwd);
+        const task = await store.createTask({
+          description: params.description,
+          dependencies: params.dependencies,
+          column: "todo",
+          assignedAgentId: params.agent_id,
+          source: {
+            sourceType: "api",
+            ...params.override === true ? { sourceMetadata: { executorRoleOverride: true } } : {}
+          }
+        });
+        const deps = task.dependencies.length ? ` (depends on: ${task.dependencies.join(", ")})` : "";
+        return {
+          content: [{
+            type: "text",
+            text: `Delegated to ${agent.name} (${agent.id}): Created ${task.id}${deps}. The task will be picked up by ${agent.name} on their next heartbeat cycle.`
+          }],
+          details: { taskId: task.id, agentId: agent.id, agentName: agent.name }
+        };
+      } catch (error) {
+        if (error instanceof Error && error.message.startsWith("Task ID already exists:")) {
+          return {
+            content: [{ type: "text", text: `ERROR: ${error.message}` }],
+            isError: true,
+            details: { error: error.message }
+          };
         }
-      });
-      const deps = task.dependencies.length ? ` (depends on: ${task.dependencies.join(", ")})` : "";
-      return {
-        content: [{
-          type: "text",
-          text: `Delegated to ${agent.name} (${agent.id}): Created ${task.id}${deps}. The task will be picked up by ${agent.name} on their next heartbeat cycle.`
-        }],
-        details: { taskId: task.id, agentId: agent.id, agentName: agent.name }
-      };
+        throw error;
+      }
     }
   });
   pi.registerTool({