comisai 1.0.34 → 1.0.37

package/node_modules/@comis/agent/dist/background/auto-background-middleware.d.ts

@@ -1,6 +1,7 @@
 import type { BackgroundTasksConfig } from "@comis/core";
 import type { AgentToolResult } from "@mariozechner/pi-agent-core";
 import type { BackgroundTaskManager, NotifyFn } from "./background-task-manager.js";
+import type { BackgroundTaskOrigin } from "./background-task-types.js";
 /**
  * Tool definition interface matching pi-agent-core ToolDefinition.
  *
@@ -19,9 +20,18 @@ export interface ToolDefinition {
 /**
  * Wrap a tool's execute() with auto-background promotion on timeout.
  *
+ * `originResolver` is called synchronously at promote-time (before the agent
+ * yields) so the captured origin reflects the originating session, not the
+ * background continuation context. Returns undefined when the wrap-site cannot
+ * resolve a valid origin (e.g., during a non-session-bound subagent path) --
+ * in that case the wrapper falls through to foreground execution (no promote).
+ *
+ * Explicit threading, NOT AsyncLocalStorage. Origin flows through factory
+ * params end-to-end.
+ *
  * If the tool is in `config.excludeTools`, returns unchanged.
  * If the tool completes before `config.autoBackgroundMs`, returns the result directly.
  * If the tool exceeds the timeout, promotes to background via manager.promote().
  * If promotion fails (concurrency limit), awaits the tool normally (foreground fallback).
  */
-export declare function wrapToolForAutoBackground(tool: ToolDefinition, manager: BackgroundTaskManager, config: BackgroundTasksConfig, notifyFn: NotifyFn, agentId: string): ToolDefinition;
+export declare function wrapToolForAutoBackground(tool: ToolDefinition, manager: BackgroundTaskManager, config: BackgroundTasksConfig, notifyFn: NotifyFn, originResolver: () => BackgroundTaskOrigin | undefined): ToolDefinition;

package/node_modules/@comis/agent/dist/background/auto-background-middleware.js

@@ -12,12 +12,30 @@ import { suppressError } from "@comis/shared";
 /**
  * Wrap a tool's execute() with auto-background promotion on timeout.
  *
+ * `originResolver` is called synchronously at promote-time (before the agent
+ * yields) so the captured origin reflects the originating session, not the
+ * background continuation context. Returns undefined when the wrap-site cannot
+ * resolve a valid origin (e.g., during a non-session-bound subagent path) --
+ * in that case the wrapper falls through to foreground execution (no promote).
+ *
+ * Explicit threading, NOT AsyncLocalStorage. Origin flows through factory
+ * params end-to-end.
+ *
  * If the tool is in `config.excludeTools`, returns unchanged.
  * If the tool completes before `config.autoBackgroundMs`, returns the result directly.
  * If the tool exceeds the timeout, promotes to background via manager.promote().
  * If promotion fails (concurrency limit), awaits the tool normally (foreground fallback).
  */
