@runfusion/fusion 0.75.0-beta.1 → 0.75.0-beta.2

package/dist/bin.js

@@ -11925,6 +11925,11 @@ APPROVE when the plan is executable and verifiable, not when it is cosmetically
 });
 
 // ../core/src/agents/agent-prompts.ts
+function buildPlanningDuplicatePolicyInstruction() {
+  return `## Duplicate policy for this task
+
+Only active tasks can be duplicate blockers. A matching task in a done or archived column is historical evidence, not a duplicate verdict: inspect it for context, then write a new plan for the reported work or regression. Do not emit \`DUPLICATE: ...\` for completed or archived work.`;
+}
 function buildTriageHeartbeatGuidance(options = {}) {
   const noTaskLine = options.plannerHeartbeatPatrolEnabled === false ? TRIAGE_HEARTBEAT_PATROL_DISABLED_INSTRUCTION : "If no task is assigned: execute your planning instructions. Patrol for vague requests, blocked tasks that need better specification, review follow-ups that should become new tasks, and dependency gaps that are slowing executors down.";
   const patrolSafetyLines = options.plannerHeartbeatPatrolEnabled === false ? "" : `
@@ -12216,7 +12221,7 @@ Write a lean, executable PROMPT.md quickly. Preserve safety gates, but skip heav
 - Preserve required safety sections for bugs, workflow routing, forensic tasks, and decision-only work.
 
 ## Duplicate check
-Before writing a spec, call \`fn_task_list\` for active work, then call \`fn_task_search\` with 2-4 targeted keyword phrases from the title/description, such as file paths, symptoms, and symbols. For any likely match in \`done\` or \`archived\`, call \`fn_task_show\` and inspect it before deciding. If an existing task covers the same work, do not write a spec \u2014 but still write PROMPT.md, with its entire contents being the single line \`DUPLICATE: {existing-task-id}\` and nothing else. That file is how the duplicate is recorded; announcing it only in your reply leaves no plan behind and re-plans the task in a loop.
+Before writing a spec, call \`fn_task_list\` for active work, then call \`fn_task_search\` with \`includeDone: false\` and \`includeArchived: false\` for 2-4 targeted keyword phrases from the title/description, such as file paths, symptoms, and symbols. Do not search completed or archived work for duplicate candidates. When an active match is a duplicate, do not write a spec \u2014 but still write PROMPT.md, with its entire contents being the single line \`DUPLICATE: {existing-task-id}\` and nothing else. That file is how the duplicate is recorded; announcing it only in your reply leaves no plan behind and re-plans the task in a loop.
 
 ## Required PROMPT.md shape
 Write PROMPT.md with Original Description, Before \u2192 After Transformation, Mission, Dependencies, Context to Read First, File Scope, Steps, Documentation Requirements, Completion Criteria, Git Commit Convention, and Do NOT. Put \`## Original Description\` immediately after the title/\`Created\`/\`Size\` metadata with the operator's original task description copied **verbatim** (do not paraphrase). Put \`## Before \u2192 After Transformation\` next, before \`## Mission\`, with concise Before/After bullets: current state, target state, why it satisfies the user's request at a glance. In \`## Steps\`, every executable heading MUST use \`### Step N: <name>\` (e.g. \`### Step 1: Preflight\`). Do not write bare \`### Preflight\` / \`### Implementation\` headings, and do not add review-level, triage subtask, or proactive subtask headings.
@@ -12484,9 +12489,9 @@ Verified facts about this codebase's storage \u2014 cite these correctly so Plan
 - New Postgres migrations must be **registered explicitly** in \`packages/core/src/postgres/schema-applier.ts\` (version constant + bookkeeping check); a \`.sql\` file dropped in the migrations dir that is not wired there silently never runs.
 
 ## Duplicate check
-Before writing a spec, first call \`fn_task_list\` to see active tasks, then call \`fn_task_search\` with 2-4 distinct keyword phrases from the task title and description (for example file paths, error symptoms, and symbol names).
-For any likely match in \`done\` or \`archived\`, call \`fn_task_show\` to inspect details before deciding.
-If a task already covers the same work (even if worded differently), do not write a spec.
+Before writing a spec, first call \`fn_task_list\` to see active tasks, then call \`fn_task_search\` with \`includeDone: false\` and \`includeArchived: false\` for 2-4 distinct keyword phrases from the task title and description (for example file paths, error symptoms, and symbol names).
+Do not search completed or archived work for duplicate candidates.
+If an actionable task already covers the same work (even if worded differently), do not write a spec.
 Instead you MUST still write PROMPT.md, with its ENTIRE contents being this one line and nothing else:
 \`DUPLICATE: {existing-task-id}\`
 Writing that file IS how you report the duplicate. Reporting it only in your reply is not recorded:
@@ -12517,7 +12522,7 @@ Workflow policy can disable proactive oversized-task splitting for operators who
 ## Triage tools
 You have these extra tools during triage:
 - \`fn_task_list\` \u2014 list existing active tasks
-- \`fn_task_search\` \u2014 keyword search across tasks, including done and archived tasks
+- \`fn_task_search\` \u2014 keyword search across active tasks by default; history is opt-in for non-duplicate research
 - \`fn_task_show\` \u2014 inspect a task and its PROMPT.md
 - \`fn_task_create\` \u2014 create a child/follow-up task while triaging
 - \`fn_task_document_write\` \u2014 save a planning document (e.g., key="plan")
@@ -20257,6 +20262,7 @@ var init_project = __esm({
       worktree: text("worktree"),
       blockedBy: text("blocked_by"),
       overlapBlockedBy: text("overlap_blocked_by"),
+      queuedLogEpisodeSignature: text("queued_log_episode_signature"),
       paused: integer("paused").default(0),
       userPaused: integer("user_paused").default(0),
       pausedReason: text("paused_reason"),
@@ -24407,6 +24413,22 @@ var init_near_duplicate_canonical = __esm({
   }
 });
 
+// ../core/src/duplicates/near-duplicate-canonical-flags.ts
+async function resolveNearDuplicateCanonicalFlags(store, canonical) {
+  if (!canonical?.column) return void 0;
+  const workflow = await resolveWorkflowIrForTask(store, canonical.id).catch(() => void 0);
+  if (!workflow || workflow.version !== "v2") return void 0;
+  const column = workflow.columns.find((candidate) => candidate.id === canonical.column);
+  return column ? resolveColumnFlags(column) : void 0;
+}
+var init_near_duplicate_canonical_flags = __esm({
+  "../core/src/duplicates/near-duplicate-canonical-flags.ts"() {
+    "use strict";
+    init_trait_registry();
+    init_workflow_ir_resolver();
+  }
+});
+
 // ../core/src/git/gitlab-tracking.ts
 function formatGitLabTrackedItemRef(item) {
   const marker = item.kind === "merge_request" ? "!" : "#";
@@ -38168,6 +38190,7 @@ async function applySchemaBaseline(db, options = {}) {
     const taskLifecycleConsumersAlreadyApplied = applied.includes(TASK_LIFECYCLE_CONSUMERS_VERSION);
     const validatorInputFingerprintAlreadyApplied = applied.includes(VALIDATOR_INPUT_FINGERPRINT_VERSION);
     const unplannedExecutionBlockDedupeAlreadyApplied = applied.includes(UNPLANNED_EXECUTION_BLOCK_DEDUPE_VERSION);
+    const queuedEpisodeSignatureAlreadyApplied = applied.includes(QUEUED_EPISODE_SIGNATURE_VERSION);
     assertBinaryNotOlderThanDatabase(applied);
     let schemaChanged = false;
     if (!baselineAlreadyApplied) {
@@ -38561,17 +38584,23 @@ async function applySchemaBaseline(db, options = {}) {
       await tx.execute(sql`INSERT INTO public.${sql.identifier(MIGRATION_BOOKKEEPING_TABLE)} (version) VALUES (${UNPLANNED_EXECUTION_BLOCK_DEDUPE_VERSION}) ON CONFLICT (version) DO NOTHING`);
       schemaChanged = true;
     }
+    if (!queuedEpisodeSignatureAlreadyApplied) {
+      const migrationSql = await readFile4(QUEUED_EPISODE_SIGNATURE_MIGRATION_PATH, "utf8");
+      await tx.execute(sql.raw(migrationSql));
+      await tx.execute(sql`INSERT INTO public.${sql.identifier(MIGRATION_BOOKKEEPING_TABLE)} (version) VALUES (${QUEUED_EPISODE_SIGNATURE_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, TASK_WEDGE_NOTIFICATION_VERSION, MILESTONE_ASSERTION_PROVENANCE_VERSION, MISSION_LINEAGE_STOP_VERSION, CHAT_SESSION_TAGS_VERSION, DROP_GLOBAL_CONCURRENCY_VERSION, MISSION_TASK_PREFIX_VERSION, CREDENTIAL_INSTANCE_SELECTION_VERSION, TASK_LIFECYCLE_OUTBOX_VERSION, TASK_LIFECYCLE_CONSUMERS_VERSION, VALIDATOR_INPUT_FINGERPRINT_VERSION, UNPLANNED_EXECUTION_BLOCK_DEDUPE_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, MILESTONE_ASSERTION_PROVENANCE_MIGRATION_PATH, MISSION_LINEAGE_STOP_MIGRATION_PATH, CHAT_SESSION_TAGS_MIGRATION_PATH, DROP_GLOBAL_CONCURRENCY_MIGRATION_PATH, MISSION_TASK_PREFIX_MIGRATION_PATH, CREDENTIAL_INSTANCE_SELECTION_MIGRATION_PATH, TASK_LIFECYCLE_OUTBOX_MIGRATION_PATH, TASK_LIFECYCLE_CONSUMERS_MIGRATION_PATH, VALIDATOR_INPUT_FINGERPRINT_MIGRATION_PATH, UNPLANNED_EXECUTION_BLOCK_DEDUPE_MIGRATION_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, MILESTONE_ASSERTION_PROVENANCE_VERSION, MISSION_LINEAGE_STOP_VERSION, CHAT_SESSION_TAGS_VERSION, DROP_GLOBAL_CONCURRENCY_VERSION, MISSION_TASK_PREFIX_VERSION, CREDENTIAL_INSTANCE_SELECTION_VERSION, TASK_LIFECYCLE_OUTBOX_VERSION, TASK_LIFECYCLE_CONSUMERS_VERSION, VALIDATOR_INPUT_FINGERPRINT_VERSION, UNPLANNED_EXECUTION_BLOCK_DEDUPE_VERSION, QUEUED_EPISODE_SIGNATURE_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, MILESTONE_ASSERTION_PROVENANCE_MIGRATION_PATH, MISSION_LINEAGE_STOP_MIGRATION_PATH, CHAT_SESSION_TAGS_MIGRATION_PATH, DROP_GLOBAL_CONCURRENCY_MIGRATION_PATH, MISSION_TASK_PREFIX_MIGRATION_PATH, CREDENTIAL_INSTANCE_SELECTION_MIGRATION_PATH, TASK_LIFECYCLE_OUTBOX_MIGRATION_PATH, TASK_LIFECYCLE_CONSUMERS_MIGRATION_PATH, VALIDATOR_INPUT_FINGERPRINT_MIGRATION_PATH, UNPLANNED_EXECUTION_BLOCK_DEDUPE_MIGRATION_PATH, QUEUED_EPISODE_SIGNATURE_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 = "0043";
+    SCHEMA_BASELINE_VERSION = "0044";
     TASK_DECLARED_SYMBOLS_VERSION = "0028";
     INITIAL_SCHEMA_VERSION = "0000";
     AUTOMATION_ISOLATION_SCHEMA_VERSION = "0001";
@@ -38615,6 +38644,7 @@ var init_schema_applier = __esm({
     TASK_LIFECYCLE_CONSUMERS_VERSION = "0041";
     VALIDATOR_INPUT_FINGERPRINT_VERSION = "0042";
     UNPLANNED_EXECUTION_BLOCK_DEDUPE_VERSION = "0043";
+    QUEUED_EPISODE_SIGNATURE_VERSION = "0044";
     LEGACY_ADOPTION_DRAINED_MARKER_FUNCTION = "fusion_mark_legacy_adoption_drained";
     StaleBinarySchemaError = class extends Error {
       constructor(databaseVersion, binaryVersion) {
@@ -38738,6 +38768,7 @@ var init_schema_applier = __esm({
     TASK_LIFECYCLE_CONSUMERS_MIGRATION_PATH = join8(MIGRATIONS_DIR, "0041_fn_8685_task_lifecycle_consumers.sql");
     VALIDATOR_INPUT_FINGERPRINT_MIGRATION_PATH = join8(MIGRATIONS_DIR, "0042_fn_8694_validator_input_fingerprint.sql");
     UNPLANNED_EXECUTION_BLOCK_DEDUPE_MIGRATION_PATH = join8(MIGRATIONS_DIR, "0043_fn8768_dispatch_dedupe.sql");
+    QUEUED_EPISODE_SIGNATURE_MIGRATION_PATH = join8(MIGRATIONS_DIR, "0044_fn_8785_queued_episode_signature.sql");
   }
 });
 
@@ -61677,9 +61708,14 @@ var init_central_core = __esm({
         incremented by real work and the durable counter it maintained was fiction.
       
         `getLiveRunningAgentCounts` SURVIVES and is now the only global readout. It is
-        TELEMETRY, not a limiter: it derives live per-project agent counts from the
-        registered side-effect-safe source so the dashboard can show "N running (all
-        projects)". Nothing gates on it.
+        TELEMETRY, not a capacity limiter: it derives live per-project agent counts
+        from the registered side-effect-safe source so the dashboard can show "N
+        running (all projects)". Task admission does not gate on it.
+      
+        FNXC:DevEngineWatch 2026-08-04-01:25:
+        The opt-in source-development restart also reads this conservative telemetry
+        to wait for active work to drain. That is shutdown safety, not capacity
+        arbitration; it never reserves slots or changes task admission.
         */
       async getLiveRunningAgentCounts(options) {
         this.ensureInitialized();
@@ -62941,6 +62977,7 @@ var init_persistence = __esm({
       defineTaskColumn("worktree", (task) => task.worktree ?? null),
       defineTaskColumn("blockedBy", (task) => task.blockedBy ?? null),
       defineTaskColumn("overlapBlockedBy", (task) => task.overlapBlockedBy ?? null),
+      defineTaskColumn("queuedLogEpisodeSignature", (task) => task.queuedLogEpisodeSignature ?? null),
       defineTaskColumn("paused", (task) => task.paused ? 1 : 0),
       defineTaskColumn("pausedReason", (task) => task.pausedReason ?? null),
       defineTaskColumn("wedgeNotification", (task) => toJsonNullable(task.wedgeNotification)),
@@ -63355,6 +63392,7 @@ function rowToTask(row) {
     worktree: row.worktree || void 0,
     blockedBy: row.blockedBy || void 0,
     overlapBlockedBy: row.overlapBlockedBy || void 0,
+    queuedLogEpisodeSignature: row.queuedLogEpisodeSignature || void 0,
     paused: row.paused ? true : void 0,
     pausedReason: row.pausedReason || void 0,
     wedgeNotification: fromJson(row.wedgeNotification) ?? void 0,
@@ -69474,6 +69512,14 @@ function noop3() {
 function matchesParentScope(task, sourceParentTaskId) {
   return !sourceParentTaskId || task.sourceParentTaskId === sourceParentTaskId;
 }
+async function findActiveDuplicate(store, candidates, predicate) {
+  for (const candidate of candidates) {
+    if (!predicate(candidate)) continue;
+    const flags = await resolveNearDuplicateCanonicalFlags(store, candidate);
+    if (!isNearDuplicateCanonicalInactive(candidate, flags)) return candidate;
+  }
+  return void 0;
+}
 async function runDeterministicDuplicateGuard(store, input, opts) {
   const fingerprint = computeContentFingerprint(input);
   if (opts?.bypass === true || !fingerprint) {
@@ -69487,7 +69533,9 @@ async function runDeterministicDuplicateGuard(store, input, opts) {
         windowMs,
         includeArchived: false
       });
-      const deterministicConflict = deterministicMatches.find(
+      const deterministicConflict = await findActiveDuplicate(
+        store,
+        deterministicMatches,
         (match) => matchesParentScope(match, opts?.sourceParentTaskId) && !acknowledged.has(match.id)
       );
       if (deterministicConflict) {
@@ -69534,7 +69582,9 @@ async function runDeterministicDuplicateGuard(store, input, opts) {
       windowMs,
       includeArchived: false
     });
-    const deterministicConflict = deterministicMatches.find(
+    const deterministicConflict = await findActiveDuplicate(
+      store,
+      deterministicMatches,
       (match) => matchesParentScope(match, opts.sourceParentTaskId) && !acknowledged.has(match.id)
     );
     if (deterministicConflict) {
@@ -69558,7 +69608,9 @@ async function reconcileDeterministicDuplicate(store, args) {
       windowMs: clampWindowMs(args.windowMs),
       includeArchived: false
     });
-    const olderSibling = siblings.find(
+    const olderSibling = await findActiveDuplicate(
+      store,
+      siblings,
       (sibling) => sibling.id !== args.createdTask.id && sibling.createdAt < args.createdTask.createdAt && matchesParentScope(sibling, args.sourceParentTaskId)
     );
     if (!olderSibling) {
@@ -69617,6 +69669,8 @@ var init_duplicate_guard = __esm({
   "../core/src/duplicates/duplicate-guard.ts"() {
     "use strict";
     init_duplicate_detection();
+    init_near_duplicate_canonical();
+    init_near_duplicate_canonical_flags();
     init_workflow_lifecycle_traits();
     FINGERPRINT_WINDOW_DEFAULT_MS = 6e5;
     FINGERPRINT_WINDOW_MAX_MS = 36e5;
@@ -93228,6 +93282,50 @@ async function runPluginColumnTransitionHooksImpl(store, taskId, workflowIr, fro
     await writeMarker2(remaining);
   }
 }
+async function transitionQueuedEpisodeImpl(store, id, transition) {
+  const layer = store.asyncLayer;
+  const projectId = layer.projectId?.trim() || "__legacy_unscoped__";
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result2 = await layer.transactionImmediate(async (tx) => {
+    await acquireTaskAdvisoryXactLock(tx, projectId, id);
+    const rows = await tx.select().from(project_exports.tasks).where(and(
+      eq(project_exports.tasks.projectId, projectId),
+      eq(project_exports.tasks.id, id),
+      isNull(project_exports.tasks.deletedAt)
+    ));
+    const current = rows[0];
+    if (!current) throw new Error(`Task ${id} not found or archived while queuing`);
+    const appended = !(current.status === "queued" && (current.blockedBy ?? null) === transition.blockedBy && (current.overlapBlockedBy ?? null) === transition.overlapBlockedBy && (current.queuedLogEpisodeSignature ?? null) === transition.signature);
+    const log43 = Array.isArray(current.log) ? [...current.log] : [];
+    if (appended) {
+      log43.push({
+        timestamp: now,
+        action: transition.action,
+        outcome: truncateTaskLogOutcome(transition.outcome),
+        ...transition.runContext ? { runContext: transition.runContext } : {}
+      });
+      const limit = getTaskActivityLogEntryLimit();
+      if (log43.length > limit) log43.splice(0, log43.length - limit);
+    }
+    const updated = await tx.update(project_exports.tasks).set({
+      status: "queued",
+      blockedBy: transition.blockedBy,
+      overlapBlockedBy: transition.overlapBlockedBy,
+      queuedLogEpisodeSignature: transition.signature,
+      ...appended ? { log: log43 } : {},
+      updatedAt: now
+    }).where(and(
+      eq(project_exports.tasks.projectId, projectId),
+      eq(project_exports.tasks.id, id)
+    )).returning();
+    return { appended, task: updated[0] };
+  });
+  const task = store.rowToTask(store.pgRowToTaskRow(result2.task));
+  await store.writeTaskJsonFile(store.taskDir(id), task);
+  if (store.isWatching) store.taskCache.set(id, { ...task });
+  store.emitTaskLifecycleEventSafely("task:updated", [task]);
+  return { appended: result2.appended, task };
+}
 async function checkAndRecordUnplannedExecutionBlockImpl(store, id, episode) {
   const layer = store.asyncLayer;
   const projectId = layer.projectId ?? "__legacy_unscoped__";
@@ -93339,6 +93437,7 @@ var init_audit_ops = __esm({
     init_comments();
     init_async_persistence();
     init_async_comments_attachments();
+    init_task_advisory_lock();
     init_project_lane_vocabulary();
     init_schema2();
   }
@@ -99121,6 +99220,9 @@ var init_store = __esm({
       async checkAndRecordUnplannedExecutionBlock(id, episode) {
         return checkAndRecordUnplannedExecutionBlockImpl(this, id, episode);
       }
+      async transitionQueuedEpisode(id, transition) {
+        return transitionQueuedEpisodeImpl(this, id, transition);
+      }
       async logEntry(id, action, outcome, runContext) {
         return logEntryImpl(this, id, action, outcome, runContext);
       }
@@ -127887,6 +127989,7 @@ __export(src_exports, {
   buildInsightExtractionPrompt: () => buildInsightExtractionPrompt,
   buildManualRetryResetPatch: () => buildManualRetryResetPatch,
   buildOriginalDescriptionSection: () => buildOriginalDescriptionSection,
+  buildPlanningDuplicatePolicyInstruction: () => buildPlanningDuplicatePolicyInstruction,
   buildQmdCollectionAddArgs: () => buildQmdCollectionAddArgs,
   buildQmdRefreshCommands: () => buildQmdRefreshCommands,
   buildQmdSearchArgs: () => buildQmdSearchArgs,
@@ -128581,6 +128684,7 @@ __export(src_exports, {
   resolveMergerFallbackModel: () => resolveMergerFallbackModel,
   resolveMergerSettingsModel: () => resolveMergerSettingsModel,
   resolveMobileNavPrimaryItems: () => resolveMobileNavPrimaryItems,
+  resolveNearDuplicateCanonicalFlags: () => resolveNearDuplicateCanonicalFlags,
   resolveNodeOverrideLanes: () => resolveNodeOverrideLanes,
   resolveOptionalReviewRevisionBudget: () => resolveOptionalReviewRevisionBudget,
   resolveOptionalStepRevisionBudget: () => resolveOptionalStepRevisionBudget,
@@ -128813,6 +128917,7 @@ var init_src2 = __esm({
     init_plugin_prompt_condition();
     init_plan_approval();
     init_near_duplicate_canonical();
+    init_near_duplicate_canonical_flags();
     init_gitlab_tracking();
     init_planner_intervention2();
     init_planner_overseer_events();
@@ -169121,14 +169226,14 @@ async function findDefinedFeatureBootstrapDuplicate(store, input, sourceAgentId,
   if (!sourceAgentId && !sourceParentTaskId) return void 0;
   const candidates = await store.listTasks({ slim: true, includeArchived: true, includeDeleted: true });
   const byId = new Map(candidates.map((task) => [task.id, task]));
-  const isArchivedCandidate = await resolveArchivedColumnsForTasks(store, candidates);
+  const isTerminalCandidate = await resolveTerminalColumnsForTasks(store, candidates);
   const matches = findSameAgentDuplicates({
     title: input.title,
     description: input.description,
     sourceParentTaskId
   }, candidates.flatMap((task) => {
     const createdAt = Date.parse(task.createdAt);
-    if (Number.isNaN(createdAt) || task.deletedAt || isArchivedCandidate(task)) return [];
+    if (Number.isNaN(createdAt) || task.deletedAt || isTerminalCandidate(task)) return [];
     return [{
       id: task.id,
       title: task.title ?? "",
@@ -169179,21 +169284,6 @@ async function resolveTerminalColumnsForTasks(store, tasks2) {
   }
   return (task) => terminalByTaskId.get(task.id)?.has(task.column) === true;
 }
-async function resolveArchivedColumnsForTasks(store, tasks2) {
-  const cache7 = /* @__PURE__ */ new Map();
-  const archivedByTaskId = /* @__PURE__ */ new Map();
-  for (const task of tasks2) {
-    if (archivedByTaskId.has(task.id)) continue;
-    const columns = /* @__PURE__ */ new Set(["archived"]);
-    try {
-      const ir2 = await resolveWorkflowIrForTask(store, task.id, cache7);
-      if (ir2) for (const id of columnsWithFlag(ir2, "archived")) columns.add(id);
-    } catch {
-    }
-    archivedByTaskId.set(task.id, columns);
-  }
-  return (task) => archivedByTaskId.get(task.id)?.has(task.column) === true;
-}
 async function createAgentTask(store, input, options) {
   const validateDuplicateCanonical = input.validateDuplicateCanonical;
   const settings = typeof store.getSettings === "function" ? await store.getSettings() : {};
@@ -169258,11 +169348,12 @@ async function createAgentTask(store, input, options) {
       try {
         const acknowledged = new Set(options?.acknowledgedDuplicates ?? []);
         const candidates = await store.findRecentTasksBySourceParentTaskId(sourceParentTaskId);
+        const isTerminalCandidate = await resolveTerminalColumnsForTasks(store, candidates);
         const matches = findSameAgentDuplicates({
           title: input.title,
           description: input.description,
           sourceParentTaskId
-        }, candidates.map((candidate) => ({
+        }, candidates.filter((candidate) => !isTerminalCandidate(candidate)).map((candidate) => ({
           id: candidate.id,
           title: candidate.title ?? "",
           description: candidate.description,
@@ -169490,7 +169581,7 @@ function createTaskSearchTool(store) {
   return {
     name: "fn_task_search",
     label: "Search Tasks",
-    description: "Keyword search across tasks, including done and archived tasks by default. Use for duplicate detection and work discovery before filing new tasks.",
+    description: "Keyword search across active tasks by default. Done and archived history is opt-in and must not be used for duplicate detection.",
     parameters: taskSearchParams,
     execute: async (_id, params) => {
       const query = params.query.trim();
@@ -169503,10 +169594,10 @@ function createTaskSearchTool(store) {
       const limit = Math.min(50, Math.max(1, Math.floor(params.limit ?? 20)));
       const results = await store.searchTasks(query, {
         slim: true,
-        includeArchived: params.includeArchived ?? true,
+        includeArchived: params.includeArchived ?? false,
         limit
       });
-      const includeDone = params.includeDone ?? true;
+      const includeDone = params.includeDone ?? false;
       const isTerminalResult = includeDone ? void 0 : await resolveTerminalColumnsForTasks(store, results);
       const filtered = includeDone ? results : results.filter((task) => !isTerminalResult(task));
       const lines = filtered.map(formatTaskSummaryLine);
@@ -186340,6 +186431,9 @@ var init_scheduler = __esm({
           }
         }
       }
+      async transitionQueuedEpisode(task, input) {
+        return (await this.store.transitionQueuedEpisode(task.id, input)).appended;
+      }
       async logDispatchQueuedReason(taskId, reason, memoKey) {
         const key = `${taskId}:${memoKey ?? reason}`;
         if (this.wasDispatchQueuedReasonLogged.has(key)) {
@@ -186852,11 +186946,13 @@ var init_scheduler = __esm({
               }
               const unmetDeps = getUnmetSchedulingDependencies(task, tasks2, schedulingDependencyOptions);
               if (unmetDeps.length > 0) {
-                await this.store.updateTask(task.id, {
-                  status: "queued",
-                  blockedBy: unmetDeps[0]
+                const normalizedUnmetDeps = [...new Set(unmetDeps)].sort();
+                await this.transitionQueuedEpisode(task, {
+                  signature: `dependency:${normalizedUnmetDeps.join(",")}`,
+                  blockedBy: unmetDeps[0] ?? null,
+                  overlapBlockedBy: task.overlapBlockedBy ?? null,
+                  action: `queued \u2014 unmet dependencies: ${unmetDeps.join(", ")}`
                 });
-                await this.logDispatchQueuedReason(task.id, `queued \u2014 unmet dependencies: ${unmetDeps.join(", ")}`);
                 this.options.onBlocked?.(task, unmetDeps);
                 return null;
               }
@@ -187217,16 +187313,13 @@ var init_scheduler = __esm({
                   const overlappingTaskId = Array.from(activeScopes.entries()).sort(([aId], [bId]) => aId.localeCompare(bId)).find(([, activeScope]) => this.pathsOverlap(taskScope, activeScope))?.[0] ?? null;
                   if (overlappingTaskId) {
                     const activeLeaseColumn = activeScopeColumns.get(overlappingTaskId) ?? "in-progress";
-                    await this.store.updateTask(task.id, {
-                      status: "queued",
+                    await this.transitionQueuedEpisode(task, {
+                      signature: `file-scope:${overlappingTaskId}`,
                       blockedBy: null,
-                      overlapBlockedBy: overlappingTaskId
+                      overlapBlockedBy: overlappingTaskId,
+                      action: `queued \u2014 blocked by active file-scope lease ${overlappingTaskId} (column=${activeLeaseColumn})`
                     });
                     await this.rollbackRunningAgentsForQueuedTodoTask(task.id);
-                    await this.logDispatchQueuedReason(
-                      task.id,
-                      `queued \u2014 blocked by active file-scope lease ${overlappingTaskId} (column=${activeLeaseColumn})`
-                    );
                     return null;
                   }
                   if (task.overlapBlockedBy) {
@@ -202705,13 +202798,6 @@ function hasTerminalInvalidDoneTransition(task) {
   const error3 = task.error ?? "";
   return error3.includes("Invalid transition:") && error3.includes("\u2192 'done'");
 }
-async function resolveNearDuplicateCanonicalFlags(store, canonical) {
-  if (!canonical?.column) return void 0;
-  const ir2 = await resolveWorkflowIrForTask(store, canonical.id).catch(() => void 0);
-  if (!ir2 || ir2.version !== "v2") return void 0;
-  const column = ir2.columns.find((candidate) => candidate.id === canonical.column);
-  return column ? resolveColumnFlags(column) : void 0;
-}
 function isTaskWorkComplete(task) {
   if (task.steps.length === 0) return false;
   return task.steps.every((step) => step.status === "done" || step.status === "skipped");
@@ -202871,7 +202957,6 @@ var init_self_healing = __esm({
       strandedHoldContinuationNoActionAudited = /* @__PURE__ */ new Set();
       /* FNXC:SymbolLock 2026-07-30-14:20: idle symbol-lock sweeps emit one no-action audit until a stale lock re-arms the diagnostic. */
       symbolLockNoActionAudited = false;
-      preservedQueuedOverlapLogged = /* @__PURE__ */ new Map();
       maintenanceTickCounter = 0;
       taskLifecycleRetentionLastPrunedAt = /* @__PURE__ */ new Map();
       processBootStartedAt = Date.now();
@@ -203531,7 +203616,6 @@ var init_self_healing = __esm({
         }
         this.finalizeUnprovenWarned.clear();
         this.strandedCompletedFailureProvenanceWarned.clear();
-        this.preservedQueuedOverlapLogged.clear();
         log33.debug("Stopped");
       }
       // ── Auto-unpause ───────────────────────────────────────────────────
@@ -206100,17 +206184,20 @@ var init_self_healing = __esm({
               if (todoTaskIds.has(dependent.id)) {
                 if (unresolvedDeps.length > 0) {
                   const nextBlocker = unresolvedDeps[0];
-                  await this.store.updateTask(dependent.id, { blockedBy: nextBlocker, overlapBlockedBy, status: "queued" });
-                  await this.store.logEntry(
-                    dependent.id,
-                    `Auto-recovered (FN-4523): cleared stale blockedBy \u2014 blocker ${taskId} is done; now blocked by ${nextBlocker}`
-                  );
+                  const normalizedUnresolvedDeps = [...new Set(unresolvedDeps)].sort();
+                  await this.store.transitionQueuedEpisode(dependent.id, {
+                    signature: `dependency:${normalizedUnresolvedDeps.join(",")}`,
+                    blockedBy: nextBlocker,
+                    overlapBlockedBy,
+                    action: `Auto-recovered (FN-4523): cleared stale blockedBy \u2014 blocker ${taskId} is done; now blocked by ${nextBlocker}`
+                  });
                 } else if (hasActiveOverlapBlocker) {
-                  await this.store.updateTask(dependent.id, { blockedBy: null, overlapBlockedBy, status: "queued" });
-                  await this.store.logEntry(
-                    dependent.id,
-                    `Auto-recovered (FN-4523): preserved queued status \u2014 still blocked by file scope overlap with ${overlapBlockedBy}`
-                  );
+                  await this.store.transitionQueuedEpisode(dependent.id, {
+                    signature: `file-scope:${overlapBlockedBy}`,
+                    blockedBy: null,
+                    overlapBlockedBy,
+                    action: `Auto-recovered (FN-4523): preserved queued status \u2014 still blocked by file scope overlap with ${overlapBlockedBy}`
+                  });
                 } else {
                   await this.store.updateTask(dependent.id, { blockedBy: null, overlapBlockedBy: null, status: null });
                   await this.store.logEntry(
@@ -206623,16 +206710,6 @@ var init_self_healing = __esm({
       countBlockedDepth(tasks2) {
         return tasks2.filter((task) => typeof task.blockedBy === "string" && task.blockedBy.trim().length > 0).length;
       }
-      shouldLogPreservedQueuedOverlap(taskId, overlapBlockedBy) {
-        if (!overlapBlockedBy) return false;
-        const previous = this.preservedQueuedOverlapLogged.get(taskId);
-        if (previous === overlapBlockedBy) return false;
-        this.preservedQueuedOverlapLogged.set(taskId, overlapBlockedBy);
-        return true;
-      }
-      clearPreservedQueuedOverlapMemo(taskId) {
-        this.preservedQueuedOverlapLogged.delete(taskId);
-      }
       /**
        * #1401: periodic transitionPending recovery sweep. Delegates to the store's
        * idempotent recovery method (a no-op when no stale markers exist), keeping
@@ -206865,7 +206942,6 @@ var init_self_healing = __esm({
             (task) => task.status === "queued" && (task.dependencies.length > 0 || Boolean(task.overlapBlockedBy))
           );
           if (blockedTasks.length === 0 && queuedDependencyTasks.length === 0) {
-            this.preservedQueuedOverlapLogged.clear();
             return 0;
           }
           const allTasks = await this.store.listTasks({ includeArchived: true });
@@ -206937,13 +207013,6 @@ var init_self_healing = __esm({
             hold: /* @__PURE__ */ new Set(["todo"]),
             review: /* @__PURE__ */ new Set(["in-review"])
           };
-          for (const [taskId, lastLoggedBlockerId] of this.preservedQueuedOverlapLogged) {
-            const memoTask = taskById.get(taskId);
-            const memoHasActiveOverlapBlocker = memoTask ? await hasActiveFileScopeOverlapBlocker(memoTask, memoTask.overlapBlockedBy) : false;
-            if (!candidates.has(taskId) || !memoTask || !lanesOf(taskId).hold.has(memoTask.column) || memoTask.status !== "queued" || memoTask.overlapBlockedBy !== lastLoggedBlockerId || !memoHasActiveOverlapBlocker) {
-              this.clearPreservedQueuedOverlapMemo(taskId);
-            }
-          }
           for (const task of candidates.values()) {
             const blockerId = task.blockedBy;
             const unresolvedDeps = task.dependencies.filter((depId) => {
@@ -207016,7 +207085,6 @@ var init_self_healing = __esm({
                   let didRecover = false;
                   if (todoTaskIds.has(task.id)) {
                     if (unresolvedDeps.length > 0) {
-                      this.clearPreservedQueuedOverlapMemo(task.id);
                       const nextBlocker2 = unresolvedDeps[0];
                       if (nextBlocker2 === blockerId) {
                         continue;
@@ -207025,19 +207093,19 @@ var init_self_healing = __esm({
                       await this.store.logEntry(task.id, `Auto-recovered (FN-5488): refreshed stale blockedBy \u2014 blocker=${blockerId} blockerStatus=${blocker?.status ?? "none"} reason=${reasonCode ?? "unspecified"}; ${reason}; now blocked by ${nextBlocker2}`);
                       didRecover = true;
                     } else if (hasActiveOverlapBlocker) {
-                      await this.store.updateTask(task.id, { blockedBy: null, status: "queued" });
-                      if (this.shouldLogPreservedQueuedOverlap(task.id, task.overlapBlockedBy)) {
-                        await this.store.logEntry(task.id, `Auto-recovered (FN-5488): preserved queued status \u2014 blocker=${blockerId} blockerStatus=${blocker?.status ?? "none"} reason=${reasonCode ?? "unspecified"}; still blocked by file scope overlap with ${task.overlapBlockedBy}`);
-                        didRecover = true;
-                      }
+                      const transition = await this.store.transitionQueuedEpisode(task.id, {
+                        signature: `file-scope:${task.overlapBlockedBy}`,
+                        blockedBy: null,
+                        overlapBlockedBy: task.overlapBlockedBy ?? null,
+                        action: `Auto-recovered (FN-5488): preserved queued status \u2014 blocker=${blockerId} blockerStatus=${blocker?.status ?? "none"} reason=${reasonCode ?? "unspecified"}; still blocked by file scope overlap with ${task.overlapBlockedBy}`
+                      });
+                      didRecover = transition.appended;
                     } else {
-                      this.clearPreservedQueuedOverlapMemo(task.id);
                       await this.store.updateTask(task.id, { blockedBy: null, overlapBlockedBy: null, status: null });
                       await this.store.logEntry(task.id, `Auto-recovered (FN-5488): cleared stale blockedBy \u2014 blocker=${blockerId} blockerStatus=${blocker?.status ?? "none"} reason=${reasonCode ?? "unspecified"}; ${reason}`);
                       didRecover = true;
                     }
                   } else {
-                    this.clearPreservedQueuedOverlapMemo(task.id);
                     await this.store.updateTask(task.id, { blockedBy: null });
                     await this.store.logEntry(task.id, `Auto-recovered (FN-4091): cleared stale blockedBy \u2014 ${reason}`);
                     didRecover = true;
@@ -207057,13 +207125,14 @@ var init_self_healing = __esm({
               if (queuedDependencyTaskIds.has(task.id)) {
                 try {
                   if (hasActiveOverlapBlocker) {
-                    await this.store.updateTask(task.id, { blockedBy: null, status: "queued" });
-                    if (this.shouldLogPreservedQueuedOverlap(task.id, task.overlapBlockedBy)) {
-                      await this.store.logEntry(task.id, `Auto-recovered: preserved queued status \u2014 still blocked by file scope overlap with ${task.overlapBlockedBy}`);
-                      recovered++;
-                    }
+                    const transition = await this.store.transitionQueuedEpisode(task.id, {
+                      signature: `file-scope:${task.overlapBlockedBy}`,
+                      blockedBy: null,
+                      overlapBlockedBy: task.overlapBlockedBy ?? null,
+                      action: `Auto-recovered: preserved queued status \u2014 still blocked by file scope overlap with ${task.overlapBlockedBy}`
+                    });
+                    if (transition.appended) recovered++;
                   } else {
-                    this.clearPreservedQueuedOverlapMemo(task.id);
                     await this.store.updateTask(task.id, { blockedBy: null, overlapBlockedBy: null, status: null });
                   }
                 } catch (err) {
@@ -207073,7 +207142,6 @@ var init_self_healing = __esm({
               }
               continue;
             }
-            this.clearPreservedQueuedOverlapMemo(task.id);
             const nextBlocker = unresolvedDeps[0] ?? null;
             if (nextBlocker && task.blockedBy !== nextBlocker) {
               try {
@@ -213284,14 +213352,12 @@ var init_self_healing = __esm({
                 if (canClearInactiveMarker) {
                   rmSync7(promptPath, { force: true });
                   const priorClearCount = typeof task.sourceMetadata?.duplicateMarkerClearCount === "number" ? task.sourceMetadata.duplicateMarkerClearCount : 0;
-                  const alreadyDismissed = isTriageDuplicateKeepAcknowledged(task.sourceMetadata, marker.canonicalId);
-                  const exhausted = alreadyDismissed || priorClearCount >= 1;
-                  const patch = exhausted ? buildMarkerExhaustedFailedTaskPatch(marker.canonicalId, priorClearCount) : buildMarkerClearedReplanTaskPatch(marker.canonicalId, priorClearCount);
+                  const patch = buildMarkerClearedReplanTaskPatch(marker.canonicalId, priorClearCount);
                   await this.store.updateTask(task.id, patch);
                   if (typeof this.store.logEntry === "function") {
                     await Promise.resolve(this.store.logEntry(
                       task.id,
-                      exhausted ? buildDuplicateReplanExhaustedError(marker.canonicalId) : TRIAGE_MARKER_CLEARED_REPLAN_LOG_ACTION,
+                      TRIAGE_MARKER_CLEARED_REPLAN_LOG_ACTION,
                       buildInactiveDuplicateClearFeedback(marker.canonicalId)
                     )).catch(() => {
                     });
@@ -214103,13 +214169,6 @@ function inlineTaskListFallback(lines, opts = {}) {
 function resolveTaskListFormatter(core) {
   return typeof core.formatTaskListText === "function" ? core.formatTaskListText : inlineTaskListFallback;
 }
-async function resolveNearDuplicateCanonicalFlags2(store, canonical) {
-  if (!canonical?.column) return void 0;
-  const ir2 = await resolveWorkflowIrForTask(store, canonical.id).catch(() => void 0);
-  if (!ir2 || ir2.version !== "v2") return void 0;
-  const column = ir2.columns.find((candidate) => candidate.id === canonical.column);
-  return column ? resolveColumnFlags(column) : void 0;
-}
 function isOrphanedLegacyTriageRow(column, declaresTriage) {
   return column === "triage" && !declaresTriage;
 }
@@ -215838,11 +215897,13 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
             const defaultTriagePrompt = resolveAgentPrompt("triage", void 0, { plannerHeartbeatPatrolEnabled });
             const resolvedBasePrompt = userTriagePrompt || (leanPlanning ? workflowFastPlanningPrompt || builtinSeamPrompt("planning-fast") || defaultTriagePrompt : workflowPlanningPrompt || defaultTriagePrompt);
             const renderedBasePrompt = renderTriagePolicyPlaceholders(resolvedBasePrompt, triagePolicySettings);
+            const duplicatePolicyInstruction = buildPlanningDuplicatePolicyInstruction();
             const triageLayers = buildPromptLayers({
               basePrompt: renderedBasePrompt,
               goalContext: triageGoalResolution.goalContext,
               agentInstructions: [
                 triageIdentitySection,
+                duplicatePolicyInstruction,
                 triageInstructions,
                 isResearchToolSurfaceEnabled(settings) ? getResearchGuidanceForSurface("triage") : ""
               ].filter((section) => section.trim()).join("\n\n"),
@@ -216471,7 +216532,7 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
         const taskSearch = {
           name: "fn_task_search",
           label: "Search Tasks",
-          description: "Keyword search across tasks, including done and archived tasks by default. Use for duplicate detection before filing a new task.",
+          description: "Keyword search across active tasks by default. Done and archived history is opt-in and must not be used for duplicate detection.",
           parameters: taskSearchParams2,
           execute: async (_callId, params) => {
             const query = params.query.trim();
@@ -216483,10 +216544,10 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
             }
             const results = await store.searchTasks(query, {
               slim: true,
-              includeArchived: params.includeArchived ?? true,
+              includeArchived: params.includeArchived ?? false,
               limit: params.limit ?? 20
             });
-            const includeDone = params.includeDone ?? true;
+            const includeDone = params.includeDone ?? false;
             const isTerminalResult = includeDone ? void 0 : await resolveTerminalColumnsForTasks(store, results);
             const filtered = includeDone ? results : results.filter((t) => !isTerminalResult(t));
             if (filtered.length === 0) {
@@ -216725,7 +216786,7 @@ Remove or replace these ids and call fn_task_create again.`
           if (canonicalTask?.id.toLowerCase() === task.id.toLowerCase()) {
             return false;
           }
-          const canonicalFlags = await resolveNearDuplicateCanonicalFlags2(this.store, canonicalTask);
+          const canonicalFlags = await resolveNearDuplicateCanonicalFlags(this.store, canonicalTask);
           if (isNearDuplicateCanonicalInactive(canonicalTask, canonicalFlags)) {
             planLog.log(`${task.id} explicit duplicate marker targets inactive ${canonicalId}; clearing marker for replanning`);
           } else {
@@ -216869,17 +216930,16 @@ Remove or replace these ids and call fn_task_create again.`
           const canonicalId = explicitDuplicateMarker.canonicalId;
           const canonicalTask = await this.store.getTask(canonicalId).catch(() => null);
           const canClearInactiveMarker = task.userPaused !== true && (task.paused !== true || task.pausedReason === "duplicate-decision-required") && (task.pausedReason == null || task.pausedReason === "duplicate-decision-required");
-          const canonicalFlags = await resolveNearDuplicateCanonicalFlags2(this.store, canonicalTask);
+          const canonicalFlags = await resolveNearDuplicateCanonicalFlags(this.store, canonicalTask);
           const liveMeta = (await this.store.getTask(task.id).catch(() => null))?.sourceMetadata ?? task.sourceMetadata;
           const priorClearCount = typeof liveMeta?.duplicateMarkerClearCount === "number" ? liveMeta.duplicateMarkerClearCount : 0;
           if (isNearDuplicateCanonicalInactive(canonicalTask ?? void 0, canonicalFlags)) {
             if (canClearInactiveMarker) {
-              const alreadyDismissed = isTriageDuplicateKeepAcknowledged(liveMeta, canonicalId);
               await this.clearDuplicateMarkerForReplan(
                 task,
                 canonicalId,
                 buildInactiveDuplicateClearFeedback(canonicalId),
-                { exhausted: alreadyDismissed || priorClearCount >= 1, priorClearCount }
+                { exhausted: false, priorClearCount }
               );
             }
             return;
@@ -217119,7 +217179,7 @@ Remove or replace these ids and call fn_task_create again.`
               if (!canonicalTask) {
                 return;
               }
-              const canonicalFlags = await resolveNearDuplicateCanonicalFlags2(this.store, canonicalTask);
+              const canonicalFlags = await resolveNearDuplicateCanonicalFlags(this.store, canonicalTask);
               if (isNearDuplicateCanonicalInactive(canonicalTask, canonicalFlags)) {
                 planLog.log(`${task.id}: near-duplicate candidate ${canonical.id} is inactive; skipping near-duplicate flag`);
                 return;
@@ -232990,13 +233050,15 @@ Graph value: ${failureValue}` : ""}`, budget.key),
             recoveryRehome: true
           });
         }
-        await this.store.updateTask(liveTask.id, { status: "queued", blockedBy: unmetDeps[0] }, this.getRunContextFor(liveTask.id));
-        await this.store.logEntry(
-          liveTask.id,
-          `queued \u2014 unmet dependencies: ${unmetDeps.join(", ")}`,
-          "Executor pre-dispatch dependency gate blocked workflow/authoritative execution.",
-          this.getRunContextFor(liveTask.id)
-        );
+        const normalizedUnmetDeps = [...new Set(unmetDeps)].sort();
+        await this.store.transitionQueuedEpisode(liveTask.id, {
+          signature: `dependency:${normalizedUnmetDeps.join(",")}`,
+          blockedBy: unmetDeps[0] ?? null,
+          overlapBlockedBy: liveTask.overlapBlockedBy ?? null,
+          action: `queued \u2014 unmet dependencies: ${unmetDeps.join(", ")}`,
+          outcome: "Executor pre-dispatch dependency gate blocked workflow/authoritative execution.",
+          runContext: this.getRunContextFor(liveTask.id)
+        });
         executorLog.log(`${liveTask.id}: executor dispatch blocked by unmet dependencies: ${unmetDeps.join(", ")}`);
         return true;
       }
@@ -258624,6 +258686,40 @@ var init_in_process_runtime = __esm({
           throw err;
         }
       }
+      /**
+       * Close every process-local admission source without aborting work that is
+       * already running. Development source reload uses this boundary before it
+       * waits for the live-agent count to reach zero.
+       */
+      beginDrain() {
+        if (this.status !== "active") return;
+        this.setStatus("paused");
+        if (this.workflowContinuationTimer) {
+          clearInterval(this.workflowContinuationTimer);
+          this.workflowContinuationTimer = void 0;
+        }
+        const admissionStops = [
+          ["self-healing manager", () => this.selfHealingManager?.stop()],
+          ["routine scheduler", () => this.routineScheduler?.stop()],
+          ["trigger scheduler", () => this.triggerScheduler?.stop()],
+          ["stuck task detector", () => this.stuckTaskDetector?.stop()],
+          ["heartbeat monitor", () => this.heartbeatMonitor?.stop()],
+          ["triage processor", () => this.triageProcessor?.stop()],
+          ["scheduler", () => this.scheduler?.stop()],
+          ["mission autopilot", () => this.missionAutopilot?.stop()],
+          ["mission execution loop", () => this.missionExecutionLoop?.stop()]
+        ];
+        for (const [label, stop] of admissionStops) {
+          try {
+            stop();
+          } catch (error3) {
+            runtimeLog.warn(
+              `Failed to stop ${label} while draining ${this.config.projectId}: ${error3 instanceof Error ? error3.message : String(error3)}`
+            );
+          }
+        }
+        runtimeLog.log(`InProcessRuntime draining for ${this.config.projectId}`);
+      }
       /**
        * Stop the runtime with graceful shutdown.
        *
@@ -262738,6 +262834,11 @@ ${detail}`);
         this.started = false;
         runtimeLog.log(`ProjectEngine stopped for ${this.config.projectId}`);
       }
+      /** Stop new lifecycle admission while allowing active work to finish. */
+      beginDrain() {
+        this.shuttingDown = true;
+        this.runtime.beginDrain();
+      }
       // ── Public accessors ──
       /** Get the underlying InProcessRuntime. */
       getRuntime() {
@@ -266316,14 +266417,30 @@ var init_project_engine_manager = __esm({
         }
         runtimeLog.log(`Engine startup complete: ${started} started, ${failed} failed`);
       }
-      /** Gracefully stop all engines and reconciliation. */
-      async stopAll() {
+      /** Close admission on every engine and stop reconciliation without tearing engines down. */
+      beginDrain() {
         this.stopped = true;
         this.reconciliationStopped = true;
         if (this.reconciliationInterval !== null) {
           clearInterval(this.reconciliationInterval);
           this.reconciliationInterval = null;
         }
+        for (const engine of this.engines.values()) {
+          try {
+            engine.beginDrain?.();
+          } catch (error3) {
+            runtimeLog.warn(
+              `Engine drain error: ${error3 instanceof Error ? error3.message : String(error3)}`
+            );
+          }
+        }
+        for (const starting of this.starting.values()) {
+          void starting.then((engine) => engine.beginDrain?.()).catch(() => void 0);
+        }
+      }
+      /** Gracefully stop all engines and reconciliation. */
+      async stopAll() {
+        this.beginDrain();
         try {
           this.centralCore.stopDiscovery();
           await this.centralCore.markLocalNodeOffline();
@@ -292512,7 +292629,7 @@ function buildDuplicateQuery(title2, description) {
   const selected = deduped.sort((left, right) => right.length - left.length).slice(0, 5);
   return selected.join(" ");
 }
-async function computeDuplicateMatches(scopedStore, input) {
+async function computeDuplicateMatches(scopedStore, input, classifyBlocker) {
   const query = buildDuplicateQuery(input.title, input.description);
   if (query.length === 0) {
     return [];
@@ -292522,7 +292639,12 @@ async function computeDuplicateMatches(scopedStore, input) {
     includeArchived: false,
     limit: 20
   });
-  const candidates = results.map((task) => ({
+  const eligibility = await Promise.all(results.map(async (task) => ({
+    task,
+    blocker: await classifyBlocker(task)
+  })));
+  const eligibleResults = eligibility.filter(({ blocker }) => blocker).map(({ task }) => task);
+  const candidates = eligibleResults.map((task) => ({
     id: task.id,
     title: task.title ?? "",
     description: task.description ?? "",
@@ -292540,6 +292662,10 @@ async function computeDuplicateMatches(scopedStore, input) {
     }
   );
 }
+async function isDuplicateBlocker(store, canonical) {
+  const flags = await resolveNearDuplicateCanonicalFlags(store, canonical);
+  return !isNearDuplicateCanonicalInactive(canonical, flags);
+}
 function buildReviewerAgentItemId(input) {
   const stepPart = input.step ? `step-${input.step}` : "step-na";
   const verdictPart = (input.verdict ?? "unknown").toLowerCase();
@@ -292951,7 +293077,7 @@ function registerTaskWorkflowRoutes(ctx, deps) {
         description: description.trim(),
         limit,
         threshold
-      });
+      }, (canonical) => isDuplicateBlocker(scopedStore, canonical));
       res.json({ matches });
       return;
     } catch (err) {
@@ -293071,6 +293197,15 @@ function registerTaskWorkflowRoutes(ctx, deps) {
         }
       } : void 0;
       const normalizedSource = source && typeof source === "object" && "sourceType" in source && typeof source.sourceType === "string" ? source : { sourceType: "api" };
+      const duplicateBlockerVerdicts = /* @__PURE__ */ new Map();
+      const classifyDuplicateBlocker = (canonical) => {
+        const key = `${canonical.id}:${canonical.column}:${canonical.deletedAt ?? ""}`;
+        const existing = duplicateBlockerVerdicts.get(key);
+        if (existing) return existing;
+        const verdict = isDuplicateBlocker(scopedStore, canonical);
+        duplicateBlockerVerdicts.set(key, verdict);
+        return verdict;
+      };
       const requestedBranchMode = getBranchSelectionMode(branchSelection);
       const { branch: normalizedBranch, baseBranch: normalizedBaseBranch, sharedFeatureBranch } = resolveBranchSelection(branchSelection, branch, baseBranch);
       let validatedGithubTracking;
@@ -293156,7 +293291,7 @@ function registerTaskWorkflowRoutes(ctx, deps) {
       contentFingerprint = deterministicGuard.fingerprint;
       let matchesAfterAckFilter = [];
       try {
-        if (deterministicGuard.action === "duplicate" && deterministicGuard.existing) {
+        if (deterministicGuard.action === "duplicate" && deterministicGuard.existing && await classifyDuplicateBlocker(deterministicGuard.existing)) {
           throw conflict("duplicate_candidates", {
             matches: [{
               id: deterministicGuard.existing.id,
@@ -293171,7 +293306,7 @@ function registerTaskWorkflowRoutes(ctx, deps) {
         const duplicateMatches = bypassDuplicateCheck === true ? [] : await computeDuplicateMatches(scopedStore, {
           title: normalizedTitle,
           description: normalizedDescription
-        });
+        }, classifyDuplicateBlocker);
         matchesAfterAckFilter = duplicateMatches.filter((match) => !acknowledgedDuplicateIds.includes(match.id));
         if (matchesAfterAckFilter.length > 0) {
           throw conflict("duplicate_candidates", { matches: matchesAfterAckFilter });
@@ -293197,11 +293332,17 @@ function registerTaskWorkflowRoutes(ctx, deps) {
               const fullRows = await scopedStore.listTasks({ slim: false, includeArchived: false });
               const byId = new Map(fullRows.map((row) => [row.id, row]));
               const candidateMap = /* @__PURE__ */ new Map();
-              for (const row of candidateRows) {
+              const classifiedRows = await Promise.all(candidateRows.map(async (row) => {
+                const full = byId.get(row.id);
+                return { row, full, blocker: full ? await classifyDuplicateBlocker(full) : true };
+              }));
+              for (const { row, full, blocker } of classifiedRows) {
                 if (acknowledgedDuplicateIds.includes(row.id)) {
                   continue;
                 }
-                const full = byId.get(row.id);
+                if (!blocker) {
+                  continue;
+                }
                 candidateMap.set(row.id, {
                   id: row.id,
                   title: row.title ?? "",
@@ -293249,7 +293390,7 @@ ${normalizedDescription}`;
           const explicitMarkerBypassed = bypassDuplicateCheck === true || (explicitDuplicateMarker ? acknowledgedDuplicateIds.includes(explicitDuplicateMarker.canonicalId) : false);
           if (explicitDuplicateMarker && !explicitMarkerBypassed) {
             const canonical = await scopedStore.getTask(explicitDuplicateMarker.canonicalId).catch(() => null);
-            if (canonical && !canonical.deletedAt) {
+            if (canonical && !canonical.deletedAt && await classifyDuplicateBlocker(canonical)) {
               try {
                 await scopedStore.recordActivity({
                   type: "task:auto-archived-duplicate",
@@ -293356,7 +293497,8 @@ ${normalizedDescription}`;
           createdTask: taskWithBranchContext,
           fingerprint: bypassDuplicateCheck === true ? null : contentFingerprint,
           windowMs: 6e4,
-          logger: runtimeLogger
+          logger: runtimeLogger,
+          onDuplicate: async (canonical) => await classifyDuplicateBlocker(canonical) ? "archive-created" : "keep-created"
         });
         if (deterministicReconcile.outcome === "archived") {
           res.status(200).json(deterministicReconcile.canonical);
@@ -396597,6 +396739,96 @@ var init_startup_phase = __esm({
   }
 });
 
+// src/commands/dev-source-restart.ts
+function isDevSourceChangeMessage(message) {
+  return Boolean(message) && typeof message === "object" && message.type === DEV_SOURCE_CHANGE_MESSAGE;
+}
+function registerDevSourceRestart({
+  enabled,
+  processEvents = process,
+  notifyArmed,
+  beginDrain,
+  getLiveRunningAgentCounts,
+  requestRestart,
+  logger: logger3 = console,
+  recheckIntervalMs = 15e3
+}) {
+  if (!enabled) return () => void 0;
+  let disposed = false;
+  let pending = false;
+  let checking = false;
+  let restartAccepted = false;
+  let deferredForActiveWork = false;
+  let drainStarted = false;
+  let timer2;
+  const schedule = (delayMs) => {
+    if (disposed || timer2) return;
+    timer2 = setTimeout(() => {
+      timer2 = void 0;
+      void checkRestartSafety();
+    }, delayMs);
+    timer2.unref?.();
+  };
+  const checkRestartSafety = async () => {
+    if (disposed || restartAccepted || !pending || checking) return;
+    checking = true;
+    try {
+      const { currentlyActive } = await getLiveRunningAgentCounts();
+      if (currentlyActive > 0) {
+        if (!deferredForActiveWork) {
+          const noun = currentlyActive === 1 ? "agent" : "agents";
+          logger3.log(`[fusion:dev] source restart deferred until ${currentlyActive} active ${noun} reach a safe boundary`);
+          deferredForActiveWork = true;
+        }
+        schedule(recheckIntervalMs);
+        return;
+      }
+      if (deferredForActiveWork) {
+        logger3.log("[fusion:dev] active work drained \u2014 applying pending source restart");
+        deferredForActiveWork = false;
+      }
+      restartAccepted = requestRestart("dev-source-change");
+      if (restartAccepted) {
+        pending = false;
+      } else {
+        logger3.warn("[fusion:dev] source restart request was declined by the host lifecycle");
+        schedule(recheckIntervalMs);
+      }
+    } catch (error3) {
+      logger3.warn(`[fusion:dev] could not verify restart safety: ${error3 instanceof Error ? error3.message : String(error3)}`);
+      schedule(recheckIntervalMs);
+    } finally {
+      checking = false;
+    }
+  };
+  const onMessage = (message) => {
+    if (restartAccepted || !isDevSourceChangeMessage(message)) return;
+    pending = true;
+    if (drainStarted) return;
+    drainStarted = true;
+    void Promise.resolve().then(beginDrain).then(() => schedule(0)).catch((error3) => {
+      logger3.warn(`[fusion:dev] could not begin source restart drain: ${error3 instanceof Error ? error3.message : String(error3)}`);
+    });
+  };
+  processEvents.on("message", onMessage);
+  notifyArmed?.();
+  return () => {
+    disposed = true;
+    pending = false;
+    if (timer2) clearTimeout(timer2);
+    timer2 = void 0;
+    processEvents.off("message", onMessage);
+  };
+}
+var DEV_SOURCE_CHANGE_MESSAGE, DEV_SOURCE_RESTART_ARMED_MESSAGE;
+var init_dev_source_restart = __esm({
+  "src/commands/dev-source-restart.ts"() {
+    "use strict";
+    DEV_SOURCE_CHANGE_MESSAGE = "fusion:dev-source-changed";
+    DEV_SOURCE_RESTART_ARMED_MESSAGE = "fusion:dev-source-restart-armed";
+  }
+});
+
 // src/commands/dashboard.ts
 var dashboard_exports = {};
 __export(dashboard_exports, {
@@ -397342,6 +397574,21 @@ async function runDashboard(port, opts = {}) {
     getRecent: (limit) => logSink.getRecentEntries(limit),
     subscribe: (listener) => logSink.subscribeEntries(listener)
   };
+  const bindDevSourceRestart = (centralCore, beginDrain) => {
+    disposeCallbacks.push(registerDevSourceRestart({
+      enabled: process.env.FUSION_DEV_WATCH === "1" && systemControlForServer.supervised && Boolean(systemControlForServer.sourceWorkspaceRoot),
+      beginDrain,
+      notifyArmed: () => {
+        process.send?.({ type: DEV_SOURCE_RESTART_ARMED_MESSAGE });
+      },
+      getLiveRunningAgentCounts: () => centralCore.getLiveRunningAgentCounts(),
+      requestRestart: (reason) => requestSelfRestart?.(reason) ?? false,
+      logger: {
+        log: (message) => logSink.log(message, "dashboard"),
+        warn: (message) => logSink.warn(message, "dashboard")
+      }
+    }));
+  };
   const SHUTDOWN_HARD_EXIT_GRACE_MS = 3e3;
   const SHUTDOWN_STEP_SLOW_MS = 1e3;
   let currentShutdownStep = null;
@@ -398079,6 +398326,7 @@ async function runDashboard(port, opts = {}) {
       }, 300);
       return true;
     };
+    bindDevSourceRestart(centralCoreForEngine, () => engineManager.beginDrain());
     registerHandler(process, "SIGINT", () => void shutdown("SIGINT"));
     registerHandler(process, "SIGTERM", () => void shutdown("SIGTERM"));
     registerHandler(process, "SIGHUP", () => {
@@ -398339,6 +398587,12 @@ async function runDashboard(port, opts = {}) {
       }, 300);
       return true;
     };
+    if (centralCoreForMesh) {
+      bindDevSourceRestart(centralCoreForMesh, () => {
+        triggerScheduler?.stop();
+        heartbeatMonitorImpl?.stop();
+      });
+    }
     registerHandler(process, "SIGINT", () => void devShutdown("SIGINT"));
     registerHandler(process, "SIGTERM", () => void devShutdown("SIGTERM"));
     registerHandler(process, "SIGHUP", () => {
@@ -399113,6 +399367,7 @@ var init_dashboard = __esm({
     init_dashboard_tui();
     init_dashboard_startup_chain();
     init_startup_phase();
+    init_dev_source_restart();
     processDiagnosticsRegistered = false;
     diagnosticIntervalHandle = null;
     DIAGNOSTIC_INTERVAL_MS = 30 * 60 * 1e3;