pi-simple-background-tasks 0.2.0 → 0.3.0

package/src/core/task-cleanup.ts

@@ -1,6 +1,7 @@
 import { readdir, readFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { TERMINAL_TASK_STATUS_VALUES } from './common.js';
+import { EXIT_MARKER_SUFFIX, RUNNER_SCRIPT_SUFFIX } from './detached-spawn.js';
 
 export type CleanupScope = 'one' | 'session' | 'all';
 
@@ -59,6 +60,11 @@ async function readTaskStatus(jsonPath: string): Promise<string | undefined> {
 async function deleteTaskFiles(runDir: string, id: string): Promise<void> {
   await rm(join(runDir, `${id}.json`), { force: true });
   await rm(join(runDir, `${id}.output`), { force: true });
+  // Ownership artifacts of a settled task: the wrapper marker and the
+  // generated runner script. Both are dead weight once the record is
+  // terminal, and they keep the run dir from ever becoming prunable.
+  await rm(join(runDir, `${id}${EXIT_MARKER_SUFFIX}`), { force: true });
+  await rm(join(runDir, `${id}${RUNNER_SCRIPT_SUFFIX}`), { force: true });
 }
 
 async function removeEmptyRunDir(runDir: string): Promise<void> {

package/src/core/windows-taskkill.ts

@@ -1,8 +1,6 @@
 import { spawn as nodeSpawn, type SpawnOptions } from 'node:child_process';
 import { win32 } from 'node:path';
 
-export type WindowsKillPhase = 'terminate' | 'force';
-
 export interface TaskkillOutcome {
   readonly exitCode: number | null;
   readonly signal: NodeJS.Signals | null;
@@ -117,11 +115,7 @@ function validatePid(pid: number): void {
   }
 }
 
-function validatePhase(phase: WindowsKillPhase): void {
-  if (phase !== 'terminate' && phase !== 'force') {
-    throw new Error(`Invalid Windows taskkill phase ${String(phase)}`);
-  }
-}
+// (the two-phase 'terminate'/'force' split was removed: /F is the only kill)
 
 function positiveFiniteInteger(value: number | undefined, fallback: number, label: string): number {
   const candidate = value ?? fallback;
@@ -157,11 +151,9 @@ function defaultSpawn(
 
 export function runWindowsTaskkill(
   pid: number,
-  phase: WindowsKillPhase,
   options: WindowsTaskkillOptions = {},
 ): Promise<TaskkillOutcome> {
   validatePid(pid);
-  validatePhase(phase);
   const env = options.env ?? process.env;
   const taskkill = resolveTaskkillPath(env);
   const timeoutMs = positiveFiniteInteger(options.timeoutMs, DEFAULT_TIMEOUT_MS, 'timeoutMs');
@@ -173,8 +165,9 @@ export function runWindowsTaskkill(
   const spawn = options.spawn ?? defaultSpawn;
   const abortSignal = options.signal;
 
-  const args = ['/PID', String(pid), '/T'];
-  if (phase === 'force') args.push('/F');
+  // Single tree termination: console applications do not honor window-close
+  // termination, so forced termination is the only kill that works.
+  const args = ['/PID', String(pid), '/T', '/F'];
 
   if (abortSignal?.aborted) {
     const stdout = new BoundedCapture(maxCaptureBytes);

package/src/core/windows-wmi-spawn.ts

@@ -0,0 +1,192 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import { join } from 'node:path';
+
+/**
+ * Windows detach helper: the task's outer process is created by the WMI
+ * service (`Win32_Process.Create`), not by the extension process.
+ *
+ * Background-task survival on this platform requires the task to be outside
+ * every process job and console session that belongs to the Pi activation:
+ * children spawned directly by the Pi process die together with it (job and
+ * console-session teardown), no matter how they are detached. Processes
+ * created through WMI have `WmiPrvSE.exe` as their service-side parent and
+ * outlive the activating process, its console, and its SSH/terminal session
+ * entirely — verified end to end on Windows 11.
+ *
+ * The helper is a short-lived PowerShell one-shot: it performs exactly one
+ * `Win32_Process.Create` and prints the new pid. It is spawned directly by the
+ * extension and never survives the launch itself, so a dead activation can
+ * never leave a launch in flight (failures surface as launch errors).
+ */
+
+export interface WmiHelperChild {
+  readonly pid?: number | undefined;
+  readonly stdout: {
+    on(event: 'data', listener: (data: Buffer | string) => void): unknown;
+  };
+  readonly stderr: {
+    on(event: 'data', listener: (data: Buffer | string) => void): unknown;
+  };
+  kill(signal?: NodeJS.Signals): boolean;
+  on(event: 'error', listener: (error: Error) => void): unknown;
+  on(
+    event: 'close',
+    listener: (code: number | null, signal: NodeJS.Signals | null) => void,
+  ): unknown;
+}
+
+export type WmiSpawnFn = (
+  file: string,
+  args: string[],
+  options: { env: NodeJS.ProcessEnv; windowsVerbatimArguments?: boolean },
+) => WmiHelperChild;
+
+export interface WindowsWmiSpawnOptions {
+  /** Full CreateProcess command line for the new process. */
+  readonly commandLine: string;
+  readonly currentDirectory: string;
+  readonly env?: NodeJS.ProcessEnv | undefined;
+  /** Test seam; defaults to PowerShell via SystemRoot. */
+  readonly spawn?: WmiSpawnFn | undefined;
+  readonly timeoutMs?: number | undefined;
+}
+
+export const WMI_CREATE_TIMEOUT_MS = 20_000;
+
+const PS_HEADER = ['$ErrorActionPreference = "Stop"'].join('\n');
+
+/**
+ * Builds the one-shot PowerShell script: creates the process hidden, reports
+ * failures as `WMIERR <ReturnValue>` on stdout, otherwise prints the pid.
+ */
+export function buildWindowsWmiCreateScript(commandLine: string, currentDirectory: string): string {
+  return [
+    PS_HEADER,
+    `$r = Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{` +
+      `CommandLine = '${escapePowerShellSingleQuoted(commandLine)}';` +
+      `CurrentDirectory = '${escapePowerShellSingleQuoted(currentDirectory)}' }`,
+    'if ($r.ReturnValue -ne 0) { Write-Output ("WMIERR " + $r.ReturnValue); exit 1 }',
+    'Write-Output $r.ProcessId',
+  ].join('\n');
+}
+
+function escapePowerShellSingleQuoted(value: string): string {
+  return value.replace(/'/g, "''");
+}
+
+export function encodeWindowsWmiScript(script: string): string {
+  return Buffer.from(script, 'utf16le').toString('base64');
+}
+
+export function powershellExecutable(env: NodeJS.ProcessEnv = process.env): string {
+  const windir = env.Windir ?? env.SYSTEMROOT ?? env.winDir ?? 'C:\\Windows';
+  return join(windir, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+}
+
+/** Parses `WMIERR N` / `<pid>` helper output into either a failure or a pid. */
+export function parseWmiHelperOutput(stdout: string, stderr: string): { pid: number } {
+  const lines = stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+  const errLine = lines.find((line) => line.startsWith('WMIERR'));
+  if (errLine !== undefined) {
+    const code = errLine.slice('WMIERR'.length).trim();
+    throw new Error(
+      `Win32_Process.Create failed (ReturnValue ${code || 'unknown'})` +
+        (stderr.length > 0 ? `; helper output: ${stderr.trim()}` : ''),
+    );
+  }
+  const candidate = lines[lines.length - 1];
+  const pid = candidate === undefined ? Number.NaN : Number(candidate);
+  if (!Number.isSafeInteger(pid) || pid <= 0) {
+    throw new Error(
+      `Windows WMI spawn did not return a pid${stderr.length > 0 ? `; helper output: ${stderr.trim()}` : ''}`,
+    );
+  }
+  return { pid };
+}
+
+export async function createProcessViaWmi(
+  options: WindowsWmiSpawnOptions,
+): Promise<{ pid: number }> {
+  const spawn = options.spawn ?? defaultWmiSpawn;
+  const env = options.env ?? process.env;
+  const scriptFile = encodeWindowsWmiScript(
+    buildWindowsWmiCreateScript(options.commandLine, options.currentDirectory),
+  );
+  const timeoutMs = options.timeoutMs ?? WMI_CREATE_TIMEOUT_MS;
+
+  const child = spawn(
+    powershellExecutable(env),
+    ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', scriptFile],
+    {
+      env,
+      windowsVerbatimArguments: false,
+    },
+  );
+
+  const stdout: string[] = [];
+  const stderr: string[] = [];
+  child.stdout?.on('data', (chunk) => stdout.push(String(chunk)));
+  child.stderr?.on('data', (chunk) => stderr.push(String(chunk)));
+
+  return new Promise((resolve, reject) => {
+    const rejectOnce = (error: Error): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(error);
+    };
+    let settled = false;
+    let timer: NodeJS.Timeout | undefined = setTimeout(() => {
+      timer = undefined;
+      rejectOnce(
+        new Error(
+          `Windows WMI spawn exceeded ${String(Math.round(timeoutMs / 1000))}s timeout; the helper was terminated`,
+        ),
+      );
+      try {
+        child.kill('SIGKILL');
+      } catch {
+        // Rejection is authoritative; the helper may already have exited.
+      }
+    }, timeoutMs);
+
+    const close = (code: number | null): void => {
+      if (settled) return;
+      settled = true;
+      if (timer !== undefined) clearTimeout(timer);
+      const detail =
+        (code === null ? 'exit signal' : `exit ${String(code)}`) + tailOutput(stderr.join(''));
+      if (code !== 0) {
+        reject(new Error(`Windows WMI helper failed (${detail})`));
+        return;
+      }
+      try {
+        resolve(parseWmiHelperOutput(stdout.join(''), stderr.join('')));
+      } catch (error) {
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    };
+    child.on('error', (error: Error) =>
+      rejectOnce(new Error(`Windows WMI helper failed to start: ${error.message}`)),
+    );
+    child.on('close', (code: number | null) => close(code));
+  });
+  function tailOutput(stderrText: string): string {
+    const normalized = stderrText.trim();
+    return normalized.length === 0 ? '' : `; helper output: ${normalized}`;
+  }
+}
+
+function defaultWmiSpawn(
+  file: string,
+  args: string[],
+  options: { env: NodeJS.ProcessEnv; windowsVerbatimArguments?: boolean },
+): WmiHelperChild {
+  return nodeSpawn(file, args, {
+    env: options.env,
+    windowsVerbatimArguments: false,
+  }) as unknown as WmiHelperChild;
+}

package/src/extension.ts

@@ -1,5 +1,3 @@
-import { randomBytes } from 'node:crypto';
-import { realpathSync } from 'node:fs';
 import type {
   ExtensionAPI,
   ExtensionCommandContext,
@@ -32,10 +30,6 @@ import {
   normalizeMaxBytes,
   normalizeTaskName,
   parseBgCommandArgs,
-  type ReloadShellActivationClaimV1,
-  type ReloadShellActivationLeaseV1,
-  type ReloadShellIdentityV1,
-  ReloadSurvivalError,
   type StartTaskOptions,
   taskDisplayName,
   truncateChars,
@@ -47,10 +41,6 @@ import {
 } from './core/extension-api.js';
 import { LazyModule, SynchronousActivationCloseFence } from './core/lazy-module.js';
 import { type BackgroundTaskContext, BackgroundTaskRegistry } from './core/registry.js';
-import {
-  getProcessReloadShellOwnerV1,
-  makeReloadShellIdentity,
-} from './core/reload-shell-owner.js';
 import { createShellPolicyGuidanceHandler, initializeShellPolicy } from './core/shell-policy.js';
 import type { CleanupScope, CleanupSummary } from './core/task-cleanup.js';
 import {
@@ -66,9 +56,11 @@ import {
  * Scope:
  * - Explicit background shell jobs only: /bg and bg_run spawn commands directly.
  * - No Ctrl+B support for backgrounding an already-running built-in bash tool.
- * - Opted ordinary shell jobs can hand their same live process ownership to a
- *   fresh extension activation on real same-process reload only.
- * - No PID/file adoption, process-restart survival, or crash recovery.
+ * - Tasks always survive /reload and Pi restarts: every task spawns detached,
+ *   its ownership facts live in its on-disk metadata, and each activation
+ *   adopts still-running records from disk. Pi session shutdown kills all
+ *   running tasks, so exit with care.
+ * - No flag negotiates any of this: there is exactly one launch path.
  */
 
 const COMMAND_PREVIEW_CHARS = 90;
@@ -88,6 +80,7 @@ interface BgToolArgumentRecord {
   readonly timeoutSeconds?: unknown;
   readonly notifyOnCompletion?: unknown;
   readonly triggerOnCompletion?: unknown;
+  /** Legacy argument, silently ignored: survival is now unconditional. */
   readonly surviveReload?: unknown;
 }
 
@@ -119,12 +112,6 @@ const BgRunParams = Type.Object({
         'Whether that notification should automatically trigger a follow-up agent turn. Default: true for bg_run; requires notifyOnCompletion.',
     }),
   ),
-  surviveReload: Type.Optional(
-    Type.Boolean({
-      description:
-        'Opt in to retaining this exact shell execution across a real same-process Pi reload. Default: false.',
-    }),
-  ),
 });
 
 const BgStatusParams = Type.Object({
@@ -213,15 +200,8 @@ function formatCleanMessage(summary: CleanupSummary): string {
 export default async function backgroundTasksExtension(pi: ExtensionAPI): Promise<void> {
   const config = resolveBackgroundTasksConfig(process.cwd());
   const shellPolicy = initializeShellPolicy();
-  const reloadShellOwner = getProcessReloadShellOwnerV1();
   pi.on('before_agent_start', createShellPolicyGuidanceHandler(shellPolicy));
-  let currentRegistryCtx: BackgroundTaskContext | undefined;
-  let activationLease: ReloadShellActivationLeaseV1 | undefined;
-  let activationIdentity: ReloadShellIdentityV1 | undefined;
-  let pendingActivationClaim: ReloadShellActivationClaimV1 | undefined;
   let disposed = false;
-  let shutdownCleanupStarted = false;
-  let reloadHandoffFailed = false;
   let shutdownReason = 'shutdown';
   const activationCloseFence = new SynchronousActivationCloseFence();
   const taskManagerLoader = new LazyModule(() => import('./ui/background-tasks-manager.js'));
@@ -240,59 +220,22 @@ export default async function backgroundTasksExtension(pi: ExtensionAPI): Promis
     },
     shellPolicy,
     tasksDir: config.tasksDir,
-    reloadShellOwner,
   });
   const eventService: BackgroundTaskExtensionService = installBackgroundTaskExtensionApi({
     events: pi.events,
     registry,
   });
 
-  const beginSessionShutdown = (reason: string): void => {
-    let handoffError: unknown;
-    if (!disposed) {
-      disposed = true;
-      registry.closeTaskAdmissions();
-      if (pendingActivationClaim !== undefined) {
-        const claim = pendingActivationClaim;
-        pendingActivationClaim = undefined;
-        registry.abortReloadActivation(claim);
-        try {
-          reloadShellOwner.abortActivation(
-            claim,
-            new ReloadSurvivalError(
-              'pi_bg_reload_owner_stale_claim',
-              'activation shut down while its reload claim was staging',
-            ),
-          );
-        } catch (error) {
-          handoffError = error;
-        }
-      } else if (reason === 'reload' && activationLease !== undefined) {
-        const lease = activationLease;
-        try {
-          registry.prepareReloadHandoff(lease);
-          activationLease = undefined;
-          activationIdentity = undefined;
-        } catch (error) {
-          reloadHandoffFailed = true;
-          handoffError = error;
-        }
-      }
-      registry.setShuttingDown(true);
-      eventService.close();
-    }
-    // Teardown remains active on repeated calls so even a handle assigned by a
-    // racing continuation is still disposed rather than hidden by idempotence.
-    currentRegistryCtx = undefined;
-    if (handoffError !== undefined) throw handoffError;
+  const beginSessionShutdown = (): void => {
+    if (disposed) return;
+    disposed = true;
+    registry.setShuttingDown(true);
+    eventService.close();
   };
-
-  // Join the one synchronous all-lane barrier before any facade can register
-  // asynchronous cleanup. The core callback performs an eligible reload
-  // handoff first; every lazy lane then closes on the same call stack before
-  // Pi can await any later cleanup handler.
+  // Join the one synchronous all-lane barrier: every lazy lane closes on the
+  // same call stack before Pi can await any later cleanup handler.
   activationCloseFence.add(() => {
-    beginSessionShutdown(shutdownReason);
+    beginSessionShutdown();
   });
   activationCloseFence.add(() => {
     taskManagerLoader.close();
@@ -302,72 +245,21 @@ export default async function backgroundTasksExtension(pi: ExtensionAPI): Promis
     activationCloseFence.close();
   });
 
-  // This is the first session_start callback. Claim synchronously before the
-  // first await, stage/import durably, then expose the fresh host adapter.
-  pi.on('session_start', async (event, ctx) => {
+  pi.on('session_start', async (_event, ctx) => {
+    // A Pi reload binds a fresh extension instance. Adoptions run before any
+    // task can start so notifications continue for tasks running across the
+    // reload, and the poller takes over ownership detection from disk records.
+    if (disposed) return;
+    registry.setShuttingDown(false);
+    await registry.ensureRuntimeDir(registryContext(ctx));
     if (disposed) return;
-    const nextRegistryCtx = registryContext(ctx);
-    const identity = makeReloadShellIdentity(
-      nextRegistryCtx.sessionId ?? '',
-      realpathSync(ctx.cwd),
-    );
-    if (activationLease !== undefined && registry.hasCurrentReloadLease()) {
-      if (
-        activationIdentity?.hostPid !== identity.hostPid ||
-        activationIdentity.sessionId !== identity.sessionId ||
-        activationIdentity.cwdRealpath !== identity.cwdRealpath
-      ) {
-        throw new ReloadSurvivalError(
-          'pi_bg_reload_owner_activation_conflict',
-          'a repeated session_start changed the bound reload owner identity without shutdown',
-        );
-      }
-      currentRegistryCtx = nextRegistryCtx;
-      return;
-    }
-    const activationNonce = randomBytes(16).toString('hex');
-    const claim = reloadShellOwner.beginActivation(identity, event.reason, activationNonce);
-    pendingActivationClaim = claim;
     try {
-      const adapter = await registry.stageReloadActivation(claim);
-      if (pendingActivationClaim !== claim) {
-        // The synchronous shutdown barrier already aborted this claim and
-        // detached staged records while the durable import awaited.
-        registry.abortReloadActivation(claim);
-        return;
-      }
-      if (disposed) {
-        registry.abortReloadActivation(claim);
-        pendingActivationClaim = undefined;
-        reloadShellOwner.abortActivation(
-          claim,
-          new ReloadSurvivalError(
-            'pi_bg_reload_owner_stale_claim',
-            'activation was disposed before reload claim commit',
-          ),
-        );
-        return;
-      }
-      const lease = reloadShellOwner.commitActivation(claim, adapter);
-      pendingActivationClaim = undefined;
-      activationLease = lease;
-      activationIdentity = identity;
-      currentRegistryCtx = nextRegistryCtx;
+      await registry.reconcileTasksFromDisk();
     } catch (error) {
-      registry.abortReloadActivation(claim);
-      if (pendingActivationClaim === claim) pendingActivationClaim = undefined;
-      try {
-        reloadShellOwner.abortActivation(claim, error);
-      } catch (abortError) {
-        if (
-          typeof abortError !== 'object' ||
-          abortError === null ||
-          Reflect.get(abortError, 'code') !== 'pi_bg_reload_owner_stale_claim'
-        ) {
-          throw new AggregateError([error, abortError], 'Reload activation claim and abort failed');
-        }
-      }
-      throw error;
+      console.error(
+        '[background-tasks] failed to reconcile background tasks from disk:',
+        error instanceof Error ? error : new Error(String(error)),
+      );
     }
   });
 
@@ -376,9 +268,7 @@ export default async function backgroundTasksExtension(pi: ExtensionAPI): Promis
     command: string,
     options: StartTaskOptions = {},
   ): Promise<BgTask> {
-    const nextRegistryCtx = registryContext(ctx);
-    currentRegistryCtx = nextRegistryCtx;
-    return registry.startTask(nextRegistryCtx, command, options);
+    return registry.startTask(registryContext(ctx), command, options);
   }
 
   async function openTaskManager(
@@ -433,7 +323,6 @@ export default async function backgroundTasksExtension(pi: ExtensionAPI): Promis
       rerunTask: async (task: BackgroundTaskForUi) => {
         const rerunOptions: StartTaskOptions = {
           name: taskDisplayName(task),
-          surviveReload: task.surviveReload,
           notifyOnCompletion: true,
           triggerOnCompletion: false,
         };
@@ -504,26 +393,12 @@ export default async function backgroundTasksExtension(pi: ExtensionAPI): Promis
     },
   );
 
-  pi.on('session_start', async (_event, ctx) => {
-    // Pi replacement binds a fresh extension instance. Never revive this old
-    // activation if a late lifecycle dispatch reaches it after shutdown.
-    if (disposed) return;
-    registry.setShuttingDown(false);
-    const nextRegistryCtx = currentRegistryCtx ?? registryContext(ctx);
-    currentRegistryCtx = nextRegistryCtx;
-    await registry.ensureRuntimeDir(nextRegistryCtx);
-    if (disposed) return;
-  });
-
   pi.on('session_shutdown', async (event, ctx) => {
-    beginSessionShutdown(event.reason);
-    if (shutdownCleanupStarted) return;
-    shutdownCleanupStarted = true;
+    if (shutdownReason.length === 0) shutdownReason = event.reason;
+    // Explicitly user-visible sessions always kill running tasks, while /reload,
+    // a Pi restart or a crash cannot reach this handler and thus never kill: the
+    // tasks survive and the next activation adopts them from disk.
     try {
-      // Admission closure aborts cooperative preflight and the drain retains
-      // ownership until subprocess/file/managed cleanup settles. Any admitted
-      // child is inserted synchronously before spawn and is visible below.
-      await registry.waitForTaskAdmissions();
       const running = registry.allTasks().filter((task) => task.status === 'running');
       if (running.length === 0) return;
 
@@ -548,30 +423,15 @@ export default async function backgroundTasksExtension(pi: ExtensionAPI): Promis
       }
     } finally {
       eventService.close();
-      if ((event.reason !== 'reload' || reloadHandoffFailed) && activationLease !== undefined) {
-        try {
-          await registry.waitForReloadHostSettlement();
-        } catch (error) {
-          console.error(
-            '[background-tasks] reload owner host settlement failed during shutdown:',
-            error,
-          );
-        }
-        registry.releaseReloadActivation(activationLease);
-        activationLease = undefined;
-        activationIdentity = undefined;
-      }
     }
   });
 
   pi.registerCommand('bg', {
-    description:
-      'Start a tracked shell command: /bg [--survive-reload] [--name "Task name"] <command>',
+    description: 'Start a tracked shell command: /bg [--name "Task name"] <command>',
     handler: async (args, ctx) => {
       try {
         const parsed = parseBgCommandArgs(args);
         const taskOptions: StartTaskOptions = {
-          surviveReload: parsed.surviveReload,
           notifyOnCompletion: true,
           triggerOnCompletion: false,
         };
@@ -747,12 +607,8 @@ export default async function backgroundTasksExtension(pi: ExtensionAPI): Promis
       if (!args || typeof args !== 'object') throw new Error('bg_run arguments must be an object');
       const input = args as BgToolArgumentRecord;
       if (typeof input.command !== 'string') throw new Error('bg_run requires command string');
-      if (Object.hasOwn(input, 'surviveReload') && typeof input.surviveReload !== 'boolean') {
-        throw new ReloadSurvivalError(
-          'pi_bg_survive_reload_invalid',
-          'bg_run surviveReload must be boolean when present',
-        );
-      }
+      // Legacy surviveReload values are silently ignored: task survival across
+      // /reload is now the only behavior, so the knob has nothing left to set.
       const prepared: BgRunParamsValue = {
         command: input.command,
         name:
@@ -766,13 +622,11 @@ export default async function backgroundTasksExtension(pi: ExtensionAPI): Promis
         prepared.notifyOnCompletion = input.notifyOnCompletion;
       if (typeof input.triggerOnCompletion === 'boolean')
         prepared.triggerOnCompletion = input.triggerOnCompletion;
-      if (typeof input.surviveReload === 'boolean') prepared.surviveReload = input.surviveReload;
       return prepared;
     },
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const taskOptions: StartTaskOptions = {
         name: params.name,
-        surviveReload: params.surviveReload ?? false,
         notifyOnCompletion: params.notifyOnCompletion ?? true,
         triggerOnCompletion: params.triggerOnCompletion ?? true,
       };