@runfusion/fusion 0.73.0-beta.3 → 0.73.0-beta.4

package/dist/extension.js

@@ -906,6 +906,7 @@ var init_workflow_steps = __esm({
       "in-review",
       "merged",
       "failed",
+      "task-wedged",
       "awaiting-approval",
       "awaiting-user-review",
       "planning-awaiting-input",
@@ -979,6 +980,50 @@ var init_documents_artifacts = __esm({
   }
 });
 
+// ../core/src/types/task-core.ts
+function assertNotWorkspaceTaskMerge(task) {
+  if (isWorkspaceTask(task)) {
+    throw new WorkspaceTaskMergeError(
+      `Workspace task ${task.id} cannot merge until per-repo merge support (master-plan U6) lands`
+    );
+  }
+}
+function isWorkspaceTask(task) {
+  const worktrees = task.workspaceWorktrees;
+  return !!worktrees && Object.keys(worktrees).length > 0;
+}
+var CheckoutConflictError, DUPLICATE_OF_METADATA_KEY, WorkspaceTaskMergeError;
+var init_task_core = __esm({
+  "../core/src/types/task-core.ts"() {
+    "use strict";
+    CheckoutConflictError = class extends Error {
+      constructor(taskId, currentHolderId, requestedById) {
+        super(`Task ${taskId} is already checked out by agent ${currentHolderId}`);
+        this.taskId = taskId;
+        this.currentHolderId = currentHolderId;
+        this.requestedById = requestedById;
+        this.name = "CheckoutConflictError";
+      }
+    };
+    DUPLICATE_OF_METADATA_KEY = "duplicateOfTaskIds";
+    WorkspaceTaskMergeError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "WorkspaceTaskMergeError";
+      }
+    };
+  }
+});
+
+// ../core/src/types/todo-list.ts
+var SHARED_STATE_SNAPSHOT_VERSION;
+var init_todo_list = __esm({
+  "../core/src/types/todo-list.ts"() {
+    "use strict";
+    SHARED_STATE_SNAPSHOT_VERSION = 1;
+  }
+});
+
 // ../core/src/task-helpers.ts
 function getPrimaryPrInfo(task) {
   return task.prInfos?.[0] ?? task.prInfo;
@@ -1468,10 +1513,18 @@ var init_settings_schema = __esm({
     "use strict";
     init_in_review_stall();
     DEFAULT_GLOBAL_SETTINGS = {
-      // Embedded PostgreSQL is shared by all local Fusion projects and processes.
-      // Keep this well above the conservative external-pool budget while still
-      // bounded for a local machine.
-      embeddedPostgresMaxConnections: 500,
+      /*
+      FNXC:PostgresEmbedded 2026-07-22-23:55:
+      Embedded PostgreSQL is shared by all local Fusion projects and processes.
+      Deliberately undefined (not 500): getSettings() merges these defaults, so a
+      concrete value here would be indistinguishable from an operator choice and
+      would mask the platform-aware server-side default in
+      resolveEmbeddedMaxConnections (win32 150, else 500). Issue #2411: Windows
+      backends are separate processes; a 500-connection cap exhausts the desktop
+      heap under load and forked backends die with 0xC0000142, taking the embedded
+      cluster and dashboard down.
+      */
+      embeddedPostgresMaxConnections: void 0,
       /*
       FNXC:DashboardTheming 2026-07-03-00:00:
       Fresh installs must follow the operating system theme until the user explicitly chooses Light, Dark, or System. Keep this global default aligned with dashboard and desktop pre-hydration fallbacks.
@@ -2234,6 +2287,53 @@ var init_settings_schema = __esm({
   }
 });
 
+// ../core/src/types/settings-scope.ts
+function isMcpSecretRef(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value;
+  return typeof candidate.secretRef === "string" && candidate.secretRef.trim().length > 0 && (candidate.scope === "project" || candidate.scope === "global");
+}
+var init_settings_scope = __esm({
+  "../core/src/types/settings-scope.ts"() {
+    "use strict";
+    init_settings_schema();
+  }
+});
+
+// ../core/src/types/board-config.ts
+var COLUMN_LABELS, COLUMN_DESCRIPTIONS, VALID_TRANSITIONS;
+var init_board_config = __esm({
+  "../core/src/types/board-config.ts"() {
+    "use strict";
+    COLUMN_LABELS = {
+      triage: "Planning",
+      todo: "Todo",
+      "in-progress": "In Progress",
+      "in-review": "In Review",
+      done: "Done",
+      archived: "Archived"
+    };
+    COLUMN_DESCRIPTIONS = {
+      triage: "Raw ideas \u2014 AI will plan these",
+      "in-progress": "AI is working on this in a worktree",
+      done: "Merged and closed",
+      archived: "Completed and archived"
+    };
+    VALID_TRANSITIONS = {
+      // FN-4892: intake-side heuristics may cold-archive tasks before execution starts.
+      triage: ["todo", "archived"],
+      // FN-4892: allow direct archival for newly specified intake tasks.
+      todo: ["in-progress", "triage", "archived"],
+      // NOTE: "in-progress" → "done" is enabled for mission validation tasks that complete directly.
+      // Regular implementation tasks should move through "in-review" before "done".
+      "in-progress": ["in-review", "todo", "triage", "done"],
+      "in-review": ["done", "in-progress", "todo", "triage"],
+      done: ["todo", "triage", "archived"],
+      archived: ["done"]
+    };
+  }
+});
+
 // ../core/src/types/docker-nodes.ts
 function validateDockerNodeConfig(config3) {
   const errors = [];
@@ -2344,6 +2444,41 @@ var init_docker_nodes = __esm({
   }
 });
 
+// ../core/src/types/archive-planning.ts
+function formatPlanningPlanMd(summary) {
+  const normalizeListItem = (item) => item.replace(/\s+/g, " ").trim();
+  const list = (items) => items && items.length > 0 ? items.map((item) => `- ${normalizeListItem(item)}`).join("\n") : "_None_";
+  const proposedChanges = list(summary.proposedChanges);
+  const acceptanceCriteria = list(summary.acceptanceCriteria);
+  const dependencies = list(summary.suggestedDependencies);
+  const deliverables = list(summary.keyDeliverables);
+  return `# ${summary.title}
+
+${summary.description}
+
+## What to change
+${proposedChanges}
+
+## Acceptance criteria
+${acceptanceCriteria}
+
+## Size
+${summary.suggestedSize}
+
+## Suggested dependencies
+${dependencies}
+
+## Key deliverables
+${deliverables}
+`;
+}
+var init_archive_planning = __esm({
+  "../core/src/types/archive-planning.ts"() {
+    "use strict";
+    init_docker_nodes();
+  }
+});
+
 // ../core/src/types/agent-state.ts
 function isEphemeralAgent(agent) {
   const metadata = agent.metadata ?? {};
@@ -4069,49 +4204,6 @@ var init_workflow_lifecycle_validation = __esm({
 });
 
 // ../core/src/types.ts
-function assertNotWorkspaceTaskMerge(task) {
-  if (isWorkspaceTask(task)) {
-    throw new WorkspaceTaskMergeError(
-      `Workspace task ${task.id} cannot merge until per-repo merge support (master-plan U6) lands`
-    );
-  }
-}
-function isWorkspaceTask(task) {
-  const worktrees = task.workspaceWorktrees;
-  return !!worktrees && Object.keys(worktrees).length > 0;
-}
-function isMcpSecretRef(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const candidate = value;
-  return typeof candidate.secretRef === "string" && candidate.secretRef.trim().length > 0 && (candidate.scope === "project" || candidate.scope === "global");
-}
-function formatPlanningPlanMd(summary) {
-  const normalizeListItem = (item) => item.replace(/\s+/g, " ").trim();
-  const list = (items) => items && items.length > 0 ? items.map((item) => `- ${normalizeListItem(item)}`).join("\n") : "_None_";
-  const proposedChanges = list(summary.proposedChanges);
-  const acceptanceCriteria = list(summary.acceptanceCriteria);
-  const dependencies = list(summary.suggestedDependencies);
-  const deliverables = list(summary.keyDeliverables);
-  return `# ${summary.title}
-
-${summary.description}
-
-## What to change
-${proposedChanges}
-
-## Acceptance criteria
-${acceptanceCriteria}
-
-## Size
-${summary.suggestedSize}
-
-## Suggested dependencies
-${dependencies}
-
-## Key deliverables
-${deliverables}
-`;
-}
 function validateMessageMetadata(metadata) {
   if (!metadata) {
     return;
@@ -4163,7 +4255,7 @@ function validateMessageMetadata(metadata) {
     if (metadata.proposalStatus === "pending" && (metadata.claimOwnerToken !== void 0 || metadata.claimStartedAt !== void 0)) throw new Error("pending proposal cannot have a creation lease");
   }
 }
-var DEPRECATED_BUILTIN_WORKFLOW_IDS, CheckoutConflictError, DUPLICATE_OF_METADATA_KEY, WorkspaceTaskMergeError, SHARED_STATE_SNAPSHOT_VERSION, COLUMN_LABELS, COLUMN_DESCRIPTIONS, VALID_TRANSITIONS;
+var DEPRECATED_BUILTIN_WORKFLOW_IDS;
 var init_types = __esm({
   "../core/src/types.ts"() {
     "use strict";
@@ -4177,8 +4269,11 @@ var init_types = __esm({
     init_merge_policy();
     init_workflow_steps();
     init_documents_artifacts();
-    init_settings_schema();
-    init_docker_nodes();
+    init_task_core();
+    init_todo_list();
+    init_settings_scope();
+    init_board_config();
+    init_archive_planning();
     init_agent_state();
     init_planner_intervention();
     init_agents();
@@ -4193,49 +4288,6 @@ var init_types = __esm({
     DEPRECATED_BUILTIN_WORKFLOW_IDS = /* @__PURE__ */ new Set([
       "builtin:brainstorming"
     ]);
-    CheckoutConflictError = class extends Error {
-      constructor(taskId, currentHolderId, requestedById) {
-        super(`Task ${taskId} is already checked out by agent ${currentHolderId}`);
-        this.taskId = taskId;
-        this.currentHolderId = currentHolderId;
-        this.requestedById = requestedById;
-        this.name = "CheckoutConflictError";
-      }
-    };
-    DUPLICATE_OF_METADATA_KEY = "duplicateOfTaskIds";
-    WorkspaceTaskMergeError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "WorkspaceTaskMergeError";
-      }
-    };
-    SHARED_STATE_SNAPSHOT_VERSION = 1;
-    COLUMN_LABELS = {
-      triage: "Planning",
-      todo: "Todo",
-      "in-progress": "In Progress",
-      "in-review": "In Review",
-      done: "Done",
-      archived: "Archived"
-    };
-    COLUMN_DESCRIPTIONS = {
-      triage: "Raw ideas \u2014 AI will plan these",
-      "in-progress": "AI is working on this in a worktree",
-      done: "Merged and closed",
-      archived: "Completed and archived"
-    };
-    VALID_TRANSITIONS = {
-      // FN-4892: intake-side heuristics may cold-archive tasks before execution starts.
-      triage: ["todo", "archived"],
-      // FN-4892: allow direct archival for newly specified intake tasks.
-      todo: ["in-progress", "triage", "archived"],
-      // NOTE: "in-progress" → "done" is enabled for mission validation tasks that complete directly.
-      // Regular implementation tasks should move through "in-review" before "done".
-      "in-progress": ["in-review", "todo", "triage", "done"],
-      "in-review": ["done", "in-progress", "todo", "triage"],
-      done: ["todo", "triage", "archived"],
-      archived: ["done"]
-    };
   }
 });
 
