pi-background-tasks 1.0.6 → 2.0.0

package/src/core/registry.ts

@@ -28,6 +28,7 @@ import {
   type KillKind,
   type StartAttestedPiTaskOptions,
   type StartDelegateTaskOptions,
+  type StartManagedTaskOptions,
   type StartTaskOptions,
   type TaskContextUsage,
   type TaskStatus,
@@ -740,11 +741,13 @@ export class BackgroundTaskRegistry {
     this.killProcess = options.killProcess ?? process.kill.bind(process);
     this.platform = options.platform ?? process.platform;
     this.env = options.env ?? process.env;
-    this.killTree = options.killTree ?? ((pid, phase, signal) => {
-      const taskkillOptions: WindowsTaskkillOptions =
-        signal === undefined ? { env: this.env } : { env: this.env, signal };
-      return runWindowsTaskkill(pid, phase, taskkillOptions);
-    });
+    this.killTree =
+      options.killTree ??
+      ((pid, phase, signal) => {
+        const taskkillOptions: WindowsTaskkillOptions =
+          signal === undefined ? { env: this.env } : { env: this.env, signal };
+        return runWindowsTaskkill(pid, phase, taskkillOptions);
+      });
     this.makeTaskIdFn = options.makeTaskId ?? defaultTaskId;
     this.now = options.now ?? Date.now;
     this.maxOutputBytes = options.maxOutputBytes ?? MAX_OUTPUT_BYTES;
@@ -869,7 +872,8 @@ export class BackgroundTaskRegistry {
       let commandToSpawn = normalizedCommand;
       if (piTelemetryRequested) {
         if (baseInvocation.dialect === 'posix') {
-          if (piTelemetryLaunch === undefined) throw new Error('Pi telemetry launch spec was not resolved');
+          if (piTelemetryLaunch === undefined)
+            throw new Error('Pi telemetry launch spec was not resolved');
           const wrapperAbsPath = join(dir.abs, `${id}.pi-telemetry-wrapper.cjs`);
           await writeFile(
             wrapperAbsPath,
@@ -962,6 +966,128 @@ export class BackgroundTaskRegistry {
     }
   }
 
+  /**
+   * Track an in-process asynchronous workflow through the same durable task,
+   * notification, status, log, and cancellation surfaces as child processes.
+   * The supplied completion promise must own all workflow cleanup before it
+   * settles; terminal publication happens only after that settlement.
+   */
+  async startManagedTask(
+    ctx: BackgroundTaskContext,
+    request: StartManagedTaskOptions,
+  ): Promise<BgTask> {
+    if (this.shuttingDown)
+      throw new Error('Cannot start a managed background task while Pi is shutting down');
+    if (!/^[a-zA-Z0-9_.-]+$/u.test(request.id))
+      throw new Error(`Managed background task id is invalid: ${request.id}`);
+    if (this.tasks.has(request.id))
+      throw new Error(`Background task id already exists: ${request.id}`);
+
+    const dir = await this.ensureRuntimeDir(ctx);
+    const outputAbsPath = join(dir.abs, `${request.id}.output`);
+    const metadataAbsPath = join(dir.abs, `${request.id}.json`);
+    const outputPath = join(dir.display, `${request.id}.output`);
+    const task: BgTask = {
+      id: request.id,
+      name: normalizeTaskName(request.name) ?? 'Managed background task',
+      command: request.command,
+      description: request.description,
+      status: 'running',
+      outputPath,
+      outputAbsPath,
+      metadataAbsPath,
+      cwd: ctx.cwd,
+      startTime: this.now(),
+      exitCode: undefined,
+      pid: undefined,
+      bytesWritten: 0,
+      isAgent: request.isAgent,
+      notified: false,
+      notifyOnCompletion: request.notifyOnCompletion,
+      triggerOnCompletion: request.triggerOnCompletion,
+      fusion: request.fusion,
+      managedCancel: request.cancel,
+      managedStopWaitMs: request.stopWaitMs,
+      terminalPublicationGate: request.terminalPublicationGate,
+      waiters: [],
+    };
+    this.tasks.set(task.id, task);
+    const stream = createWriteStream(outputAbsPath, { flags: 'a', encoding: 'utf8' });
+    task.stream = stream;
+    stream.on('error', (error) => {
+      task.error = `Output file write failed: ${error.message}`;
+      if (task.status === 'running' && !task.managedCancelRequested) {
+        task.managedCancelRequested = true;
+        try {
+          request.cancel();
+        } catch (cancelError) {
+          task.error = `${task.error}; cancellation failed: ${BackgroundTaskRegistry.errorMessage(cancelError)}`;
+        }
+      }
+    });
+
+    try {
+      await this.writeMetadata(task);
+      this.onChange();
+    } catch (error) {
+      this.tasks.delete(task.id);
+      if (!stream.destroyed) stream.destroy();
+      try {
+        request.cancel();
+      } catch (cancelError) {
+        this.logger.error(
+          `[background-tasks] managed task cancellation after metadata failure also failed for ${task.id}:`,
+          cancelError,
+        );
+      }
+      throw new Error(
+        `Failed to register managed background task: ${BackgroundTaskRegistry.errorMessage(error)}`,
+      );
+    }
+
+    void request.completion
+      .then(
+        () => this.finalizeTask(task, 'completed', 0),
+        (error: unknown) => {
+          const message = BackgroundTaskRegistry.errorMessage(error);
+          const killed = task.killKind === 'user' || task.killKind === 'shutdown';
+          return this.finalizeTask(task, killed ? 'killed' : 'failed', null, undefined, message);
+        },
+      )
+      .catch((error: unknown) => {
+        this.logger.error(
+          `[background-tasks] managed task finalization failed for ${task.id}:`,
+          error,
+        );
+      });
+    return task;
+  }
+
+  async updateManagedTask(task: BgTask, state: string, line?: string): Promise<void> {
+    if (task.status !== 'running' || task.fusion === undefined) return;
+    task.fusion.state = state;
+    if (line !== undefined && line.length > 0) this.writeNotice(task, `${line}\n`);
+    await this.writeMetadata(task);
+    this.onChange();
+  }
+
+  /** Claim deferred Fusion usage exactly once before returning it from bg_result. */
+  async claimFusionUsage(task: BgTask): Promise<boolean> {
+    if (task.fusion === undefined) throw new Error(`Task ${task.id} is not a Fusion task`);
+    let claimed = false;
+    const write = async () => {
+      if (!task.fusion || task.fusion.usageDelivered) return;
+      task.fusion.usageDelivered = true;
+      await writeJsonAtomic(task.metadataAbsPath, snapshot(task));
+      claimed = true;
+    };
+    const previous = task.metadataWriteChain ?? Promise.resolve();
+    const next = previous.then(write, write);
+    task.metadataWriteChain = next.catch(() => undefined);
+    await next;
+    return claimed;
+  }
+
   /**
    * Start a prepared delegate child.
    *
@@ -1420,15 +1546,16 @@ export class BackgroundTaskRegistry {
     task.killKind = kind;
     if (reason) task.error = reason;
     this.requestKill(task, 'SIGTERM');
+    const stopWaitMs = task.managedStopWaitMs ?? this.stopWaitMs;
     const stopped =
-      this.platform === 'win32'
-        ? await this.waitForEndOrWindowsForceFailure(task, this.stopWaitMs)
-        : await this.waitForEnd(task, this.stopWaitMs);
+      this.platform === 'win32' && task.managedCancel === undefined
+        ? await this.waitForEndOrWindowsForceFailure(task, stopWaitMs)
+        : await this.waitForEnd(task, stopWaitMs);
     const forceFailure = this.windowsKillStates.get(task)?.forceFailure;
     if (forceFailure !== undefined) throw forceFailure;
     if (!stopped) {
       throw new Error(
-        `Task ${task.id} did not exit within ${formatDuration(this.stopWaitMs)} after SIGTERM/SIGKILL`,
+        `Task ${task.id} did not exit within ${formatDuration(stopWaitMs)} after cancellation`,
       );
     }
     return task;
@@ -1880,7 +2007,10 @@ export class BackgroundTaskRegistry {
     const rejectForceReady = rejectForce;
     state.forcePromise = forcePromise;
     void forcePromise.catch((error: unknown) => {
-      this.logger.error(`[background-tasks] Windows force tree termination failed for ${task.id}:`, error);
+      this.logger.error(
+        `[background-tasks] Windows force tree termination failed for ${task.id}:`,
+        error,
+      );
     });
 
     this.clearKillEscalationTimer(task);
@@ -1922,7 +2052,11 @@ export class BackgroundTaskRegistry {
           resolveForceReady();
           return;
         }
-        const failure = this.makeWindowsForceFailure(task, pid, BackgroundTaskRegistry.errorMessage(error));
+        const failure = this.makeWindowsForceFailure(
+          task,
+          pid,
+          BackgroundTaskRegistry.errorMessage(error),
+        );
         this.recordWindowsForceFailure(task, failure);
         rejectForceReady(failure);
       },
@@ -1965,6 +2099,19 @@ export class BackgroundTaskRegistry {
     if (task.status !== 'running') {
       throw new Error(`Task ${task.id} is ${task.status}, not running`);
     }
+    if (task.managedCancel !== undefined) {
+      if (task.managedCancelRequested) return;
+      task.managedCancelRequested = true;
+      try {
+        task.managedCancel();
+      } catch (error) {
+        throw new Error(
+          `Could not cancel managed task ${task.id}: ${BackgroundTaskRegistry.errorMessage(error)}`,
+        );
+      }
+      task.killSignalSent = true;
+      return;
+    }
     if (!task.child) {
       throw new Error(`Task ${task.id} has no child process handle`);
     }
@@ -2145,6 +2292,12 @@ export class BackgroundTaskRegistry {
       task.exitCode === undefined ? '' : `\n  <exit-code>${String(task.exitCode)}</exit-code>`;
     const error = task.error ? `\n  <error>${escapeXml(task.error)}</error>` : '';
     const taskName = taskDisplayName(task);
+    const guidance =
+      task.fusion === undefined
+        ? 'Terminal state and output metadata are durable. Do not call bg_status to reconfirm; use bg_logs only if output is needed.'
+        : task.status === 'completed'
+          ? `Fusion result is durably committed at ${task.fusion.artifactDir}. Call bg_result({taskId:${JSON.stringify(task.id)}}) once to retrieve it; do not poll.`
+          : `Fusion ended ${task.status}. Inspect the preserved artifacts at ${task.fusion.artifactDir}; do not poll.`;
     const content = [
       '<background-task-notification>',
       `  <task-id>${task.id}</task-id>`,
@@ -2154,7 +2307,7 @@ export class BackgroundTaskRegistry {
       error,
       `  <output-file>${escapeXml(task.outputPath)}</output-file>`,
       `  <summary>${escapeXml(`Background task ${JSON.stringify(taskName)} ${task.status}`)}</summary>`,
-      '  <guidance>Terminal state and output metadata are durable. Do not call bg_status to reconfirm; use bg_logs only if output is needed.</guidance>',
+      `  <guidance>${escapeXml(guidance)}</guidance>`,
       '</background-task-notification>',
     ]
       .filter(Boolean)
@@ -2250,13 +2403,27 @@ export class BackgroundTaskRegistry {
     for (const waiter of task.waiters.splice(0)) waiter();
     this.onChange();
     this.publishTerminal(task);
-    try {
-      this.notifyCompletion(task);
-    } catch (notificationError) {
-      this.logger.error(
-        `[background-tasks] notification failed for ${task.id}:`,
-        notificationError,
-      );
+    let deliveryGateReady = true;
+    if (task.terminalPublicationGate !== undefined) {
+      try {
+        await task.terminalPublicationGate;
+      } catch (error) {
+        deliveryGateReady = false;
+        this.logger.error(
+          `[background-tasks] completion delivery gate failed for ${task.id}:`,
+          error,
+        );
+      }
+    }
+    if (deliveryGateReady) {
+      try {
+        this.notifyCompletion(task);
+      } catch (notificationError) {
+        this.logger.error(
+          `[background-tasks] notification failed for ${task.id}:`,
+          notificationError,
+        );
+      }
     }
     try {
       await this.writeMetadata(task);

package/src/delegate-extension.ts

@@ -10,6 +10,9 @@ import { Text } from '@earendil-works/pi-tui';
 import { Type, type Static } from 'typebox';
 import type { BgTask, BgTaskSnapshot, StartDelegateTaskOptions } from './core/common.js';
 import { truncateChars } from './core/common.js';
+import { sha256Buffer } from './core/attested-pi-run.js';
+import { readFusionCommittedResult } from './core/fusion/result-package.js';
+import { cloneFusionUsage, type FusionUsage, type FusionWorkflowId } from './core/fusion/types.js';
 import {
   DELEGATE_AUTO_DELIVER_MODES,
   DELEGATE_CAPABILITIES,
@@ -74,7 +77,10 @@ const DelegateParams = Type.Object(
           provider: Type.String({ description: 'Exact provider name to pin.' }),
           model: Type.String({ description: 'Exact provider-local model id to pin.' }),
         },
-        { additionalProperties: false, description: 'Explicit route. Defaults to the current model.' },
+        {
+          additionalProperties: false,
+          description: 'Explicit route. Defaults to the current model.',
+        },
       ),
     ),
     capability: Type.Optional(
@@ -83,7 +89,9 @@ const DelegateParams = Type.Object(
       }),
     ),
     maxTurns: Type.Optional(
-      Type.Number({ description: `Maximum agent turns. Default ${String(DELEGATE_DEFAULT_MAX_TURNS)}.` }),
+      Type.Number({
+        description: `Maximum agent turns. Default ${String(DELEGATE_DEFAULT_MAX_TURNS)}.`,
+      }),
     ),
     maxToolCalls: Type.Optional(
       Type.Number({
@@ -113,7 +121,9 @@ const DelegateParams = Type.Object(
 
 const ResultParams = Type.Object(
   {
-    taskId: Type.String({ description: 'Delegate task id returned by bg_delegate.' }),
+    taskId: Type.String({
+      description: 'Background delegate or Fusion task id returned by its launch tool.',
+    }),
     delivery: Type.Optional(
       Type.String({
         description:
@@ -141,6 +151,20 @@ export interface DelegateLaunchDetails {
   trigger_on_completion: boolean;
 }
 
+export interface FusionBackgroundResultDetails {
+  schema_version: 'pi-background-tasks.fusion-result-view.v1';
+  task_id: string;
+  state: 'running' | 'committed' | 'failed' | 'cancelled';
+  delivery: DelegateDeliveryMode | 'none';
+  workflow: FusionWorkflowId;
+  artifact_dir: string;
+  answer_bytes?: number | undefined;
+  answer_sha256?: string | undefined;
+  usage_delivered?: boolean | undefined;
+}
+
+export type BackgroundResultDetails = DelegateResultDetails | FusionBackgroundResultDetails;
+
 export interface DelegateResultDetails {
   schema_version: 'pi-background-tasks.delegate-result-view.v1';
   task_id: string;
@@ -217,7 +241,12 @@ function requireRoute(value: unknown): DelegateRoute | undefined {
 
 function optionalPositiveInteger(value: unknown, label: string): number | undefined {
   if (value === undefined) return undefined;
-  if (typeof value !== 'number' || !Number.isFinite(value) || !Number.isInteger(value) || value <= 0)
+  if (
+    typeof value !== 'number' ||
+    !Number.isFinite(value) ||
+    !Number.isInteger(value) ||
+    value <= 0
+  )
     throw new DelegateError(`bg_delegate ${label} must be a positive integer`, {
       code: 'invalid_arguments',
       childCreated: false,
@@ -226,12 +255,10 @@ function optionalPositiveInteger(value: unknown, label: string): number | undefi
 }
 
 export interface DelegateExtensionDependencies {
-  startDelegateTask: (
-    ctx: ExtensionContext,
-    options: StartDelegateTaskOptions,
-  ) => Promise<BgTask>;
+  startDelegateTask: (ctx: ExtensionContext, options: StartDelegateTaskOptions) => Promise<BgTask>;
   snapshot: (task: BgTask) => BgTaskSnapshot;
   resolveTask: (idOrPrefix: string) => BgTask;
+  claimFusionUsage: (task: BgTask) => Promise<boolean>;
   /** Overridable so tests can supply observed evidence without touching disk. */
   loadHookEvidence?: (() => Promise<DelegateHookContractEvidence>) | undefined;
 }
@@ -326,13 +353,11 @@ export function registerDelegateExtension(
                 id: ctx.model.id,
                 contextWindow: ctx.model.contextWindow,
               },
-        availableModels: ctx.modelRegistry
-          .getAll()
-          .map((model) => ({
-            provider: model.provider,
-            id: model.id,
-            contextWindow: model.contextWindow,
-          })),
+        availableModels: ctx.modelRegistry.getAll().map((model) => ({
+          provider: model.provider,
+          id: model.id,
+          contextWindow: model.contextWindow,
+        })),
         thinkingLevel: pi.getThinkingLevel(),
       });
 
@@ -425,15 +450,15 @@ export function registerDelegateExtension(
     },
   });
 
