byterover-cli 3.11.0 → 3.13.0

package/dist/server/infra/process/task-history-entry-builder.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Build a `TaskHistoryEntry` from a live `TaskInfo`. Single source of truth
+ * for `task-router.ts:handleTaskGet` (in-memory synthesis) and
+ * `task-history-hook.ts:persist` (lifecycle persistence) — extracting it here
+ * eliminates the duplicate `baseFromTaskInfo` + `statusShapeFromTaskInfo`
+ * pair that previously lived in both modules and would silently drift.
+ *
+ * Two functions are exposed:
+ * - `buildTaskHistoryEntry(task)` — full Zod-parsed `TaskHistoryEntry`,
+ *   used by `task-router.handleTaskGet` to return the same shape as
+ *   `store.getById` for in-flight tasks. Returns `undefined` when the
+ *   `TaskInfo` is incomplete (e.g. missing `projectPath`) or when the
+ *   inferred shape fails Zod validation.
+ * - `buildTaskHistoryEntryCandidate({task, override})` — pre-Zod object
+ *   used by the lifecycle hook, which sometimes injects branch-specific
+ *   fields (terminal completedAt / error / result) before validation.
+ */
+import type { TaskInfo } from '../../core/domain/transport/task-info.js';
+import { type TaskHistoryEntry } from '../../core/domain/entities/task-history-entry.js';
+/**
+ * Build the pre-validation candidate object. The lifecycle hook calls this
+ * with an `override` to inject terminal-status fields before Zod-parsing.
+ */
+export declare function buildTaskHistoryEntryCandidate(args: {
+    override?: Record<string, unknown>;
+    task: TaskInfo;
+}): Record<string, unknown>;
+/**
+ * Build a fully-validated `TaskHistoryEntry` from in-memory `TaskInfo`.
+ * Returns `undefined` when `task.projectPath` is missing or when the
+ * candidate fails Zod validation.
+ *
+ * Used by `task-router.handleTaskGet` to return live in-flight tasks in the
+ * same shape `store.getById` would have returned for persisted ones.
+ */
+export declare function buildTaskHistoryEntry(task: TaskInfo): TaskHistoryEntry | undefined;

package/dist/server/infra/process/task-history-entry-builder.js

