@goodandready/dsh-cron 0.3.25 → 0.3.26

package/lib/runner.js

@@ -1,881 +1 @@
-import { logStreamer } from './log-streamer.js';
-import { logger } from './logger.js';
-import { bestEffort } from './best-effort.js';
-import { estimateTokenCost } from './integrations.js';
-import { resolveDynamicCredentialsInText, resolveDynamicCredentialsInObject } from './secrets.js';
-import {
-  EXTERNAL_RUNTIMES,
-  normalizeTaskType,
-} from './runtimes.js';
-import {
-  isContextOverflowError,
-  terminateProcessTree,
-  isTransientError,
-  runHttp,
-  runViaRemoteWorkspace,
-  runExternal,
-} from './runner-external.js';
-import {
-  resolveCwd,
-  createTaskWorktree,
-  removeTaskWorktree,
-} from './runner-worktree.js';
-
-export {
-  isContextOverflowError,
-  terminateProcessTree,
-  isTransientError,
-  resolveCwd,
-  createTaskWorktree,
-  removeTaskWorktree,
-};
-
-/**
- * Runner executing scheduled tasks in DeepSeek Harness sessions.
- */
-
-/**
- * Resolves the effective target session ID taking into account rotation policies (#143).
- * Supports {{date}} interpolation, 'daily' rotation (adds -YYYY-MM-DD), and 'weekly' rotation (-YYYY-Www).
- */
-export function formatDateYmd(date = new Date()) {
-  const yyyy = date.getFullYear();
-  const mm = String(date.getMonth() + 1).padStart(2, '0');
-  const dd = String(date.getDate()).padStart(2, '0');
-  return `${yyyy}-${mm}-${dd}`;
-}
-
-export function resolveTargetSessionId(targetSessionId, resetPolicy = 'never', date = new Date()) {
-  if (!targetSessionId || typeof targetSessionId !== 'string') return null;
-  let baseId = targetSessionId.trim();
-  if (!baseId) return null;
-
-  const yyyymmdd = formatDateYmd(date);
-
-  if (baseId.includes('{{date}}')) {
-    return baseId.replaceAll('{{date}}', yyyymmdd);
-  }
-
-  if (resetPolicy === 'daily') {
-    return `${baseId}-${yyyymmdd}`;
-  }
-
-  if (resetPolicy === 'weekly') {
-    const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
-    const dayNum = d.getUTCDay() || 7;
-    d.setUTCDate(d.getUTCDate() + 4 - dayNum);
-    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
-    const weekNo = Math.ceil((((d - yearStart) / 86400000) + 1) / 7);
-    const ww = String(weekNo).padStart(2, '0');
-    return `${baseId}-${d.getUTCFullYear()}-W${ww}`;
-  }
-
-  return baseId;
-}
-
-export class SessionRunner {
-  constructor(ctx, store = null) {
-    this.ctx = ctx;
-    this.store = store;
-  }
-
-  _getAgentsService() {
-    if (!this.ctx) return null;
-    try {
-      if (typeof this.ctx.get === 'function') {
-        const svc = this.ctx.get('agents');
-        if (svc) return svc;
-      }
-    } catch (_err) {
-      // service unavailable via ctx.get
-    }
-    try {
-      return this.ctx.agents || null;
-    } catch (_err) {
-      return null;
-    }
-  }
-
-  _getSessionService() {
-    if (!this.ctx) return null;
-    try {
-      if (typeof this.ctx.get === 'function') {
-        const svc = this.ctx.get('session');
-        if (svc) return svc;
-      }
-    } catch (_err) {
-      // service unavailable via ctx.get
-    }
-    try {
-      return this.ctx.session || null;
-    } catch (_err) {
-      return null;
-    }
-  }
-
-  async execute(task, options = {}) {
-    const timeoutSeconds = Number(task.timeoutSeconds) > 0 ? Number(task.timeoutSeconds) : 1800;
-    const timeoutMs = timeoutSeconds * 1000;
-    const externalSignal = options.signal;
-
-    // Internal abort controller combining external signal + timeout
-    const controller = new AbortController();
-    let timeoutId = null;
-
-    if (externalSignal) {
-      if (externalSignal.aborted) {
-        throw new Error(externalSignal.reason?.message || 'Task aborted before execution');
-      }
-      externalSignal.addEventListener('abort', () => {
-        controller.abort(externalSignal.reason || new Error('Task aborted by overlap policy'));
-      }, { once: true });
-    }
-
-    const streamRunId = options.runId || `run_${Date.now()}`;
-    logStreamer.startStream(task.id, streamRunId);
-    logStreamer.appendLog(task.id, `[dsh-cron] Starting task "${task.title}" (type: ${task.type || 'llm'})
-`, 'stdout');
-
-    const timeoutPromise = new Promise((_, reject) => {
-      timeoutId = setTimeout(() => {
-        const timeoutErr = new Error(`Task execution timed out after ${timeoutSeconds} seconds`);
-        controller.abort(timeoutErr);
-        reject(timeoutErr);
-      }, timeoutMs);
-    });
-
-    const executionPromise = this._run(task, controller.signal, options);
-
-    try {
-      const res = await Promise.race([executionPromise, timeoutPromise]);
-      logStreamer.appendLog(task.id, `
-[dsh-cron] Task execution finished
-`, 'stdout');
-      logStreamer.completeStream(task.id, { status: 'success' });
-      return res;
-    } catch (err) {
-      logStreamer.appendLog(task.id, `
-[dsh-cron] Task execution error: ${err.message}
-`, 'stderr');
-      logStreamer.completeStream(task.id, { status: 'error', error: err.message });
-      throw err;
-    } finally {
-      if (timeoutId) clearTimeout(timeoutId);
-    }
-  }
-
-  /** Resolve working directory for task via runner-worktree */
-  resolveCwd(task) {
-    return resolveCwd(task, this.ctx);
-  }
-
-  /** Create isolated worktree via runner-worktree */
-  async createTaskWorktree(cwd, task) {
-    return createTaskWorktree(cwd, task);
-  }
-
-  /** Remove isolated worktree via runner-worktree */
-  async removeTaskWorktree(cwd, wtPath) {
-    return removeTaskWorktree(cwd, wtPath);
-  }
-
-  /** HTTP trigger runtime via runner-external */
-  async _runHttp(task, request, signal) {
-    return runHttp(task, request, signal);
-  }
-
-  /** Remote workspace execution via runner-external */
-  async _runViaRemoteWorkspace(task, signal) {
-    return runViaRemoteWorkspace(task, signal, this.ctx);
-  }
-
-  /** Non-LLM external runtimes via runner-external */
-  async _runExternal(task, runtime, signal, execOptions = {}) {
-    return runExternal(task, runtime, signal, execOptions, {
-      ctx: this.ctx,
-      resolveCwdFn: (t) => this.resolveCwd(t),
-    });
-  }
-
-  async _run(task, signal, options = {}) {
-    logger.info(`[dsh-cron] executing task "${task.title}" (${task.id})`);
-
-    // Dynamic credentials resolution in-memory (#335)
-    let effectiveTask = task;
-    const resolvedSecrets = [];
-    const settings = (this.store && typeof this.store.getSettings === 'function')
-      ? this.store.getSettings()
-      : {};
-
-    if (settings.enableDynamicCredentials) {
-      effectiveTask = { ...task };
-      if (typeof effectiveTask.prompt === 'string') {
-        const res = await resolveDynamicCredentialsInText(effectiveTask.prompt, this.ctx);
-        effectiveTask.prompt = res.text;
-        resolvedSecrets.push(...res.resolvedSecrets);
-      }
-      if (typeof effectiveTask.script === 'string') {
-        const res = await resolveDynamicCredentialsInText(effectiveTask.script, this.ctx);
-        effectiveTask.script = res.text;
-        resolvedSecrets.push(...res.resolvedSecrets);
-      }
-      if (typeof effectiveTask.command === 'string') {
-        const res = await resolveDynamicCredentialsInText(effectiveTask.command, this.ctx);
-        effectiveTask.command = res.text;
-        resolvedSecrets.push(...res.resolvedSecrets);
-      }
-      if (typeof effectiveTask.httpUrl === 'string') {
-        const res = await resolveDynamicCredentialsInText(effectiveTask.httpUrl, this.ctx);
-        effectiveTask.httpUrl = res.text;
-        resolvedSecrets.push(...res.resolvedSecrets);
-      }
-      if (typeof effectiveTask.httpBody === 'string') {
-        const res = await resolveDynamicCredentialsInText(effectiveTask.httpBody, this.ctx);
-        effectiveTask.httpBody = res.text;
-        resolvedSecrets.push(...res.resolvedSecrets);
-      }
-      if (effectiveTask.httpHeaders) {
-        const res = await resolveDynamicCredentialsInObject(effectiveTask.httpHeaders, this.ctx);
-        effectiveTask.httpHeaders = res.data;
-        resolvedSecrets.push(...res.resolvedSecrets);
-      }
-      if (effectiveTask.env) {
-        const res = await resolveDynamicCredentialsInObject(effectiveTask.env, this.ctx);
-        effectiveTask.env = res.data;
-        resolvedSecrets.push(...res.resolvedSecrets);
-      }
-    }
-
-    const maskSecrets = (result) => {
-      if (!result || typeof result !== 'object') return result;
-      if (resolvedSecrets.length > 0 && typeof result.output === 'string') {
-        let out = result.output;
-        for (const secret of resolvedSecrets) {
-          if (secret && String(secret).length >= 4 && out.includes(secret)) {
-            out = out.replaceAll(secret, '[REDACTED_CREDENTIAL]');
-          }
-        }
-        result.output = out;
-      }
-      return result;
-    };
-
-    const runInternal = async () => {
-      // 1. Non-LLM runtimes: shell, Node.js, Python, HTTP, SSH, Docker (#4 #5 #7 #8 #9)
-      const runtime = normalizeTaskType(effectiveTask.type);
-      if (EXTERNAL_RUNTIMES.includes(runtime) || effectiveTask.mode === 'no-llm') {
-        return this._runExternal(effectiveTask, runtime === 'llm' ? 'script' : runtime, signal, options);
-      }
-
-      // 2. Agent session, when the harness exposes one
-      const agentsSvc = this._getAgentsService();
-      if (agentsSvc && typeof agentsSvc.create === 'function') {
-        return this._runAgentSession(effectiveTask, runtime, signal, options);
-      }
-
-      // 3. Legacy session service
-      const sessionSvc = this._getSessionService();
-      if (sessionSvc && typeof sessionSvc.create === 'function') {
-        return this._runLegacySession(effectiveTask, options);
-      }
-
-      // 4. Nothing to run through: report the prompt as triggered
-      return this._runBare(effectiveTask, options);
-    };
-
-    try {
-      const outcome = await runInternal();
-      return maskSecrets(outcome);
-    } catch (err) {
-      if (resolvedSecrets.length > 0 && err && err.message) {
-        for (const secret of resolvedSecrets) {
-          if (secret && String(secret).length >= 4 && err.message.includes(secret)) {
-            err.message = err.message.replaceAll(secret, '[REDACTED_CREDENTIAL]');
-          }
-        }
-      }
-      throw err;
-    }
-  }
-
-  // Legacy dispatch replaced above; original runner helpers remain unchanged below:
-  async _runOriginalDispatch(task, signal, options = {}) {
-    const runtime = normalizeTaskType(task.type);
-    if (EXTERNAL_RUNTIMES.includes(runtime) || task.mode === 'no-llm') {
-      return this._runExternal(task, runtime === 'llm' ? 'script' : runtime, signal, options);
-    }
-
-    // 2. Agent session, when the harness exposes one
-    const agentsSvc2 = this._getAgentsService();
-    if (agentsSvc2 && typeof agentsSvc2.create === 'function') {
-      return this._runAgentSession(task, runtime, signal, options);
-    }
-
-    // 3. Legacy session service
-    const sessionSvc2 = this._getSessionService();
-    if (sessionSvc2 && typeof sessionSvc2.create === 'function') {
-      return this._runLegacySession(task, options);
-    }
-
-    // 4. Nothing to run through: report the prompt as triggered
-    return this._runBare(task, options);
-  }
-
-  /** Legacy session service path; falls back to the bare report. */
-  async _runLegacySession(task) {
-    try {
-      const ymd = formatDateYmd();
-      const explicit = task.sessionTitle ? String(task.sessionTitle).trim().replaceAll('{{date}}', ymd) : '';
-      const legacyTitle = explicit || `[Cron] ${ymd} ${task.title}`;
-      const session = await this.ctx.session.create({
-        title: legacyTitle,
-        ephemeral: task.delivery === 'isolated',
-      });
-      if (session && typeof session.send === 'function') {
-        const result = await session.send(task.prompt);
-        const out = typeof result === 'string' ? result : JSON.stringify(result);
-        const usage = session.usage || { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
-        return { output: out, usage, costUsd: estimateTokenCost(task.model, usage) };
-      }
-    } catch (err) {
-      logger.error(`[dsh-cron] session execution failed:`, err.message);
-      throw err;
-    }
-    return this._runBare(task);
-  }
-
-  _runBare(task, execOptions = {}) {
-    return {
-      output: `[dsh-cron] Prompt triggered: "${task.prompt.slice(0, 100)}..."`,
-      usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
-      costUsd: 0,
-    };
-  }
-
-  async _runAgentSession(task, runtime, signal, execOptions = {}) {
-    let effectiveTask = task;
-    if (execOptions?.prevOutput) {
-      const prev = String(execOptions.prevOutput);
-      const prompt = task.prompt || '';
-      const newPrompt = prompt.includes('{{prevOutput}}')
-        ? prompt.replaceAll('{{prevOutput}}', prev)
-        : `[Previous Output]:\n${prev}\n\n${prompt}`;
-      effectiveTask = { ...task, prompt: newPrompt };
-    }
-    const prep = await this._prepareAgentRun(effectiveTask, runtime, signal);
-    try {
-      return await this._executeAgentTurn(task, prep);
-    } catch (err) {
-      // Context window overflow auto-recovery in persistent sessions (#145)
-      if (prep.targetSessionId && isContextOverflowError(err) && !signal?.aborted) {
-        logger.warn(`[dsh-cron] Persistent session "${prep.targetSessionId}" exceeded context window (${err.message}). Auto-recovering with fresh session...`);
-        bestEffort('archive-rotated-session', () => {
-          const sessions = this.ctx?.get?.('sessions');
-          if (sessions && typeof sessions.archive === 'function') {
-            sessions.archive(prep.targetSessionId);
-          }
-        });
-        const rotatedSessionId = `${prep.targetSessionId}-${Date.now().toString(36)}`;
-        logger.info(`[dsh-cron] Rotated persistent session "${prep.targetSessionId}" -> "${rotatedSessionId}"`);
-        if (this.store) {
-          bestEffort('update-stored-rotated-session', () => {
-            const stored = this.store.get(task.id);
-            if (stored) {
-              stored.targetSessionId = rotatedSessionId;
-              this.store.set(stored);
-            }
-          });
-        }
-        task.targetSessionId = rotatedSessionId;
-        effectiveTask.targetSessionId = rotatedSessionId;
-        const freshPrep = await this._prepareAgentRun(effectiveTask, runtime, signal);
-        return await this._executeAgentTurn(task, freshPrep);
-      }
-      logger.error(`[dsh-cron] agent execution failed:`, err.message);
-      throw err;
-    }
-  }
-
-  /** Everything an agent run needs before the session is created. */
-  async _prepareAgentRun(task, runtime, signal) {
-    const { randomUUID } = await import('node:crypto');
-    let createUserMessage = (m) => m;
-    const llmModule = await bestEffort('import-dsh-llm', () => import('@deepseek-ai/dsh-llm'));
-    if (llmModule && typeof llmModule.createUserMessage === 'function') {
-      createUserMessage = llmModule.createUserMessage;
-    }
-    const sessionModule = await bestEffort('import-dsh-session', () => import('@deepseek-ai/dsh-session'));
-
-    const targetSessionId = resolveTargetSessionId(task.targetSessionId, task.targetSessionReset);
-
-    const mintSessionId = () => {
-      if (targetSessionId) {
-        if (sessionModule && typeof sessionModule.SessionId === 'function') {
-          return sessionModule.SessionId(targetSessionId);
-        }
-        return targetSessionId;
-      }
-      const sid = `cron-exec-${task.id}-${randomUUID()}`;
-      if (sessionModule && typeof sessionModule.SessionId === 'function') {
-        return sessionModule.SessionId(sid);
-      }
-      return sid;
-    };
-
-    const defaultSel = this.ctx.get?.('agentDefaultModel')?.currentSelection?.();
-    return {
-      createUserMessage,
-      mintSessionId,
-      targetSessionId,
-      provider: task.provider || defaultSel?.provider,
-      model: task.model || defaultSel?.model || undefined,
-      ...(await this._resolveRunContext(task)),
-      agentPrompt: this._shapeAgentPrompt(task, runtime),
-      raceAbort: this._makeAbortRacer(signal),
-    };
-  }
-
-  /**
-   * The agent session cannot take the AbortSignal natively, so any abort
-   * (timeout, overlap replace, pause, scheduler stop) races against the session
-   * awaits and forces an immediate dispose (#88).
-   */
-  _makeAbortRacer(signal) {
-    const abortError = () => (signal && signal.reason) || new Error('Task aborted');
-    return (promise) => {
-      if (!signal) return promise;
-      return Promise.race([
-        promise,
-        new Promise((_, reject) => {
-          if (signal.aborted) {
-            reject(abortError());
-            return;
-          }
-          signal.addEventListener('abort', () => reject(abortError()), { once: true });
-        }),
-      ]);
-    };
-  }
-
-  /** Working directory for the run, in an isolated worktree when requested (#29, #231). */
-  async _resolveRunContext(task) {
-    const baseCwd = this.resolveCwd(task);
-    let cwd = baseCwd;
-    let taskWorktree = null;
-    if (task.worktree) {
-      // Issue #231: Fail-closed — if worktree creation fails, abort run and preserve base workspace
-      taskWorktree = await this.createTaskWorktree(baseCwd, task);
-      cwd = taskWorktree;
-    }
-    return { baseCwd, cwd, taskWorktree };
-  }
-
-  /** #6/#10: skill- and workflow-driven tasks name the skill/workflow. */
-  _shapeAgentPrompt(task, runtime) {
-    const prompt = String(task.prompt || '');
-    if (runtime === 'skill' && task.skillName) {
-      return `Use the DSH skill "${task.skillName}" for this task:\n${prompt}`;
-    }
-    if (runtime === 'workflow' && task.workflowName) {
-      return `Execute this through the DSH workflow "${task.workflowName}" step by step:\n${prompt}`;
-    }
-    return prompt;
-  }
-
-  /** Create the session, drive one turn, and always clean up. */
-  async _executeAgentTurn(task, prep) {
-    let handle = prep?.handle || null;
-    let isResumed = false;
-    try {
-      // Resolve agent preset (#GH-1, #GH-2): scheduled llm sessions must join an agent preset
-      // (default or task-configured), otherwise tools resolve against the empty global layer.
-      let presets = null;
-      try {
-        if (typeof this.ctx.get === 'function') {
-          presets = this.ctx.get('agentPresets');
-        } else {
-          presets = this.ctx.agentPresets;
-        }
-      } catch {
-        presets = null;
-      }
-      let preset = null;
-      if (presets && typeof presets.resolve === 'function') {
-        try {
-          preset = await presets.resolve(task.agentPreset || undefined);
-          if (preset && typeof presets.standingKeyFor === 'function') {
-            await presets.standingKeyFor(preset.id);
-          }
-        } catch (presetErr) {
-          logger.warn('[dsh-cron] agent preset unavailable, running without one:', presetErr && presetErr.message);
-          preset = null;
-        }
-      }
-
-      const presetSetup = preset ? {
-        setup: async (agentCtx) => {
-          if (typeof presets.mount === 'function') {
-            await presets.mount(agentCtx, preset.id);
-          }
-        }
-      } : {};
-
-      // If targetSessionId is set, attempt to resume the existing session (#143, #346, GH #9)
-      let resumeFailure = null;
-      const agents = this._getAgentsService();
-      if (prep.targetSessionId && agents && typeof agents.resume === 'function') {
-        try {
-          handle = await agents.resume({
-            sessionId: prep.targetSessionId,
-            resumeSessionId: prep.targetSessionId,
-            meta: {
-              cwd: prep.cwd,
-              ...(preset ? { agentPreset: preset.id } : {})
-            },
-            agentOptions: prep.provider && prep.model ? { provider: prep.provider, model: prep.model } : undefined,
-            ...presetSetup,
-          });
-          isResumed = true;
-          logger.info(`[dsh-cron] resumed existing persistent session: ${prep.targetSessionId}`);
-        } catch (resumeErr) {
-          resumeFailure = resumeErr;
-          logger.warn(`[dsh-cron] could not resume session ${prep.targetSessionId} (${resumeErr.message}), fallback creating new session`);
-          handle = null;
-        }
-      }
-
-      // Create new session if not resumed
-      if (!handle) {
-        try {
-          handle = await agents.create({
-            sessionId: prep.mintSessionId(),
-            meta: {
-              cwd: prep.cwd,
-              ephemeral: !prep.targetSessionId,
-              internal: !prep.targetSessionId,
-              ...(preset ? { agentPreset: preset.id } : {})
-            },
-            agentOptions: prep.provider && prep.model ? { provider: prep.provider, model: prep.model } : undefined,
-            ...presetSetup,
-          });
-        } catch (createErr) {
-          if (resumeFailure) {
-            throw new Error(`could not resume session "${prep.targetSessionId}" (${resumeFailure.message}): ${createErr.message}`);
-          }
-          throw createErr;
-        }
-      }
-
-      this._applyPermissionPreset(task, handle);
-      this._nameSession(task, handle, isResumed);
-      await prep.raceAbort(handle.agent.whenIdle());
-
-      // 1. Capture starting sequence before sending user message (#227, #228)
-      const session = handle.agent.session;
-      const startSeq = (session && typeof session.seq === 'number')
-        ? session.seq
-        : (Array.isArray(session?.log) ? session.log.length : 0);
-
-      handle.agent.followup(prep.createUserMessage({
-        content: [{ type: 'text', text: prep.agentPrompt }],
-        source: { kind: 'plugin:dsh-cron', form: 'cron-execute' },
-      }));
-      // Await agent turn completion (#67), abortable on timeout/overlap (#88)
-      if (typeof handle.agent.whenIdle === 'function') {
-        await prep.raceAbort(handle.agent.whenIdle());
-      }
-
-      // 2. Snapshot events from this turn only (#227, #228)
-      let turnEvents = [];
-      if (typeof session?.snapshotEvents === 'function') {
-        turnEvents = session.snapshotEvents(startSeq) || [];
-      } else if (Array.isArray(session?.log)) {
-        turnEvents = session.log.slice(startSeq);
-      } else if (Array.isArray(handle.agent?.log)) {
-        turnEvents = handle.agent.log.slice(startSeq);
-      }
-
-      // Extract usage FIRST so failed turns and budget checks have accurate token and cost accounting (#228)
-      const usage = this._extractUsage(handle, turnEvents);
-      const costUsd = estimateTokenCost(prep.model, usage);
-
-      // 3. Terminal turn failure and settlement check (#227)
-      let hasTerminalEvent = false;
-      for (const ev of turnEvents) {
-        if (!ev) continue;
-        if (ev.type === 'turn/end' || ev.type === 'turn/error' || ev.type === 'turn/failure') {
-          hasTerminalEvent = true;
-          const reason = ev.data?.reason || ev.reason;
-          const reasonKind = (reason && typeof reason === 'object') ? reason.kind : reason;
-          if (['error', 'interrupted', 'failed', 'aborted', 'blocked'].includes(reasonKind) || ev.data?.error || ev.error) {
-            const errMsg = ev.data?.error?.message || ev.error?.message || reason?.message || (typeof reason === 'string' ? reason : `Agent turn ended with status: ${reasonKind || 'error'}`);
-            const err = new Error(errMsg);
-            err.reason = reason;
-            err.reasonKind = reasonKind;
-            err.turnFailed = true;
-            err.usage = usage;
-            err.costUsd = costUsd;
-            err.sessionId = handle.agent.session?.id || null;
-            throw err;
-          }
-        }
-      }
-
-      const hasEventLog = typeof session?.snapshotEvents === 'function' || Array.isArray(session?.log) || Array.isArray(handle.agent?.log);
-      if (hasEventLog && !hasTerminalEvent) {
-        const err = new Error(
-          turnEvents.length === 0
-            ? 'Agent turn produced no events before quiescence'
-            : 'Agent turn ended without terminal completion event'
-        );
-        err.turnFailed = true;
-        err.usage = usage;
-        err.costUsd = costUsd;
-        err.sessionId = handle.agent.session?.id || null;
-        throw err;
-      }
-
-      // 4. Extract assistant message text from turn events (#227)
-      const messageTexts = [];
-      const chunkTexts = [];
-      for (const ev of turnEvents) {
-        if (!ev) continue;
-        if (ev.type === 'assistant/message') {
-          const msg = ev.data?.message || ev.data;
-          if (msg) {
-            if (typeof msg.content === 'string' && msg.content.trim()) {
-              messageTexts.push(msg.content.trim());
-            } else if (Array.isArray(msg.content)) {
-              const parts = msg.content
-                .filter((p) => p && p.type === 'text' && typeof p.text === 'string')
-                .map((p) => p.text)
-                .join('');
-              if (parts.trim()) messageTexts.push(parts.trim());
-            }
-          }
-        } else if (ev.type === 'assistant/chunk' && ev.data?.chunk) {
-          const chunk = ev.data.chunk;
-          if (chunk.type === 'text' && typeof chunk.text === 'string') {
-            chunkTexts.push(chunk.text);
-          } else if (chunk.type === 'text-delta' && typeof chunk.delta === 'string') {
-            chunkTexts.push(chunk.delta);
-          }
-        }
-      }
-      let outputText = messageTexts.length > 0 ? messageTexts.join('\n') : chunkTexts.join('');
-
-      // Fallback if no assistant message text was extracted from turn events
-      if (!outputText.trim()) {
-        const sessionNote = isResumed
-          ? `resumed: ${prep.targetSessionId}`
-          : `session: ${handle.agent.session?.id || 'cron'}`;
-        outputText = `[dsh-cron] Agent finished turn for task "${task.title}" (${sessionNote})`;
-      }
-
-      return {
-        output: outputText,
-        usage,
-        costUsd,
-        sessionId: handle.agent.session?.id || null,
-      };
-    } finally {
-      await this._disposeAgentRun(task, prep, handle);
-    }
-  }
-
-  /** Per-job permission preset (#32, #380, GH #18): read-only | workspace-write | danger-full-access (or full alias). */
-  _applyPermissionPreset(task, handle) {
-    if (!task.permissionPreset || task.permissionPreset === 'default') {
-      this._pinApprovalPolicy(handle);
-      return;
-    }
-    const targetPreset = task.permissionPreset === 'full' ? 'danger-full-access' : task.permissionPreset;
-    try {
-      const presets = this.ctx.get ? this.ctx.get('permissionPresets') : this.ctx.permissionPresets;
-      if (presets && typeof presets.set === 'function') {
-        presets.set(handle.agent.session, targetPreset);
-      }
-    } catch (ppErr) {
-      logger.warn(`[dsh-cron] permission preset "${task.permissionPreset}" (target: "${targetPreset}") not applied to task ${task.id || ''}:`, ppErr.message);
-    }
-    this._pinApprovalPolicy(handle);
-  }
-
-  _pinApprovalPolicy(handle) {
-    try {
-      const approval = this.ctx.get ? this.ctx.get('approval') : this.ctx.approval;
-      if (approval && typeof approval.setPolicy === 'function') {
-        if (handle?.agent) {
-          bestEffort('approval-set-policy-agent', () => approval.setPolicy(handle.agent, 'never'), logger);
-        }
-        if (handle?.agent?.session) {
-          bestEffort('approval-set-policy-session', () => approval.setPolicy(handle.agent.session, 'never'), logger);
-        }
-      }
-    } catch (appErr) {
-      logger.warn('[dsh-cron] approval setPolicy not applied:', appErr.message);
-    }
-  }
-
-  _nameSession(task, handle, isResumed) {
-    if (!handle?.agent?.session) return;
-    const session = handle.agent.session;
-    try {
-      const sessionTitle = this.ctx.get ? this.ctx.get('sessionTitle') : this.ctx.sessionTitle;
-      if (!sessionTitle || typeof sessionTitle.rename !== 'function') return;
-
-      const explicitTitle = task.sessionTitle ? String(task.sessionTitle).trim() : '';
-      const taskTitle = task.title ? String(task.title).trim() : '';
-      const ymd = formatDateYmd();
-
-      let label = '';
-      if (explicitTitle) {
-        label = explicitTitle.replaceAll('{{date}}', ymd);
-      } else if (taskTitle.startsWith('[')) {
-        label = taskTitle.replaceAll('{{date}}', ymd);
-      } else if (taskTitle) {
-        label = `${ymd} ${taskTitle}`;
-      }
-
-      if (!label.trim()) return;
-      if (isResumed && !explicitTitle) return;
-
-      sessionTitle.rename(session, label.trim());
-      logger.info(`[dsh-cron] assigned session title "${label.trim()}" for session ${session.id}`);
-    } catch (titleErr) {
-      logger.debug?.(`[dsh-cron] could not rename session ${session?.id}: ${titleErr.message}`);
-    }
-  }
-
-  /** Token usage reported by session events or the handle (#228). */
-  _extractUsage(handle, turnEvents = []) {
-    const usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
-    let hasEventUsage = false;
-
-    bestEffort('extract-session-events-usage', () => {
-      const stepUsage = new Map();
-      const failedAttempts = [];
-
-      for (const ev of turnEvents) {
-        if (!ev || !ev.type) continue;
-
-        // assistant/chunk with usage type
-        if (ev.type === 'assistant/chunk' && ev.data?.chunk?.type === 'usage' && ev.data.chunk.usage) {
-          const u = ev.data.chunk.usage;
-          const key = `${ev.data.turn || 0}:${ev.data.step || 0}`;
-          if (!stepUsage.has(key)) {
-            stepUsage.set(key, {
-              inputTokens: Number(u.inputTokens || u.promptTokens || u.uncachedInputTokens) || 0,
-              outputTokens: Number(u.outputTokens || u.completionTokens) || 0,
-              cacheReadTokens: Number(u.cacheReadTokens || u.cachedTokens) || 0,
-            });
-            hasEventUsage = true;
-          }
-        }
-
-        // assistant/message finalized usage overwrites intermediate chunk usage for this step
-        if (ev.type === 'assistant/message') {
-          const u = ev.data?.usage || ev.data?.message?.usage;
-          if (u) {
-            const key = `${ev.data.turn || 0}:${ev.data.step || 0}`;
-            stepUsage.set(key, {
-              inputTokens: Number(u.inputTokens || u.promptTokens || u.uncachedInputTokens) || 0,
-              outputTokens: Number(u.outputTokens || u.completionTokens) || 0,
-              cacheReadTokens: Number(u.cacheReadTokens || u.cachedTokens) || 0,
-            });
-            hasEventUsage = true;
-          }
-        }
-
-        // assistant/attempt usage (e.g. paid failed attempts, retries, streaming attempts) (#228)
-        if (ev.type === 'assistant/attempt') {
-          let attemptUsage = null;
-          if (ev.data?.usage) {
-            const u = ev.data.usage;
-            attemptUsage = {
-              inputTokens: Number(u.inputTokens || u.promptTokens || u.uncachedInputTokens) || 0,
-              outputTokens: Number(u.outputTokens || u.completionTokens) || 0,
-              cacheReadTokens: Number(u.cacheReadTokens || u.cachedTokens) || 0,
-            };
-          }
-          // DSH 0.2.0-rc.2 AssistantStreamRecord: stream contains usage chunks
-          if (Array.isArray(ev.data?.stream)) {
-            for (const item of ev.data.stream) {
-              const u = item?.chunk?.usage || item?.usage;
-              if (u) {
-                if (!attemptUsage) {
-                  attemptUsage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
-                }
-                attemptUsage.inputTokens += Number(u.inputTokens || u.promptTokens || u.uncachedInputTokens) || 0;
-                attemptUsage.outputTokens += Number(u.outputTokens || u.completionTokens) || 0;
-                attemptUsage.cacheReadTokens += Number(u.cacheReadTokens || u.cachedTokens) || 0;
-              }
-            }
-          }
-          if (attemptUsage) {
-            failedAttempts.push(attemptUsage);
-            hasEventUsage = true;
-          }
-        }
-      }
-
-      if (hasEventUsage) {
-        for (const item of stepUsage.values()) {
-          usage.inputTokens += item.inputTokens;
-          usage.outputTokens += item.outputTokens;
-          usage.cacheReadTokens += item.cacheReadTokens;
-        }
-        for (const item of failedAttempts) {
-          usage.inputTokens += item.inputTokens;
-          usage.outputTokens += item.outputTokens;
-          usage.cacheReadTokens += item.cacheReadTokens;
-        }
-      }
-    });
-
-    if (!hasEventUsage) {
-      bestEffort('extract-session-usage-fallback', () => {
-        const sessionUsage = handle?.agent?.session?.usage || handle?.agent?.usage;
-        if (sessionUsage) {
-          usage.inputTokens = Number(sessionUsage.inputTokens || sessionUsage.promptTokens) || 0;
-          usage.outputTokens = Number(sessionUsage.outputTokens || sessionUsage.completionTokens) || 0;
-          usage.cacheReadTokens = Number(sessionUsage.cacheReadTokens || sessionUsage.cachedTokens) || 0;
-        }
-      });
-    }
-
-    return usage;
-  }
-
-  /** Dispose the session, archive it best-effort, drop the worktree (#30, #29). */
-  async _disposeAgentRun(task, prep, handle) {
-    let archivedSessionId = null;
-    archivedSessionId = bestEffort('get-archived-session-id', () => {
-      return (handle && handle.agent && handle.agent.session && handle.agent.session.id) || null;
-    }) || null;
-    try {
-      if (handle && typeof handle.dispose === 'function') {
-        await handle.dispose();
-      } else if (handle && handle.agent && typeof handle.agent.destroy === 'function') {
-        await handle.agent.destroy();
-      }
-    } catch (disposeErr) {
-      logger.warn('[dsh-cron] session dispose notice:', disposeErr.message);
-    }
-    // Best-effort: keep ephemeral cron sessions out of the main chat list (#30).
-    // Persistent sessions (targetSessionId configured) stay unarchived so users can interact with them (#143).
-    if (archivedSessionId && this.ctx && this.ctx.get && !prep.targetSessionId) {
-      bestEffort('archive-session-cleanup', () => {
-        const sessions = this.ctx.get('sessions');
-        if (sessions && typeof sessions.archive === 'function') {
-          sessions.archive(archivedSessionId);
-        }
-      });
-    }
-    // #29: dispose the isolated worktree (kept when keepWorktree is set).
-    if (prep.taskWorktree && !task.keepWorktree) {
-      await this.removeTaskWorktree(prep.baseCwd, prep.taskWorktree);
-    }
-  }
-}
-
+export * from './runtimes/runner.js';