-  pi.registerTool<typeof ResultParams, DelegateResultDetails>({
+  pi.registerTool<typeof ResultParams, BackgroundResultDetails>({
     name: DELEGATE_RESULT_TOOL_NAME,
-    label: 'Delegate Result',
+    label: 'Background Result',
     description:
-      'Retrieve the hash-verified answer from a bg_delegate task. Never blocks: a running task returns a typed not-ready result. A completed answer is verified against its recorded SHA-256 before it is returned, and an oversized answer is never truncated.',
-    promptSnippet: 'Retrieve the verified answer from a completed bg_delegate task',
+      'Retrieve a hash-verified result from a bg_delegate or background Fusion task. Never blocks: a running task returns a typed not-ready result. Oversized answers are never truncated.',
+    promptSnippet: 'Retrieve the verified answer from a completed delegate or Fusion task',
     promptGuidelines: [
-      'Call bg_result once the delegate terminal notification has arrived. It never blocks and must not be polled.',
-      'A not-ready result means the delegate is still running; end the turn and wait for the notification.',
+      'Call bg_result once the delegate or Fusion terminal notification has arrived. It never blocks and must not be polled.',
+      'A not-ready result means the task is still running; end the turn and wait for the notification.',
     ],
     parameters: ResultParams,
     prepareArguments(args): ResultParamsValue {
@@ -463,10 +488,86 @@ export function registerDelegateExtension(
           { code: 'task_unknown', childCreated: false },
         );
       }
+      const fusion = task.fusion;
+      if (fusion !== undefined) {
+        const requestedDelivery = requireDelivery(params.delivery);
+        if (task.status === 'running') {
+          const details: FusionBackgroundResultDetails = {
+            schema_version: 'pi-background-tasks.fusion-result-view.v1',
+            task_id: task.id,
+            state: 'running',
+            delivery: 'none',
+            workflow: fusion.workflow,
+            artifact_dir: fusion.artifactDir,
+          };
+          return {
+            content: textContent(
+              `Fusion ${task.id} is still running. bg_result never blocks. End this turn; the terminal notification will wake you, then call bg_result again.`,
+            ),
+            details,
+          };
+        }
+        if (task.status !== 'completed' || fusion.outcome?.status !== 'committed') {
+          throw new Error(
+            `Fusion ${task.id} did not commit a result (${task.status}): ${fusion.outcome?.error ?? task.error ?? 'no terminal detail'}`,
+          );
+        }
+        const verified = await readFusionCommittedResult({
+          artifactDirAbs: fusion.artifactDirAbs,
+          artifactDir: fusion.artifactDir,
+          runId: fusion.runId,
+          workflow: fusion.workflow,
+        });
+        const answerBytes = Buffer.byteLength(verified.mergedText, 'utf8');
+        const answerSha256 = sha256Buffer(Buffer.from(verified.mergedText, 'utf8'));
+        const useArtifact =
+          requestedDelivery === 'artifact' ||
+          (requestedDelivery === undefined && answerBytes > DELEGATE_INLINE_ANSWER_BYTES);
+        if (requestedDelivery === 'inline' && answerBytes > DELEGATE_INLINE_ANSWER_BYTES) {
+          throw new Error(
+            `Fusion result ${task.id} is ${String(answerBytes)} bytes, above the ${String(DELEGATE_INLINE_ANSWER_BYTES)}-byte inline limit. Use delivery:"artifact"; nothing was truncated.`,
+          );
+        }
+        const usageDelivered = await deps.claimFusionUsage(task);
+        const details: FusionBackgroundResultDetails = {
+          schema_version: 'pi-background-tasks.fusion-result-view.v1',
+          task_id: task.id,
+          state: 'committed',
+          delivery: useArtifact ? 'artifact' : 'inline',
+          workflow: fusion.workflow,
+          artifact_dir: fusion.artifactDir,
+          answer_bytes: answerBytes,
+          answer_sha256: answerSha256,
+          usage_delivered: usageDelivered,
+        };
+        const header = [
+          `Fusion ${task.id} completed (${fusion.workflow}).`,
+          `Answer: ${String(answerBytes)} bytes, ${answerSha256} (verified).`,
+          `Artifacts: ${fusion.artifactDir}`,
+          usageDelivered
+            ? 'Usage: attached to this retrieval exactly once.'
+            : 'Usage: already attached by an earlier retrieval; not counted again.',
+        ].join('\n');
+        const result = useArtifact
+          ? {
+              content: textContent(
+                `${header}\nDelivery: artifact. The complete answer is ${fusion.artifactDir}/merged.md; it was not truncated.`,
+              ),
+              details,
+            }
+          : { content: textContent(`${header}\n\n${verified.mergedText}`), details };
+        if (!usageDelivered) return result;
+        const resultWithUsage: typeof result & { usage: FusionUsage } = {
+          ...result,
+          usage: cloneFusionUsage(verified.details.usage),
+        };
+        return resultWithUsage;
+      }
+
       const facts = task.delegate;
       if (facts === undefined) {
         throw new DelegateError(
-          `bg_result task ${task.id} is not a bg_delegate task; use bg_logs for ordinary background tasks`,
+          `bg_result task ${task.id} has no retrievable delegate or Fusion result; use bg_logs for ordinary background tasks`,
           { code: 'task_unknown', childCreated: false },
         );
       }
@@ -565,10 +666,15 @@ export function registerDelegateExtension(
     renderResult(result, options: ToolRenderResultOptions, theme: Theme) {
       void options;
       const details = result.details;
+      const fusion = details.schema_version === 'pi-background-tasks.fusion-result-view.v1';
       if (details.state === 'running')
-        return new Text(theme.fg('warning', `delegate ${details.task_id} still running`), 0, 0);
+        return new Text(
+          theme.fg('warning', `${fusion ? 'fusion' : 'delegate'} ${details.task_id} still running`),
+          0,
+          0,
+        );
       return new Text(
-        `${theme.fg('success', '✓ delegate answer')} ${theme.fg('dim', `${String(details.answer_bytes ?? 0)}B · ${details.delivery}`)}`,
+        `${theme.fg('success', fusion ? '✓ fusion answer' : '✓ delegate answer')} ${theme.fg('dim', `${String(details.answer_bytes ?? 0)}B · ${details.delivery}`)}`,
         0,
         0,
       );

package/src/extension.ts

@@ -204,8 +204,6 @@ function renderPlainResult(result: TextToolResult, options: ToolRenderResultOpti
 }
 
 export default function backgroundTasksExtension(pi: ExtensionAPI): void {
-  registerFusionExtension(pi);
-
   const seenTaskIds = new Set<string>();
   let currentCtx: ExtensionContext | undefined;
   let dockOpen = false;
@@ -213,7 +211,6 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
   let latestKnownVersion: string | undefined;
   let updateCheckStarted = false;
 
-  let eventService: BackgroundTaskExtensionService | undefined;
   const registry = new BackgroundTaskRegistry({
     onChange: () => {
       updateUi();
@@ -222,17 +219,25 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
       pi.sendMessage(message, options);
     },
     publishTerminal: (task) => {
-      if (!eventService) throw new Error('Background task EventBus service is not installed');
       eventService.publishTerminal(task);
     },
   });
-  eventService = installBackgroundTaskExtensionApi({
+  const eventService: BackgroundTaskExtensionService = installBackgroundTaskExtensionApi({
     events: pi.events,
     registry,
     getContext: () => currentCtx,
     isShuttingDown: () => registry.isShuttingDown(),
   });
 
+  registerFusionExtension(pi, {
+    startManagedTask: async (ctx, options) => {
+      currentCtx = ctx;
+      return registry.startManagedTask(ctx, options);
+    },
+    snapshot: (task) => registry.snapshot(task),
+    updateManagedTask: (task, state, line) => registry.updateManagedTask(task, state, line),
+  });
+
   registerDelegateExtension(pi, {
     startDelegateTask: async (ctx, options) => {
       currentCtx = ctx;
@@ -240,6 +245,7 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
     },
     snapshot: (task) => registry.snapshot(task),
     resolveTask: (idOrPrefix) => registry.resolveTask(idOrPrefix),
+    claimFusionUsage: (task) => registry.claimFusionUsage(task),
   });
 
   function unseenFinishedTasks(): BgTask[] {
@@ -359,6 +365,11 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
               return result;
             },
             rerunTask: async (task: BackgroundTaskForUi) => {
+              if (task.fusion !== undefined || task.delegate !== undefined) {
+                throw new Error(
+                  'Only shell-command tasks can be rerun from the dock; relaunch this typed workflow through its owning tool.',
+                );
+              }
               const rerunOptions: StartTaskOptions = {
                 name: taskDisplayName(task),
                 isAgent: task.isAgent,
@@ -499,7 +510,7 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
         ctx.ui.notify(`Background task cleanup failed:\n${failures.join('\n')}`, 'error');
       }
     } finally {
-      eventService?.close();
+      eventService.close();
     }
   });