@runfusion/fusion 0.43.0 → 0.43.1

package/dist/bin.js

@@ -2295,6 +2295,25 @@ var init_redact_secrets = __esm({
   }
 });
 
+// ../core/src/near-duplicate-canonical.ts
+function isActiveNearDuplicateColumn(column) {
+  return column !== "archived" && column !== "done";
+}
+function isNearDuplicateCanonicalInactive(canonical) {
+  if (!canonical) {
+    return true;
+  }
+  if (canonical.deletedAt) {
+    return true;
+  }
+  return !isActiveNearDuplicateColumn(canonical.column);
+}
+var init_near_duplicate_canonical = __esm({
+  "../core/src/near-duplicate-canonical.ts"() {
+    "use strict";
+  }
+});
+
 // ../core/src/frontend-ux-policy.ts
 function applyFrontendUxCriteria(promptMarkdown, fileScopePaths) {
   if (promptMarkdown.includes(FRONTEND_UX_HEADING)) {
@@ -48225,6 +48244,7 @@ var init_store = __esm({
     init_stalled_review_detector();
     init_retry_summary();
     init_duplicate_intake();
+    init_near_duplicate_canonical();
     init_task_id_integrity();
     init_mesh_task_replication();
     init_step_parsers();
@@ -52545,6 +52565,65 @@ ${newTask.description}
     `).all(trimmedFingerprint, cutoffIso);
         return rows.map((row) => this.rowToTask(row));
       }
+      /**
+       * FNXC:NearDuplicateDetection 2026-06-14-12:00:
+       * FN-6439 requires the store to reconcile persisted duplicate flags after a canonical becomes inactive.
+       * sourceMetadataPatch only merges, so this reverse lookup performs a bounded read-modify-write that strips stale near-duplicate keys without pausing or failing the referencing tasks.
+       */
+      async clearNearDuplicateReferencesTo(canonicalId, inactiveState) {
+        if (!isNearDuplicateCanonicalInactive(inactiveState)) {
+          return [];
+        }
+        const selectClause = this.getTaskSelectClause(false, "t");
+        const rows = this.db.prepare(`
+      SELECT ${selectClause}
+      FROM tasks t
+      WHERE t."deletedAt" IS NULL
+        AND t."column" != 'archived'
+        AND t."column" != 'done'
+        AND json_extract(t.sourceMetadata, '$.nearDuplicateOf') = ?
+      ORDER BY t.createdAt ASC
+    `).all(canonicalId);
+        const updatedTasks = [];
+        for (const row of rows) {
+          const task = this.rowToTask(row);
+          const nextSourceMetadata = { ...task.sourceMetadata ?? {} };
+          delete nextSourceMetadata.nearDuplicateOf;
+          delete nextSourceMetadata.nearDuplicateScore;
+          delete nextSourceMetadata.nearDuplicateSharedTokens;
+          delete nextSourceMetadata.nearDuplicateDismissed;
+          task.sourceMetadata = Object.keys(nextSourceMetadata).length > 0 ? nextSourceMetadata : void 0;
+          const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          task.updatedAt = updatedAt;
+          task.log = [
+            ...task.log ?? [],
+            {
+              timestamp: updatedAt,
+              action: `Near-duplicate canonical ${canonicalId} is now inactive (${inactiveState.reason}); cleared duplicate flag (informational, no decision required)`
+            }
+          ];
+          this.db.transactionImmediate(() => {
+            this.upsertTaskWithFtsRecovery(task);
+            this.db.bumpLastModified();
+          });
+          await this.writeTaskJsonFile(this.taskDir(task.id), task);
+          if (this.isWatching) this.taskCache.set(task.id, { ...task });
+          this.emit("task:updated", task);
+          updatedTasks.push(task);
+        }
+        return updatedTasks;
+      }
+      async clearNearDuplicateReferencesToFailSoft(canonicalId, inactiveState) {
+        try {
+          await this.clearNearDuplicateReferencesTo(canonicalId, inactiveState);
+        } catch (error) {
+          storeLog.warn("Failed to clear stale near-duplicate references (degraded)", {
+            taskId: canonicalId,
+            reason: inactiveState.reason,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
       async getTasksByAssignedAgent(agentId, options) {
         const whereClauses = ["assignedAgentId = ?", _TaskStore.ACTIVE_TASKS_WHERE];
         const params = [agentId];
@@ -52928,6 +53007,12 @@ ${newTask.description}
             if (this.isWatching) this.taskCache.set(id, { ...task });
             this.emit("task:updated", task);
           }
+          if (toColumn === "done") {
+            await this.clearNearDuplicateReferencesToFailSoft(id, {
+              column: "done",
+              reason: "done"
+            });
+          }
           return task;
         }
         const fromColumn = task.column;
@@ -53311,6 +53396,12 @@ ${newTask.description}
         if (fromColumn !== toColumn) {
           this.emit("task:moved", { task, from: fromColumn, to: toColumn, source: moveSource });
         }
+        if (toColumn === "done") {
+          await this.clearNearDuplicateReferencesToFailSoft(id, {
+            column: "done",
+            reason: "done"
+          });
+        }
         return task;
       }
       /**
@@ -55756,7 +55847,7 @@ ${newTask.description}
        * a no-op and does not re-emit task:deleted.
        */
       async deleteTask(id, options) {
-        return this.withTaskLock(id, async () => {
+        const deletedTask = await this.withTaskLock(id, async () => {
           this.flushAgentLogBuffer();
           const task = this.readTaskFromDb(id, { includeDeleted: true });
           if (!task) {
@@ -55831,6 +55922,12 @@ ${newTask.description}
           this.emit("task:deleted", task, { githubIssueAction: options?.githubIssueAction ?? "auto" });
           return task;
         });
+        await this.clearNearDuplicateReferencesToFailSoft(id, {
+          column: "archived",
+          deletedAt: deletedTask.deletedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+          reason: "deleted"
+        });
+        return deletedTask;
       }
       deleteTaskById(taskId) {
         this.clearLinkedAgentTaskIds(taskId);
@@ -56289,7 +56386,7 @@ ${newTask.description}
        * or an options object that also allows removeLineageReferences.
        */
       async archiveTask(id, optionsOrCleanup = true) {
-        return this.withTaskLock(id, async () => {
+        const archivedTask = await this.withTaskLock(id, async () => {
           const dir2 = this.taskDir(id);
           const task = await this.readTaskJson(dir2);
           if (!task.log) {
@@ -56360,6 +56457,11 @@ ${newTask.description}
           this.emit("task:moved", { task, from: fromColumn, to: "archived", source: "engine" });
           return this.archiveEntryToTask(entry, false);
         });
+        await this.clearNearDuplicateReferencesToFailSoft(id, {
+          column: "archived",
+          reason: "archived"
+        });
+        return archivedTask;
       }
       /**
        * Archive a task and immediately clean up its directory.
@@ -60413,6 +60515,7 @@ var init_near_duplicate = __esm({
   "../core/src/near-duplicate.ts"() {
     "use strict";
     init_duplicate_detection();
+    init_near_duplicate_canonical();
     DEFAULT_WINDOW_MS3 = 7 * 24 * 60 * 60 * 1e3;
     DEFAULT_LIMIT2 = 5;
     DEFAULT_MIN_SHARED_TOKENS = 2;
@@ -82743,6 +82846,7 @@ __export(src_exports, {
   importSettings: () => importSettings,
   installQmd: () => installQmd,
   instanceNodeId: () => instanceNodeId,
+  isActiveNearDuplicateColumn: () => isActiveNearDuplicateColumn,
   isAgentPermissionPolicyPresetId: () => isAgentPermissionPolicyPresetId,
   isApiTrigger: () => isApiTrigger,
   isBranchGroupComplete: () => isBranchGroupComplete,
@@ -82772,6 +82876,7 @@ __export(src_exports, {
   isMeshIntentState: () => isMeshIntentState,
   isMeshWriteClass: () => isMeshWriteClass,
   isMovedSettingsKey: () => isMovedSettingsKey,
+  isNearDuplicateCanonicalInactive: () => isNearDuplicateCanonicalInactive,
   isPolicyBroaderThanDefault: () => isPolicyBroaderThanDefault,
   isPrBacked: () => isPrBacked,
   isPrEntityActionable: () => isPrEntityActionable,
@@ -83076,6 +83181,7 @@ var init_src = __esm({
     init_branch_assignment();
     init_custom_provider_key();
     init_redact_secrets();
+    init_near_duplicate_canonical();
     init_frontend_ux_policy();
     init_mock_provider_constants();
     init_zai_provider();
@@ -120224,9 +120330,13 @@ var init_self_healing = __esm({
        * Terminal contract for stuck-loop exhaustion and no-progress churn:
        * - `STUCK_LOOP_EXHAUSTED`: increments the kill budget until exhausted. Once
        *   exhausted, tasks with incomplete steps are moved back to `todo` with
-       *   progress preserved and pause metadata reapplied for manual resume or
+       *   progress preserved, marked failed, and paused for manual resume or
        *   decomposition; tasks with only terminal steps keep the legacy failed
        *   `in-review` handoff path.
+       *
+       * FNXC:SelfHealing 2026-06-14-10:51:
+       * Incomplete stuck-loop exhaustion must park work in a failed/paused state before moving columns, because a post-move patch failure must not leave the task scheduler-runnable.
+       * Engine-owned recovery must not mutate `userPaused`; user intent stays authoritative across races.
        * - `STUCK_NO_PROGRESS_CHURN`: skips the budget entirely and terminalizes on
        *   the first trigger with operator guidance to decompose or rescope.
        *
@@ -120313,8 +120423,25 @@ var init_self_healing = __esm({
                 );
                 return false;
               }
-              log22.warn(`${taskId} exceeded stuck kill budget (${newCount}/${maxKills}, reason=${reason}) with incomplete steps \u2014 re-queueing in todo with progress preserved`);
-              await this.store.updateTask(taskId, { stuckKillCount: newCount });
+              log22.warn(`${taskId} exceeded stuck kill budget (${newCount}/${maxKills}, reason=${reason}) with incomplete steps \u2014 parking in todo with progress preserved`);
+              const exhaustedError2 = `STUCK_LOOP_EXHAUSTED: incomplete task exhausted stuck kill budget (${newCount}/${maxKills}) after last reason=${reason}. Progress was preserved; manually retry, decompose, or rescope before execution resumes.`;
+              const parkUpdate = {
+                stuckKillCount: newCount,
+                status: "failed",
+                error: exhaustedError2,
+                paused: true,
+                pausedReason: "stuck-loop-exhausted-manual-intervention-required",
+                pausedByAgentId: "self-healing",
+                assignedAgentId: null,
+                checkedOutBy: null,
+                checkedOutAt: null,
+                checkoutNodeId: null,
+                checkoutRunId: null,
+                checkoutLeaseRenewedAt: null,
+                checkoutLeaseEpoch: 0,
+                nextRecoveryAt: null
+              };
+              await this.store.updateTask(taskId, parkUpdate);
               try {
                 await this.store.moveTask(taskId, "todo", {
                   preserveProgress: true,
@@ -120325,33 +120452,43 @@ var init_self_healing = __esm({
                 });
               } catch (moveErr) {
                 const moveErrMessage = moveErr instanceof Error ? moveErr.message : String(moveErr);
-                log22.warn(`${taskId} moveTask(todo) failed (${moveErrMessage}) after incomplete STUCK_LOOP_EXHAUSTED terminalization \u2014 falling back to executor stuck-kill requeue`);
+                log22.warn(`${taskId} moveTask(todo) failed (${moveErrMessage}) after incomplete STUCK_LOOP_EXHAUSTED terminalization \u2014 marking failed/paused in place`);
+                try {
+                  await this.store.updateTask(taskId, parkUpdate);
+                } catch (patchErr) {
+                  const patchErrMessage = patchErr instanceof Error ? patchErr.message : String(patchErr);
+                  log22.warn(`${taskId} in-place park patch failed after moveTask(todo) failure during incomplete STUCK_LOOP_EXHAUSTED terminalization: ${patchErrMessage}`);
+                  await this.store.logEntry(
+                    taskId,
+                    `STUCK_LOOP_EXHAUSTED: incomplete task failed to move to todo (${moveErrMessage}), and the in-place park patch also failed (${patchErrMessage}); pre-move park metadata was already applied, but operator verification is required before retry.`
+                  );
+                  return false;
+                }
+                try {
+                  await this.store.logEntry(
+                    taskId,
+                    `STUCK_LOOP_EXHAUSTED: incomplete task exhausted stuck kill budget (${newCount}/${maxKills}), last reason=${reason}. Failed to move task to todo (${moveErrMessage}); task was marked failed/paused in place and will not be automatically retried.`
+                  );
+                } catch (logErr) {
+                  const logErrMessage = logErr instanceof Error ? logErr.message : String(logErr);
+                  log22.warn(`${taskId} failed to log in-place stuck-loop park success after moveTask(todo) failure: ${logErrMessage}`);
+                }
+                return false;
+              }
+              try {
+                await this.store.updateTask(taskId, parkUpdate);
                 await this.store.logEntry(
                   taskId,
-                  `STUCK_LOOP_EXHAUSTED: incomplete task exhausted stuck kill budget (${newCount}/${maxKills}), last reason=${reason}. Failed to move task to todo (${moveErrMessage}); falling back to executor stuck-kill requeue.`
+                  `STUCK_LOOP_EXHAUSTED: incomplete task exhausted stuck kill budget (${newCount}/${maxKills}), last reason=${reason}. Parked in todo with progress preserved; no further automatic retries will run until an operator manually retries, decomposes, or rescopes the task.`
                 );
-                return true;
-              }
-              const requeueUpdate = {
-                stuckKillCount: newCount,
-                paused: false,
-                pausedReason: null,
-                status: "queued"
-              };
-              try {
-                await this.store.updateTask(taskId, requeueUpdate);
               } catch (patchErr) {
                 const patchErrMessage = patchErr instanceof Error ? patchErr.message : String(patchErr);
-                log22.warn(`${taskId} post-move requeue patch failed after incomplete STUCK_LOOP_EXHAUSTED terminalization: ${patchErrMessage}`);
+                log22.warn(`${taskId} post-move park patch failed after incomplete STUCK_LOOP_EXHAUSTED terminalization: ${patchErrMessage}`);
                 await this.store.logEntry(
                   taskId,
-                  `STUCK_LOOP_EXHAUSTED: incomplete task moved to todo with progress preserved, but post-move requeue patch failed (${patchErrMessage}); scheduler retry may wait for the next state repair pass.`
+                  `STUCK_LOOP_EXHAUSTED: incomplete task moved to todo with progress preserved, but post-move park patch failed (${patchErrMessage}); operator repair is required before retry.`
                 );
               }
-              await this.store.logEntry(
-                taskId,
-                `STUCK_LOOP_EXHAUSTED: incomplete task exhausted stuck kill budget (${newCount}/${maxKills}), last reason=${reason}. Re-queued in todo with progress preserved; scheduler may retry without manual unpause.`
-              );
               return false;
             }
             log22.warn(`${taskId} exceeded stuck kill budget (${newCount}/${maxKills}, reason=${reason}) \u2014 marking failed`);
@@ -129635,6 +129772,10 @@ Take a completely different approach to writing this specification. Do NOT repea
               if (!canonicalTask) {
                 return;
               }
+              if (isNearDuplicateCanonicalInactive(canonicalTask)) {
+                planLog.log(`${task.id}: near-duplicate candidate ${canonical.id} is inactive; skipping near-duplicate flag`);
+                return;
+              }
               if (isStrictlyOlderOrTieCanonical(canonicalTask)) {
                 await this.store.updateTask(task.id, {
                   sourceMetadataPatch: {
@@ -173693,15 +173834,13 @@ async function submitResponse(sessionId, responses, rootDir, promptOverrides, st
       thinkingOutput: session.lastGeneratedThinking || ""
     };
     session.error = void 0;
+    session.history.push(historyEntry);
     persistSession(session, "generating");
     if (!session.agent) {
-      await ensureSessionAgent(session, rootDir, session.history, promptOverrides, store);
+      await ensureSessionAgent(session, rootDir, session.history.slice(0, -1), promptOverrides, store);
     }
     const message = formatResponseForAgent(currentQuestion, responses);
     await continueAgentConversation(session, message);
-    if (!session.error) {
-      session.history.push(historyEntry);
-    }
   }
   if (session.summary) {
     return { type: "complete", data: session.summary };
@@ -286412,6 +286551,7 @@ export default definePlugin({
     version: "0.1.0",
     description: "A standalone Fusion plugin",
   },
+  state: "installed",
   hooks: {
     onLoad: async (ctx) => {
       ctx.logger.info("${titleCase} plugin loaded");