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

package/dist/child-process-worker.js

@@ -983,6 +983,7 @@ var init_workflow_steps = __esm({
       "in-review",
       "merged",
       "failed",
+      "task-wedged",
       "awaiting-approval",
       "awaiting-user-review",
       "planning-awaiting-input",
@@ -1056,6 +1057,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;
@@ -1545,10 +1590,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.
@@ -2311,6 +2364,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 = [];
@@ -2421,6 +2521,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 ?? {};
@@ -4146,49 +4281,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;
@@ -4240,7 +4332,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";
@@ -4254,8 +4346,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();
@@ -4270,49 +4365,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"]
-    };
   }
 });
 
@@ -12933,6 +12985,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"),
@@ -21297,6 +21350,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`);
     }
@@ -36520,6 +36576,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) {
@@ -36843,17 +36900,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";
@@ -36886,6 +36951,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) {
@@ -36992,6 +37058,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"
+    );
   }
 });
 
@@ -37382,6 +37452,7 @@ __export(sqlite_migrator_exports, {
   isSqliteMigrationComplete: () => isSqliteMigrationComplete,
   migrateLegacyProjectPluginRows: () => migrateLegacyProjectPluginRows,
   migrateSqliteToPostgres: () => migrateSqliteToPostgres,
+  projectPluginSqliteMigrationKey: () => projectPluginSqliteMigrationKey,
   recordSqliteMigrationComplete: () => recordSqliteMigrationComplete,
   toSnakeCase: () => toSnakeCase2
 });
@@ -37924,7 +37995,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,
@@ -37934,19 +38010,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 {
@@ -39032,6 +39103,17 @@ function buildPgCtlOptionsString(port, flags) {
 function buildPgCtlStartArgs(dataDir, logFile, optionsString) {
   return ["-D", dataDir, "-o", optionsString, "-l", logFile, "-W", "start"];
 }
+function withWindowsNativeBinPath(environment, nativeRoot, platform3 = process.platform) {
+  if (platform3 !== "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");
@@ -39086,7 +39168,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"], {
@@ -39120,14 +39208,21 @@ async function startServerElevatedRestricted(opts) {
       killAll();
       await waitForDown();
     },
+    stopMonitoring,
     async stopWrapperOnly() {
+      stopMonitoring();
       stopped = true;
     }
   };
   opts.onLaunched?.(handle);
   const launch = await new Promise(
     (resolve39, 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());
@@ -39152,16 +39247,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();
@@ -39193,6 +39286,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) {
@@ -39212,10 +39317,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;
   }
 });
@@ -39225,10 +39346,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,
@@ -39247,6 +39372,7 @@ __export(embedded_lifecycle_exports, {
   normalizeMacosEmbeddedPostgresDylibSymlinks: () => normalizeMacosEmbeddedPostgresDylibSymlinks,
   readPortFromPostmasterPid: () => readPortFromPostmasterPid,
   resolveElectronAsarUnpackedPath: () => resolveElectronAsarUnpackedPath,
+  resolveEmbeddedMaxConnections: () => resolveEmbeddedMaxConnections,
   uninstallElectronAsarNativePathPatchForTests: () => uninstallElectronAsarNativePathPatchForTests
 });
 import {
@@ -39456,6 +39582,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;
@@ -39473,7 +39616,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);
@@ -39522,6 +39668,12 @@ function getEmbeddedPostgresCtor() {
 function defaultEmbeddedPostgresFlagsFor(platform3) {
   return platform3 === "win32" ? [] : ["-c", "shared_memory_type=mmap"];
 }
+function resolveEmbeddedMaxConnections(configured, platform3 = process.platform) {
+  if (typeof configured === "number" && Number.isInteger(configured)) {
+    return Math.min(EMBEDDED_MAX_CONNECTIONS_MAX, Math.max(EMBEDDED_MAX_CONNECTIONS_MIN, configured));
+  }
+  return platform3 === "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");
@@ -39708,7 +39860,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";
@@ -39739,6 +39891,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"
@@ -39781,6 +39937,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,
@@ -39795,6 +39955,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;
@@ -39891,11 +40060,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(() => {
@@ -39921,12 +40098,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);
@@ -39940,7 +40114,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;
@@ -39972,7 +40146,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,
@@ -40050,6 +40224,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 {
@@ -40196,6 +40407,7 @@ var init_embedded_lifecycle = __esm({
       */
       detachWithoutStop() {
         this.uninstallShutdownHook();
+        this.nonAdminHandle?.stopMonitoring();
         this.pg = null;
         this.nonAdminHandle = null;
         this.running = false;
@@ -40203,6 +40415,7 @@ var init_embedded_lifecycle = __esm({
         runningInstances.delete(this.options.dataDir);
       }
       async stop() {
+        this.stopRequested = true;
         this.uninstallShutdownHook();
         if (!this.ownsProcess) {
           this.running = false;
@@ -52227,10 +52440,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})`);
@@ -52467,7 +52680,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 {
@@ -52477,21 +52703,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);
@@ -52507,14 +52736,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)`);
@@ -52549,6 +52773,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(
@@ -52566,14 +52796,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(
@@ -62240,6 +62465,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),
@@ -62649,6 +62875,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,
@@ -84904,6 +85131,7 @@ function getTaskSelectClauseImpl2(store, slim, tableAlias) {
     "overlapBlockedBy",
     "paused",
     "pausedReason",
+    "wedgeNotification",
     "userPaused",
     "baseBranch",
     "branch",
@@ -91622,7 +91850,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";
@@ -92490,8 +92718,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();
@@ -99191,6 +99419,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) {
@@ -99853,7 +100086,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();
@@ -100717,6 +100950,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);
       }
@@ -163344,6 +163597,7 @@ var init_ntfy_provider = __esm({
       "in-review",
       "merged",
       "failed",
+      "task-wedged",
       "awaiting-approval",
       "awaiting-user-review",
       "planning-awaiting-input",
@@ -163447,6 +163701,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}`,
             /*
@@ -163801,6 +164064,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({
@@ -163812,6 +164201,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;
@@ -163842,6 +164232,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);
@@ -163953,6 +164345,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);
@@ -163963,7 +164359,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;
@@ -164049,6 +164445,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";
       }
@@ -164414,6 +164873,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;
@@ -165242,7 +165706,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",
@@ -205139,6 +205606,9 @@ var DependencyBlockedTodoReporter = class {
   }
 };
 
+// ../engine/src/self-healing.ts
+init_task_wedge_notification();
+
 // ../engine/src/self-healing-constants.ts
 var COMPLETED_BLOCKED_PAUSE_REASON = "completed-work-blocked";
 var STALE_TEMP_MERGE_WORKTREE_MS = 2 * 60 * 60 * 1e3;
@@ -205779,6 +206249,15 @@ var SelfHealingManager = class _SelfHealingManager {
       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)`);
   }
   /*