@@ -12856,6 +12908,7 @@ var init_project = __esm({
       paused: integer("paused").default(0),
       userPaused: integer("user_paused").default(0),
       pausedReason: text("paused_reason"),
+      wedgeNotification: text("wedge_notification"),
       baseBranch: text("base_branch"),
       branch: text("branch"),
       autoMerge: integer("auto_merge"),
@@ -21220,6 +21273,9 @@ function validateColumns(ir2) {
       throw new WorkflowIrError(`Workflow IR has duplicate column id '${column.id}'`);
     }
     seen.add(column.id);
+    if (column.description !== void 0 && typeof column.description !== "string") {
+      throw new WorkflowIrError(`Workflow IR column '${column.id}' description must be a string`);
+    }
     if (!Array.isArray(column.traits)) {
       throw new WorkflowIrError(`Workflow IR column '${column.id}' traits must be an array`);
     }
@@ -36443,6 +36499,7 @@ async function applySchemaBaseline(db, options = {}) {
     const legacyAdoptionDrainedMarkerRuntimeGrantsAlreadyApplied = applied.includes(
       LEGACY_ADOPTION_DRAINED_MARKER_RUNTIME_GRANTS_VERSION
     );
+    const taskWedgeNotificationAlreadyApplied = applied.includes(TASK_WEDGE_NOTIFICATION_VERSION);
     assertBinaryNotOlderThanDatabase(applied);
     let schemaChanged = false;
     if (!baselineAlreadyApplied) {
@@ -36766,17 +36823,25 @@ async function applySchemaBaseline(db, options = {}) {
       );
       schemaChanged = true;
     }
+    if (!taskWedgeNotificationAlreadyApplied) {
+      const migrationSql = await readFile4(TASK_WEDGE_NOTIFICATION_MIGRATION_PATH, "utf8");
+      await tx.execute(sql.raw(migrationSql));
+      await tx.execute(
+        sql`INSERT INTO public.${sql.identifier(MIGRATION_BOOKKEEPING_TABLE)} (version) VALUES (${TASK_WEDGE_NOTIFICATION_VERSION}) ON CONFLICT (version) DO NOTHING`
+      );
+      schemaChanged = true;
+    }
     return { applied: schemaChanged, pluginHooksRun: pluginHooks.length };
   });
 }