-export function wrapToolForAutoBackground(tool, manager, config, notifyFn, agentId) {
+export function wrapToolForAutoBackground(tool, manager, config, notifyFn, originResolver) {
+    // `exec` opts out of the generic auto-background wrapper to enforce
+    // single-owner backgrounding. The exec-tool's own internal escalation path
+    // (packages/skills/src/builtin/exec-tool.ts:613-668) is the SOLE
+    // backgrounding owner for `exec`; the generic timeout-based wrapper would
+    // double-promote. Hardcoded literal — does NOT modify config.excludeTools
+    // so operator-set exclusions remain unchanged.
+    if (tool.name === "exec") {
+        return tool;
+    }
     if (config.excludeTools.includes(tool.name)) {
         return tool;
     }
@@ -57,8 +75,16 @@ export function wrapToolForAutoBackground(tool, manager, config, notifyFn, agent
             if (raceResult.kind === "result") {
                 return raceResult.value;
             }
-            // Timeout: attempt background promotion
-            const promoteResult = manager.promote(agentId, tool.name, taskPromise, ac);
+            // Timeout: resolve origin synchronously before yielding to the background.
+            // Explicit threading, NOT AsyncLocalStorage.
+            const origin = originResolver();
+            if (!origin) {
+                // No originating session context (e.g., wrap-site is a subagent without
+                // a captured caller session). Treat like a concurrency-limit fallback:
+                // run the tool in the foreground, no background promotion.
+                return await taskPromise;
+            }
+            const promoteResult = manager.promote(tool.name, taskPromise, ac, origin);
             if (!promoteResult.ok) {
                 // Concurrency limit hit: fall back to foreground (await normally)
                 return await taskPromise;
@@ -73,7 +99,7 @@ export function wrapToolForAutoBackground(tool, manager, config, notifyFn, agent
             // collapses to `content: undefined` and triggers the silent-LLM-failure
             // cascade (see AGENTS.md / auto-background-middleware.test.ts invariant).
             const placeholderText = `Tool "${tool.name}" is taking longer than expected and has been moved to the background. ` +
-                `Task ID: ${taskId}. The user will be notified when it completes.`;
+                `Task ID: ${taskId}. I'll continue when it completes.`;
             return {
                 content: [{ type: "text", text: placeholderText }],
                 details: {

package/node_modules/@comis/agent/dist/background/background-task-manager.d.ts

@@ -1,6 +1,6 @@
 import { type Result } from "@comis/shared";
 import type { TypedEventBus } from "@comis/core";
-import type { BackgroundTask } from "./background-task-types.js";
+import type { BackgroundTask, BackgroundTaskOrigin, BackgroundSessionState, BackgroundTaskNotificationPolicy } from "./background-task-types.js";
 /** Notification callback fired when background task completes or fails. */
 export type NotifyFn = (opts: {
     agentId: string;
@@ -21,8 +21,21 @@ export interface BackgroundTaskManagerOpts {
     maxBackgroundDurationMs?: number;
 }
 export interface BackgroundTaskManager {
-    promote(agentId: string, toolName: string, promise: Promise<unknown>, ac: AbortController): Result<string, Error>;
+    promote(toolName: string, promise: Promise<unknown>, ac: AbortController, origin: BackgroundTaskOrigin, notificationPolicy?: BackgroundTaskNotificationPolicy): Result<string, Error>;
+    /**
+     * Mark a task as completed.
+     *
+     * The legacy `notifyFn` argument is preserved for backward compatibility but
+     * unused — the completion-dispatcher subscribes to the
+     * `background_task:completed` event emitted here and decides whether to fire
+     * the user-visible fallback notification. Single-owner contract eliminates
+     * double-notify.
+     */
     complete(taskId: string, result: unknown, notifyFn?: NotifyFn): void;
+    /**
+     * Mark a task as failed. See `complete` for the single-owner note — the
+     * `notifyFn` argument is unused; the dispatcher routes notification.
+     */
     fail(taskId: string, error: unknown, notifyFn?: NotifyFn): void;
     cancel(taskId: string): Result<void, Error>;
     getTask(taskId: string): BackgroundTask | undefined;
@@ -30,5 +43,12 @@ export interface BackgroundTaskManager {
     getAllTasks(): BackgroundTask[];
     recoverOnStartup(): void;
     cleanup(maxAgeMs?: number): void;
+    /**
+     * Atomically transition the in-memory task's dispatchState AND persist.
+     * Returns true on success; false if task does not exist. The dispatcher
+     * calls this from its handler so SIGKILL-recovery preserves the recovered
+     * state across daemon restart.
+     */
+    transitionDispatchState(taskId: string, next: BackgroundSessionState): boolean;
 }
 export declare function createBackgroundTaskManager(opts: BackgroundTaskManagerOpts): BackgroundTaskManager;

package/node_modules/@comis/agent/dist/background/background-task-manager.js

@@ -8,7 +8,7 @@
  * @module
  */
 import { randomUUID } from "node:crypto";
-import { ok, err, suppressError } from "@comis/shared";
+import { ok, err } from "@comis/shared";
 import { persistTaskSync, recoverTasks, removeTaskFile } from "./background-task-persistence.js";
 const MAX_RESULT_CHARS = 102_400; // 100KB
 export function createBackgroundTaskManager(opts) {
@@ -35,7 +35,26 @@ export function createBackgroundTaskManager(opts) {
         }
     }
     const manager = {
-        promote(agentId, toolName, promise, ac) {
+        promote(toolName, promise, ac, origin, notificationPolicy) {
+            // Reject calls with missing/invalid origin (no silent fallback).
+            if (!origin || typeof origin !== "object") {
+                return err(new Error("BackgroundTaskOrigin is required (received undefined or non-object)"));
+            }
+            if (!origin.agentId || origin.agentId.length === 0) {
+                return err(new Error("BackgroundTaskOrigin.agentId must be a non-empty string"));
+            }
+            if (!origin.sessionKey || origin.sessionKey.length === 0) {
+                return err(new Error("BackgroundTaskOrigin.sessionKey must be a non-empty string"));
+            }
+            if (!origin.channelType || origin.channelType.length === 0) {
+                return err(new Error("BackgroundTaskOrigin.channelType must be a non-empty string"));
+            }
+            if (!origin.channelId || origin.channelId.length === 0) {
+                return err(new Error("BackgroundTaskOrigin.channelId must be a non-empty string"));
+            }
+            // traceId may be null (per BackgroundTaskOriginSchema), so no length check.
+            // backgroundHopCount has a schema-level default of 0; no inline guard needed.
+            const agentId = origin.agentId;
             const agentCurrent = perAgentCount.get(agentId) ?? 0;
             if (agentCurrent >= maxPerAgent) {
                 return err(new Error(`Concurrency limit exceeded: agent ${agentId} has ${agentCurrent}/${maxPerAgent} tasks`));
@@ -46,24 +65,30 @@ export function createBackgroundTaskManager(opts) {
             const taskId = randomUUID();
             const task = {
                 id: taskId,
-                agentId,
                 toolName,
                 status: "running",
                 startedAt: Date.now(),
+                origin,
+                // Seed the dispatch state machine. Default policy is "deferred" —
+                // the dispatcher inspects dispatchState before firing fallback notify
+                // (at-most-once).
+                notificationPolicy: notificationPolicy ?? "deferred",
+                dispatchState: "pending",
                 _promise: promise,
                 _abortController: ac,
             };
-            tasks.set(taskId, task);
-            incrementCounters(agentId);
-            // sync write BEFORE returning placeholder
-            persistTaskSync(dataDir, task);
-            // Hard timeout
-            task._hardTimeoutTimer = setTimeout(() => {
+            // Hard-timeout abort
+            const timer = setTimeout(() => {
                 if (task.status === "running") {
                     ac.abort();
                     manager.fail(taskId, new Error("Hard timeout exceeded"));
                 }
             }, maxBackgroundDurationMs);
+            timer.unref();
+            task._hardTimeoutTimer = timer;
+            tasks.set(taskId, task);
+            incrementCounters(agentId);
+            persistTaskSync(dataDir, task);
             eventBus.emit("background_task:promoted", {
                 agentId,
                 taskId,
@@ -72,7 +97,7 @@ export function createBackgroundTaskManager(opts) {
             });
             return ok(taskId);
         },
-        complete(taskId, result, notifyFn) {
+        complete(taskId, result, _notifyFn) {
             const task = tasks.get(taskId);
             if (!task || task.status !== "running")
                 return;
@@ -81,26 +106,25 @@ export function createBackgroundTaskManager(opts) {
             task.result = truncateResult(result);
             if (task._hardTimeoutTimer)
                 clearTimeout(task._hardTimeoutTimer);
-            decrementCounters(task.agentId);
+            decrementCounters(task.origin.agentId);
             persistTaskSync(dataDir, task);
             const durationMs = task.completedAt - task.startedAt;
             eventBus.emit("background_task:completed", {
-                agentId: task.agentId,
+                agentId: task.origin.agentId,
                 taskId,
                 toolName: task.toolName,
                 durationMs,
+                origin: task.origin,
                 timestamp: Date.now(),
             });
-            if (notifyFn) {
-                suppressError(notifyFn({
-                    agentId: task.agentId,
-                    message: `Background task "${task.toolName}" completed (${Math.round(durationMs / 1000)}s). Task ID: ${taskId}`,
-                    priority: "normal",
-                    origin: "background_task",
-                }), "background task completion notification");
-            }
+            // Notification routing lives in the completion-dispatcher (subscribed
+            // to background_task:completed above). The legacy `notifyFn` argument
+            // is kept for backward compatibility but unused here — the dispatcher
+            // inspects task.dispatchState before firing the user-visible fallback,
+            // and the runner skips when state is "notified" (single-owner contract,
+            // zero spurious outbound).
         },
-        fail(taskId, error, notifyFn) {
+        fail(taskId, error, _notifyFn) {
             const task = tasks.get(taskId);
             if (!task || task.status !== "running")
                 return;
@@ -109,25 +133,19 @@ export function createBackgroundTaskManager(opts) {
             task.error = error instanceof Error ? error.message : String(error);
             if (task._hardTimeoutTimer)
                 clearTimeout(task._hardTimeoutTimer);
-            decrementCounters(task.agentId);
+            decrementCounters(task.origin.agentId);
             persistTaskSync(dataDir, task);
             const durationMs = task.completedAt - task.startedAt;
             eventBus.emit("background_task:failed", {
-                agentId: task.agentId,
+                agentId: task.origin.agentId,
                 taskId,
                 toolName: task.toolName,
                 error: task.error,
                 durationMs,
+                origin: task.origin,
                 timestamp: Date.now(),
             });
-            if (notifyFn) {
-                suppressError(notifyFn({
-                    agentId: task.agentId,
-                    message: `Background task "${task.toolName}" failed: ${task.error}. Task ID: ${taskId}`,
-                    priority: "normal",
-                    origin: "background_task",
-                }), "background task failure notification");
-            }
+            // See complete() above — notifyFn arg is unused; dispatcher owns routing.
         },
         cancel(taskId) {
             const task = tasks.get(taskId);
@@ -141,10 +159,10 @@ export function createBackgroundTaskManager(opts) {
                 task._abortController.abort();
             if (task._hardTimeoutTimer)
                 clearTimeout(task._hardTimeoutTimer);
-            decrementCounters(task.agentId);
+            decrementCounters(task.origin.agentId);
             persistTaskSync(dataDir, task);
             eventBus.emit("background_task:cancelled", {
-                agentId: task.agentId,
+                agentId: task.origin.agentId,
                 taskId,
                 toolName: task.toolName,
                 timestamp: Date.now(),
@@ -155,7 +173,7 @@ export function createBackgroundTaskManager(opts) {
             return tasks.get(taskId);
         },
         getTasks(agentId) {
-            return [...tasks.values()].filter((t) => t.agentId === agentId);
+            return [...tasks.values()].filter((t) => t.origin.agentId === agentId);
         },
         getAllTasks() {
             return [...tasks.values()];
@@ -163,20 +181,37 @@ export function createBackgroundTaskManager(opts) {
         recoverOnStartup() {
             const recovered = recoverTasks(dataDir);
             let count = 0;
+            let dispatchPreserved = 0;
             for (const persisted of recovered) {
-                // Only import tasks that were recovered (previously running -> now failed)
-                const task = {
-                    ...persisted,
-                };
+                // The persistence-write contract guarantees populated origin /
+                // notificationPolicy / dispatchState on every task file.
+                // background-task-persistence.ts rejects shape-malformed files
+                // (missing id / toolName) before they reach here; we propagate the
+                // persisted record as-is.
+                const task = persisted;
                 tasks.set(task.id, task);
                 if (persisted.status === "failed" && persisted.error === "Daemon restarted while task was running") {
+                    // Recovery-without-events: if dispatchState is already "notified" or
+                    // "dispatched", the dispatcher already routed pre-restart; do NOT
+                    // re-emit the background_task:failed event (which would re-trigger
+                    // fallback).
+                    if (task.dispatchState === "notified" || task.dispatchState === "dispatched") {
+                        dispatchPreserved++;
+                        logger.debug({
+                            taskId: task.id,
+                            dispatchState: task.dispatchState,
+                            hint: "Pre-restart dispatch state preserved; skipping re-emit (D-S2 recovery-without-events)",
+                        }, "Recovery: skipped re-emit");
+                        continue;
+                    }
                     count++;
                     eventBus.emit("background_task:failed", {
-                        agentId: task.agentId,
+                        agentId: task.origin.agentId,
                         taskId: task.id,
                         toolName: task.toolName,
                         error: persisted.error,
                         durationMs: (persisted.completedAt ?? Date.now()) - persisted.startedAt,
+                        origin: task.origin,
                         timestamp: Date.now(),
                     });
                 }
@@ -184,13 +219,26 @@ export function createBackgroundTaskManager(opts) {
             if (count > 0) {
                 logger.info({ count }, "Recovered background tasks marked as failed");
             }
+            if (dispatchPreserved > 0) {
+                logger.info({ count: dispatchPreserved }, "Recovered tasks with preserved dispatch state (no re-emit)");
+            }
+        },
+        transitionDispatchState(taskId, next) {
+            const task = tasks.get(taskId);
+            if (!task)
+                return false;
+            // Idempotent — same-state transitions are allowed (no-op write).
+            task.dispatchState = next;
+            // Persist atomically so recovery-after-SIGKILL sees the transition.
+            persistTaskSync(dataDir, task);
+            return true;
         },
         cleanup(maxAgeMs = 86_400_000) {
             const cutoff = Date.now() - maxAgeMs;
             for (const [taskId, task] of tasks) {
                 if (task.status !== "running" && (task.completedAt ?? task.startedAt) < cutoff) {
                     tasks.delete(taskId);
-                    removeTaskFile(dataDir, task.agentId, taskId);
+                    removeTaskFile(dataDir, task.origin.agentId, taskId);
                 }
             }
         },

package/node_modules/@comis/agent/dist/background/background-task-persistence.js

@@ -7,23 +7,30 @@
  *
  * @module
  */
-import { mkdirSync, writeFileSync, readFileSync, readdirSync, unlinkSync, existsSync } from "node:fs";
+import { mkdirSync, writeFileSync, readFileSync, readdirSync, statSync, unlinkSync, existsSync } from "node:fs";
 import { safePath } from "@comis/core";
 /** Directory name under data dir for background task state files. */
 export const TASK_DIR_NAME = "background-tasks";
 /**
  * Extract the serializable subset from a BackgroundTask.
+ *
+ * notificationPolicy + dispatchState are copied across when present so the
+ * state machine survives daemon restart-recovery. Both fields are optional in
+ * PersistedTaskState; we use spread-when-defined to avoid emitting
+ * `"notificationPolicy": undefined` to disk for callers that do not set them.
  */
 function toPersistedState(task) {
     return {
         id: task.id,
-        agentId: task.agentId,
         toolName: task.toolName,
         status: task.status,
         startedAt: task.startedAt,
         completedAt: task.completedAt,
         result: task.result,
         error: task.error,
+        origin: task.origin,
+        ...(task.notificationPolicy !== undefined && { notificationPolicy: task.notificationPolicy }),
+        ...(task.dispatchState !== undefined && { dispatchState: task.dispatchState }),
     };
 }
 /**
@@ -32,7 +39,7 @@ function toPersistedState(task) {
  * Writes to `dataDir/{agentId}/{taskId}.json`.
  */
 export function persistTaskSync(dataDir, task) {
-    const agentDir = safePath(dataDir, task.agentId);
+    const agentDir = safePath(dataDir, task.origin.agentId);
     mkdirSync(agentDir, { recursive: true });
     const filePath = safePath(agentDir, `${task.id}.json`);
     const state = "_promise" in task ? toPersistedState(task) : task;
@@ -72,6 +79,20 @@ export function recoverTasks(dataDir) {
     }
     for (const agentId of agentDirs) {
         const agentDir = safePath(dataDir, agentId);
+        // Guard against non-directory entries in dataDir. statSync may throw if
+        // the entry vanished between readdirSync and here; skip gracefully.
+        // Non-directory entries (lock files, READMEs, accidental
+        // file-with-agentId-name) MUST be skipped explicitly so they don't
+        // shadow legitimate agent recovery silently.
+        let dirStat;
+        try {
+            dirStat = statSync(agentDir);
+        }
+        catch {
+            continue;
+        }
+        if (!dirStat.isDirectory())
+            continue;
         let files;
         try {
             files = readdirSync(agentDir);
@@ -85,7 +106,16 @@ export function recoverTasks(dataDir) {
             const filePath = safePath(agentDir, file);
             try {
                 const raw = readFileSync(filePath, "utf-8");
-                const task = JSON.parse(raw);
+                const parsed = JSON.parse(raw);
+                // Shape guard — skip completely malformed files. Tasks always carry
+                // id + toolName + origin; the producer-side persistTaskSync writes
+                // all three unconditionally. A file failing this guard is either
+                // truncated mid-write or a legacy artifact operators should clean
+                // up manually.
+                if (!parsed.id || !parsed.toolName || !parsed.origin) {
+                    continue;
+                }
+                const task = parsed;
                 if (task.status === "running") {
                     task.status = "failed";
                     task.error = "Daemon restarted while task was running";

package/node_modules/@comis/agent/dist/background/background-task-types.d.ts

@@ -1,18 +1,62 @@
 /**
- * Background task types for automatic tool execution promotion.
+ * Background task type definitions.
  *
  * @module
  */
+import type { BackgroundTaskOrigin } from "@comis/core";
+export type { BackgroundTaskOrigin };
 export type BackgroundTaskStatus = "running" | "completed" | "failed" | "cancelled";
+/**
+ * Notification policy for a background task. Typed enum (NOT a boolean):
+ * preserves intent across restart-recovery so the recovered task's dispatch
+ * path matches its original promote-time intent. A boolean collapses to
+ * true/false on rehydrate and loses the distinction between "the operator
+ * wanted deferred routing" and "the operator wanted immediate notification".
+ *
+ * - "deferred"  — Default. Wait for the dispatcher to attempt session
+ *                 re-entry; only fall back to user-visible notification
+ *                 when re-entry fails (session expired, hop cap hit).
+ * - "immediate" — Skip the dispatcher; fire user-visible notification
+ *                 immediately. Reserved for tasks that explicitly want
+ *                 the legacy literal-text notification.
+ * - "silent"    — Skip both dispatcher and user-visible notification.
+ *                 Reserved for fully-internal tasks.
+ *
+ * Default for new promote() calls: "deferred".
+ */
+export type BackgroundTaskNotificationPolicy = "deferred" | "immediate" | "silent";
+/**
+ * Three-state session lifecycle for a background task's notification routing.
+ * State-machine transitions are the single source of truth for at-most-once
+ * fallback.
+ *
+ * - "pending"    — Promotion happened; no completion event yet (or completion
+ *                   event arrived but dispatcher has not classified it).
+ * - "notified"   — Fallback notification fired (user-visible literal text);
+ *                   recovery-after-restart MUST NOT re-emit.
+ * - "dispatched" — Re-entry triggered against the originating session;
+ *                   no fallback notification needed.
+ */
+export type BackgroundSessionState = "pending" | "notified" | "dispatched";
 export interface BackgroundTask {
     id: string;
-    agentId: string;
     toolName: string;
     status: BackgroundTaskStatus;
     startedAt: number;
     completedAt?: number;
     result?: string;
     error?: string;
+    /** Originating session attribution (incl. backgroundHopCount) -- captured at
+     *  promote-time, persisted on disk, preserved across recoverOnStartup.
+     *  Required (no silent fallback). */
+    origin: BackgroundTaskOrigin;
+    /** Live notification policy. Optional; recovery defaults to "deferred" when
+     *  absent. */
+    notificationPolicy?: BackgroundTaskNotificationPolicy;
+    /** Live three-state session lifecycle. Optional; recovery defaults to
+     *  "pending" when absent. The dispatcher inspects this before firing
+     *  notifyFn. */
+    dispatchState?: BackgroundSessionState;
     _promise?: Promise<unknown>;
     _abortController?: AbortController;
     _hardTimeoutTimer?: ReturnType<typeof setTimeout>;
@@ -20,11 +64,23 @@ export interface BackgroundTask {
 /** Serializable subset of BackgroundTask for file persistence. */
 export interface PersistedTaskState {
     id: string;
-    agentId: string;
     toolName: string;
     status: BackgroundTaskStatus;
     startedAt: number;
     completedAt?: number;
     result?: string;
     error?: string;
+    /** Persisted origin -- read back by recoverOnStartup so completion routing
+     *  survives daemon restarts. */
+    origin: BackgroundTaskOrigin;
+    /**
+     * Notification policy chosen at promote time. Optional; recovery defaults
+     * to "deferred" when absent.
+     */
+    notificationPolicy?: BackgroundTaskNotificationPolicy;
+    /**
+     * Three-state session lifecycle. Optional; recovery defaults to "pending"
+     * when absent. The dispatcher inspects this before firing notifyFn.
+     */
+    dispatchState?: BackgroundSessionState;
 }

package/node_modules/@comis/agent/dist/background/background-task-types.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Background task types for automatic tool execution promotion.
+ * Background task type definitions.
  *
  * @module
  */