@@ -0,0 +1,101 @@
+/**
+ * Build a `TaskHistoryEntry` from a live `TaskInfo`. Single source of truth
+ * for `task-router.ts:handleTaskGet` (in-memory synthesis) and
+ * `task-history-hook.ts:persist` (lifecycle persistence) — extracting it here
+ * eliminates the duplicate `baseFromTaskInfo` + `statusShapeFromTaskInfo`
+ * pair that previously lived in both modules and would silently drift.
+ *
+ * Two functions are exposed:
+ * - `buildTaskHistoryEntry(task)` — full Zod-parsed `TaskHistoryEntry`,
+ *   used by `task-router.handleTaskGet` to return the same shape as
+ *   `store.getById` for in-flight tasks. Returns `undefined` when the
+ *   `TaskInfo` is incomplete (e.g. missing `projectPath`) or when the
+ *   inferred shape fails Zod validation.
+ * - `buildTaskHistoryEntryCandidate({task, override})` — pre-Zod object
+ *   used by the lifecycle hook, which sometimes injects branch-specific
+ *   fields (terminal completedAt / error / result) before validation.
+ */
+import { TASK_HISTORY_ID_PREFIX } from '../../constants.js';
+import { TASK_HISTORY_SCHEMA_VERSION, TaskHistoryEntrySchema, } from '../../core/domain/entities/task-history-entry.js';
+/** Build the base shape (fields shared by every status branch). */
+function baseFromTaskInfo(task) {
+    return {
+        content: task.content,
+        createdAt: task.createdAt,
+        id: `${TASK_HISTORY_ID_PREFIX}-${task.taskId}`,
+        projectPath: task.projectPath,
+        schemaVersion: TASK_HISTORY_SCHEMA_VERSION,
+        taskId: task.taskId,
+        type: task.type,
+        ...(task.clientCwd === undefined ? {} : { clientCwd: task.clientCwd }),
+        ...(task.files === undefined ? {} : { files: task.files }),
+        ...(task.folderPath === undefined ? {} : { folderPath: task.folderPath }),
+        ...(task.logId === undefined ? {} : { logId: task.logId }),
+        ...(task.model === undefined ? {} : { model: task.model }),
+        ...(task.provider === undefined ? {} : { provider: task.provider }),
+        ...(task.reasoningContents === undefined ? {} : { reasoningContents: task.reasoningContents }),
+        ...(task.responseContent === undefined ? {} : { responseContent: task.responseContent }),
+        ...(task.sessionId === undefined ? {} : { sessionId: task.sessionId }),
+        ...(task.toolCalls === undefined ? {} : { toolCalls: task.toolCalls }),
+        ...(task.worktreeRoot === undefined ? {} : { worktreeRoot: task.worktreeRoot }),
+    };
+}
+/**
+ * Build the per-branch shape inferred from `task.status`. Override-only
+ * paths (terminal hooks) supply their own status; this is the default for
+ * in-flight transitions.
+ */
+function statusShapeFromTaskInfo(task) {
+    switch (task.status) {
+        case 'cancelled':
+        case 'completed': {
+            return {
+                completedAt: task.completedAt ?? Date.now(),
+                status: task.status,
+                ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
+                ...(task.status === 'completed' && task.result !== undefined ? { result: task.result } : {}),
+            };
+        }
+        case 'error': {
+            return {
+                completedAt: task.completedAt ?? Date.now(),
+                error: task.error ?? { code: 'TASK_ERROR', message: 'unknown error', name: 'TaskError' },
+                status: 'error',
+                ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
+            };
+        }
+        case 'started': {
+            return { startedAt: task.startedAt ?? task.createdAt, status: 'started' };
+        }
+        // 'created' or undefined — minimal base, no extra branch fields.
+        default: {
+            return { status: 'created' };
+        }
+    }
+}
+/**
+ * Build the pre-validation candidate object. The lifecycle hook calls this
+ * with an `override` to inject terminal-status fields before Zod-parsing.
+ */
+export function buildTaskHistoryEntryCandidate(args) {
+    const { override, task } = args;
+    if (override !== undefined) {
+        return { ...baseFromTaskInfo(task), ...statusShapeFromTaskInfo(task), ...override };
+    }
+    return { ...baseFromTaskInfo(task), ...statusShapeFromTaskInfo(task) };
+}
+/**
+ * Build a fully-validated `TaskHistoryEntry` from in-memory `TaskInfo`.
+ * Returns `undefined` when `task.projectPath` is missing or when the
+ * candidate fails Zod validation.
+ *
+ * Used by `task-router.handleTaskGet` to return live in-flight tasks in the
+ * same shape `store.getById` would have returned for persisted ones.
+ */
+export function buildTaskHistoryEntry(task) {
+    if (task.projectPath === undefined)
+        return undefined;
+    const candidate = buildTaskHistoryEntryCandidate({ task });
+    const parsed = TaskHistoryEntrySchema.safeParse(candidate);
+    return parsed.success ? parsed.data : undefined;
+}

package/dist/server/infra/process/task-history-hook.d.ts

@@ -0,0 +1,37 @@
+/**
+ * TaskHistoryHook — persists `TaskInfo` to `ITaskHistoryStore` at every
+ * lifecycle transition (created / started-via-throttle / terminal).
+ *
+ * Wired into TaskRouter via `lifecycleHooks[]`. The 4 existing methods fire
+ * synchronously at create + terminal; the new `onTaskUpdate` fires on the
+ * throttled flush (~100ms) for in-flight mutations populated by the
+ * llmservice accumulator.
+ *
+ * Holds NO per-task state — every method reads from the live `TaskInfo`
+ * passed in. Errors are swallowed via `processLog`; tasks without
+ * `projectPath` are skipped silently.
+ */
+import type { TaskInfo } from '../../core/domain/transport/task-info.js';
+import type { ITaskLifecycleHook } from '../../core/interfaces/process/i-task-lifecycle-hook.js';
+import type { ITaskHistoryStore } from '../../core/interfaces/storage/i-task-history-store.js';
+type TaskHistoryHookOptions = {
+    /** Per-project store factory (DIP — never depends on FileTaskHistoryStore directly). */
+    getStore: (projectPath: string) => ITaskHistoryStore;
+};
+export declare class TaskHistoryHook implements ITaskLifecycleHook {
+    private readonly getStore;
+    constructor(opts: TaskHistoryHookOptions);
+    onTaskCancelled(_taskId: string, task: TaskInfo): Promise<void>;
+    onTaskCompleted(_taskId: string, result: string, task: TaskInfo): Promise<void>;
+    onTaskCreate(task: TaskInfo): Promise<void>;
+    onTaskError(_taskId: string, errorMessage: string, task: TaskInfo): Promise<void>;
+    onTaskUpdate(task: TaskInfo): Promise<void>;
+    /**
+     * Build + save a `TaskHistoryEntry` from the current `TaskInfo`. Optional
+     * `override` injects branch-specific fields (status / completedAt / error /
+     * result). When omitted, the branch shape is inferred from `task.status`
+     * by `buildTaskHistoryEntryCandidate`.
+     */
+    private persist;
+}
+export {};