-var SCHEMA_BASELINE_VERSION, TASK_DECLARED_SYMBOLS_VERSION, INITIAL_SCHEMA_VERSION, AUTOMATION_ISOLATION_SCHEMA_VERSION, ANALYTICS_ISOLATION_SCHEMA_VERSION, MONITOR_APPROVAL_ISOLATION_SCHEMA_VERSION, LEGACY_CUTOVER_PRESERVATION_SCHEMA_VERSION, MULTI_PROJECT_CUTOVER_SCHEMA_VERSION, PROJECT_OWNERSHIP_SCHEMA_VERSION, SQLITE_SCHEMA_PARITY_VERSION, SESSION_ADVISOR_ENABLED_SCHEMA_VERSION, MISSION_FIX_IDEMPOTENCY_VERSION, IMPORT_TRANSLATION_CACHE_VERSION, IMPORT_TRANSLATION_CACHE_SCOPE_FIX_VERSION, IMPORT_TRANSLATION_CACHE_LEGACY_PARTITION_BACKFILL_VERSION, OWNER_PROJECT_ID_SPLIT_VERSION, CHAT_SESSION_PINS_VERSION, EXECUTOR_TOOL_FAILURE_RETRY_VERSION, EXECUTOR_ESCALATION_ATTEMPT_VERSION, GLOBAL_ROUTINES_SCHEMA_VERSION, TASK_MERGER_MODEL_LANE_VERSION, BULK_COMPLETION_REFUSAL_AT_VERSION, TASK_PROPOSAL_CLAIM_VERSION, CONFIGURATION_REVISIONS_VERSION, IDEATION_SCHEMA_VERSION, RESEARCH_FEATURE_PROVENANCE_VERSION, TASK_VERIFICATION_REQUEST_VERSION, SYMBOL_LOCKS_SCHEMA_VERSION, BIGINT_COUNTERS_VERSION, PLANNING_ACTIVE_TIMING_VERSION, SQLITE_MIGRATION_RUNTIME_READ_VERSION, WORKFLOW_TASK_CONTINUATIONS_VERSION, LEGACY_ADOPTION_DRAINED_MARKER_RUNTIME_GRANTS_VERSION, LEGACY_ADOPTION_DRAINED_MARKER_FUNCTION, StaleBinarySchemaError, MIGRATION_BOOKKEEPING_TABLE, LEGACY_ADOPTION_DRAINED_MARKER, __dirname, MIGRATIONS_DIR, BASELINE_MIGRATION_PATH, AUTOMATION_ISOLATION_MIGRATION_PATH, ANALYTICS_ISOLATION_MIGRATION_PATH, MONITOR_APPROVAL_ISOLATION_MIGRATION_PATH, LEGACY_CUTOVER_PRESERVATION_MIGRATION_PATH, MULTI_PROJECT_CUTOVER_MIGRATION_PATH, PROJECT_OWNERSHIP_MIGRATION_PATH, SQLITE_SCHEMA_PARITY_MIGRATION_PATH, SESSION_ADVISOR_ENABLED_MIGRATION_PATH, MISSION_FIX_IDEMPOTENCY_MIGRATION_PATH, IMPORT_TRANSLATION_CACHE_MIGRATION_PATH, IMPORT_TRANSLATION_CACHE_SCOPE_FIX_MIGRATION_PATH, IMPORT_TRANSLATION_CACHE_LEGACY_PARTITION_BACKFILL_MIGRATION_PATH, OWNER_PROJECT_ID_SPLIT_MIGRATION_PATH, CHAT_SESSION_PINS_MIGRATION_PATH, EXECUTOR_TOOL_FAILURE_RETRY_MIGRATION_PATH, EXECUTOR_ESCALATION_ATTEMPT_MIGRATION_PATH, GLOBAL_ROUTINES_MIGRATION_PATH, TASK_MERGER_MODEL_LANE_MIGRATION_PATH, BULK_COMPLETION_REFUSAL_AT_MIGRATION_PATH, TASK_PROPOSAL_CLAIM_MIGRATION_PATH, CONFIGURATION_REVISIONS_MIGRATION_PATH, IDEATION_MIGRATION_PATH, RESEARCH_FEATURE_PROVENANCE_MIGRATION_PATH, TASK_VERIFICATION_REQUEST_MIGRATION_PATH, SYMBOL_LOCKS_MIGRATION_PATH, BIGINT_COUNTERS_MIGRATION_PATH, WORKFLOW_IR_PIN_AND_LEGACY_ADOPTION_VERSION, WORKFLOW_IR_PIN_AND_LEGACY_ADOPTION_MIGRATION_PATH, PLANNING_ACTIVE_TIMING_MIGRATION_PATH, TASK_DECLARED_SYMBOLS_MIGRATION_PATH, SQLITE_MIGRATION_RUNTIME_READ_PATH, WORKFLOW_TASK_CONTINUATIONS_PATH, LEGACY_ADOPTION_DRAINED_MARKER_RUNTIME_GRANTS_PATH;
+var SCHEMA_BASELINE_VERSION, TASK_DECLARED_SYMBOLS_VERSION, INITIAL_SCHEMA_VERSION, AUTOMATION_ISOLATION_SCHEMA_VERSION, ANALYTICS_ISOLATION_SCHEMA_VERSION, MONITOR_APPROVAL_ISOLATION_SCHEMA_VERSION, LEGACY_CUTOVER_PRESERVATION_SCHEMA_VERSION, MULTI_PROJECT_CUTOVER_SCHEMA_VERSION, PROJECT_OWNERSHIP_SCHEMA_VERSION, SQLITE_SCHEMA_PARITY_VERSION, SESSION_ADVISOR_ENABLED_SCHEMA_VERSION, MISSION_FIX_IDEMPOTENCY_VERSION, IMPORT_TRANSLATION_CACHE_VERSION, IMPORT_TRANSLATION_CACHE_SCOPE_FIX_VERSION, IMPORT_TRANSLATION_CACHE_LEGACY_PARTITION_BACKFILL_VERSION, OWNER_PROJECT_ID_SPLIT_VERSION, CHAT_SESSION_PINS_VERSION, EXECUTOR_TOOL_FAILURE_RETRY_VERSION, EXECUTOR_ESCALATION_ATTEMPT_VERSION, GLOBAL_ROUTINES_SCHEMA_VERSION, TASK_MERGER_MODEL_LANE_VERSION, BULK_COMPLETION_REFUSAL_AT_VERSION, TASK_PROPOSAL_CLAIM_VERSION, CONFIGURATION_REVISIONS_VERSION, IDEATION_SCHEMA_VERSION, RESEARCH_FEATURE_PROVENANCE_VERSION, TASK_VERIFICATION_REQUEST_VERSION, SYMBOL_LOCKS_SCHEMA_VERSION, BIGINT_COUNTERS_VERSION, PLANNING_ACTIVE_TIMING_VERSION, SQLITE_MIGRATION_RUNTIME_READ_VERSION, WORKFLOW_TASK_CONTINUATIONS_VERSION, LEGACY_ADOPTION_DRAINED_MARKER_RUNTIME_GRANTS_VERSION, TASK_WEDGE_NOTIFICATION_VERSION, LEGACY_ADOPTION_DRAINED_MARKER_FUNCTION, StaleBinarySchemaError, MIGRATION_BOOKKEEPING_TABLE, LEGACY_ADOPTION_DRAINED_MARKER, __dirname, MIGRATIONS_DIR, BASELINE_MIGRATION_PATH, AUTOMATION_ISOLATION_MIGRATION_PATH, ANALYTICS_ISOLATION_MIGRATION_PATH, MONITOR_APPROVAL_ISOLATION_MIGRATION_PATH, LEGACY_CUTOVER_PRESERVATION_MIGRATION_PATH, MULTI_PROJECT_CUTOVER_MIGRATION_PATH, PROJECT_OWNERSHIP_MIGRATION_PATH, SQLITE_SCHEMA_PARITY_MIGRATION_PATH, SESSION_ADVISOR_ENABLED_MIGRATION_PATH, MISSION_FIX_IDEMPOTENCY_MIGRATION_PATH, IMPORT_TRANSLATION_CACHE_MIGRATION_PATH, IMPORT_TRANSLATION_CACHE_SCOPE_FIX_MIGRATION_PATH, IMPORT_TRANSLATION_CACHE_LEGACY_PARTITION_BACKFILL_MIGRATION_PATH, OWNER_PROJECT_ID_SPLIT_MIGRATION_PATH, CHAT_SESSION_PINS_MIGRATION_PATH, EXECUTOR_TOOL_FAILURE_RETRY_MIGRATION_PATH, EXECUTOR_ESCALATION_ATTEMPT_MIGRATION_PATH, GLOBAL_ROUTINES_MIGRATION_PATH, TASK_MERGER_MODEL_LANE_MIGRATION_PATH, BULK_COMPLETION_REFUSAL_AT_MIGRATION_PATH, TASK_PROPOSAL_CLAIM_MIGRATION_PATH, CONFIGURATION_REVISIONS_MIGRATION_PATH, IDEATION_MIGRATION_PATH, RESEARCH_FEATURE_PROVENANCE_MIGRATION_PATH, TASK_VERIFICATION_REQUEST_MIGRATION_PATH, SYMBOL_LOCKS_MIGRATION_PATH, BIGINT_COUNTERS_MIGRATION_PATH, WORKFLOW_IR_PIN_AND_LEGACY_ADOPTION_VERSION, WORKFLOW_IR_PIN_AND_LEGACY_ADOPTION_MIGRATION_PATH, PLANNING_ACTIVE_TIMING_MIGRATION_PATH, TASK_DECLARED_SYMBOLS_MIGRATION_PATH, SQLITE_MIGRATION_RUNTIME_READ_PATH, WORKFLOW_TASK_CONTINUATIONS_PATH, LEGACY_ADOPTION_DRAINED_MARKER_RUNTIME_GRANTS_PATH, TASK_WEDGE_NOTIFICATION_MIGRATION_PATH;
 var init_schema_applier = __esm({
   "../core/src/postgres/schema-applier.ts"() {
     "use strict";
     init_drizzle_orm();
     init_plugin_schema_hook();
     init_advisory_locks();
-    SCHEMA_BASELINE_VERSION = "0032";
+    SCHEMA_BASELINE_VERSION = "0033";
     TASK_DECLARED_SYMBOLS_VERSION = "0028";
     INITIAL_SCHEMA_VERSION = "0000";
     AUTOMATION_ISOLATION_SCHEMA_VERSION = "0001";
@@ -36809,6 +36874,7 @@ var init_schema_applier = __esm({
     SQLITE_MIGRATION_RUNTIME_READ_VERSION = "0030";
     WORKFLOW_TASK_CONTINUATIONS_VERSION = "0031";
     LEGACY_ADOPTION_DRAINED_MARKER_RUNTIME_GRANTS_VERSION = "0032";
+    TASK_WEDGE_NOTIFICATION_VERSION = "0033";
     LEGACY_ADOPTION_DRAINED_MARKER_FUNCTION = "fusion_mark_legacy_adoption_drained";
     StaleBinarySchemaError = class extends Error {
       constructor(databaseVersion, binaryVersion) {
@@ -36915,6 +36981,10 @@ var init_schema_applier = __esm({
       MIGRATIONS_DIR,
       "0032_legacy_adoption_drained_marker_runtime_grants.sql"
     );
+    TASK_WEDGE_NOTIFICATION_MIGRATION_PATH = join8(
+      MIGRATIONS_DIR,
+      "0033_fn-8505_wedge_notification.sql"
+    );
   }
 });
 
@@ -37305,6 +37375,7 @@ __export(sqlite_migrator_exports, {
   isSqliteMigrationComplete: () => isSqliteMigrationComplete,
   migrateLegacyProjectPluginRows: () => migrateLegacyProjectPluginRows,
   migrateSqliteToPostgres: () => migrateSqliteToPostgres,
+  projectPluginSqliteMigrationKey: () => projectPluginSqliteMigrationKey,
   recordSqliteMigrationComplete: () => recordSqliteMigrationComplete,
   toSnakeCase: () => toSnakeCase2
 });
@@ -37847,7 +37918,12 @@ function normalizeLegacyJson(value, fallback) {
     return fallback;
   }
 }
+function projectPluginSqliteMigrationKey(projectPath) {
+  return `project-plugins:${resolve6(projectPath)}`;
+}
 async function migrateLegacyProjectPluginRows(db, sqlitePath, projectPath) {
+  const migrationKey = projectPluginSqliteMigrationKey(projectPath);
+  if (await isSqliteMigrationComplete(db, migrationKey)) return;
   await db.transaction(async (tx) => {
     await migrateLegacyProjectPluginRowsOnSession(
       tx,
@@ -37857,19 +37933,14 @@ async function migrateLegacyProjectPluginRows(db, sqlitePath, projectPath) {
   });
 }
 async function migrateLegacyProjectPluginRowsOnSession(db, sqlitePath, projectPath) {
-  if (!sqliteTableExists(sqlitePath, "plugins")) return;
-  await acquireSqliteMigrationStateLock(db);
   const canonicalProjectPath = resolve6(projectPath);
-  const migrationKey = `project-plugins:${canonicalProjectPath}`;
+  const migrationKey = projectPluginSqliteMigrationKey(projectPath);
+  await acquireSqliteMigrationStateLock(db);
   await ensureMigrationStateTable(db);
   await db.execute(sql`SELECT pg_advisory_xact_lock(hashtextextended(${migrationKey}, 0))`);
-  const completed = await db.execute(sql`
-    SELECT 1 AS complete
-    FROM public.${sql.identifier(SQLITE_MIGRATION_STATE_TABLE)}
-    WHERE migration_key = ${migrationKey} AND status = 'complete'
-    LIMIT 1
-  `);
-  if (completed.length > 0) return;
+  const completed = await isSqliteMigrationComplete(db, migrationKey);
+  if (completed) return;
+  if (!sqliteTableExists(sqlitePath, "plugins")) return;
   const sqlite = openSqlite(sqlitePath);
   let rows;
   try {
@@ -38955,6 +39026,17 @@ function buildPgCtlOptionsString(port, flags) {
 function buildPgCtlStartArgs(dataDir, logFile, optionsString) {
   return ["-D", dataDir, "-o", optionsString, "-l", logFile, "-W", "start"];
 }
+function withWindowsNativeBinPath(environment, nativeRoot, platform4 = process.platform) {
+  if (platform4 !== "win32") return environment;
+  const pathKey = Object.keys(environment).find((key) => key.toLowerCase() === "path") ?? "PATH";
+  const bin = nativeRoot.replace(/[\\/]+$/, "") + "\\bin";
+  const normalize8 = (value) => value.replace(/\//g, "\\").toLowerCase();
+  const inherited = environment[pathKey] ?? "";
+  const segments = inherited.split(";").filter(Boolean);
+  const normalizedBin = normalize8(bin);
+  const deduplicated = segments.filter((segment) => normalize8(segment) !== normalizedBin);
+  return { ...environment, [pathKey]: [bin, ...deduplicated].join(";") };
+}
 function readPostgresPid(dataDir) {
   try {
     const lines = readFileSync3(join9(dataDir, "postmaster.pid"), "utf-8").split("\n");
@@ -39009,7 +39091,13 @@ async function startServerElevatedRestricted(opts) {
     `embedded postgres: elevated start via pg_ctl restricted token (no helper account); log ${logFile}`
   );
   let stopped = false;
+  let logMonitor = null;
+  const stopMonitoring = () => {
+    if (logMonitor) clearInterval(logMonitor);
+    logMonitor = null;
+  };
   const killAll = () => {
+    stopMonitoring();
     if (stopped) return;
     stopped = true;
     const r = spawnSync(pgCtl, ["-D", opts.dataDir, "-m", "fast", "-t", "30", "-w", "stop"], {
@@ -39043,14 +39131,21 @@ async function startServerElevatedRestricted(opts) {
       killAll();
       await waitForDown();
     },
+    stopMonitoring,
     async stopWrapperOnly() {
+      stopMonitoring();
       stopped = true;
     }
   };
   opts.onLaunched?.(handle);
   const launch = await new Promise(
     (resolve51, reject) => {
-      const child = spawn(pgCtl, args, { windowsHide: true });
+      const child = spawn(pgCtl, args, {
+        windowsHide: true,
+        // Do not mutate process.env: sibling dashboard/engine children must
+        // retain their inherited environment unchanged.
+        env: withWindowsNativeBinPath(process.env, opts.nativeRoot)
+      });
       let output = "";
       child.stdout.on("data", (d) => output += d.toString());
       child.stderr.on("data", (d) => output += d.toString());
@@ -39075,16 +39170,14 @@ ${readTail(logFile, 2e3)}`
       killAll();
       throw new Error("embedded postgres: elevated launch cancelled before ready.");
     }
+    if (await probeTcpPort(opts.port, 500)) {
+      ready = true;
+      break;
+    }
     const tail = readTail(logFile, 3e3);
     if (tail !== lastSnapshot) {
       lastSnapshot = tail;
-      opts.onLog(`elevated poll pg={${tail.slice(-400)}}`);
-    }
-    if (/database system is ready to accept connections/.test(tail)) {
-      if (await probeTcpPort(opts.port, 500)) {
-        ready = true;
-        break;
-      }
+      opts.onLog(`elevated diagnostic pg={${tail.slice(-400)}}`);
     }
     if (/\bFATAL\b|\bPANIC\b|could not (bind|start|create|access|connect|load)|not permitted|Permission denied|is not the owner/i.test(tail)) {
       killAll();
@@ -39116,6 +39209,18 @@ ${tail}`
   opts.onLog(
     `embedded postgres: elevated server ready on 127.0.0.1:${opts.port} (pid ${postgresPid ?? 0}, restricted token)`
   );
+  let lastLogSnapshot = "";
+  const observePostReadyLog = () => {
+    if (stopped) return;
+    const snapshot = readTail(logFile, 16384);
+    if (snapshot === "(no log file)" || snapshot === lastLogSnapshot) return;
+    const next = snapshot.startsWith(lastLogSnapshot) ? snapshot.slice(lastLogSnapshot.length) : snapshot;
+    lastLogSnapshot = snapshot;
+    if (next) opts.onLog(next);
+  };
+  observePostReadyLog();
+  logMonitor = setInterval(observePostReadyLog, 250);
+  if (typeof logMonitor.unref === "function") logMonitor.unref();
   return handle;
 }
 function probeTcpPort(port, timeoutMs) {
@@ -39135,10 +39240,26 @@ function probeTcpPort(port, timeoutMs) {
     socket.once("error", () => finish(false));
   });
 }
-var elevatedCache;
+var WindowsPostgresFatalDetector, elevatedCache;
 var init_embedded_windows_elevated = __esm({
   "../core/src/postgres/embedded-windows-elevated.ts"() {
     "use strict";
+    WindowsPostgresFatalDetector = class {
+      buffer = "";
+      matched = false;
+      push(chunk) {
+        if (this.matched || !chunk) return false;
+        this.buffer = (this.buffer + chunk).slice(-16384);
+        const text2 = this.buffer.toLowerCase();
+        if (/server process(?:\s+\(pid\s+\d+\))?\s+was terminated by exception\s+0xc0000142[\s\S]*?terminating any other active server processes[\s\S]*?shutting down due to startup process failure[\s\S]*?database system is shut down/.test(
+          text2
+        )) {
+          this.matched = true;
+          return true;
+        }
+        return false;
+      }
+    };
     elevatedCache = null;
   }
 });
@@ -39148,10 +39269,14 @@ var embedded_lifecycle_exports = {};
 __export(embedded_lifecycle_exports, {
   DEFAULT_EMBEDDED_DATABASE: () => DEFAULT_EMBEDDED_DATABASE,
   DEFAULT_EMBEDDED_INITDB_FLAGS: () => DEFAULT_EMBEDDED_INITDB_FLAGS,
+  DEFAULT_EMBEDDED_MAX_CONNECTIONS: () => DEFAULT_EMBEDDED_MAX_CONNECTIONS,
+  DEFAULT_EMBEDDED_MAX_CONNECTIONS_WIN32: () => DEFAULT_EMBEDDED_MAX_CONNECTIONS_WIN32,
   DEFAULT_EMBEDDED_PASSWORD: () => DEFAULT_EMBEDDED_PASSWORD,
   DEFAULT_EMBEDDED_POSTGRES_FLAGS: () => DEFAULT_EMBEDDED_POSTGRES_FLAGS,
   DEFAULT_EMBEDDED_USER: () => DEFAULT_EMBEDDED_USER,
   DEFAULT_START_TIMEOUT_MS: () => DEFAULT_START_TIMEOUT_MS,
+  EMBEDDED_MAX_CONNECTIONS_MAX: () => EMBEDDED_MAX_CONNECTIONS_MAX,
+  EMBEDDED_MAX_CONNECTIONS_MIN: () => EMBEDDED_MAX_CONNECTIONS_MIN,
   EmbeddedPostgresLifecycle: () => EmbeddedPostgresLifecycle,
   EmbeddedStartTimeoutError: () => EmbeddedStartTimeoutError,
   __setEmbeddedPostgresCtorForTests: () => __setEmbeddedPostgresCtorForTests,
@@ -39170,6 +39295,7 @@ __export(embedded_lifecycle_exports, {
   normalizeMacosEmbeddedPostgresDylibSymlinks: () => normalizeMacosEmbeddedPostgresDylibSymlinks,
   readPortFromPostmasterPid: () => readPortFromPostmasterPid,
   resolveElectronAsarUnpackedPath: () => resolveElectronAsarUnpackedPath,
+  resolveEmbeddedMaxConnections: () => resolveEmbeddedMaxConnections,
   uninstallElectronAsarNativePathPatchForTests: () => uninstallElectronAsarNativePathPatchForTests
 });
 import {
@@ -39379,6 +39505,23 @@ function materializeEmbeddedPostgresRuntimeBinaries(nativeRoot, options) {
   writeFileSync2(marker, sourceMarker, "utf8");
   return destRoot;
 }
+function isWindowsEmbeddedPostgresBinary(command) {
+  return process.platform === "win32" && typeof command === "string" && /[\\/]bin[\\/](?:postgres|initdb|pg_ctl)\.exe$/i.test(command);
+}
+function withWindowsPostgresSpawnEnvironment(command, rest) {
+  if (!isWindowsEmbeddedPostgresBinary(command)) return rest;
+  const args = [...rest];
+  const optionIndex = args.length - 1;
+  const existing = args[optionIndex];
+  if (!existing || typeof existing !== "object" || Array.isArray(existing)) return args;
+  const binDir = dirname6(command);
+  const nativeRoot = dirname6(binDir);
+  args[optionIndex] = {
+    ...existing,
+    env: withWindowsNativeBinPath(existing.env ?? process.env, nativeRoot)
+  };
+  return args;
+}
 function installElectronAsarNativePathPatch() {
   if (electronAsarNativePathPatchInstalled) return;
   electronAsarNativePathPatchInstalled = true;
@@ -39396,7 +39539,10 @@ function installElectronAsarNativePathPatch() {
   const originalSpawn = childProcessMod.spawn.bind(childProcessMod);
   childProcessMod.spawn = (command, ...rest) => {
     const fixedCommand = typeof command === "string" ? resolveElectronAsarUnpackedPath(command) : command;
-    return originalSpawn(fixedCommand, ...rest);
+    return originalSpawn(
+      fixedCommand,
+      ...withWindowsPostgresSpawnEnvironment(fixedCommand, rest)
+    );
   };
   const fsPromisesMod = require2("fs/promises");
   const originalStat = fsPromisesMod.stat.bind(fsPromisesMod);
@@ -39445,6 +39591,12 @@ function getEmbeddedPostgresCtor() {
 function defaultEmbeddedPostgresFlagsFor(platform4) {
   return platform4 === "win32" ? [] : ["-c", "shared_memory_type=mmap"];
 }
+function resolveEmbeddedMaxConnections(configured, platform4 = process.platform) {
+  if (typeof configured === "number" && Number.isInteger(configured)) {
+    return Math.min(EMBEDDED_MAX_CONNECTIONS_MAX, Math.max(EMBEDDED_MAX_CONNECTIONS_MIN, configured));
+  }
+  return platform4 === "win32" ? DEFAULT_EMBEDDED_MAX_CONNECTIONS_WIN32 : DEFAULT_EMBEDDED_MAX_CONNECTIONS;
+}
 function defaultEmbeddedDataDir() {
   const home = process.env.HOME || process.env.USERPROFILE || process.cwd();
   return join10(home, ".fusion", "embedded-postgres", "default");
@@ -39631,7 +39783,7 @@ function signalNumber(signal) {
       return 0;
   }
 }
-var require2, stagedEmbeddedPgBundleCache, EMBEDDED_PG_BIN_NAMES, MATERIALIZATION_MARKER_VERSION, electronAsarNativePathPatchInstalled, electronAsarNativePathPatchRestore, embeddedPostgresCtorCache, embeddedPostgresCtorIsTestOverride, windowsElevatedAdminForTests, windowsNativeRootForTests, windowsLauncherForTests, log4, DEFAULT_EMBEDDED_USER, DEFAULT_EMBEDDED_PASSWORD, DEFAULT_EMBEDDED_DATABASE, DEFAULT_EMBEDDED_POSTGRES_FLAGS, DEFAULT_EMBEDDED_INITDB_FLAGS, DEFAULT_START_TIMEOUT_MS, PG_VERSION_FILENAME, MACOS_EMBEDDED_DYLIB_SYMLINKS, runningInstances, POSTMASTER_PID_READ_ATTEMPTS, POSTMASTER_PID_READ_RETRY_MS, EmbeddedPostgresLifecycle, EmbeddedStartCancelledError, EmbeddedStartTimeoutError;
+var require2, stagedEmbeddedPgBundleCache, EMBEDDED_PG_BIN_NAMES, MATERIALIZATION_MARKER_VERSION, electronAsarNativePathPatchInstalled, electronAsarNativePathPatchRestore, embeddedPostgresCtorCache, embeddedPostgresCtorIsTestOverride, windowsElevatedAdminForTests, windowsNativeRootForTests, windowsLauncherForTests, log4, DEFAULT_EMBEDDED_USER, DEFAULT_EMBEDDED_PASSWORD, DEFAULT_EMBEDDED_DATABASE, DEFAULT_EMBEDDED_POSTGRES_FLAGS, DEFAULT_EMBEDDED_MAX_CONNECTIONS, DEFAULT_EMBEDDED_MAX_CONNECTIONS_WIN32, EMBEDDED_MAX_CONNECTIONS_MIN, EMBEDDED_MAX_CONNECTIONS_MAX, DEFAULT_EMBEDDED_INITDB_FLAGS, DEFAULT_START_TIMEOUT_MS, PG_VERSION_FILENAME, MACOS_EMBEDDED_DYLIB_SYMLINKS, runningInstances, POSTMASTER_PID_READ_ATTEMPTS, POSTMASTER_PID_READ_RETRY_MS, EmbeddedPostgresLifecycle, EmbeddedStartCancelledError, EmbeddedStartTimeoutError;
 var init_embedded_lifecycle = __esm({
   "../core/src/postgres/embedded-lifecycle.ts"() {
     "use strict";
@@ -39662,6 +39814,10 @@ var init_embedded_lifecycle = __esm({
     DEFAULT_EMBEDDED_PASSWORD = "password";
     DEFAULT_EMBEDDED_DATABASE = "fusion";
     DEFAULT_EMBEDDED_POSTGRES_FLAGS = defaultEmbeddedPostgresFlagsFor(process.platform);
+    DEFAULT_EMBEDDED_MAX_CONNECTIONS = 500;
+    DEFAULT_EMBEDDED_MAX_CONNECTIONS_WIN32 = 150;
+    EMBEDDED_MAX_CONNECTIONS_MIN = 32;
+    EMBEDDED_MAX_CONNECTIONS_MAX = 2e3;
     DEFAULT_EMBEDDED_INITDB_FLAGS = [
       "--encoding=UTF8",
       "--locale=C"
@@ -39704,6 +39860,10 @@ var init_embedded_lifecycle = __esm({
        * on a failure that is handled before the timeout fires.
        */
       startTimer = null;
+      windowsFatalDetector = new WindowsPostgresFatalDetector();
+      recoveryAttempts = 0;
+      recoveryInFlight = null;
+      stopRequested = false;
       constructor(opts) {
         this.options = {
           dataDir: opts.dataDir,
@@ -39718,6 +39878,15 @@ var init_embedded_lifecycle = __esm({
           onError: opts.onError ?? ((err) => log4.error(String(err)))
         };
       }
+      /**
+       * Forward native process output to the existing sink, then schedule recovery
+       * only for a confirmed owned Windows fatal shutdown sequence.
+       */
+      forwardPostgresLog = (message) => {
+        this.options.onLog(message);
+        if (process.platform !== "win32" || !this.running || !this.ownsProcess) return;
+        if (this.windowsFatalDetector.push(message)) void this.recoverWindowsFatalOnce();
+      };
       /** The configured or discovered port. Undefined until assigned (explicit or discovered in `start()`). */
       getPort() {
         return this.options.port ?? this.resolvedPort;
@@ -39814,11 +39983,19 @@ var init_embedded_lifecycle = __esm({
             migrationUrlOverridden: false
           };
         }
+        return this.startBounded();
+      }
+      /**
+       * Start an owned postmaster with the same cancellation and timeout contract
+       * used by public startup. Recovery calls this directly because it must not
+       * join a stale pid file or allocate a new endpoint between pool reconnects.
+       */
+      async startBounded(preferredPort) {
         if (this.options.startTimeoutMs <= 0) {
-          return this.startInternal();
+          return this.startInternal(void 0, preferredPort);
         }
         const controller = new AbortController();
-        const startAttempt = this.startInternal(controller.signal);
+        const startAttempt = this.startInternal(controller.signal, preferredPort);
         let timer2;
         const timeout = new Promise((_resolve, reject) => {
           timer2 = setTimeout(() => {
@@ -39844,12 +40021,9 @@ var init_embedded_lifecycle = __esm({
           this.startTimer = null;
         }
       }
-      /**
-       * The actual start sequence, with no timeout wrapper. Called by {@link start}
-       * either directly (timeout disabled) or via Promise.race with the timeout.
-       */
-      async startInternal(signal) {
-        const port = this.options.port ?? await findFreePort();
+      /** The actual start sequence, invoked only through {@link startBounded}. */
+      async startInternal(signal, preferredPort) {
+        const port = this.options.port ?? preferredPort ?? this.resolvedPort ?? await findFreePort();
         if (signal?.aborted) throw new EmbeddedStartCancelledError(this.options.dataDir);
         this.resolvedPort = port;
         const alreadyInitialized = isDataDirInitialized(this.options.dataDir);
@@ -39863,7 +40037,7 @@ var init_embedded_lifecycle = __esm({
           authMethod: "password",
           initdbFlags: [...this.options.initdbFlags],
           postgresFlags: [...this.options.postgresFlags],
-          onLog: this.options.onLog,
+          onLog: this.forwardPostgresLog,
           onError: this.options.onError
         });
         this.pg = pg;
@@ -39895,7 +40069,7 @@ var init_embedded_lifecycle = __esm({
               dataDir: this.options.dataDir,
               port,
               postgresFlags: this.options.postgresFlags,
-              onLog: this.options.onLog,
+              onLog: this.forwardPostgresLog,
               onError: this.options.onError,
               startTimeoutMs: this.options.startTimeoutMs,
               signal,
@@ -39973,6 +40147,43 @@ var init_embedded_lifecycle = __esm({
           migrationUrlOverridden: false
         };
       }
+      /**
+       * FNXC:PostgresEmbedded 2026-07-22-16:25:
+       * A 0xC0000142 backend crash shuts down its whole PostgreSQL cluster. One
+       * lifecycle-owned retry reuses the initialized directory and same resolved
+       * port; joiners, stop/detach, and a second incident are deliberately inert.
+       */
+      async recoverWindowsFatalOnce() {
+        if (this.recoveryInFlight || this.recoveryAttempts >= 1 || this.stopRequested || !this.ownsProcess) return;
+        this.recoveryAttempts += 1;
+        this.recoveryInFlight = (async () => {
+          this.options.onLog("embedded postgres: detected Windows DLL initialization shutdown; attempting one owned-cluster recovery");
+          try {
+            if (this.nonAdminHandle) await this.nonAdminHandle.stop();
+            else await this.pg?.stop();
+            this.pg = null;
+            this.nonAdminHandle = null;
+            this.running = false;
+            runningInstances.delete(this.options.dataDir);
+            if (this.stopRequested || !this.ownsProcess) return;
+            const recoveryPort = this.resolvedPort;
+            if (recoveryPort === void 0) {
+              throw new Error("embedded postgres: recovery lost its resolved port");
+            }
+            await this.startBounded(recoveryPort);
+            this.options.onLog("embedded postgres: Windows owned-cluster recovery completed; existing pools may reconnect");
+          } catch (error2) {
+            this.running = false;
+            runningInstances.delete(this.options.dataDir);
+            this.options.onError(
+              `embedded postgres: Windows DLL initialization recovery failed after one retry; restart Fusion and inspect the System log. ${error2 instanceof Error ? error2.message : String(error2)}`
+            );
+          } finally {
+            this.recoveryInFlight = null;
+          }
+        })();
+        await this.recoveryInFlight;
+      }
       async settleCancelledStart(pg) {
         if (this.nonAdminHandle) {
           try {
@@ -40119,6 +40330,7 @@ var init_embedded_lifecycle = __esm({
       */
       detachWithoutStop() {
         this.uninstallShutdownHook();
+        this.nonAdminHandle?.stopMonitoring();
         this.pg = null;
         this.nonAdminHandle = null;
         this.running = false;
@@ -40126,6 +40338,7 @@ var init_embedded_lifecycle = __esm({
         runningInstances.delete(this.options.dataDir);
       }
       async stop() {
+        this.stopRequested = true;
         this.uninstallShutdownHook();
         if (!this.ownsProcess) {
           this.running = false;
@@ -52150,10 +52363,10 @@ async function bootSchemaBackendOnce(options, bypassProjectIsolation = false) {
   let resolvedBackend = backend;
   let embeddedDataDir = null;
   if (backend.mode === "embedded") {
-    const { EmbeddedPostgresLifecycle: EmbeddedPostgresLifecycle2, defaultEmbeddedDataDir: defaultEmbeddedDataDir2, DEFAULT_EMBEDDED_DATABASE: DEFAULT_EMBEDDED_DATABASE2 } = await Promise.resolve().then(() => (init_embedded_lifecycle(), embedded_lifecycle_exports));
+    const { EmbeddedPostgresLifecycle: EmbeddedPostgresLifecycle2, defaultEmbeddedDataDir: defaultEmbeddedDataDir2, DEFAULT_EMBEDDED_DATABASE: DEFAULT_EMBEDDED_DATABASE2, resolveEmbeddedMaxConnections: resolveEmbeddedMaxConnections2 } = await Promise.resolve().then(() => (init_embedded_lifecycle(), embedded_lifecycle_exports));
     const { GlobalSettingsStore: GlobalSettingsStore2 } = await Promise.resolve().then(() => (init_global_settings(), global_settings_exports));
     const configuredMaxConnections = process.env.VITEST === "true" && !options.globalSettingsDir ? void 0 : (await new GlobalSettingsStore2(options.globalSettingsDir).getSettings()).embeddedPostgresMaxConnections;
-    const maxConnections = Number.isInteger(configuredMaxConnections) ? Math.min(2e3, Math.max(32, configuredMaxConnections)) : 500;
+    const maxConnections = resolveEmbeddedMaxConnections2(configuredMaxConnections);
     const dataDir = resolve8(options.embeddedDataDir ?? defaultEmbeddedDataDir2());
     embeddedDataDir = dataDir;
     log5.log(`startup-factory: starting embedded PostgreSQL (data dir ${dataDir})`);
@@ -52390,7 +52603,20 @@ async function createTaskStoreForBackend(options) {
     try {
       const fusionDir = join16(rootDir, ".fusion");
       const legacySqlitePath = join16(fusionDir, "fusion.db");
-      if (existsSync11(legacySqlitePath)) {
+      const {
+        migrateSqliteToPostgres: migrateSqliteToPostgres2,
+        defaultMigrationSources: defaultMigrationSources2,
+        formatMigrationProgress: formatMigrationProgress2,
+        isSqliteMigrationComplete: isSqliteMigrationComplete2,
+        completeSqliteMigration: completeSqliteMigration2,
+        recordSqliteMigrationComplete: recordSqliteMigrationComplete2,
+        CENTRAL_SQLITE_MIGRATION_KEY: CENTRAL_SQLITE_MIGRATION_KEY2
+      } = await Promise.resolve().then(() => (init_sqlite_migrator(), sqlite_migrator_exports));
+      const fallbackProjectId = fallbackProjectIdForRoot(rootDir);
+      let migrationProjectId = options.projectId ?? await lookupRegisteredProjectIdByPath(connections.migration, rootDir) ?? fallbackProjectId;
+      let migrationKey = `project:${migrationProjectId}`;
+      let migrationComplete = await isSqliteMigrationComplete2(connections.migration, migrationKey);
+      if (!migrationComplete && existsSync11(legacySqlitePath)) {
         let globalDir = options.globalSettingsDir;
         if (!globalDir) {
           try {
@@ -52400,21 +52626,24 @@ async function createTaskStoreForBackend(options) {
             globalDir = void 0;
           }
         }
-        let migrationProjectId = options.projectId ?? await lookupRegisteredProjectIdByPath(connections.migration, rootDir);
+        let resolvedFromLegacyCentral = false;
+        const centralMigrationComplete = await isSqliteMigrationComplete2(
+          connections.migration,
+          CENTRAL_SQLITE_MIGRATION_KEY2
+        );
         const legacyCentralPath = globalDir ? join16(globalDir, "fusion-central.db") : void 0;
-        if (!migrationProjectId && legacyCentralPath && existsSync11(legacyCentralPath) && isValidSqliteDatabaseFile(legacyCentralPath)) {
+        if (!centralMigrationComplete && migrationProjectId === fallbackProjectId && legacyCentralPath && existsSync11(legacyCentralPath) && isValidSqliteDatabaseFile(legacyCentralPath)) {
           const { DatabaseSync: DatabaseSync2 } = await Promise.resolve().then(() => (init_sqlite_adapter(), sqlite_adapter_exports));
           const legacyCentral = new DatabaseSync2(legacyCentralPath, { readOnly: true });
           try {
             const row = legacyCentral.prepare(`SELECT id FROM projects WHERE path = ? LIMIT 1`).get(rootDir);
-            migrationProjectId = row?.id;
+            migrationProjectId = row?.id ?? migrationProjectId;
+            resolvedFromLegacyCentral = Boolean(row?.id);
           } catch {
           } finally {
             legacyCentral.close();
           }
         }
-        const fallbackProjectId = fallbackProjectIdForRoot(rootDir);
-        migrationProjectId ??= fallbackProjectId;
         if (migrationProjectId !== fallbackProjectId) {
           try {
             await rekeyFallbackProjectPartition(connections.migration, fallbackProjectId, migrationProjectId);
@@ -52430,14 +52659,9 @@ async function createTaskStoreForBackend(options) {
             }
           }
         }
-        const migrationKey = `project:${migrationProjectId ?? rootDir}`;
-        const { migrateSqliteToPostgres: migrateSqliteToPostgres2, migrateLegacyProjectPluginRows: migrateLegacyProjectPluginRows2, defaultMigrationSources: defaultMigrationSources2, formatMigrationProgress: formatMigrationProgress2, isSqliteMigrationComplete: isSqliteMigrationComplete2, completeSqliteMigration: completeSqliteMigration2, recordSqliteMigrationComplete: recordSqliteMigrationComplete2, CENTRAL_SQLITE_MIGRATION_KEY: CENTRAL_SQLITE_MIGRATION_KEY2 } = await Promise.resolve().then(() => (init_sqlite_migrator(), sqlite_migrator_exports));
-        const migrationComplete = await isSqliteMigrationComplete2(connections.migration, migrationKey);
+        migrationKey = `project:${migrationProjectId}`;
+        migrationComplete = await isSqliteMigrationComplete2(connections.migration, migrationKey);
         if (!migrationComplete && isValidSqliteDatabaseFile(legacySqlitePath)) {
-          const centralMigrationComplete = await isSqliteMigrationComplete2(
-            connections.migration,
-            CENTRAL_SQLITE_MIGRATION_KEY2
-          );
           const sources = defaultMigrationSources2(fusionDir, globalDir ?? join16(fusionDir, "__no-global-dir__")).filter((source) => !centralMigrationComplete || source.pgSchema !== "central").filter((source) => existsSync11(source.sqlitePath) && isValidSqliteDatabaseFile(source.sqlitePath));
           if (sources.length > 0) {
             log5.log(`startup-factory: empty PostgreSQL database with legacy SQLite data present \u2014 auto-migrating ${sources.length} source(s) (SQLite files are kept as backups)`);
@@ -52472,6 +52696,12 @@ async function createTaskStoreForBackend(options) {
                 rootDir
               });
             }
+            if (resolvedFromLegacyCentral) {
+              const registeredId = await lookupRegisteredProjectIdByPath(connections.migration, rootDir);
+              if (registeredId !== migrationProjectId) {
+                throw new Error(`legacy project identity ${migrationProjectId} was not materialized for ${rootDir} before migration completion`);
+              }
+            }
             await completeSqliteMigration2(connections.migration, migrationKey);
             if (sources.some((source) => source.pgSchema === "central")) {
               await recordSqliteMigrationComplete2(
@@ -52489,14 +52719,9 @@ async function createTaskStoreForBackend(options) {
             log5.log(`startup-factory: SQLite \u2192 PostgreSQL auto-migration complete (${migratedRows} row(s) across ${report.tables.length} table(s))`);
           }
         }
-        if (isValidSqliteDatabaseFile(legacySqlitePath)) {
-          await migrateLegacyProjectPluginRows2(
-            connections.migration,
-            legacySqlitePath,
-            rootDir
-          );
-        }
       }
+      const { migrateLegacyProjectPluginRows: migrateLegacyProjectPluginRows2 } = await Promise.resolve().then(() => (init_sqlite_migrator(), sqlite_migrator_exports));
+      await migrateLegacyProjectPluginRows2(connections.migration, legacySqlitePath, rootDir);
     } catch (err) {
       await connections.close().catch(() => void 0);
       await stopEmbeddedRuntime(
@@ -62163,6 +62388,7 @@ var init_persistence = __esm({
       defineTaskColumn("overlapBlockedBy", (task) => task.overlapBlockedBy ?? null),
       defineTaskColumn("paused", (task) => task.paused ? 1 : 0),
       defineTaskColumn("pausedReason", (task) => task.pausedReason ?? null),
+      defineTaskColumn("wedgeNotification", (task) => toJsonNullable(task.wedgeNotification)),
       defineTaskColumn("userPaused", (task) => task.userPaused ? 1 : 0),
       defineTaskColumn("baseBranch", (task) => task.baseBranch ?? null),
       defineTaskColumn("branch", (task) => task.branch ?? null),
@@ -62572,6 +62798,7 @@ function rowToTask(row) {
     overlapBlockedBy: row.overlapBlockedBy || void 0,
     paused: row.paused ? true : void 0,
     pausedReason: row.pausedReason || void 0,
+    wedgeNotification: fromJson(row.wedgeNotification) ?? void 0,
     userPaused: row.userPaused ? true : void 0,
     baseBranch: row.baseBranch || void 0,
     executionStartBranch: row.executionStartBranch || void 0,
@@ -84827,6 +85054,7 @@ function getTaskSelectClauseImpl2(store, slim, tableAlias) {
     "overlapBlockedBy",
     "paused",
     "pausedReason",
+    "wedgeNotification",
     "userPaused",
     "baseBranch",
     "branch",
@@ -91545,7 +91773,7 @@ var init_async_eval_store = __esm({
   }
 });
 
-// ../core/src/task-store/remaining-ops-1.ts
+// ../core/src/task-store/project-store-ops.ts
 import { randomUUID as randomUUID33 } from "node:crypto";
 import { mkdir as mkdir13, writeFile as writeFile12 } from "node:fs/promises";
 import { join as join33 } from "node:path";
@@ -92413,8 +92641,8 @@ function getEvalStoreImpl(store) {
   return store.evalStore;
 }
 var workflowDefinitionBeforeInsertForTesting;
-var init_remaining_ops_1 = __esm({
-  "../core/src/task-store/remaining-ops-1.ts"() {
+var init_project_store_ops = __esm({
+  "../core/src/task-store/project-store-ops.ts"() {
     "use strict";
     init_store();
     init_errors3();
@@ -99114,6 +99342,11 @@ async function updateTaskUnlockedImpl(store, id, updates, runContext) {
     } else if (updates.pausedReason !== void 0) {
       task.pausedReason = updates.pausedReason;
     }
+    if (updates.wedgeNotification === null) {
+      task.wedgeNotification = void 0;
+    } else if (updates.wedgeNotification !== void 0) {
+      task.wedgeNotification = updates.wedgeNotification;
+    }
     if (updates.tokenBudgetSoftAlertedAt === null) {
       task.tokenBudgetSoftAlertedAt = void 0;
     } else if (updates.tokenBudgetSoftAlertedAt !== void 0) {
@@ -99776,7 +100009,7 @@ var init_store = __esm({
     init_task_store_helpers();
     init_task_row_mappers();
     init_task_mutation_ops();
-    init_remaining_ops_1();
+    init_project_store_ops();
     init_workflow_integrity();
     init_branch_group_ops();
     init_archive_lifecycle_2();
@@ -100640,6 +100873,26 @@ var init_store = __esm({
       async updateTask(id, updates, runContext) {
         return updateTaskImpl(this, id, updates, runContext);
       }
+      /**
+       * Atomically opens or resolves the durable task-wedge episode. The task lock is
+       * shared by SQLite and PostgreSQL persistence writes, so concurrent engine
+       * observers cannot allocate two episodes for one active normalized reason.
+       */
+      async claimTaskWedgeNotificationEpisode(taskId, reasonKey) {
+        let result = { claimed: false };
+        await this.updateTaskAtomic(taskId, (current) => {
+          const prior = current.wedgeNotification;
+          if (reasonKey === null) {
+            if (!prior || prior.status === "resolved") return null;
+            return { wedgeNotification: { ...prior, status: "resolved", transitionedAt: (/* @__PURE__ */ new Date()).toISOString() } };
+          }
+          if (prior?.status === "active" && prior.reasonKey === reasonKey) return null;
+          const episodeId = randomUUID37();
+          result = { episodeId, claimed: true };
+          return { wedgeNotification: { reasonKey, episodeId, status: "active", transitionedAt: (/* @__PURE__ */ new Date()).toISOString() } };
+        });
+        return result;
+      }
       async claimNextToolFailureRetry(taskId, expectedCursor, maxRetries) {
         return claimNextToolFailureRetryImpl(this, taskId, expectedCursor, maxRetries);
       }
@@ -172025,6 +172278,7 @@ var init_ntfy_provider = __esm({
       "in-review",
       "merged",
       "failed",
+      "task-wedged",
       "awaiting-approval",
       "awaiting-user-review",
       "planning-awaiting-input",
@@ -172128,6 +172382,15 @@ var init_ntfy_provider = __esm({
             message: `Task "${identifier}" has failed and needs attention`,
             priority: "high"
           },
+          "task-wedged": {
+            title: `Task ${taskId} needs operator action`,
+            message: [
+              `Task "${identifier}" is wedged${typeof payload.metadata?.reason === "string" ? `: ${payload.metadata.reason}` : " and needs operator action"}`,
+              typeof payload.metadata?.gate === "string" ? `Gate: ${payload.metadata.gate}` : null,
+              typeof payload.metadata?.action === "string" ? `Recommended action: ${payload.metadata.action}` : null
+            ].filter((part) => part !== null).join("\n"),
+            priority: "high"
+          },
           "awaiting-approval": {
             title: payload.metadata?.awaitingApprovalReason === "plan-review-replan-cap" ? `Plan Review cap reached for ${taskId}` : `Plan needs approval for ${taskId}`,
             /*
@@ -172482,6 +172745,132 @@ var init_transient_merge_error_classifier = __esm({
   }
 });
 
+// ../engine/src/notification/task-wedge-notification.ts
+function describeSelfHealingNoActionWedge(task, stage, metadata) {
+  const description = SELF_HEALING_NO_ACTIONS[stage];
+  if (!description || task.userPaused || task.paused || task.autoMerge === false) return null;
+  const proof = metadata ?? {};
+  if (proof.taskActive === true || proof.hasExecutingTaskLock === true || proof.mergePending === true) return null;
+  if (Array.isArray(proof.livePaths) && proof.livePaths.length > 0) return null;
+  return { reasonKey: `self-healing-no-action:${stage}`, ...description };
+}
+function describeTaskWedge(task) {
+  const error2 = task.error ?? "";
+  if (task.pausedReason === "completed-blocked") {
+    return { reasonKey: "completion-blocked", reason: "Completed work is blocked from advancing to review.", action: "Clear the blocker or reset the task to todo." };
+  }
+  if (task.pausedReason === "error-retry-exhausted") {
+    return { reasonKey: "heartbeat-retry-exhausted", reason: "The assigned agent exhausted its heartbeat recovery budget.", action: "Repair the agent configuration, then retry the task." };
+  }
+  if (task.pausedReason === "error-unrecoverable") {
+    return { reasonKey: "heartbeat-error-unrecoverable", reason: "The assigned agent needs operator repair before it can resume.", action: "Repair credentials, access, or configuration, then retry the task." };
+  }
+  const pausedDescriptors = {
+    "branch-cross-contamination": { reasonKey: "branch-cross-contamination", reason: "Branch contamination recovery requires operator intervention.", action: "Inspect the branch history, repair the contamination, then retry or reset to todo." },
+    "branch-conflict-tripwire": { reasonKey: "branch-conflict-tripwire", reason: "A repeated branch conflict stopped automatic recovery.", action: "Resolve the branch conflict, then retry or reset to todo." },
+    "branch-conflict-recovery-exhausted": { reasonKey: "branch-conflict-recovery-exhausted", reason: "Branch conflict recovery retries were exhausted.", action: "Resolve the conflict, then retry or reset to todo." },
+    "branch-conflict-unrecoverable": { reasonKey: "branch-conflict-unrecoverable", reason: "An unrecoverable branch conflict needs operator intervention.", action: "Resolve the conflict or reset the task to todo and retry." },
+    "stuck-loop-exhausted-manual-intervention-required": { reasonKey: "stuck-loop-exhausted", reason: "Self-healing exhausted its stalled-task recovery loop.", action: "Inspect the task state, then retry or reset to todo." },
+    "non-retryable-provider-error": { reasonKey: "non-retryable-provider-error", reason: "A non-retryable provider error stopped the task.", action: "Repair provider access or configuration, then retry the task." },
+    "in-review-stall-deadlock": { reasonKey: "in-review-stall-deadlock", reason: "Review stalled in a deadlock that needs operator intervention.", action: "Inspect review ownership and retry or reset to todo." }
+  };
+  if (task.pausedReason && pausedDescriptors[task.pausedReason]) return pausedDescriptors[task.pausedReason];
+  if (task.status !== "failed") return null;
+  if (error2.startsWith("EXECUTION_DISPATCH_LOOP_EXHAUSTED")) {
+    return { reasonKey: "execution-dispatch-loop-exhausted", reason: "Execution re-queued without progress until its retry budget was exhausted.", action: "Retry, decompose, or rescope the task." };
+  }
+  if (error2.includes("tool failure") || error2.includes("Tool failure")) {
+    return { reasonKey: "tool-failure-retry-exhausted", reason: "Execution tool-failure retries were exhausted.", action: "Inspect the failing tool and retry the task." };
+  }
+  if (/escalat(?:ion|ed).*exhaust|exhaust.*escalat/i.test(error2)) {
+    return { reasonKey: "execution-escalation-exhausted", reason: "The alternate execution escalation was exhausted.", action: "Inspect the failure and retry or rescope the task." };
+  }
+  if (/review.*(?:retry|rework|revision).*(?:exhaust|limit)|(?:exhaust|limit).*review/i.test(error2)) {
+    return { reasonKey: "review-retry-exhausted", reason: "The configured review recovery budget was exhausted.", action: "Review the feedback, fix the task, or use the approved review recovery action." };
+  }
+  const gate = error2.match(/check:([\w:-]+)/)?.[1];
+  if (gate) {
+    return {
+      reasonKey: `merge-blocked:${gate}`,
+      reason: `Merge is blocked by the check:${gate} verification gate.`,
+      action: gate === "changeset-format" ? "Fix the changeset format, then retry the task." : "Fix the failing gate or reset the task to todo and retry.",
+      gate: `check:${gate}`
+    };
+  }
+  if (error2.startsWith("BLOCKED:")) {
+    return { reasonKey: "execution-blocked", reason: "Execution was parked because an external blocker requires operator action.", action: "Resolve the dependency or blocker, then retry the task." };
+  }
+  if (/merge.*(?:blocked|verification|gate)|(?:verification|gate).*(?:failed|exhaust)/i.test(error2)) {
+    return { reasonKey: "merge-blocked", reason: "Merge verification cannot progress without operator action.", action: "Fix the failing verification, then retry the task." };
+  }
+  if (!error2 && (task.mergeRetries ?? 0) < 3) return null;
+  return {
+    reasonKey: "terminal-failed",
+    reason: "The task entered a terminal failed state and needs operator intervention.",
+    action: "Inspect the task error, fix the underlying issue, then retry or reset to todo."
+  };
+}
+var SELF_HEALING_NO_ACTIONS;
+var init_task_wedge_notification = __esm({
+  "../engine/src/notification/task-wedge-notification.ts"() {
+    "use strict";
+    SELF_HEALING_NO_ACTIONS = {
+      "reclaim-pr-conflict": {
+        reason: "Self-healing could not reclaim a stalled pull-request conflict.",
+        action: "Inspect the branch conflict and retry or reset the task to todo."
+      },
+      "reclaim-self-owned-branch-conflict": {
+        reason: "Self-healing could not recover a stalled branch conflict.",
+        action: "Inspect the branch conflict and retry or reset the task to todo."
+      },
+      "reconcile-in-review-unmet-dependencies": {
+        reason: "Unmet dependencies are preventing review from progressing.",
+        action: "Resolve the dependencies, then retry or reset the task to todo."
+      },
+      "reconcile-dependency-blocking-lease": {
+        reason: "A dependency-blocking task lease could not be safely reclaimed.",
+        action: "Inspect the task owner and lease, then retry or reset the task to todo."
+      },
+      "auto-rebound-paused-scope-decay": {
+        reason: "A paused task with stale scope could not be safely resumed.",
+        action: "Inspect the task scope and retry or reset the task to todo."
+      },
+      "stuck-merge-deadlock": {
+        reason: "A merge deadlock needs operator intervention.",
+        action: "Inspect merge ownership and retry or reset the task to todo."
+      },
+      "missing-worktree-merge-active": {
+        reason: "An active merge has an unusable worktree and could not be recovered.",
+        action: "Repair the worktree or reset the task to todo and retry."
+      },
+      "missing-worktree-review": {
+        reason: "Review has an unusable worktree and could not be recovered.",
+        action: "Repair the worktree or reset the task to todo and retry."
+      },
+      "finalize-no-op-review": {
+        reason: "A no-op review task could not be safely finalized.",
+        action: "Inspect merge state and retry or reset the task to todo."
+      },
+      "stale-incomplete-review": {
+        reason: "Incomplete review work could not be safely resumed.",
+        action: "Inspect incomplete steps and retry or reset the task to todo."
+      },
+      "ghost-review": {
+        reason: "A review task has no recoverable workflow owner.",
+        action: "Inspect workflow state and retry or reset the task to todo."
+      },
+      "no-progress-no-task-done": {
+        reason: "Execution stopped without progress and could not be safely requeued.",
+        action: "Inspect the task worktree and retry or reset the task to todo."
+      },
+      "partial-progress-no-task-done": {
+        reason: "Partial execution progress could not be safely resumed.",
+        action: "Inspect partial work and retry or reset the task to todo."
+      }
+    };
+  }
+});
+
 // ../engine/src/notification/notification-service.ts
 var NotificationService;
 var init_notification_service = __esm({
@@ -172493,6 +172882,7 @@ var init_notification_service = __esm({
     init_transient_merge_error_classifier();
     init_ntfy_provider();
     init_webhook_provider();
+    init_task_wedge_notification();
     NotificationService = class {
       constructor(store, options = {}) {
         this.store = store;
@@ -172523,6 +172913,8 @@ var init_notification_service = __esm({
       failureNotificationSuppressedCount = 0;
       failureNotificationDelayMs = 6e4;
       failureNotificationMode = "sticky-only";
+      /** Compatibility fallback for lightweight test stores without the durable TaskStore CAS. */
+      activeWedgeReasons = /* @__PURE__ */ new Map();
       attachChatStore(chatStore) {
         if (this.chatStore && this.chatStore !== chatStore) {
           this.detachChatStoreListener(this.chatStore);
@@ -172634,6 +173026,10 @@ var init_notification_service = __esm({
         }
       }
       handleTaskUpdated = (task) => {
+        const transientFailure = task.status === "failed" ? classifyTransientMergeError(task.error) : null;
+        const wedge = transientFailure ? null : describeTaskWedge(task);
+        if (wedge) this.cancelPendingFailureNotification(task.id, "classified-terminal-wedge");
+        if (!transientFailure) void this.maybeNotifyTaskWedge(task, wedge);
         void this.maybeSuppressTransientFailedNotification(task, `status=${task.status ?? "undefined"}`);
         if (task.status === "awaiting-approval") {
           void this.writeAwaitingApprovalMailboxMessage(task);
@@ -172644,7 +173040,7 @@ var init_notification_service = __esm({
         if (!this.notificationsEnabled) {
           return;
         }
-        if (task.status === "failed") {
+        if (task.status === "failed" && !wedge) {
           const transientClass = classifyTransientMergeError(task.error);
           if (transientClass) {
             this.failureNotificationSuppressedCount += 1;
@@ -172730,6 +173126,69 @@ var init_notification_service = __esm({
           );
         }
       }
+      /*
+      FNXC:TaskWedgeNotifications 2026-07-22-12:00:
+      Terminal task updates are the shared seam for merger, executor, heartbeat, and
+      self-healing parks. Clear only on a non-wedge lifecycle update, allowing a
+      resolved-then-reparked reason to begin a new actionable episode.
+      */
+      /** Delivers a self-healing no-action escalation through the durable wedge episode seam. */
+      async notifyTaskWedge(task, descriptor) {
+        await this.maybeNotifyTaskWedge(task, descriptor);
+      }
+      async maybeNotifyTaskWedge(task, suppliedDescriptor) {
+        const descriptor = suppliedDescriptor ?? describeTaskWedge(task);
+        let episode;
+        if (!descriptor) {
+          const isActiveSelfHealingNoAction = task.wedgeNotification?.status === "active" && task.wedgeNotification.reasonKey.startsWith("self-healing-no-action:");
+          const hasProgressed = task.column === "todo" || task.column === "in-progress" || task.column === "done" || task.column === "archived" || !isActiveSelfHealingNoAction && typeof task.status === "string" && task.status !== "failed" || isActiveSelfHealingNoAction && ["queued", "planning", "in-progress", "merging", "merging-pr", "merged", "done"].includes(task.status ?? "");
+          if (hasProgressed) {
+            this.activeWedgeReasons.delete(task.id);
+            await this.store.claimTaskWedgeNotificationEpisode?.(task.id, null);
+          }
+          return;
+        }
+        if (this.store.claimTaskWedgeNotificationEpisode) {
+          const claim = await this.store.claimTaskWedgeNotificationEpisode(task.id, descriptor.reasonKey);
+          if (!claim.claimed || !claim.episodeId) return;
+          episode = claim.episodeId;
+        } else {
+          if (this.activeWedgeReasons.get(task.id) === descriptor.reasonKey) return;
+          this.activeWedgeReasons.set(task.id, descriptor.reasonKey);
+          episode = `${task.id}:${descriptor.reasonKey}:${task.updatedAt}`;
+        }
+        const link = buildNtfyClickUrl({ dashboardHost: this.dashboardHost, projectId: this.options.projectId, taskId: task.id });
+        const content = [
+          `**${formatTaskIdentifier(task)} needs operator action**`,
+          "",
+          descriptor.reason,
+          ...descriptor.gate ? [`Gate: \`${descriptor.gate}\`.`] : [],
+          `Recommended action: ${descriptor.action}`,
+          ...link ? ["", `[Open ${task.id}](${link})`] : []
+        ].join("\n");
+        const payload = {
+          taskId: task.id,
+          taskTitle: task.title,
+          taskDescription: task.description,
+          event: "task-wedged",
+          // Bounded descriptor text is operator-facing provider content, never audit metadata.
+          metadata: { wedgeReason: descriptor.reasonKey, reason: descriptor.reason, action: descriptor.action, ...descriptor.gate ? { gate: descriptor.gate } : {}, notificationDedupeKey: `task-wedge:${episode}` }
+        };
+        void this.dispatch("task-wedged", payload);
+        try {
+          await this.options.messageStore?.sendMessageOnce?.({
+            fromId: "system",
+            fromType: "system",
+            toId: DASHBOARD_USER_ID,
+            toType: "user",
+            type: "system",
+            content,
+            metadata: { taskId: task.id, kind: "task-wedge", wedgeReason: descriptor.reasonKey, ...descriptor.gate ? { gate: descriptor.gate } : {} }
+          }, `task-wedge:${episode}`);
+        } catch (error2) {
+          schedulerLog.log(`[notify] ${task.id} wedge mailbox message failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        }
+      }
       isTriageDuplicateDecision(task) {
         return task.paused === true && task.pausedReason === "duplicate-decision-required" && task.sourceMetadata?.duplicateSource === "triage-marker" && typeof task.sourceMetadata.nearDuplicateOf === "string";
       }
@@ -173095,6 +173554,11 @@ var init_notification_service = __esm({
           );
           return;
         }
+        if (describeTaskWedge(task)) {
+          this.failureNotificationSuppressedCount += 1;
+          schedulerLog.log(`[notify] ${taskId} classified terminal wedge at dispatch time \u2014 suppressed generic failed notification`);
+          return;
+        }
         const isTerminal2 = task.paused === true || task.column === "in-review";
         if (this.failureNotificationMode === "terminal-only" && !isTerminal2) {
           this.failureNotificationSuppressedCount += 1;
@@ -173923,7 +174387,10 @@ var init_notifier = __esm({
     DEFAULT_NTFY_EVENTS = [
       "in-review",
       "merged",
+      // FNXC:TaskWedgeNotifications 2026-07-22-19:00: Wedge episodes are operator
+      // escalation events, so normal Ntfy defaults must not silently filter them.
       "failed",
+      "task-wedged",
       "awaiting-approval",
       "awaiting-user-review",
       "planning-awaiting-input",
@@ -200471,6 +200938,7 @@ var init_self_healing = __esm({
     init_dependency_blocked_todo_reporter();
     init_scheduler();
     init_task_agent_sync();
+    init_task_wedge_notification();
     init_self_healing_constants();
     init_self_healing_constants();
     init_self_healing_branch();
@@ -200778,6 +201246,15 @@ var init_self_healing = __esm({
           const message = error2 instanceof Error ? error2.message : String(error2);
           log28.warn(`[${stage}] ${task.id}: no-action audit emission failed: ${message}`);
         }
+        const descriptor = describeSelfHealingNoActionWedge(task, stage, proof.metadata);
+        if (descriptor) {
+          try {
+            await getActiveNotificationService()?.notifyTaskWedge(task, descriptor);
+          } catch (error2) {
+            const message = error2 instanceof Error ? error2.message : String(error2);
+            log28.warn(`[${stage}] ${task.id}: wedge notification failed: ${message}`);
+          }
+        }
         log28.log(`[${stage}] ${task.id}: triple-proof not satisfied \u2014 no action (operator-decides)`);
       }
       /*
@@ -261747,6 +262224,40 @@ async function resolvePlanningModeSystemPrompt(store, promptOverrides, workflowI
 
 ${PLANNING_SYSTEM_PROMPT}`;
 }
+function isPlanningTurnActive(sessionId) {
+  return activeGenerations.has(sessionId) || pendingTurnReservations.has(sessionId);
+}
+function reservePlanningTurn(sessionId) {
+  if (isPlanningTurnActive(sessionId)) {
+    throw new GenerationInProgressError("Generation already in progress");
+  }
+  let resolveDone;
+  const done = new Promise((resolve51) => {
+    resolveDone = resolve51;
+  });
+  const reservation = { done, resolveDone };
+  pendingTurnReservations.set(sessionId, reservation);
+  return () => {
+    if (pendingTurnReservations.get(sessionId) === reservation) {
+      pendingTurnReservations.delete(sessionId);
+    }
+    reservation.resolveDone();
+  };
+}
+function trackTurnOperationSettled(sessionId, operationPromise) {
+  const settled = operationPromise.then(
+    () => {
+    },
+    () => {
+    }
+  );
+  settlingTurnOperations.set(sessionId, settled);
+  void settled.then(() => {
+    if (settlingTurnOperations.get(sessionId) === settled) {
+      settlingTurnOperations.delete(sessionId);
+    }
+  });
+}
 function isTaskPriority2(value) {
   return typeof value === "string" && TASK_PRIORITIES.includes(value);
 }
@@ -262090,7 +262601,7 @@ async function getFirstQuestionFromAgent(session, message) {
   if (!session.agent) {
     throw new InvalidSessionStateError("AI agent not initialized");
   }
-  await session.agent.session.prompt(message);
+  await promptPlanningAgent(session.agent.session, message);
   const lastMessage = session.agent.session.state.messages.filter((m2) => m2.role === "assistant").pop();
   let responseText = "";
   if (lastMessage?.content) {
@@ -262129,7 +262640,8 @@ async function getFirstQuestionFromAgent(session, message) {
       lastError = err instanceof Error ? err : new Error(String(err));
       if (attempt < MAX_PARSE_RETRIES2) {
         try {
-          await session.agent.session.prompt(
+          await promptPlanningAgent(
+            session.agent.session,
             'Your previous response could not be parsed as JSON. Please respond with ONLY a valid JSON object: {"type":"question","data":{"runningPlan":{...},...}}. No markdown, no explanation, just the JSON.'
           );
           const retryMessage = session.agent.session.state.messages.filter((m2) => m2.role === "assistant").pop();
@@ -262189,7 +262701,8 @@ function buildMandatoryFirstPlanningQuestion(userInput = "") {
 }
 async function requestMandatoryFirstPlanningQuestion(session, abortSignal) {
   try {
-    await session.agent.session.prompt(
+    await promptPlanningAgent(
+      session.agent.session,
       'Before producing a plan, ask one clarifying question. Return ONLY valid JSON: {"type":"question","data":{...}}.',
       { signal: abortSignal }
     );
@@ -262212,6 +262725,8 @@ async function createPlanningAgent(session, rootDir, store, modelProvider, model
   await ensureEngineReady();
   const systemPrompt = await resolvePlanningModeSystemPrompt(store, promptOverrides, session.workflowId);
   const skillContext = buildSessionSkillContextSync(null, "executor", rootDir, pluginRunner);
+  const callbackEpoch = session.agentCallbackEpoch ?? 0;
+  const callbacksInvalidated = () => (session.agentCallbackEpoch ?? 0) !== callbackEpoch;
   return createFnAgent4({
     cwd: rootDir,
     systemPrompt,
@@ -262235,6 +262750,7 @@ async function createPlanningAgent(session, rootDir, store, modelProvider, model
     } : {},
     ...thinkingLevel ? { defaultThinkingLevel: thinkingLevel } : {},
     onThinking: (delta) => {
+      if (callbacksInvalidated()) return;
       markPlanningGenerationProgress(session.id, delta);
       session.thinkingOutput += delta;
       persistThinking(session.id, session.thinkingOutput);
@@ -262244,6 +262760,7 @@ async function createPlanningAgent(session, rootDir, store, modelProvider, model
       });
     },
     onText: (delta) => {
+      if (callbacksInvalidated()) return;
       markPlanningGenerationProgress(session.id, delta);
       session.thinkingOutput += delta;
       persistThinking(session.id, session.thinkingOutput);
@@ -262290,7 +262807,7 @@ async function ensureSessionAgent(session, rootDir, historyForReplay, promptOver
     if (abortSignal.aborted) {
       throw createAbortError2();
     }
-    await session.agent.session.prompt(contextMessage, {
+    await promptPlanningAgent(session.agent.session, contextMessage, {
       signal: abortSignal
     });
     if (abortSignal.aborted) {
@@ -262328,7 +262845,7 @@ async function maybeNotifyPlanningAwaitingInput(session, question, proactiveClar
   }
 }
 function buildRetryableParseErrorMessage(error2) {
-  const baseMessage = (error2?.message || "Failed to parse AI response").replace(/\s*Please try again\.?\s*$/i, "").trim();
+  const baseMessage = (error2?.message || "Failed to parse AI response").replace(/\s*Please try again\.?\s*$/i, "").replace(/[.\s]+$/, "").trim();
   return `${baseMessage}. Retry this planning session or start a new one.`;
 }
 function setSessionError(session, message) {
@@ -262345,6 +262862,19 @@ function createAbortError2() {
   error2.name = "AbortError";
   return error2;
 }
+async function promptPlanningAgent(agentSession, message, options) {
+  let promptWithFallback2;
+  try {
+    promptWithFallback2 = promptWithFallback;
+  } catch {
+    promptWithFallback2 = void 0;
+  }
+  if (typeof promptWithFallback2 === "function") {
+    await promptWithFallback2(agentSession, message, options);
+    return;
+  }
+  await agentSession.prompt(message, options);
+}
 function normalizeGenerationProgress(output) {
   return output.replace(/\s+/g, " ").trim();
 }
@@ -262420,7 +262950,9 @@ async function runGenerationWithTimeout(session, operation) {
     );
   });
   try {
-    return await Promise.race([operation(abortController.signal), abortPromise]);
+    const operationPromise = operation(abortController.signal);
+    trackTurnOperationSettled(session.id, operationPromise);
+    return await Promise.race([operationPromise, abortPromise]);
   } finally {
     clearTimeout(generationRecord.timer);
     if (activeGenerations.get(session.id) === generationRecord) {
@@ -262572,7 +263104,7 @@ async function continueAgentConversation(session, message) {
       if (abortSignal.aborted) {
         throw createAbortError2();
       }
-      await session.agent.session.prompt(message, {
+      await promptPlanningAgent(session.agent.session, message, {
         signal: abortSignal
       });
       if (abortSignal.aborted) {
@@ -262622,7 +263154,8 @@ async function continueAgentConversation(session, message) {
               if (abortSignal.aborted) {
                 throw createAbortError2();
               }
-              await session.agent.session.prompt(
+              await promptPlanningAgent(
+                session.agent.session,
                 'Your previous response could not be parsed as JSON. Please respond with ONLY a valid JSON object: {"type":"question","data":{"runningPlan":{...},...}}. No markdown, no explanation, just the JSON.',
                 { signal: abortSignal }
               );
@@ -262898,57 +263431,62 @@ async function submitResponse(sessionId, responses, rootDir, promptOverrides, st
   }
   if (store && !session.store) session.store = store;
   if (rootDir && !session.rootDir) session.rootDir = rootDir;
-  if (activeGenerations.has(session.id)) {
+  if (isPlanningTurnActive(session.id)) {
     if (didSubmitSameAnswer(session, responses)) {
       throw new GenerationInProgressError("Generation already in progress for this response");
     }
     throw new GenerationInProgressError("Generation already in progress");
   }
+  const releaseTurn = reservePlanningTurn(session.id);
   let answeredQuestion;
-  if (isRefineRequest(responses) && session.summary) {
-    beginPlanningGeneration(session, "question");
-    session.currentQuestion = void 0;
-    session.error = void 0;
-    await persistSession(session, "generating");
-    await ensureSessionAgent(session, rootDir, session.history, promptOverrides, store);
-    const focus = typeof responses.focus === "string" ? responses.focus.trim() : void 0;
-    const refineMessage = formatRefineRequestForAgent(session.summary, focus);
-    await continueAgentConversation(session, refineMessage);
-  } else if (!session.currentQuestion) {
-    throw new InvalidSessionStateError("No active question in session");
-  } else {
-    const currentQuestion = captureOtherCustomText(session.currentQuestion, responses);
-    const historyEntry = {
-      question: currentQuestion,
-      response: responses,
-      thinkingOutput: session.lastGeneratedThinking || ""
-    };
-    session.error = void 0;
-    const editIndex = session.editingQuestionId ? session.history.findIndex((entry) => entry.question.id === session.editingQuestionId) : -1;
-    const isEditingPriorAnswer = editIndex >= 0;
-    if (isEditingPriorAnswer) {
-      session.history[editIndex] = historyEntry;
-      session.editingQuestionId = void 0;
-      session.summary = buildRunningSummary(session.initialPlan, session.history);
-      disposeSessionAgentForRetry(session);
+  try {
+    if (isRefineRequest(responses) && session.summary) {
+      beginPlanningGeneration(session, "question");
+      session.currentQuestion = void 0;
+      session.error = void 0;
+      await persistSession(session, "generating");
+      await ensureSessionAgent(session, rootDir, session.history, promptOverrides, store);
+      const focus = typeof responses.focus === "string" ? responses.focus.trim() : void 0;
+      const refineMessage = formatRefineRequestForAgent(session.summary, focus);
+      await continueAgentConversation(session, refineMessage);
+    } else if (!session.currentQuestion) {
+      throw new InvalidSessionStateError("No active question in session");
     } else {
-      session.history.push(historyEntry);
-    }
-    answeredQuestion = currentQuestion;
-    beginPlanningGeneration(session, "plan_update");
-    session.currentQuestion = void 0;
-    await persistSession(session, "generating");
-    if (!session.agent) {
-      await ensureSessionAgent(
-        session,
-        rootDir,
-        isEditingPriorAnswer ? session.history : session.history.slice(0, -1),
-        promptOverrides,
-        store
-      );
+      const currentQuestion = captureOtherCustomText(session.currentQuestion, responses);
+      const historyEntry = {
+        question: currentQuestion,
+        response: responses,
+        thinkingOutput: session.lastGeneratedThinking || ""
+      };
+      session.error = void 0;
+      const editIndex = session.editingQuestionId ? session.history.findIndex((entry) => entry.question.id === session.editingQuestionId) : -1;
+      const isEditingPriorAnswer = editIndex >= 0;
+      if (isEditingPriorAnswer) {
+        session.history[editIndex] = historyEntry;
+        session.editingQuestionId = void 0;
+        session.summary = buildRunningSummary(session.initialPlan, session.history);
+        disposeSessionAgentForRetry(session);
+      } else {
+        session.history.push(historyEntry);
+      }
+      answeredQuestion = currentQuestion;
+      beginPlanningGeneration(session, "plan_update");
+      session.currentQuestion = void 0;
+      await persistSession(session, "generating");
+      if (!session.agent) {
+        await ensureSessionAgent(
+          session,
+          rootDir,
+          isEditingPriorAnswer ? session.history : session.history.slice(0, -1),
+          promptOverrides,
+          store
+        );
+      }
+      const message = isEditingPriorAnswer ? "An earlier answer was edited. Use the complete preserved interview context above, regenerate the running plan, and ask exactly one next question." : formatResponseForAgent(currentQuestion, responses);
+      await continueAgentConversation(session, message);
     }
-    const message = isEditingPriorAnswer ? "An earlier answer was edited. Use the complete preserved interview context above, regenerate the running plan, and ask exactly one next question." : formatResponseForAgent(currentQuestion, responses);
-    await continueAgentConversation(session, message);
+  } finally {
+    releaseTurn();
   }
   if (session.currentQuestion) {
     return { type: "question", data: session.currentQuestion };
@@ -263029,6 +263567,7 @@ Additional context: ${comment}` : formatted;
 Regenerate the runningPlan fields (title, description, concrete proposedChanges, observable acceptanceCriteria, suggestedSize, optional priority, suggestedDependencies, concrete keyDeliverables, and all distinct high-value suggestedRefinements) informed by this answer; do not cap suggestedRefinements at three. Author the operator-facing plan in Markdown: use concise GitHub-flavored Markdown in the description, with the structured fields supplying its Markdown sections and lists. Never list interview questions as deliverables or PROMPT.md sections such as Mission, Steps, File Scope, Review Level, Completion Criteria, or Do NOT. Return type:"question" with that complete runningPlan and ask exactly one next question. Do not validate the plan; only the user can proceed with it.`;
 }
 function disposeSessionAgentForRetry(session) {
+  session.agentCallbackEpoch = (session.agentCallbackEpoch ?? 0) + 1;
   if (!session.agent) {
     return;
   }
@@ -263111,7 +263650,7 @@ async function getSession(sessionId) {
     return void 0;
   }
 }
-var PLANNING_NO_AMBIENT_TASK_ID, PLANNING_BUILTIN_WEB_TOOLS, createFnAgent4, planningNtfyHelpers, diagnostics2, PLANNING_SYSTEM_PROMPT, SESSION_TTL_MS, CLEANUP_INTERVAL_MS2, MAX_SESSIONS_PER_IP_PER_HOUR, RATE_LIMIT_WINDOW_MS2, GENERATION_TIMEOUT_MS, GENERATION_LOOP_REPEAT_LIMIT, PLANNING_STUCK_ERROR_MESSAGE, PLANNING_LOOP_ERROR_MESSAGE, sessions, rateLimits2, activeGenerations, _aiSessionStore, sessionPersistenceQueues, cleanupInterval2, PlanningStreamManager, planningStreamManager, MAX_PARSE_RETRIES2, TruncatedPlanningCompletionError, RateLimitError3, SessionNotFoundError, InvalidSessionStateError, GenerationInProgressError;
+var PLANNING_NO_AMBIENT_TASK_ID, PLANNING_BUILTIN_WEB_TOOLS, createFnAgent4, planningNtfyHelpers, diagnostics2, PLANNING_SYSTEM_PROMPT, SESSION_TTL_MS, CLEANUP_INTERVAL_MS2, MAX_SESSIONS_PER_IP_PER_HOUR, RATE_LIMIT_WINDOW_MS2, GENERATION_TIMEOUT_MS, GENERATION_LOOP_REPEAT_LIMIT, PLANNING_STUCK_ERROR_MESSAGE, PLANNING_LOOP_ERROR_MESSAGE, sessions, rateLimits2, activeGenerations, pendingTurnReservations, settlingTurnOperations, _aiSessionStore, sessionPersistenceQueues, cleanupInterval2, PlanningStreamManager, planningStreamManager, MAX_PARSE_RETRIES2, TruncatedPlanningCompletionError, RateLimitError3, SessionNotFoundError, InvalidSessionStateError, GenerationInProgressError;
 var init_planning = __esm({
   "../dashboard/src/planning.ts"() {
     "use strict";
@@ -263146,6 +263685,8 @@ Every turn must include the running-plan fields: only title, description, concre
     sessions = /* @__PURE__ */ new Map();
     rateLimits2 = /* @__PURE__ */ new Map();
     activeGenerations = /* @__PURE__ */ new Map();
+    pendingTurnReservations = /* @__PURE__ */ new Map();
+    settlingTurnOperations = /* @__PURE__ */ new Map();
     sessionPersistenceQueues = /* @__PURE__ */ new Map();
     cleanupInterval2 = setInterval(cleanupExpiredSessions, CLEANUP_INTERVAL_MS2);
     cleanupInterval2.unref?.();
@@ -263219,6 +263760,10 @@ Every turn must include the running-plan fields: only title, description, concre
         }
         this.pendingInitialTurns.set(sessionId, start);
       }
+      /** True while a registered initial turn has not been consumed by a stream connection yet. */
+      hasPendingInitialTurn(sessionId) {
+        return this.pendingInitialTurns.has(sessionId);
+      }
       consumeInitialTurn(sessionId) {
         const start = this.pendingInitialTurns.get(sessionId);
         if (!start) {
@@ -263258,7 +263803,7 @@ Every turn must include the running-plan fields: only title, description, concre
         this.removeAllListeners();
       }
     };
-    planningStreamManager = new PlanningStreamManager();
+    planningStreamManager = new PlanningStreamManager(2e3);
     MAX_PARSE_RETRIES2 = 1;
     TruncatedPlanningCompletionError = class extends Error {
       constructor() {
@@ -270646,7 +271191,7 @@ var init_chat = __esm({
     };
     CHAT_SYSTEM_PROMPT = `${FUSION_RUNTIME_SELF_AWARENESS}
 
-You are a helpful AI assistant integrated into the fn task board system. You help users with questions about their project, code, architecture, and tasks. You have coding workspace tools on the project checkout: \`read\`, \`write\`, \`edit\`, \`bash\`, \`grep\`, \`find\`, and \`ls\`. Use \`write\`, \`edit\`, and \`bash\` for user-requested code changes, file edits, or shell investigation; prefer minimal, user-directed mutations and respect any pending-approval or blocked tool result. Do not claim that you only have read access. Do not change the branch the working directory is checked out on: do not run \`git checkout <branch>\` or \`git switch <branch>\` to a different branch unless the user explicitly asks. Read-only Git and branch inspection, such as \`git status\`, \`git branch\`, and \`git log\`, is allowed. Response length policy: default to a short, crisp reply (a few sentences or a short bulleted list) that directly answers the user; avoid preamble, restating the question, and filler. If a thorough answer genuinely needs long-form content (for example multi-step plans, design proposals, deep analyses, or long file excerpts), keep the chat reply brief with a one- or two-sentence summary and then send the full write-up via \`fn_send_message\` using \`type: "agent-to-user"\` and \`to_id: "dashboard"\`. That mailbox follow-up must add new substantive detail and must not duplicate the chat reply.`;
+You are a helpful AI assistant integrated into the fn task board system. You help users with questions about their project, code, architecture, and tasks. You have coding workspace tools on the project checkout: \`read\`, \`write\`, \`edit\`, \`bash\`, \`grep\`, \`find\`, and \`ls\`. Use \`write\`, \`edit\`, and \`bash\` for user-requested code changes, file edits, or shell investigation; prefer minimal, user-directed mutations and respect any pending-approval or blocked tool result. Do not claim that you only have read access. Do not change the branch the working directory is checked out on: do not run \`git checkout <branch>\` or \`git switch <branch>\` to a different branch unless the user explicitly asks. Read-only Git and branch inspection, such as \`git status\`, \`git branch\`, and \`git log\`, is allowed. Response length policy: default to a short, crisp reply (a few sentences or a short bulleted list) that directly answers the user; avoid preamble, restating the question, and filler. For questions about this repository's code or architecture, prioritize correctness and cite real paths/symbols over maximum brevity \u2014 still lead short, but do not omit the evidence needed to be accurate. If a thorough answer genuinely needs long-form content (for example multi-step plans, design proposals, deep multi-file traces, deep analyses, or long file excerpts), keep the chat reply brief with a one- or two-sentence summary plus key citations. When \`fn_send_message\` is available in this session, send the full write-up via \`fn_send_message\` using \`type: "agent-to-user"\` and \`to_id: "dashboard"\` (additive detail that must not duplicate the chat reply). When that tool is not available, put the necessary detail in the chat reply itself rather than inventing a mailbox path.`;
     RATE_LIMIT_WINDOW_MS5 = 60 * 1e3;
     MAX_REFERENCED_FILE_SIZE = 50 * 1024;
     ChatStreamManager = class extends EventEmitter39 {