@runfusion/fusion 0.45.0 → 0.46.0

package/dist/extension.js

@@ -433,6 +433,9 @@ var init_settings_schema = __esm({
       defaultProvider: void 0,
       defaultModelId: void 0,
       testMode: void 0,
+      modelPricingOverrides: void 0,
+      modelPricingFetchedAt: void 0,
+      modelPricingSource: void 0,
       modelRouterEnabled: void 0,
       modelRouterCheapProvider: void 0,
       modelRouterCheapModelId: void 0,
@@ -49376,6 +49379,9 @@ import { randomUUID as randomUUID15 } from "node:crypto";
 import { mkdir as mkdir7, readdir as readdir5, readFile as readFile8, stat as stat3, writeFile as writeFile6, rename as rename4, unlink as unlink3 } from "node:fs/promises";
 import { join as join20 } from "node:path";
 import { existsSync as existsSync16, watch } from "node:fs";
+function isWorkflowColumnsCompatibilityFlagEnabled(settings) {
+  return settings?.experimentalFeatures?.workflowColumns === true;
+}
 function defineTaskColumn(column, serialize, sqlIdentifier = column) {
   return { column, sqlIdentifier, serialize };
 }
@@ -49690,7 +49696,6 @@ var init_store = __esm({
     init_moved_settings();
     init_workflow_ir();
     init_workflow_steps_to_ir();
-    init_workflow_columns_settings();
     init_workflow_transitions();
     init_plugin_gate_verdict();
     init_trait_registry();
@@ -50488,7 +50493,7 @@ var init_store = __esm({
         }
         try {
           const settings = await this.getSettingsFast();
-          if (isWorkflowColumnsEnabled(settings)) {
+          if (isWorkflowColumnsCompatibilityFlagEnabled(settings)) {
             await this.runWorkflowColumnsIntegrityPass();
             await this.recoverStaleTransitionPending();
           } else {
@@ -52292,7 +52297,7 @@ ${TASK_UPSERT_SQL_ASSIGNMENTS}
           await this.writeConfig(config);
           const updatedMerged = { ...DEFAULT_SETTINGS, ...globalSettings, ...updatedProjectSettings };
           this.emit("settings:updated", { settings: updatedMerged, previous: previousMerged });
-          if (isWorkflowColumnsEnabled(previousMerged) && !isWorkflowColumnsEnabled(updatedMerged)) {
+          if (isWorkflowColumnsCompatibilityFlagEnabled(previousMerged) && !isWorkflowColumnsCompatibilityFlagEnabled(updatedMerged)) {
             try {
               await this.evacuateCustomColumnsToLegacy("flag-toggled-off");
             } catch (err) {
@@ -52375,7 +52380,7 @@ ${TASK_UPSERT_SQL_ASSIGNMENTS}
           merged.secretsSyncPassphraseConfigured = false;
         }
         this.emit("settings:updated", { settings: merged, previous });
-        if (isWorkflowColumnsEnabled(previous) && !isWorkflowColumnsEnabled(merged)) {
+        if (isWorkflowColumnsCompatibilityFlagEnabled(previous) && !isWorkflowColumnsCompatibilityFlagEnabled(merged)) {
           try {
             await this.evacuateCustomColumnsToLegacy("flag-toggled-off");
           } catch (err) {
@@ -54619,7 +54624,8 @@ ${newTask.description}
         return { kind: "engine" };
       }
       resolveWorkflowBypassGuards(moveSource, options) {
-        return options?.recoveryRehome === true || (options?.bypassGuards ?? (moveSource === "engine" || moveSource === "scheduler" || options?.skipMergeBlocker === true));
+        void moveSource;
+        return options?.recoveryRehome === true || (options?.bypassGuards ?? (options?.moveSource === "engine" || options?.moveSource === "scheduler" || options?.skipMergeBlocker === true));
       }
       shouldSkipWorkflowMovePolicies(params) {
         if (params.bypassGuards) return true;
@@ -54630,7 +54636,7 @@ ${newTask.description}
         const task = await this.readTaskForMove(id);
         const moveSource = options?.moveSource ?? "engine";
         const mergedSettingsForMove = await this.getSettingsFast();
-        if (!isWorkflowColumnsEnabled(mergedSettingsForMove)) return void 0;
+        if (!isWorkflowColumnsCompatibilityFlagEnabled(mergedSettingsForMove)) return void 0;
         if (task.column === toColumn) return void 0;
         const workflowIr = this.resolveTaskWorkflowIrSync(id);
         const workflowSignature = serializeWorkflowIr(workflowIr);
@@ -54714,7 +54720,7 @@ ${newTask.description}
         const task = currentTask ?? await this.readTaskForMove(id);
         const moveSource = options?.moveSource ?? "engine";
         const mergedSettingsForMove = await this.getSettingsFast();
-        const useWorkflow = isWorkflowColumnsEnabled(mergedSettingsForMove);
+        const useWorkflow = isWorkflowColumnsCompatibilityFlagEnabled(mergedSettingsForMove);
         const bypassGuards = this.resolveWorkflowBypassGuards(moveSource, options);
         const workflowIr = useWorkflow ? this.resolveTaskWorkflowIrSync(id) : void 0;
         if (task.column === toColumn) {
@@ -59341,12 +59347,32 @@ ${newTask.description}
       /**
        * FNXC:ArtifactRegistry 2026-06-19-22:04:
        * Cross-agent registry query path for filtering artifacts across tasks, authors, and media types. LEFT JOIN keeps task-less registry artifacts visible while excluding artifacts attached to soft-deleted tasks.
+       *
+       * FNXC:ArtifactRegistry 2026-06-23-12:48:
+       * Agent execution can list artifacts frequently while large generated outputs are stored inline. The registry list is metadata-only, so avoid selecting artifact content here and require callers to use getArtifact for the full payload.
        */
       async listArtifacts(options) {
         const limit = Math.min(Math.max(1, options?.limit ?? 200), 1e3);
         const offset = Math.max(0, options?.offset ?? 0);
         let sql = `
-      SELECT a.*, t.title as taskTitle, t.description as taskDescription, t.column as taskColumn
+      SELECT
+        a.id,
+        a.type,
+        a.title,
+        a.description,
+        a.mimeType,
+        a.sizeBytes,
+        a.uri,
+        NULL as content,
+        a.authorId,
+        a.authorType,
+        a.taskId,
+        a.metadata,
+        a.createdAt,
+        a.updatedAt,
+        t.title as taskTitle,
+        t.description as taskDescription,
+        t.column as taskColumn
       FROM artifacts a
       LEFT JOIN tasks t ON a.taskId = t.id
       WHERE (a.taskId IS NULL OR t.${_TaskStore.ACTIVE_TASKS_WHERE})
@@ -61006,9 +61032,9 @@ ${stepsSection}`;
       // always route through `moveTask` with `moveSource: "engine"` + `bypassGuards`
       // (a recovery-class move, KTD-9) — never a raw column write — so capacity
       // (KTD-10) and the single transition authority (KTD-3) are honored.
-      /** True when the `workflowColumns` flag is ON (merged global + project). */
+      /** True when the raw `workflowColumns` compatibility flag is ON (merged global + project). */
       async workflowColumnsFlagOn() {
-        return isWorkflowColumnsEnabled(await this.getSettingsFast());
+        return isWorkflowColumnsCompatibilityFlagEnabled(await this.getSettingsFast());
       }
       /** The active (non-deleted) task ids currently selecting `workflowId`. A
        *  built-in/default workflow additionally owns every task with NO selection
@@ -62970,18 +62996,70 @@ var init_agent_token_usage = __esm({
 function normalize4(s3) {
   return (s3 ?? "").trim().toLowerCase();
 }
-function lookupPricing(ref) {
+function findBareModelPricing(model, entries) {
+  for (const [key, entry] of Object.entries(entries)) {
+    if (key.endsWith(`:${model}`)) return entry;
+  }
+  return void 0;
+}
+function lookupPricing(ref, overrides2) {
   const provider = normalize4(ref.provider);
   const model = normalize4(ref.model);
   if (!model) return void 0;
+  if (provider) {
+    const exactOverride = overrides2?.[`${provider}:${model}`];
+    if (exactOverride) return exactOverride;
+  }
+  const bareOverride = overrides2 ? findBareModelPricing(model, overrides2) : void 0;
+  if (bareOverride) return bareOverride;
   if (provider) {
     const exact = MODEL_PRICING[`${provider}:${model}`];
     if (exact) return exact;
   }
-  for (const [key, entry] of Object.entries(MODEL_PRICING)) {
-    if (key.endsWith(`:${model}`)) return entry;
-  }
-  return void 0;
+  return findBareModelPricing(model, MODEL_PRICING);
+}
+function litellmProviderToFusionProvider(provider) {
+  if (typeof provider !== "string") return null;
+  const normalized = normalize4(provider);
+  if (normalized === "openai") return "openai";
+  if (normalized === "anthropic") return "anthropic";
+  if (normalized === "gemini" || normalized.startsWith("gemini")) return "google";
+  if (normalized === "vertex_ai" || normalized.startsWith("vertex_ai")) return "google";
+  if (normalized === "vertex_ai-language-models") return "google";
+  return null;
+}
+function numericField(entry, key) {
+  const value = entry[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function parseLiteLLMPricing(json) {
+  const overrides2 = {};
+  if (json === null || typeof json !== "object" || Array.isArray(json)) {
+    return { overrides: overrides2, count: 0 };
+  }
+  for (const [modelId, value] of Object.entries(json)) {
+    if (modelId === "sample_spec") continue;
+    if (value === null || typeof value !== "object" || Array.isArray(value)) continue;
+    const entry = value;
+    if (entry.mode !== "chat") continue;
+    const provider = litellmProviderToFusionProvider(entry.litellm_provider);
+    if (!provider) continue;
+    const inputCost = numericField(entry, "input_cost_per_token");
+    const outputCost = numericField(entry, "output_cost_per_token");
+    if (inputCost === void 0 || outputCost === void 0) continue;
+    const inputPer1M = inputCost * 1e6;
+    const outputPer1M = outputCost * 1e6;
+    const cacheRead = numericField(entry, "cache_read_input_token_cost");
+    const cacheWrite = numericField(entry, "cache_creation_input_token_cost");
+    overrides2[`${provider}:${normalize4(modelId)}`] = {
+      inputPer1M,
+      outputPer1M,
+      cacheReadPer1M: cacheRead === void 0 ? inputPer1M : cacheRead * 1e6,
+      cacheWritePer1M: cacheWrite === void 0 ? inputPer1M : cacheWrite * 1e6,
+      source: LITELLM_PRICING_SOURCE_LABEL
+    };
+  }
+  return { overrides: overrides2, count: Object.keys(overrides2).length };
 }
 function isStale(now) {
   if (now === void 0) return false;
@@ -62989,21 +63067,23 @@ function isStale(now) {
   if (Number.isNaN(asOf)) return false;
   return now - asOf > PRICING_STALE_AFTER_MS;
 }
-function costFor(usage, model, now) {
+function costFor(usage, model, now, overrides2) {
   const stale = isStale(now);
-  const pricing = lookupPricing(model);
+  const pricing = lookupPricing(model, overrides2);
   if (!pricing) {
     return { usd: null, unavailable: true, stale };
   }
   const usd = (usage.inputTokens * pricing.inputPer1M + usage.outputTokens * pricing.outputPer1M + usage.cachedTokens * pricing.cacheReadPer1M + usage.cacheWriteTokens * pricing.cacheWritePer1M) / 1e6;
   return { usd, unavailable: false, stale };
 }
-var pricingAsOf, PRICING_STALE_AFTER_MS, MODEL_PRICING;
+var pricingAsOf, PRICING_STALE_AFTER_MS, LITELLM_PRICING_SOURCE_URL, LITELLM_PRICING_SOURCE_LABEL, MODEL_PRICING;
 var init_model_pricing = __esm({
   "../core/src/model-pricing.ts"() {
     "use strict";
     pricingAsOf = "2026-06-21";
     PRICING_STALE_AFTER_MS = 180 * 24 * 60 * 60 * 1e3;
+    LITELLM_PRICING_SOURCE_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+    LITELLM_PRICING_SOURCE_LABEL = "litellm/model_prices_and_context_window.json";
     MODEL_PRICING = {
       // ── Anthropic Claude ────────────────────────────────────────────────
       // input / output / cacheRead(0.1×) / cacheWrite(1.25×, 5-min TTL)
@@ -63250,7 +63330,7 @@ function groupKeyFor(row, groupBy) {
 function emptyCostAccumulator() {
   return { usd: 0, anyPriced: false, anyUnavailable: false, anyStale: false };
 }
-function addRowCost(acc, row, now) {
+function addRowCost(acc, row, now, pricingOverrides) {
   const result = costFor(
     {
       inputTokens: row.inputTokens ?? 0,
@@ -63262,7 +63342,8 @@ function addRowCost(acc, row, now) {
       provider: row.tokenUsageModelProvider ?? row.modelProvider,
       model: row.tokenUsageModelId ?? row.modelId
     },
-    now
+    now,
+    pricingOverrides
   );
   if (result.stale) acc.anyStale = true;
   if (result.unavailable || result.usd === null) {
@@ -63371,9 +63452,10 @@ function aggregateTokenAnalytics(db, query = {}) {
   const groupBy = query.groupBy;
   const granularity = query.granularity;
   const now = query.now;
+  const pricingOverrides = query.pricingOverrides;
   for (const row of rows) {
     addRow(totals, row);
-    addRowCost(totalCost, row, now);
+    addRowCost(totalCost, row, now, pricingOverrides);
     if (groupBy) {
       const groupRows = groupBy === "model" || groupBy === "provider" ? parsePerModelRows(row) : [];
       const rowsForGroup = groupRows.length > 0 ? groupRows : [row];
@@ -63386,7 +63468,7 @@ function aggregateTokenAnalytics(db, query = {}) {
           groupCostMap.set(key, emptyCostAccumulator());
         }
         addRow(group, groupRow);
-        addRowCost(groupCostMap.get(key), groupRow, now);
+        addRowCost(groupCostMap.get(key), groupRow, now, pricingOverrides);
       }
     }
     if (granularity) {
@@ -63398,7 +63480,7 @@ function aggregateTokenAnalytics(db, query = {}) {
         seriesCostMap.set(bucket, emptyCostAccumulator());
       }
       addRow(point, row);
-      addRowCost(seriesCostMap.get(bucket), row, now);
+      addRowCost(seriesCostMap.get(bucket), row, now, pricingOverrides);
     }
   }
   for (const [key, group] of groupMap) {
@@ -64049,7 +64131,7 @@ function addTokenRow(totals, row) {
   totals.totalTokens += row.totalTokens ?? (row.inputTokens ?? 0) + (row.outputTokens ?? 0) + (row.cachedTokens ?? 0) + (row.cacheWriteTokens ?? 0);
   totals.nTasks += 1;
 }
-function addRowCost2(acc, row, now) {
+function addRowCost2(acc, row, now, pricingOverrides) {
   const result = costFor(
     {
       inputTokens: row.inputTokens ?? 0,
@@ -64058,7 +64140,8 @@ function addRowCost2(acc, row, now) {
       cacheWriteTokens: row.cacheWriteTokens ?? 0
     },
     { provider: row.modelProvider, model: row.modelId },
-    now
+    now,
+    pricingOverrides
   );
   if (result.stale) acc.anyStale = true;
   if (result.unavailable || result.usd === null) {
@@ -64117,6 +64200,7 @@ function aggregateTeamAnalytics(db, query = {}) {
   const costAccumulators = /* @__PURE__ */ new Map();
   const totalTokens = emptyTokenTotals();
   const totalCost = emptyCostAccumulator2();
+  const pricingOverrides = query.pricingOverrides;
   const agents = db.prepare(`SELECT id, name, role, state FROM agents ORDER BY id`).all();
   for (const agent of agents) {
     summaries.set(agent.id, makeSummary(agent.id, agent));
@@ -64152,8 +64236,8 @@ function aggregateTeamAnalytics(db, query = {}) {
     costAccumulators.set(row.agentId, agentCost);
     addTokenRow(summary.tokens, row);
     addTokenRow(totalTokens, row);
-    addRowCost2(agentCost, row, query.now);
-    addRowCost2(totalCost, row, query.now);
+    addRowCost2(agentCost, row, query.now, pricingOverrides);
+    addRowCost2(totalCost, row, query.now, pricingOverrides);
   }
   const completedClauses = ["assignedAgentId IS NOT NULL", `"column" = 'done'`, "columnMovedAt IS NOT NULL"];
   const completedParams = [];
@@ -86357,6 +86441,8 @@ __export(src_exports, {
   InvalidMergeQueueLeaseDurationError: () => InvalidMergeQueueLeaseDurationError,
   InvalidRehomeTargetError: () => InvalidRehomeTargetError,
   LEGACY_AGENT_PERMISSION_POLICY_ACTION_CATEGORY_ALIASES: () => LEGACY_AGENT_PERMISSION_POLICY_ACTION_CATEGORY_ALIASES,
+  LITELLM_PRICING_SOURCE_LABEL: () => LITELLM_PRICING_SOURCE_LABEL,
+  LITELLM_PRICING_SOURCE_URL: () => LITELLM_PRICING_SOURCE_URL,
   LinkedWorktreeBootstrapRefusedError: () => LinkedWorktreeBootstrapRefusedError,
   MANUAL_RETRY_RESET_COUNTER_KEYS: () => MANUAL_RETRY_RESET_COUNTER_KEYS,
   MASTER_KEY_FILENAME: () => MASTER_KEY_FILENAME,
@@ -86897,6 +86983,7 @@ __export(src_exports, {
   parseInsightExtractionResponse: () => parseInsightExtractionResponse,
   parseInstanceNodeId: () => parseInstanceNodeId,
   parseJsonSteps: () => parseJsonSteps,
+  parseLiteLLMPricing: () => parseLiteLLMPricing,
   parseNoOpCompletionMarker: () => parseNoOpCompletionMarker,
   parseProjectManifest: () => parseProjectManifest,
   parseRepoFromRemote: () => parseRepoFromRemote,
@@ -87398,6 +87485,74 @@ var init_logger2 = __esm({
 });
 
 // ../engine/src/agent-logger.ts
+function truncateToolResultDetail(value) {
+  if (value.length <= TOOL_RESULT_DETAIL_LIMIT) return value;
+  return `${value.slice(0, TOOL_RESULT_DETAIL_LIMIT)}${TOOL_RESULT_DETAIL_TRUNCATION_NOTICE}`;
+}
+function summarizeToolResultValue(value, state) {
+  if (state.remainingChars <= 0) return "[truncated]";
+  if (value === null || value === void 0) return value;
+  if (typeof value === "string") {
+    const truncated = value.length > state.remainingChars ? `${value.slice(0, state.remainingChars)}${TOOL_RESULT_DETAIL_TRUNCATION_NOTICE}` : value;
+    state.remainingChars -= Math.min(value.length, state.remainingChars);
+    return truncated;
+  }
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "function" || typeof value === "symbol") return `[${typeof value}]`;
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: summarizeToolResultValue(value.message, state),
+      ...value.stack ? { stack: summarizeToolResultValue(value.stack, state) } : {}
+    };
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+    return `<Buffer ${value.byteLength} bytes>`;
+  }
+  if (ArrayBuffer.isView(value)) {
+    return `<${value.constructor.name} ${value.byteLength} bytes>`;
+  }
+  if (value instanceof ArrayBuffer) {
+    return `<ArrayBuffer ${value.byteLength} bytes>`;
+  }
+  if (typeof value !== "object") return String(value);
+  if (state.seen.has(value)) return "[Circular]";
+  state.seen.add(value);
+  if (Array.isArray(value)) {
+    const summarized2 = value.slice(0, TOOL_RESULT_MAX_ARRAY_ITEMS).map((item) => summarizeToolResultValue(item, state));
+    if (value.length > TOOL_RESULT_MAX_ARRAY_ITEMS) summarized2.push(`[${value.length - TOOL_RESULT_MAX_ARRAY_ITEMS} more items truncated]`);
+    return summarized2;
+  }
+  const summarized = {};
+  let count2 = 0;
+  for (const key of Object.keys(value)) {
+    if (count2 >= TOOL_RESULT_MAX_OBJECT_KEYS) {
+      summarized.__truncatedKeys = true;
+      break;
+    }
+    summarized[key] = summarizeToolResultValue(value[key], state);
+    count2 += 1;
+    if (state.remainingChars <= 0) {
+      summarized.__truncated = true;
+      break;
+    }
+  }
+  return summarized;
+}
+function summarizeToolResultDetail(result) {
+  if (result === void 0 || result === null) return void 0;
+  if (typeof result === "string") return truncateToolResultDetail(result);
+  try {
+    const preview = summarizeToolResultValue(result, {
+      remainingChars: TOOL_RESULT_DETAIL_LIMIT,
+      seen: /* @__PURE__ */ new WeakSet()
+    });
+    return truncateToolResultDetail(JSON.stringify(preview));
+  } catch {
+    return truncateToolResultDetail(String(result));
+  }
+}
 function summarizeToolArgs(name, args) {
   if (!args) return void 0;
   const lowerName = name.toLowerCase();
@@ -87414,7 +87569,7 @@ function summarizeToolArgs(name, args) {
   }
   return void 0;
 }
-var FLUSH_SIZE_BYTES, FLUSH_INTERVAL_MS, ENTRY_BATCH_SIZE, AgentLogger;
+var FLUSH_SIZE_BYTES, FLUSH_INTERVAL_MS, ENTRY_BATCH_SIZE, TOOL_RESULT_DETAIL_LIMIT, TOOL_RESULT_DETAIL_TRUNCATION_NOTICE, TOOL_RESULT_MAX_ARRAY_ITEMS, TOOL_RESULT_MAX_OBJECT_KEYS, AgentLogger;
 var init_agent_logger = __esm({
   "../engine/src/agent-logger.ts"() {
     "use strict";
@@ -87423,6 +87578,10 @@ var init_agent_logger = __esm({
     FLUSH_SIZE_BYTES = 1024;
     FLUSH_INTERVAL_MS = 500;
     ENTRY_BATCH_SIZE = 50;
+    TOOL_RESULT_DETAIL_LIMIT = 4096;
+    TOOL_RESULT_DETAIL_TRUNCATION_NOTICE = "\n\n[tool output truncated to keep dashboard log views responsive]";
+    TOOL_RESULT_MAX_ARRAY_ITEMS = 25;
+    TOOL_RESULT_MAX_OBJECT_KEYS = 50;
     AgentLogger = class {
       textBuffer = "";
       thinkingBuffer = "";
@@ -87568,10 +87727,7 @@ var init_agent_logger = __esm({
        */
       onToolEnd(name, isError, result) {
         const type = isError ? "tool_error" : "tool_result";
-        let detail;
-        if (result !== void 0 && result !== null) {
-          detail = typeof result === "string" ? result : JSON.stringify(result);
-        }
+        const detail = summarizeToolResultDetail(result);
         this.writeEntry(name, type, detail, `Failed to log tool end "${name}" (${type}) for ${this.taskId}`);
         const startedAt = this.toolStartedAt.get(name);
         if (startedAt !== void 0) this.toolStartedAt.delete(name);
@@ -88618,7 +88774,6 @@ function countCapacitySlot(allTasks, effectiveWorkflowIdByTask, targetColumn, wo
 async function runHoldReleaseSweep(store, deps) {
   const result = { released: [], held: [] };
   const settings = await store.getSettings();
-  if (!isWorkflowColumnsEnabled(settings)) return result;
   const allTasks = await store.listTasks({ includeArchived: false });
   const irCache = /* @__PURE__ */ new Map();
   const effectiveWorkflowIdByTask = /* @__PURE__ */ new Map();
@@ -107616,10 +107771,83 @@ var init_unlinked_missions_advisory_reporter = __esm({
   }
 });
 
+// ../engine/src/task-agent-sync.ts
+function hasFreshActiveHeartbeatRun(activeRun, now = Date.now(), freshRunMs = PARKED_AGENT_LINK_FRESH_RUN_MS) {
+  const runStartedAt = activeRun?.startedAt;
+  const runAgeMs = runStartedAt ? now - Date.parse(runStartedAt) : Number.POSITIVE_INFINITY;
+  return {
+    hasFreshRun: Boolean(activeRun) && Number.isFinite(runAgeMs) && runAgeMs <= freshRunMs,
+    runAgeMs
+  };
+}
+function isParkedTaskColumn(task) {
+  return task?.column === "todo" || task?.column === "triage";
+}
+function evaluateParkedAgentTaskLink(options) {
+  const { hasFreshRun, runAgeMs } = hasFreshActiveHeartbeatRun(options.activeRun, options.now);
+  const hasActiveExecution = options.hasActiveAgentExecution?.(options.agent.id) === true;
+  return {
+    hasFreshRun,
+    hasActiveExecution,
+    shouldPreserveParkedLink: isParkedTaskColumn(options.linkedTask) && (hasFreshRun || hasActiveExecution),
+    runAgeMs
+  };
+}
+function attachAgentLinkSync(opts) {
+  const logger3 = opts.logger ?? console;
+  const handler = async ({ task, from, to: to2 }) => {
+    if (!CLEAR_COLUMNS.has(to2)) {
+      return;
+    }
+    try {
+      const agents = await opts.agentStore.listAgents({ includeEphemeral: false });
+      const linkedAgents = agents.filter((agent) => agent.taskId === task.id);
+      for (const agent of linkedAgents) {
+        if (to2 === "todo" || to2 === "triage") {
+          const activeRun = await opts.agentStore.getActiveHeartbeatRun?.(agent.id);
+          const proof = evaluateParkedAgentTaskLink({
+            agent,
+            linkedTask: { column: to2 },
+            activeRun,
+            hasActiveAgentExecution: opts.hasActiveAgentExecution
+          });
+          if (proof.shouldPreserveParkedLink) {
+            continue;
+          }
+        }
+        if (agent.state === "running") {
+          await opts.agentStore.updateAgentState(agent.id, "active");
+        }
+        await opts.agentStore.syncExecutionTaskLink(agent.id, void 0);
+        logger3.log(`taskAgentLinkSync: cleared agent ${agent.id} taskId from ${task.id} after move ${from} \u2192 ${to2}`);
+      }
+    } catch (error) {
+      logger3.warn(
+        `taskAgentLinkSync: failed to sync agents for task ${task.id} after move ${from} \u2192 ${to2}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  };
+  opts.store.on("task:moved", handler);
+  return () => {
+    opts.store.off("task:moved", handler);
+  };
+}
+var PARKED_AGENT_LINK_FRESH_RUN_MS, CLEAR_COLUMNS;
+var init_task_agent_sync = __esm({
+  "../engine/src/task-agent-sync.ts"() {
+    "use strict";
+    PARKED_AGENT_LINK_FRESH_RUN_MS = 5 * 6e4;
+    CLEAR_COLUMNS = /* @__PURE__ */ new Set(["done", "archived", "todo", "triage"]);
+  }
+});
+
 // ../engine/src/scheduler.ts
 import { existsSync as existsSync37 } from "node:fs";
 import { readFile as readFile20 } from "node:fs/promises";
 import { join as join42 } from "node:path";
+function shouldRunWorkflowColumnScheduler(_settings) {
+  return true;
+}
 function pathsOverlap2(a, b2) {
   for (const pa of a) {
     const prefixA = pa.endsWith("/*") ? pa.slice(0, -1) : null;
@@ -107860,6 +108088,7 @@ var init_scheduler = __esm({
     init_run_audit();
     init_src();
     init_hold_release();
+    init_task_agent_sync();
     COORDINATION_SAFE_SCOPE_EXACT = /* @__PURE__ */ new Set([
       // Literal glob scope entries from PROMPT.md are kept here; concrete
       // `.changeset/<name>.md` files are covered by COORDINATION_SAFE_SCOPE_PREFIXES.
@@ -108306,12 +108535,27 @@ var init_scheduler = __esm({
       async rollbackRunningAgentsForQueuedTodoTask(taskId) {
         const agentStore = this.options.agentStore;
         if (!agentStore) return;
-        const runningAgents = await agentStore.listAgents({ state: "running", includeEphemeral: true });
+        const runningAgents = await agentStore.listAgents({ state: "running", includeEphemeral: false });
         const linkedAgents = runningAgents.filter((agent) => agent.taskId === taskId);
         for (const agent of linkedAgents) {
+          const activeRun = await agentStore.getActiveHeartbeatRun?.(agent.id);
+          const proof = evaluateParkedAgentTaskLink({
+            agent,
+            linkedTask: { column: "todo" },
+            activeRun,
+            hasActiveAgentExecution: this.options.hasActiveAgentExecution
+          });
+          if (proof.shouldPreserveParkedLink) {
+            schedulerLog.log(
+              `Preserved running agent ${agent.id} for queued ${taskId}; live proof freshRun=${proof.hasFreshRun} activeExecution=${proof.hasActiveExecution}`
+            );
+            continue;
+          }
           await agentStore.updateAgentState(agent.id, "active");
           await agentStore.syncExecutionTaskLink(agent.id, void 0);
-          schedulerLog.log(`Rolled back running agent ${agent.id} after overlap requeue of ${taskId}`);
+          schedulerLog.log(
+            `Cleared stale running agent ${agent.id} after overlap requeue of ${taskId}; file-scope lease remains queued`
+          );
         }
       }
       /**
@@ -108431,7 +108675,7 @@ var init_scheduler = __esm({
             schedulerLog.log("Engine pause cleared \u2014 scheduling resumed");
           }
           this.wasEnginePaused = false;
-          if (isWorkflowColumnsEnabled(settings)) {
+          if (shouldRunWorkflowColumnScheduler(settings)) {
             await this.runHoldReleaseSweepPass(tasks, settings);
             tasks = await this.store.listTasks({ slim: true, includeArchived: false, startupMemo: false });
             settings = await this.store.getSettings();
@@ -109457,6 +109701,7 @@ var init_scheduler = __esm({
                       blockedBy: null,
                       overlapBlockedBy: overlappingTaskId
                     });
+                    await this.rollbackRunningAgentsForQueuedTodoTask(task.id);
                     await this.logDispatchQueuedReason(
                       task.id,
                       `queued \u2014 blocked by active file-scope lease ${overlappingTaskId} (column=${activeLeaseColumn})`
@@ -124385,6 +124630,7 @@ var init_self_healing = __esm({
     init_notifier();
     init_dependency_blocked_todo_reporter();
     init_scheduler();
+    init_task_agent_sync();
     init_transient_merge_error_classifier();
     init_transient_merge_error_classifier();
     log22 = createLogger2("self-healing");
@@ -124451,7 +124697,7 @@ var init_self_healing = __esm({
     DURABLE_ERROR_RECOVERY_MAX_RETRIES = 5;
     DURABLE_ERROR_RECOVERY_BASE_COOLDOWN_MS = 3e4;
     DURABLE_ERROR_RECOVERY_MAX_COOLDOWN_MS = 15 * 6e4;
-    RUNNING_ON_INACTIVE_TASK_STALE_RUN_MS = 5 * 6e4;
+    RUNNING_ON_INACTIVE_TASK_STALE_RUN_MS = PARKED_AGENT_LINK_FRESH_RUN_MS;
     SelfHealingManager = class _SelfHealingManager {
       constructor(store, options) {
         this.store = store;
@@ -131279,6 +131525,36 @@ var init_self_healing = __esm({
         const exponential = DURABLE_ERROR_RECOVERY_BASE_COOLDOWN_MS * Math.pow(2, clampedAttempts - 1);
         return Math.min(exponential, DURABLE_ERROR_RECOVERY_MAX_COOLDOWN_MS);
       }
+      async emitStaleAgentAssignmentAudit(options) {
+        try {
+          await createRunAuditor(this.store, {
+            runId: generateSyntheticRunId("self-healing-stale-agent-assignment", options.taskId),
+            agentId: "self-healing",
+            taskId: options.taskId,
+            taskLineageId: options.linkedTask?.lineageId,
+            phase: "reconcile-stale-agent-assignment"
+          }).database({
+            type: "task:reconcile-stale-agent-assignment",
+            target: options.agent.id,
+            metadata: {
+              agentId: options.agent.id,
+              taskId: options.taskId,
+              taskColumn: options.linkedTask?.column ?? null,
+              agentState: options.agent.state,
+              status: options.linkedTask?.status ?? null,
+              blockedBy: options.linkedTask?.blockedBy ?? null,
+              overlapBlockedBy: options.linkedTask?.overlapBlockedBy ?? null,
+              hadFreshRun: options.hadFreshRun,
+              hadActiveExecution: options.hadActiveExecution,
+              reason: options.reason
+            }
+          });
+        } catch (error) {
+          log22.warn(
+            `Failed to emit stale agent assignment audit for ${options.agent.id}/${options.taskId}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
       async recoverAgentsRunningOnInactiveTasks() {
         const agentStore = this.options.agentStore;
         if (!agentStore) {
@@ -131296,16 +131572,30 @@ var init_self_healing = __esm({
             continue;
           }
           const activeRun = await agentStore.getActiveHeartbeatRun(agent.id);
-          const runStartedAt = activeRun?.startedAt;
-          const runAgeMs = runStartedAt ? now - Date.parse(runStartedAt) : Number.POSITIVE_INFINITY;
-          const hasFreshRun = Boolean(activeRun) && Number.isFinite(runAgeMs) && runAgeMs <= RUNNING_ON_INACTIVE_TASK_STALE_RUN_MS;
-          if (hasFreshRun || this.options.hasActiveAgentExecution?.(agent.id) === true) {
+          const proof = evaluateParkedAgentTaskLink({
+            agent,
+            linkedTask: linkedTask ?? { column: "todo" },
+            activeRun,
+            hasActiveAgentExecution: this.options.hasActiveAgentExecution,
+            now
+          });
+          if (proof.hasFreshRun || proof.hasActiveExecution) {
             continue;
           }
+          const reason = linkedTask ? `running durable agent linked to inactive ${linkedTask.column} task without live execution proof` : "running durable agent linked to missing task without live execution proof";
+          const staleAgentState = agent.state;
           await agentStore.updateAgentState(agent.id, "active");
           await agentStore.syncExecutionTaskLink(agent.id, void 0);
+          await this.emitStaleAgentAssignmentAudit({
+            agent: { id: agent.id, state: staleAgentState },
+            taskId: agent.taskId,
+            linkedTask,
+            hadFreshRun: proof.hasFreshRun,
+            hadActiveExecution: proof.hasActiveExecution,
+            reason
+          });
           recoveredAgentIds.add(agent.id);
-          log22.log(`Recovered running durable agent ${agent.id} on inactive task ${agent.taskId}`);
+          log22.log(`Recovered running durable agent ${agent.id} on inactive task ${agent.taskId}; file-scope lease preserved when present`);
         }
         return recoveredAgentIds.size;
       }
@@ -131325,6 +131615,8 @@ var init_self_healing = __esm({
           const linkedTask = await this.store.getTask(linkedTaskId);
           let shouldClear = false;
           let reason = "";
+          let hadFreshRun = false;
+          let hadActiveExecution = false;
           if (!linkedTask) {
             shouldClear = true;
             reason = "linked task missing";
@@ -131336,21 +131628,38 @@ var init_self_healing = __esm({
             reason = `linked task assigned to ${linkedTask.assignedAgentId}`;
           } else if (linkedTask.column === "todo" || linkedTask.column === "triage") {
             const activeRun = await agentStore.getActiveHeartbeatRun(agent.id);
-            const runStartedAt = activeRun?.startedAt;
-            const runAgeMs = runStartedAt ? now - Date.parse(runStartedAt) : Number.POSITIVE_INFINITY;
-            const hasFreshRun = Boolean(activeRun) && Number.isFinite(runAgeMs) && runAgeMs <= RUNNING_ON_INACTIVE_TASK_STALE_RUN_MS;
-            const hasActiveExecution = this.options.hasActiveAgentExecution?.(agent.id) === true;
-            if (!hasFreshRun && !hasActiveExecution) {
+            const proof = evaluateParkedAgentTaskLink({
+              agent,
+              linkedTask,
+              activeRun,
+              hasActiveAgentExecution: this.options.hasActiveAgentExecution,
+              now
+            });
+            hadFreshRun = proof.hasFreshRun;
+            hadActiveExecution = proof.hasActiveExecution;
+            if (!proof.shouldPreserveParkedLink) {
               shouldClear = true;
-              reason = `linked task in queued column ${linkedTask.column} without fresh run`;
+              reason = `linked task in queued column ${linkedTask.column} without fresh run or active execution`;
             }
           }
           if (!shouldClear) {
             continue;
           }
+          const staleAgentState = agent.state;
+          if (agent.state === "running") {
+            await agentStore.updateAgentState(agent.id, "active");
+          }
           await agentStore.syncExecutionTaskLink(agent.id, void 0);
+          await this.emitStaleAgentAssignmentAudit({
+            agent: { id: agent.id, state: staleAgentState },
+            taskId: linkedTaskId,
+            linkedTask,
+            hadFreshRun,
+            hadActiveExecution,
+            reason
+          });
           clearedAgentIds.add(agent.id);
-          log22.log(`Cleared drifted durable agent task link for ${agent.id} (${linkedTaskId}): ${reason}`);
+          log22.log(`Cleared drifted durable agent task link for ${agent.id} (${linkedTaskId}): ${reason}; file-scope lease preserved when present`);
         }
         log22.log(`Recovered ${clearedAgentIds.size} drifted durable agent task link(s)`);
         return clearedAgentIds.size;
@@ -134505,6 +134814,10 @@ Remove or replace these ids and call fn_task_create again.`
                   // Project-level validator fallback
                   projectValidatorFallbackProvider: currentSettings.validatorFallbackProvider,
                   projectValidatorFallbackModelId: currentSettings.validatorFallbackModelId,
+                  // FNXC:SpecReviewerFallback 2026-06-23-08:50:
+                  // Spec review must inherit global/default fallback reviewer model settings when no validator-specific fallback is configured, plus the project settings/prompt payload that reviewer sessions use for memory and custom prompt behavior.
+                  fallbackProvider: currentSettings.fallbackProvider,
+                  fallbackModelId: currentSettings.fallbackModelId,
                   // Global validator lane
                   globalValidatorProvider: currentSettings.validatorGlobalProvider,
                   globalValidatorModelId: currentSettings.validatorGlobalModelId,
@@ -134516,8 +134829,10 @@ Remove or replace these ids and call fn_task_create again.`
                   taskId,
                   task: currentDetail,
                   userComments: currentUserComments.length > 0 ? currentUserComments : void 0,
+                  agentPrompts: currentSettings.agentPrompts,
                   agentStore: this.options.agentStore,
                   rootDir,
+                  settings: currentSettings,
                   // Track the spec reviewer's session under this task so it's
                   // disposed alongside the main triage session on global pause.
                   onSessionCreated: (s3) => this.registerSubagentSession(taskId, s3),
@@ -152927,7 +153242,14 @@ Review the work done in this worktree and evaluate it against the criteria in yo
           const errorMessage = err instanceof Error ? err.message : String(err);
           executorLog.warn(`Child agent ${agentId} failed: ${errorMessage}`);
         } finally {
-          this.childSessions.delete(agentId);
+          if (this.childSessions.get(agentId) === childSession) {
+            try {
+              await childSession.dispose();
+            } catch (disposeErr) {
+              executorLog.warn(`Child agent ${agentId} session dispose failed: ${disposeErr instanceof Error ? disposeErr.message : String(disposeErr)}`);
+            }
+            this.childSessions.delete(agentId);
+          }
           this.totalSpawnedCount = Math.max(0, this.totalSpawnedCount - 1);
         }
       }
@@ -157616,6 +157938,7 @@ var init_agent_heartbeat = __esm({
     init_heartbeat_prompt_trim();
     init_room_ambiguity();
     init_room_coordination();
+    init_task_agent_sync();
     promptSizeLog = createLogger2("prompt-size");
     REPORTS_STALE_INTERVAL_MULTIPLIER = 1.5;
     MIN_HEARTBEAT_STALENESS_MS = 10 * 6e4;
@@ -158322,6 +158645,37 @@ Critical: a heartbeat without observable progress (or an explicit no-op reason)
           void this.checkMissedHeartbeats();
         }, this.pollIntervalMs);
       }
+      async emitStaleAgentAssignmentAudit(options) {
+        if (!this.taskStore) return;
+        try {
+          await createRunAuditor(this.taskStore, {
+            runId: generateSyntheticRunId("heartbeat-stale-agent-assignment", options.taskId),
+            agentId: "heartbeat-monitor",
+            taskId: options.taskId,
+            taskLineageId: options.linkedTask?.lineageId,
+            phase: "reconcile-stale-agent-assignment"
+          }).database({
+            type: "task:reconcile-stale-agent-assignment",
+            target: options.agent.id,
+            metadata: {
+              agentId: options.agent.id,
+              taskId: options.taskId,
+              taskColumn: options.linkedTask?.column ?? null,
+              agentState: options.agent.state,
+              status: options.linkedTask?.status ?? null,
+              blockedBy: options.linkedTask?.blockedBy ?? null,
+              overlapBlockedBy: options.linkedTask?.overlapBlockedBy ?? null,
+              hadFreshRun: options.hadFreshRun,
+              hadActiveExecution: options.hadActiveExecution,
+              reason: options.reason
+            }
+          });
+        } catch (error) {
+          heartbeatLog.warn(
+            `Failed to emit stale agent assignment audit for ${options.agent.id}/${options.taskId}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
       /**
        * Find agents in `state="running"` that are not actually running and flip
        * them to `"active"`. An agent is considered orphaned when either:
@@ -158339,8 +158693,8 @@ Critical: a heartbeat without observable progress (or an explicit no-op reason)
        * logged but do not block the caller.
        *
        * Complements SelfHealingManager.recoverAgentsRunningOnInactiveTasks():
-       * heartbeat reconciliation handles stale/no-run conditions, while self-healing
-       * handles task-column mismatches (for example running agents linked to todo tasks).
+       * heartbeat reconciliation handles stale/no-run conditions and the prompt-critical
+       * parked todo/triage assignment drift before Reports Health Check renders.
        */
       async reconcileOrphanedRunningAgents() {
         try {
@@ -158348,10 +158702,29 @@ Critical: a heartbeat without observable progress (or an explicit no-op reason)
           const now = Date.now();
           for (const agent of runningAgents) {
             let reason = null;
+            let clearTaskLink = false;
+            let taskIdToClear = null;
+            let parkedProof = null;
+            let linkedTask = null;
             const activeRun = await this.store.getActiveHeartbeatRun(agent.id);
-            if (!activeRun) {
+            if (!isEphemeralAgent(agent) && agent.taskId && this.taskStore) {
+              linkedTask = await this.taskStore.getTask(agent.taskId);
+              parkedProof = evaluateParkedAgentTaskLink({
+                agent,
+                linkedTask,
+                activeRun,
+                hasActiveAgentExecution: (agentId) => this.trackedAgents.has(agentId),
+                now
+              });
+              if (isParkedTaskColumn(linkedTask) && !parkedProof.shouldPreserveParkedLink) {
+                reason = `parked ${linkedTask.column} task ${agent.taskId} without live execution proof`;
+                clearTaskLink = true;
+                taskIdToClear = agent.taskId;
+              }
+            }
+            if (!reason && !activeRun) {
               reason = "no active run";
-            } else if (!this.trackedAgents.has(agent.id)) {
+            } else if (!reason && activeRun && !this.trackedAgents.has(agent.id)) {
               const timeoutMs = this.resolveAgentConfig(agent.id).heartbeatTimeoutMs;
               const heartbeatAgeMs = getHeartbeatAgeMs(agent, now);
               if (!Number.isFinite(heartbeatAgeMs) || heartbeatAgeMs > timeoutMs * 3) {
@@ -158370,9 +158743,21 @@ Critical: a heartbeat without observable progress (or an explicit no-op reason)
             }
             if (!reason) continue;
             try {
+              const staleAgentState = agent.state;
               await this.store.updateAgentState(agent.id, "active");
+              if (clearTaskLink) {
+                await this.store.syncExecutionTaskLink(agent.id, void 0);
+                await this.emitStaleAgentAssignmentAudit({
+                  agent: { id: agent.id, state: staleAgentState },
+                  taskId: taskIdToClear,
+                  linkedTask,
+                  hadFreshRun: parkedProof?.hasFreshRun ?? false,
+                  hadActiveExecution: parkedProof?.hasActiveExecution ?? false,
+                  reason
+                });
+              }
               this.clearRunState(agent.id);
-              heartbeatLog.log(`Reconciled orphaned running agent ${agent.id} \u2192 active (${reason})`);
+              heartbeatLog.log(`Reconciled orphaned running agent ${agent.id} \u2192 active (${reason})${clearTaskLink ? "; stale task link cleared" : ""}`);
             } catch (err) {
               heartbeatLog.warn(`Failed to reconcile orphaned running agent ${agent.id}: ${err instanceof Error ? err.message : String(err)}`);
             }
@@ -159925,8 +160310,35 @@ ${trimPromptMd(taskDetail.prompt, promptTemplate)}` : "No PROMPT.md available.",
           );
           const lastHeartbeatTs = report.lastHeartbeatAt ? Date.parse(report.lastHeartbeatAt) : NaN;
           const heartbeatAgeMs = Number.isFinite(lastHeartbeatTs) ? Math.max(0, now - lastHeartbeatTs) : Infinity;
+          let renderedState = report.state;
+          let renderedTask = report.taskId ?? "\u2014";
+          let staleParkedAssignment = false;
+          if (report.state === "running" && !isEphemeralAgent(report) && report.taskId && this.taskStore) {
+            try {
+              const linkedTask = await this.taskStore.getTask(report.taskId);
+              if (isParkedTaskColumn(linkedTask)) {
+                const activeRun = await agentStore.getActiveHeartbeatRun(report.id);
+                const proof = evaluateParkedAgentTaskLink({
+                  agent: report,
+                  linkedTask,
+                  activeRun,
+                  hasActiveAgentExecution: (candidateId) => this.trackedAgents.has(candidateId),
+                  now
+                });
+                if (!proof.shouldPreserveParkedLink) {
+                  staleParkedAssignment = true;
+                  renderedState = "active";
+                  renderedTask = `${report.taskId} (queued/no live run)`;
+                }
+              }
+            } catch (error) {
+              heartbeatLog.warn(`[reports-health] failed to validate task link for ${report.id}/${report.taskId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+          }
           let health = "healthy";
-          if (report.state === "paused") {
+          if (staleParkedAssignment) {
+            health = "**stale** assignment";
+          } else if (report.state === "paused") {
             health = report.pauseReason ? `paused (${report.pauseReason})` : "paused";
           } else if (report.state === "error") {
             health = "**stuck**";
@@ -159936,8 +160348,8 @@ ${trimPromptMd(taskDetail.prompt, promptTemplate)}` : "No PROMPT.md available.",
             health = "**stale**";
             heartbeatLog.log(`[reports-health] stale report ${report.id} intervalSource=${intervalSource} staleThresholdMs=${staleThresholdMs} heartbeatAgeMs=${heartbeatAgeMs}`);
           }
-          const task = report.taskId ?? "\u2014";
-          const state = report.state;
+          const task = renderedTask;
+          const state = renderedState;
           const heartbeat = formatRelativeTime(report.lastHeartbeatAt);
           return `| ${report.name} | ${state} | ${task} | ${heartbeat} | ${health} |`;
         }));
@@ -168018,42 +168430,6 @@ var init_node_dispatch_validation = __esm({
   }
 });
 
-// ../engine/src/task-agent-sync.ts
-function attachAgentLinkSync(opts) {
-  const logger3 = opts.logger ?? console;
-  const handler = async ({ task, from, to: to2 }) => {
-    if (!CLEAR_COLUMNS.has(to2)) {
-      return;
-    }
-    try {
-      const agents = await opts.agentStore.listAgents({ includeEphemeral: false });
-      const linkedAgents = agents.filter((agent) => agent.taskId === task.id);
-      for (const agent of linkedAgents) {
-        if ((to2 === "todo" || to2 === "triage") && opts.hasActiveAgentExecution?.(agent.id) === true) {
-          continue;
-        }
-        await opts.agentStore.syncExecutionTaskLink(agent.id, void 0);
-        logger3.log(`taskAgentLinkSync: cleared agent ${agent.id} taskId from ${task.id} after move ${from} \u2192 ${to2}`);
-      }
-    } catch (error) {
-      logger3.warn(
-        `taskAgentLinkSync: failed to sync agents for task ${task.id} after move ${from} \u2192 ${to2}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  };
-  opts.store.on("task:moved", handler);
-  return () => {
-    opts.store.off("task:moved", handler);
-  };
-}
-var CLEAR_COLUMNS;
-var init_task_agent_sync = __esm({
-  "../engine/src/task-agent-sync.ts"() {
-    "use strict";
-    CLEAR_COLUMNS = /* @__PURE__ */ new Set(["done", "archived", "todo", "triage"]);
-  }
-});
-
 // ../engine/src/runtimes/in-process-runtime.ts
 import { EventEmitter as EventEmitter21 } from "node:events";
 import { setImmediate as setImmediateCb4 } from "node:timers";
@@ -168308,6 +168684,7 @@ var init_in_process_runtime = __esm({
             maxWorktrees: this.config.maxWorktrees,
             semaphore: this.globalSemaphore,
             agentStore: this.agentStore,
+            hasActiveAgentExecution: (agentId) => this.heartbeatMonitor?.getTrackedAgents().includes(agentId) ?? false,
             missionStore,
             missionAutopilot,
             missionExecutionLoop,
@@ -191936,6 +192313,7 @@ var init_register_command_center_routes = __esm({
     init_src();
     init_api_error();
     init_command_center_csv();
+    init_project_store_resolver();
   }
 });