blun-king-cli 9.1.527 → 9.1.550

package/bin/agent-resume-snapshot.cjs

@@ -1,12 +1,39 @@
 'use strict';
 
 const AGENT_RESUME_SNAPSHOT_SCHEMA_VERSION = 1;
+const MAX_TODO_PROGRESS_EVIDENCE = 8;
+const MAX_TODO_PROGRESS_EVIDENCE_CHARS = 200;
 
 function copyJsonObject(value, fallback) {
   if (value === undefined) return fallback;
   return JSON.parse(JSON.stringify(value));
 }
 
+function normalizeTodoProgressState(value) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return undefined;
+  const nonNegativeInteger = (candidate, maximum) => Number.isSafeInteger(candidate)
+    ? Math.max(0, Math.min(candidate, maximum))
+    : 0;
+  const evidenceRevision = nonNegativeInteger(value.evidenceRevision, Number.MAX_SAFE_INTEGER);
+  return {
+    workCallsSinceRefresh: nonNegativeInteger(value.workCallsSinceRefresh, 64),
+    refreshRequired: value.refreshRequired === true,
+    unchangedRefreshStreak: nonNegativeInteger(value.unchangedRefreshStreak, 3),
+    recentEvidence: Array.isArray(value.recentEvidence)
+      ? value.recentEvidence
+        .filter((entry) => typeof entry === 'string')
+        .slice(-MAX_TODO_PROGRESS_EVIDENCE)
+        .map((entry) => entry.slice(0, MAX_TODO_PROGRESS_EVIDENCE_CHARS))
+      : [],
+    evidenceRevision,
+    lastMaintenanceEvidenceRevision: Math.min(
+      nonNegativeInteger(value.lastMaintenanceEvidenceRevision, Number.MAX_SAFE_INTEGER),
+      evidenceRevision,
+    ),
+    allVisibleWorkCompleted: value.allVisibleWorkCompleted === true,
+  };
+}
+
 function captureMessageTimes(agent) {
   const replayTimes = new Map();
   for (const record of agent.replayBuilder.records) {
@@ -63,6 +90,7 @@ function createAgentResumeSnapshot(agent) {
       allowedTools: agent.tools.allowedTools,
       excludedTools: [...agent.tools.excludedTools],
     },
+    todoProgress: normalizeTodoProgressState(agent.goalTodoPolicyState) ?? null,
     goal: agent.goal.state ?? null,
     turn: {
       turnId: agent.turn.turnId,
@@ -175,6 +203,8 @@ function restoreAgentResumeSnapshot(agent, snapshot) {
       : [];
     if (agent.config.hasProvider) agent.tools.initializeBuiltinTools();
 
+    agent.goalTodoPolicyState = normalizeTodoProgressState(snapshot.todoProgress);
+
     agent.goal.state = snapshot.goal === null
       ? undefined
       : copyJsonObject(snapshot.goal, undefined);
@@ -206,5 +236,6 @@ function restoreAgentResumeSnapshot(agent, snapshot) {
 module.exports = {
   AGENT_RESUME_SNAPSHOT_SCHEMA_VERSION,
   createAgentResumeSnapshot,
+  normalizeTodoProgressState,
   restoreAgentResumeSnapshot,
 };

package/bin/assistant-message-offload-policy.cjs

@@ -1,5 +1,11 @@
 'use strict';
 
+const {
+  hasHistoricalOffloadPressure,
+  historyTextChars,
+} = require('./history-offload-pressure-policy.cjs');
+const { hasContextPressure } = require('./context-pressure-policy.cjs');
+
 const ASSISTANT_MESSAGE_MAX_CHARS = 4_000;
 const ASSISTANT_MESSAGE_KEEP_RECENT_MESSAGES = 20;
 const ASSISTANT_MESSAGE_PREVIEW_LINES = 5;
@@ -34,6 +40,7 @@ function isSyntheticToolArguments(value) {
 function shouldOffloadHistoricalAssistantMessage(options = {}) {
   const historyIndex = Number(options.historyIndex);
   const historyLength = Number(options.historyLength);
+  const historyChars = Number(options.historyChars);
   const textChars = Number(options.textChars);
   if (
     !Number.isSafeInteger(historyIndex)
@@ -44,7 +51,10 @@ function shouldOffloadHistoricalAssistantMessage(options = {}) {
     || historyIndex >= historyLength
   ) return false;
   const cutoff = Math.max(0, historyLength - ASSISTANT_MESSAGE_KEEP_RECENT_MESSAGES);
-  return historyIndex < cutoff && textChars > ASSISTANT_MESSAGE_MAX_CHARS;
+  return hasContextPressure(options)
+    && hasHistoricalOffloadPressure({ historyLength, historyChars })
+    && historyIndex < cutoff
+    && textChars > ASSISTANT_MESSAGE_MAX_CHARS;
 }
 
 function createAssistantMessagePreview(text) {
@@ -68,6 +78,7 @@ function createAssistantMessagePreview(text) {
 function shouldCompactHistoricalAssistantToolNarration(options = {}) {
   const historyIndex = Number(options.historyIndex);
   const historyLength = Number(options.historyLength);
+  const historyChars = Number(options.historyChars);
   const textChars = Number(options.textChars);
   const toolCallCount = Number(options.toolCallCount);
   const completedToolCallCount = Number(options.completedToolCallCount);
@@ -83,13 +94,18 @@ function shouldCompactHistoricalAssistantToolNarration(options = {}) {
     || toolCallCount <= 0
   ) return false;
   const cutoff = Math.max(0, historyLength - ASSISTANT_MESSAGE_KEEP_RECENT_MESSAGES);
-  return historyIndex < cutoff
+  return hasHistoricalOffloadPressure({ historyLength, historyChars })
+    && historyIndex < cutoff
     && textChars > ASSISTANT_TOOL_NARRATION_MIN_CHARS
     && completedToolCallCount === toolCallCount;
 }
 
 function compactHistoricalPostTelegramReplyNarration(messages) {
   if (!Array.isArray(messages) || messages.length === 0) return messages;
+  if (!hasHistoricalOffloadPressure({
+    historyLength: messages.length,
+    historyChars: historyTextChars(messages),
+  })) return messages;
 
   const toolNameByCallId = new Map(messages.flatMap((message) => (
     message?.role === 'assistant' && Array.isArray(message.toolCalls)
@@ -175,6 +191,10 @@ function compactCompletedSubagentCall(call, completedIds) {
 
 function compactHistoricalCompletedSubagentPrompts(messages) {
   if (!Array.isArray(messages) || messages.length === 0) return messages;
+  if (!hasHistoricalOffloadPressure({
+    historyLength: messages.length,
+    historyChars: historyTextChars(messages),
+  })) return messages;
 
   const completedIds = completedSubagentResultIds(messages);
   if (completedIds.size === 0) return messages;
@@ -256,6 +276,7 @@ module.exports = {
   compactHistoricalCompletedSubagentPrompts,
   compactHistoricalPostTelegramReplyNarration,
   createAssistantMessagePreview,
+  historyTextChars,
   isSyntheticToolArguments,
   removeSyntheticToolArgumentFailures,
   shouldCompactHistoricalAssistantToolNarration,

package/bin/codebase-search-runtime.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+const { existsSync } = require('node:fs');
+const { fileURLToPath } = require('node:url');
+const { isAbsolute } = require('node:path');
+
+function resolveCodebaseIndexScript(moduleUrl, envPath) {
+  if (typeof moduleUrl !== 'string' || moduleUrl.length === 0) return '';
+
+  if (typeof envPath === 'string' && envPath.length > 0) {
+    if (!isAbsolute(envPath) || !existsSync(envPath)) return '';
+    return envPath;
+  }
+
+  try {
+    const packaged = fileURLToPath(new URL('./codebase-index/codebase_index.py', moduleUrl));
+    return existsSync(packaged) ? packaged : '';
+  } catch {
+    return '';
+  }
+}
+
+module.exports = { resolveCodebaseIndexScript };

package/bin/context-performance-policy.cjs

@@ -3,12 +3,9 @@
 const DEFAULT_COMPACTION_TRIGGER_MAX_TOKENS = 256_000;
 const DEFAULT_COMPACTION_BLOCK_MAX_TOKENS = 288_000;
 
-function capCompactionThreshold(threshold, phase) {
+function capCompactionThreshold(threshold, _phase) {
   if (threshold === undefined) return undefined;
-  const maximum = phase === "block"
-    ? DEFAULT_COMPACTION_BLOCK_MAX_TOKENS
-    : DEFAULT_COMPACTION_TRIGGER_MAX_TOKENS;
-  return Math.min(threshold, maximum);
+  return threshold;
 }
 
 module.exports = {

package/bin/context-pressure-policy.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+const DEFAULT_CONTEXT_PRESSURE_RATIO = 0.75;
+
+function hasContextPressure(options = {}) {
+  if (typeof options.underPressure === 'boolean') return options.underPressure;
+  const overridePercent = Number((options.env ?? process.env).BLUN_CONTEXT_PRESSURE_PERCENT);
+  const pressureRatio = Number.isFinite(overridePercent)
+    && overridePercent > 0
+    && overridePercent <= 100
+    ? overridePercent / 100
+    : DEFAULT_CONTEXT_PRESSURE_RATIO;
+  return !Number.isFinite(options.contextUsageRatio)
+    || options.contextUsageRatio >= pressureRatio;
+}
+
+module.exports = {
+  DEFAULT_CONTEXT_PRESSURE_RATIO,
+  hasContextPressure,
+};

package/bin/cron-run-output.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+const fs = require('node:fs');
+
+const DEFAULT_MAX_CHARS = 16_384;
+
+function eventStepId(event, activeStepId) {
+  if (typeof event?.uuid === 'string') return event.uuid;
+  if (typeof event?.stepUuid === 'string') return event.stepUuid;
+  return activeStepId;
+}
+
+function readCronFinalMessage(wirePath, stepId, maxChars = DEFAULT_MAX_CHARS) {
+  if (typeof stepId !== 'string' || stepId.length === 0) return null;
+  if (!Number.isSafeInteger(maxChars) || maxChars < 1) throw new TypeError('maxChars must be positive');
+  let text = '';
+  let activeStepId = null;
+  const lines = fs.readFileSync(wirePath, 'utf8').split(/\r?\n/u);
+  for (const line of lines) {
+    if (line.length === 0) continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (record?.type !== 'context.append_loop_event') continue;
+    const event = record.event;
+    if (event?.type === 'step.begin') {
+      activeStepId = event.uuid;
+      continue;
+    }
+    if (event?.type === 'step.end') {
+      if (eventStepId(event, activeStepId) === stepId) activeStepId = null;
+      continue;
+    }
+    if (event?.type !== 'content.part' || eventStepId(event, activeStepId) !== stepId) continue;
+    if (event.part?.type === 'text' && typeof event.part.text === 'string') text += event.part.text;
+  }
+  if (text.length === 0) return null;
+  if (text.length <= maxChars) return {text, truncated: false, chars: text.length};
+  return {text: `${text.slice(0, maxChars)}\n...[truncated]`, truncated: true, chars: text.length};
+}
+
+module.exports = {DEFAULT_MAX_CHARS, readCronFinalMessage};

package/bin/cron-run-store.cjs

@@ -0,0 +1,145 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const {
+  isValidCronRunReceipt,
+  markCronJobDeleted,
+  transitionCronRunReceipt,
+} = require('./scoped-cron-run-policy.cjs');
+
+const RUN_ID_RE = /^[0-9a-f]{16}$/u;
+
+function atomicWriteJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), {recursive: true, mode: 0o700});
+  const tempPath = `${filePath}.tmp.${process.pid}.${crypto.randomBytes(4).toString('hex')}`;
+  fs.writeFileSync(tempPath, `${JSON.stringify(value)}\n`, {encoding: 'utf8', mode: 0o600, flag: 'wx'});
+  fs.renameSync(tempPath, filePath);
+}
+
+function createCronRunStore(sessionDir, options = {}) {
+  const rootDir = path.join(sessionDir, 'cron-runs');
+  const now = options.now || (() => Date.now());
+  const runs = new Map();
+
+  function filePath(runId) {
+    if (!RUN_ID_RE.test(runId)) throw new TypeError('Invalid cron run id');
+    return path.join(rootDir, `${runId}.json`);
+  }
+
+  function persist(receipt) {
+    atomicWriteJson(filePath(receipt.runId), receipt);
+  }
+
+  function create(receipt) {
+    if (!isValidCronRunReceipt(receipt) || receipt.status !== 'buffered') {
+      throw new TypeError('Invalid new cron run receipt');
+    }
+    if (runs.has(receipt.runId)) throw new Error(`Cron run already exists: ${receipt.runId}`);
+    runs.set(receipt.runId, receipt);
+    persist(receipt);
+    return receipt;
+  }
+
+  function replace(receipt) {
+    if (!isValidCronRunReceipt(receipt)) throw new TypeError('Invalid cron run receipt');
+    if (!runs.has(receipt.runId)) throw new Error(`Unknown cron run: ${receipt.runId}`);
+    runs.set(receipt.runId, receipt);
+    persist(receipt);
+    return receipt;
+  }
+
+  function transition(runId, status, details) {
+    const current = runs.get(runId);
+    if (current === undefined) throw new Error(`Unknown cron run: ${runId}`);
+    return replace(transitionCronRunReceipt(current, status, details));
+  }
+
+  function markJobDeletedById(jobId) {
+    const changed = [];
+    for (const receipt of runs.values()) {
+      if (receipt.jobId !== jobId || receipt.jobDeleted === true) continue;
+      changed.push(replace(markCronJobDeleted(receipt)));
+    }
+    return changed;
+  }
+
+  function load() {
+    runs.clear();
+    if (!fs.existsSync(rootDir)) return {loaded: 0, lost: 0, lostRunIds: []};
+    let loaded = 0;
+    let lost = 0;
+    const lostRunIds = [];
+    for (const entry of fs.readdirSync(rootDir, {withFileTypes: true})) {
+      if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
+      const runId = entry.name.slice(0, -5);
+      if (!RUN_ID_RE.test(runId)) continue;
+      try {
+        const receipt = JSON.parse(fs.readFileSync(path.join(rootDir, entry.name), 'utf8'));
+        if (!isValidCronRunReceipt(receipt) || receipt.runId !== runId) continue;
+        let restored = receipt;
+        if (receipt.status === 'buffered' || receipt.status === 'running') {
+          restored = transitionCronRunReceipt(receipt, 'lost', {
+            endedAt: new Date(now()).toISOString(),
+          });
+          persist(restored);
+          lost += 1;
+          lostRunIds.push(runId);
+        }
+        runs.set(runId, restored);
+        loaded += 1;
+      } catch {}
+    }
+    return {loaded, lost, lostRunIds};
+  }
+
+  return Object.freeze({
+    create,
+    get: (runId) => runs.get(runId),
+    list: () => [...runs.values()],
+    load,
+    markJobDeletedById,
+    replace,
+    transition,
+  });
+}
+
+function createMemoryCronRunStore() {
+  const runs = new Map();
+  function replace(receipt) {
+    if (!isValidCronRunReceipt(receipt)) throw new TypeError('Invalid cron run receipt');
+    if (!runs.has(receipt.runId)) throw new Error(`Unknown cron run: ${receipt.runId}`);
+    runs.set(receipt.runId, receipt);
+    return receipt;
+  }
+  return Object.freeze({
+    create(receipt) {
+      if (!isValidCronRunReceipt(receipt) || receipt.status !== 'buffered') {
+        throw new TypeError('Invalid new cron run receipt');
+      }
+      if (runs.has(receipt.runId)) throw new Error(`Cron run already exists: ${receipt.runId}`);
+      runs.set(receipt.runId, receipt);
+      return receipt;
+    },
+    get: (runId) => runs.get(runId),
+    list: () => [...runs.values()],
+    load: () => ({loaded: 0, lost: 0, lostRunIds: []}),
+    markJobDeletedById(jobId) {
+      const changed = [];
+      for (const receipt of runs.values()) {
+        if (receipt.jobId !== jobId || receipt.jobDeleted === true) continue;
+        changed.push(replace(markCronJobDeleted(receipt)));
+      }
+      return changed;
+    },
+    replace,
+    transition(runId, status, details) {
+      const current = runs.get(runId);
+      if (current === undefined) throw new Error(`Unknown cron run: ${runId}`);
+      return replace(transitionCronRunReceipt(current, status, details));
+    },
+  });
+}
+
+module.exports = {createCronRunStore, createMemoryCronRunStore};

package/bin/durable-task-resume-policy.cjs

@@ -0,0 +1,130 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+const INTERRUPTED_TOOL_REMINDER = [
+  "The previous process ended during this agent's work.",
+  'An in-flight tool call may have completed without its result being observed.',
+  'Inspect current state before repeating any side effect.',
+].join(' ');
+
+const TASK_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*-[0-9a-z]{8}$/u;
+const DIGEST_PATTERN = /^[0-9a-f]{64}$/u;
+const FAILURE_CATEGORIES = new Set(['validation', 'conflict', 'launcher', 'persistence', 'unknown']);
+const INTENT_KEYS = new Set([
+  'version',
+  'status',
+  'sourceTaskId',
+  'replacementTaskId',
+  'agentId',
+  'resumeRootTaskId',
+  'requestDigest',
+  'createdAt',
+  'startedAt',
+]);
+
+function contractError(message, category = 'validation') {
+  const error = new Error(message);
+  error.code = 'ERR_DURABLE_TASK_RESUME';
+  error.category = FAILURE_CATEGORIES.has(category) ? category : 'unknown';
+  return error;
+}
+
+function assertTaskId(value, field = 'task ID') {
+  if (typeof value !== 'string' || !TASK_ID_PATTERN.test(value)) {
+    throw contractError(`${field} is invalid`);
+  }
+  return value;
+}
+
+function assertText(value, field, maxBytes) {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw contractError(`${field} is required`);
+  }
+  if (Buffer.byteLength(value, 'utf8') > maxBytes) {
+    throw contractError(`${field} is too large`);
+  }
+  return value;
+}
+
+function requestDigest(prompt, description) {
+  assertText(prompt, 'prompt', 32 * 1024);
+  assertText(description, 'description', 1024);
+  return crypto.createHash('sha256')
+    .update(JSON.stringify({ prompt, description }))
+    .digest('hex');
+}
+
+function isResumedSuccessor(task) {
+  return task.status === 'completed'
+    && task.resumed === true
+    && typeof task.replacesTaskId === 'string'
+    && typeof task.resumeRootTaskId === 'string';
+}
+
+function validateResumeSource(task) {
+  if (!task
+      || task.kind !== 'agent'
+      || typeof task.agentId !== 'string'
+      || task.agentId.length === 0
+      || (task.status !== 'lost' && !isResumedSuccessor(task))) {
+    throw contractError('Task is not a recoverable agent task. Only a lost agent task or a completed TaskResume successor can be resumed.');
+  }
+  assertTaskId(task.taskId);
+  return task;
+}
+
+function createPreparedIntent({ source, replacementTaskId, digest, now }) {
+  validateResumeSource(source);
+  assertTaskId(replacementTaskId, 'replacement task ID');
+  if (replacementTaskId === source.taskId) {
+    throw contractError('Replacement task ID must differ from source task ID', 'conflict');
+  }
+  if (typeof digest !== 'string' || !DIGEST_PATTERN.test(digest)) {
+    throw contractError('request digest is invalid');
+  }
+  if (!Number.isFinite(now)) throw contractError('intent timestamp is invalid');
+  return {
+    version: 1,
+    status: 'prepared',
+    sourceTaskId: source.taskId,
+    replacementTaskId,
+    agentId: source.agentId,
+    resumeRootTaskId: source.resumeRootTaskId || source.taskId,
+    requestDigest: digest,
+    createdAt: now,
+  };
+}
+
+function isResumeIntent(value) {
+  if (!value || typeof value !== 'object') return false;
+  if (Object.keys(value).some((key) => !INTENT_KEYS.has(key))) return false;
+  if (value.version !== 1 || (value.status !== 'prepared' && value.status !== 'started')) return false;
+  if (!TASK_ID_PATTERN.test(value.sourceTaskId) || !TASK_ID_PATTERN.test(value.replacementTaskId)) return false;
+  if (typeof value.agentId !== 'string' || value.agentId.length === 0) return false;
+  if (!TASK_ID_PATTERN.test(value.resumeRootTaskId) || !DIGEST_PATTERN.test(value.requestDigest)) return false;
+  if (!Number.isFinite(value.createdAt)) return false;
+  if (value.status === 'started' && !Number.isFinite(value.startedAt)) return false;
+  return true;
+}
+
+function decorateTaskInfo(task, intent) {
+  if (!task || !intent || intent.sourceTaskId !== task.taskId) return task;
+  return { ...task, replacementTaskId: intent.replacementTaskId };
+}
+
+function failureCategory(error) {
+  return FAILURE_CATEGORIES.has(error && error.category) ? error.category : 'launcher';
+}
+
+module.exports = {
+  INTERRUPTED_TOOL_REMINDER,
+  TASK_ID_PATTERN,
+  contractError,
+  createPreparedIntent,
+  decorateTaskInfo,
+  failureCategory,
+  isResumeIntent,
+  requestDigest,
+  validateResumeSource,
+};

package/bin/durable-task-resume-runtime.cjs

@@ -0,0 +1,117 @@
+'use strict';
+
+const {
+  INTERRUPTED_TOOL_REMINDER,
+  contractError,
+  createPreparedIntent,
+  failureCategory,
+  requestDigest,
+  validateResumeSource,
+} = require('./durable-task-resume-policy.cjs');
+
+class DurableTaskResumeRuntime {
+  constructor(adapters) {
+    this.adapters = adapters;
+    this.inFlightSources = new Set();
+  }
+
+  async resolveIntent(source, digest, now) {
+    const existing = this.adapters.getIntent(source.taskId);
+    if (existing) {
+      const successor = this.adapters.getTask(existing.replacementTaskId);
+      if (successor || existing.status === 'started') {
+        throw contractError(`Task ${source.taskId} already has successor ${existing.replacementTaskId}`, 'conflict');
+      }
+      if (existing.requestDigest !== digest) {
+        throw contractError('Resume request differs from prepared intent', 'conflict');
+      }
+      return existing;
+    }
+    const replacementTaskId = this.adapters.reserveTaskId('agent');
+    const intent = createPreparedIntent({ source, replacementTaskId, digest, now });
+    await this.adapters.writeIntent(intent);
+    this.adapters.emitEvent({
+      type: 'background.task.resume_requested',
+      sourceTaskId: intent.sourceTaskId,
+      replacementTaskId: intent.replacementTaskId,
+      agentId: intent.agentId,
+    });
+    return intent;
+  }
+
+  async resume(input) {
+    const runSignal = input.controller ? input.controller.signal : input.signal;
+    runSignal.throwIfAborted();
+    if (this.inFlightSources.has(input.taskId)) {
+      throw contractError(`Task ${input.taskId} already has a resume request in flight`, 'conflict');
+    }
+    this.inFlightSources.add(input.taskId);
+    try {
+      const source = validateResumeSource(this.adapters.getTask(input.taskId));
+      const digest = requestDigest(input.prompt, input.description);
+      const now = this.adapters.now();
+      let intent;
+      try {
+        intent = await this.resolveIntent(source, digest, now);
+        runSignal.throwIfAborted();
+        const handle = await this.adapters.resumeAgent(intent.agentId, {
+          parentToolCallId: input.parentToolCallId,
+          prompt: input.prompt,
+          description: input.description,
+          runInBackground: true,
+          responseFormat: undefined,
+          toolScope: input.toolScope,
+          signal: runSignal,
+          systemReminder: INTERRUPTED_TOOL_REMINDER,
+        });
+        if (!handle || handle.agentId !== intent.agentId) {
+          throw contractError('Resume launcher changed the preserved agent identity', 'launcher');
+        }
+        const metadata = {
+          timeoutMinutes: input.timeoutMinutes,
+          parentToolCallId: input.parentToolCallId,
+          controller: input.controller,
+          replacesTaskId: intent.sourceTaskId,
+          resumeRootTaskId: intent.resumeRootTaskId,
+        };
+        const task = this.adapters.createTask(handle, input.description, metadata);
+        const registeredTaskId = this.adapters.registerTask(task, {
+          detached: true,
+          taskId: intent.replacementTaskId,
+        });
+        if (registeredTaskId !== intent.replacementTaskId) {
+          throw contractError('Background manager did not honor the reserved replacement task ID', 'launcher');
+        }
+        await this.adapters.awaitTaskPersisted(registeredTaskId);
+        await this.adapters.markIntentStarted(intent.sourceTaskId, now);
+        this.adapters.emitEvent({
+          type: 'background.task.resumed',
+          sourceTaskId: intent.sourceTaskId,
+          replacementTaskId: intent.replacementTaskId,
+          agentId: intent.agentId,
+        });
+        return {
+          taskId: registeredTaskId,
+          agentId: intent.agentId,
+          replacesTaskId: intent.sourceTaskId,
+          resumeRootTaskId: intent.resumeRootTaskId,
+          status: 'running',
+        };
+      } catch (error) {
+        if (intent) {
+          this.adapters.emitEvent({
+            type: 'background.task.resume_failed',
+            sourceTaskId: intent.sourceTaskId,
+            replacementTaskId: intent.replacementTaskId,
+            category: failureCategory(error),
+          });
+        }
+        throw error;
+      }
+    } finally {
+      this.inFlightSources.delete(input.taskId);
+    }
+  }
+}
+
+module.exports = { DurableTaskResumeRuntime };