package/dist/server/infra/process/task-history-hook.js

@@ -0,0 +1,70 @@
+/**
+ * TaskHistoryHook — persists `TaskInfo` to `ITaskHistoryStore` at every
+ * lifecycle transition (created / started-via-throttle / terminal).
+ *
+ * Wired into TaskRouter via `lifecycleHooks[]`. The 4 existing methods fire
+ * synchronously at create + terminal; the new `onTaskUpdate` fires on the
+ * throttled flush (~100ms) for in-flight mutations populated by the
+ * llmservice accumulator.
+ *
+ * Holds NO per-task state — every method reads from the live `TaskInfo`
+ * passed in. Errors are swallowed via `processLog`; tasks without
+ * `projectPath` are skipped silently.
+ */
+import { TaskHistoryEntrySchema } from '../../core/domain/entities/task-history-entry.js';
+import { processLog } from '../../utils/process-logger.js';
+import { buildTaskHistoryEntryCandidate } from './task-history-entry-builder.js';
+export class TaskHistoryHook {
+    getStore;
+    constructor(opts) {
+        this.getStore = opts.getStore;
+    }
+    async onTaskCancelled(_taskId, task) {
+        await this.persist(task, { completedAt: Date.now(), status: 'cancelled' });
+    }
+    async onTaskCompleted(_taskId, result, task) {
+        await this.persist(task, {
+            completedAt: Date.now(),
+            ...(result ? { result } : {}),
+            status: 'completed',
+        });
+    }
+    async onTaskCreate(task) {
+        await this.persist(task, { status: 'created' });
+    }
+    async onTaskError(_taskId, errorMessage, task) {
+        await this.persist(task, {
+            completedAt: Date.now(),
+            error: { code: 'TASK_ERROR', message: errorMessage, name: 'TaskError' },
+            status: 'error',
+        });
+    }
+    async onTaskUpdate(task) {
+        await this.persist(task);
+    }
+    /**
+     * Build + save a `TaskHistoryEntry` from the current `TaskInfo`. Optional
+     * `override` injects branch-specific fields (status / completedAt / error /
+     * result). When omitted, the branch shape is inferred from `task.status`
+     * by `buildTaskHistoryEntryCandidate`.
+     */
+    async persist(task, override) {
+        if (!task.projectPath)
+            return;
+        const candidate = buildTaskHistoryEntryCandidate({ override, task });
+        let entry;
+        try {
+            entry = TaskHistoryEntrySchema.parse(candidate);
+        }
+        catch (error) {
+            processLog(`TaskHistoryHook: failed to build entry for ${task.taskId}: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+        try {
+            await this.getStore(task.projectPath).save(entry);
+        }
+        catch (error) {
+            processLog(`TaskHistoryHook: store.save failed for ${task.taskId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/server/infra/process/task-history-store-cache.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Per-project FileTaskHistoryStore cache + lazy startup audit.
+ *
+ * Module-scoped so M2.09's wire handlers can reuse the same store instances
+ * the M2.06 lifecycle hook writes to. Audit fires once per project on first
+ * access, comparing `_index.jsonl` ↔ `data/` files to flag orphans without
+ * auto-fixing (M2.03 compaction owns the cleanup pass).
+ */
+import { FileTaskHistoryStore } from '../storage/file-task-history-store.js';
+/**
+ * Resolve (or lazily create) the per-project store. The first call for a
+ * given `projectPath` schedules a best-effort audit; subsequent calls reuse
+ * the cached store and skip re-auditing.
+ */
+export declare function getStore(projectPath: string): FileTaskHistoryStore;
+/**
+ * Compare `_index.jsonl` (live entries) against the `data/` directory and log
+ * orphans. Best-effort: never throws to caller. The `log` parameter defaults
+ * to `processLog` for production; tests inject a stub.
+ */
+export declare function auditTaskHistory(projectPath: string, store: FileTaskHistoryStore, log?: ((msg: string) => void) | undefined): Promise<void>;
+/** Test-only: clear module-scope state so each test sees a fresh cache. */
+export declare function resetTaskHistoryStoreCache(): void;
+/** Test-only: inject a logger into the audit path triggered by `getStore`. Pass no arg to clear. */
+export declare function _setTestLoggerForGetStore(log?: (msg: string) => void): void;

package/dist/server/infra/process/task-history-store-cache.js

@@ -0,0 +1,106 @@
+/**
+ * Per-project FileTaskHistoryStore cache + lazy startup audit.
+ *
+ * Module-scoped so M2.09's wire handlers can reuse the same store instances
+ * the M2.06 lifecycle hook writes to. Audit fires once per project on first
+ * access, comparing `_index.jsonl` ↔ `data/` files to flag orphans without
+ * auto-fixing (M2.03 compaction owns the cleanup pass).
+ */
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { TASK_HISTORY_DIR } from '../../constants.js';
+import { getProjectDataDir } from '../../utils/path-utils.js';
+import { processLog } from '../../utils/process-logger.js';
+import { FileTaskHistoryStore } from '../storage/file-task-history-store.js';
+const FILENAME_PATTERN = /^tsk-(.+)\.json$/;
+const MAX_LISTED_ORPHANS = 5;
+const stores = new Map();
+const auditedProjects = new Set();
+/**
+ * Daemon boot wall-clock timestamp. Captured at module load so EVERY per-project
+ * store shares the same boot reference. The C0 daemon-startup gate inside
+ * `FileTaskHistoryStore.isStaleAndRecoverable` uses this to skip stale-recovery
+ * for entries written post-boot — those belong to live in-memory tasks whose
+ * lifecycle hooks are still firing throttled saves and must not be tombstoned
+ * to `INTERRUPTED`.
+ *
+ * `resetTaskHistoryStoreCache()` re-captures it so tests see fresh boot
+ * semantics per `beforeEach`.
+ */
+let daemonStartedAt = Date.now();
+/** Optional logger override for tests — when set, audit triggered inside getStore uses this. */
+let testLoggerForGetStore;
+/**
+ * Resolve (or lazily create) the per-project store. The first call for a
+ * given `projectPath` schedules a best-effort audit; subsequent calls reuse
+ * the cached store and skip re-auditing.
+ */
+export function getStore(projectPath) {
+    let store = stores.get(projectPath);
+    if (!store) {
+        store = new FileTaskHistoryStore({ baseDir: getProjectDataDir(projectPath), daemonStartedAt });
+        stores.set(projectPath, store);
+    }
+    if (!auditedProjects.has(projectPath)) {
+        auditedProjects.add(projectPath);
+        auditTaskHistory(projectPath, store, testLoggerForGetStore).catch((error) => {
+            processLog(`[task-history] audit failed for ${projectPath}: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    }
+    return store;
+}
+/**
+ * Compare `_index.jsonl` (live entries) against the `data/` directory and log
+ * orphans. Best-effort: never throws to caller. The `log` parameter defaults
+ * to `processLog` for production; tests inject a stub.
+ */
+export async function auditTaskHistory(projectPath, store, log = undefined) {
+    const effectiveLog = log ?? processLog;
+    const liveEntries = await store.list();
+    const liveTaskIds = new Set(liveEntries.map((e) => e.taskId));
+    const dataDir = join(getProjectDataDir(projectPath), TASK_HISTORY_DIR, 'data');
+    let dataFiles;
+    try {
+        dataFiles = await readdir(dataDir);
+    }
+    catch {
+        dataFiles = [];
+    }
+    const dataTaskIds = new Set();
+    for (const filename of dataFiles) {
+        const match = FILENAME_PATTERN.exec(filename);
+        if (match)
+            dataTaskIds.add(match[1]);
+    }
+    const orphanIndex = [...liveTaskIds].filter((id) => !dataTaskIds.has(id));
+    const orphanData = [...dataTaskIds].filter((id) => !liveTaskIds.has(id));
+    const head = `[task-history] audit ${projectPath} — ${liveTaskIds.size} live entries, ${dataTaskIds.size} data files.`;
+    if (orphanIndex.length === 0 && orphanData.length === 0) {
+        effectiveLog(`${head} ok.`);
+        return;
+    }
+    const parts = [];
+    if (orphanIndex.length > 0)
+        parts.push(formatOrphans('orphan-index', orphanIndex));
+    if (orphanData.length > 0)
+        parts.push(formatOrphans('orphan-data', orphanData));
+    effectiveLog(`${head} WARN: ${parts.join('; ')}.`);
+}
+/** Test-only: clear module-scope state so each test sees a fresh cache. */
+export function resetTaskHistoryStoreCache() {
+    stores.clear();
+    auditedProjects.clear();
+    testLoggerForGetStore = undefined;
+    // Re-capture boot time so tests see fresh "this daemon just started" semantics
+    // for the C0 stale-recovery gate.
+    daemonStartedAt = Date.now();
+}
+/** Test-only: inject a logger into the audit path triggered by `getStore`. Pass no arg to clear. */
+export function _setTestLoggerForGetStore(log) {
+    testLoggerForGetStore = log;
+}
+function formatOrphans(label, ids) {
+    const listed = ids.slice(0, MAX_LISTED_ORPHANS).map((id) => `tsk-${id}`).join(', ');
+    const remainder = ids.length > MAX_LISTED_ORPHANS ? ` (+${ids.length - MAX_LISTED_ORPHANS} more)` : '';
+    return `${ids.length} ${label} ${listed}${remainder}`;
+}

package/dist/server/infra/process/task-router.d.ts

@@ -19,6 +19,7 @@ import type { IAgentPool } from '../../core/interfaces/agent/i-agent-pool.js';
 import type { ITaskLifecycleHook } from '../../core/interfaces/process/i-task-lifecycle-hook.js';
 import type { IProjectRegistry } from '../../core/interfaces/project/i-project-registry.js';
 import type { IProjectRouter } from '../../core/interfaces/routing/i-project-router.js';
+import type { ITaskHistoryStore } from '../../core/interfaces/storage/i-task-history-store.js';
 import type { ITransportServer } from '../../core/interfaces/transport/i-transport-server.js';
 import type { TaskInfo } from './types.js';
 /**
@@ -47,6 +48,13 @@ type TaskRouterOptions = {
     agentPool?: IAgentPool;
     /** Function to resolve agent clientId for a given project */
     getAgentForProject: (projectPath?: string) => string | undefined;
+    /**
+     * Per-project `ITaskHistoryStore` factory (DIP). When omitted, the new
+     * persistent-history handlers (`task:list` paginated, `task:get`,
+     * `task:delete*`, `task:clearCompleted`) gracefully degrade to in-memory
+     * only — keeping pre-M2.09 unit tests unaffected.
+     */
+    getTaskHistoryStore?: (projectPath: string) => ITaskHistoryStore;
     /** Resolves project's review-disabled flag at task-create. Optional; missing → undefined → enabled. */
     isReviewDisabled?: IsReviewDisabledResolver;
     /** Lifecycle hooks for task events (e.g. CurateLogHandler). */
@@ -61,23 +69,43 @@ type TaskRouterOptions = {
     preDispatchCheck?: PreDispatchCheck;
     projectRegistry?: IProjectRegistry;
     projectRouter?: IProjectRouter;
+    /**
+     * Resolves the active provider/model snapshot at task-create time.
+     * Failures are swallowed (fail-open) so dispatch is never blocked.
+     */
+    resolveActiveProvider?: () => Promise<{
+        model?: string;
+        provider?: string;
+    }>;
     /** Resolves the projectPath a client registered with (from client:register). */
     resolveClientProjectPath?: (clientId: string) => string | undefined;
     transport: ITransportServer;
 };
 export declare class TaskRouter {
+    /**
+     * Throttle window for `onTaskUpdate` flushes — bursts of llmservice events
+     * are coalesced into one save per window. 100ms keeps perceived latency low
+     * while bounding write volume on chatty multi-step agents.
+     */
+    private static readonly FLUSH_INTERVAL_MS;
     private readonly agentPool;
     /**
      * Track recently completed tasks for grace period.
      * Allows late-arriving llmservice:* events to be routed even after task:completed.
      */
     private completedTasks;
+    /** TaskIds with pending in-flight mutations awaiting the next throttled flush. */
+    private readonly dirtyTaskIds;
+    /** Pending throttle timer, if any. */
+    private flushTimer;
     private readonly getAgentForProject;
+    private readonly getTaskHistoryStore;
     private readonly isReviewDisabled;
     private readonly lifecycleHooks;
     private readonly preDispatchCheck;
     private readonly projectRegistry;
     private readonly projectRouter;
+    private readonly resolveActiveProvider;
     private readonly resolveClientProjectPath;
     /** Track active tasks */
     private tasks;
@@ -117,8 +145,37 @@ export declare class TaskRouter {
      * Register all task and LLM event handlers on the transport.
      */
     setup(): void;
+    /**
+     * Mutate the live `TaskInfo` from an `llmservice:*` event so a tab refresh
+     * during the throttle window sees the in-flight state. Each branch:
+     *   - thinking: push a `{isThinking: true, content: ''}` marker
+     *   - chunk(reasoning): append to last item / flip empty marker / push fresh
+     *   - chunk(text): IGNORED for persistence (transient stream)
+     *   - response: set responseContent + sessionId (overwrite — multi-step keeps latest)
+     *   - toolCall: push running entry
+     *   - toolResult: update existing entry by callId
+     *   - error / unsupportedInput: IGNORED (terminal hooks capture failure)
+     *
+     * Mutations use immutable `tasks.set(id, {...task, ...delta})` so consumers
+     * holding a captured reference (e.g. notifyHooks*) see a stable snapshot.
+     */
+    private accumulateLlmEvent;
+    /**
+     * Emit `task:deleted` to the project room when a task is removed. Skips
+     * silently when no projectPath is resolvable (broadcast wouldn't reach
+     * any room). Clients that miss the broadcast will simply not see a row
+     * disappear; they reconcile on next `task:list`.
+     */
+    private broadcastTaskDeleted;
+    /**
+     * Drain the dirty set: for each taskId still active, fire `onTaskUpdate` on
+     * each lifecycle hook. Tasks moved to `completedTasks` between markDirty
+     * and flush are skipped — their terminal lifecycle hook already saved.
+     */
+    private flushDirty;
     private handleTaskCancel;
     private handleTaskCancelled;
+    private handleTaskClearCompleted;
     private handleTaskCompleted;
     /**
      * Handle task creation from a client.
@@ -134,7 +191,10 @@ export declare class TaskRouter {
      * 6. Submit to agentPool (fire-and-forget)
      */
     private handleTaskCreate;
+    private handleTaskDelete;
+    private handleTaskDeleteBulk;
     private handleTaskError;
+    private handleTaskGet;
     private handleTaskList;
     /**
      * Emit `task:completed` for a task that the daemon's pre-dispatch gate skipped
@@ -153,6 +213,12 @@ export declare class TaskRouter {
      */
     private handleTaskSkippedByPreCheck;
     private handleTaskStarted;
+    /**
+     * Mark a taskId for the next throttled `onTaskUpdate` flush.
+     * Schedules a timer if none is pending. Bursts of dirty marks within the
+     * 100ms window coalesce into a single flush.
+     */
+    private markDirty;
     /**
      * Move a task to the completed tasks map with grace period cleanup.
      */
@@ -188,6 +254,12 @@ export declare class TaskRouter {
      * Each hook is called independently; errors are caught and logged.
      */
     private runCreateHooks;
+    /**
+     * Invoke `resolveActiveProvider` with a try/catch so a thrown resolver
+     * cannot block task dispatch. Returns `{}` when no resolver is configured
+     * or when the resolver rejects/throws.
+     */
+    private safeResolveActiveProvider;
     /**
      * Reads the project's reviewDisabled flag at task-create.
      *