blun-king-cli 9.1.536 → 9.1.550

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

@@ -4,6 +4,7 @@ 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;
@@ -50,7 +51,8 @@ function shouldOffloadHistoricalAssistantMessage(options = {}) {
     || historyIndex >= historyLength
   ) return false;
   const cutoff = Math.max(0, historyLength - ASSISTANT_MESSAGE_KEEP_RECENT_MESSAGES);
-  return hasHistoricalOffloadPressure({ historyLength, historyChars })
+  return hasContextPressure(options)
+    && hasHistoricalOffloadPressure({ historyLength, historyChars })
     && historyIndex < cutoff
     && textChars > ASSISTANT_MESSAGE_MAX_CHARS;
 }

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 };

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

@@ -0,0 +1,88 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const {
+  TASK_ID_PATTERN,
+  contractError,
+  isResumeIntent,
+} = require('./durable-task-resume-policy.cjs');
+
+class DurableTaskResumeStore {
+  constructor(sessionDir) {
+    if (typeof sessionDir !== 'string' || sessionDir.length === 0) {
+      throw contractError('session directory is required', 'persistence');
+    }
+    this.directory = path.join(sessionDir, 'task-resume-intents');
+    this.intents = new Map();
+  }
+
+  fileFor(sourceTaskId) {
+    if (!TASK_ID_PATTERN.test(sourceTaskId)) throw contractError('source task ID is invalid');
+    return path.join(this.directory, `${sourceTaskId}.json`);
+  }
+
+  async load() {
+    this.intents.clear();
+    let names;
+    try {
+      names = await fs.readdir(this.directory);
+    } catch (error) {
+      if (error && error.code === 'ENOENT') return;
+      throw error;
+    }
+    for (const name of names) {
+      if (!name.endsWith('.json')) continue;
+      const sourceTaskId = name.slice(0, -5);
+      if (!TASK_ID_PATTERN.test(sourceTaskId)) continue;
+      try {
+        const intent = JSON.parse(await fs.readFile(this.fileFor(sourceTaskId), 'utf8'));
+        if (isResumeIntent(intent) && intent.sourceTaskId === sourceTaskId) {
+          this.intents.set(sourceTaskId, intent);
+        }
+      } catch {}
+    }
+  }
+
+  getBySourceTaskId(sourceTaskId) {
+    const intent = this.intents.get(sourceTaskId);
+    return intent === undefined ? undefined : { ...intent };
+  }
+
+  list() {
+    return [...this.intents.values()].map((intent) => ({ ...intent }));
+  }
+
+  startupRecoveryPlan() {
+    return [];
+  }
+
+  async write(intent) {
+    if (!isResumeIntent(intent)) throw contractError('resume intent is invalid', 'persistence');
+    await fs.mkdir(this.directory, { recursive: true, mode: 0o700 });
+    const target = this.fileFor(intent.sourceTaskId);
+    const temporary = `${target}.tmp-${process.pid}-${Date.now().toString(36)}`;
+    try {
+      const handle = await fs.open(temporary, 'wx', 0o600);
+      try {
+        await handle.writeFile(JSON.stringify(intent, null, 2), 'utf8');
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await fs.rename(temporary, target);
+    } catch (error) {
+      await fs.rm(temporary, { force: true }).catch(() => {});
+      throw error;
+    }
+    this.intents.set(intent.sourceTaskId, { ...intent });
+  }
+
+  async markStarted(sourceTaskId, startedAt) {
+    const intent = this.intents.get(sourceTaskId);
+    if (!intent) throw contractError('prepared resume intent not found', 'persistence');
+    await this.write({ ...intent, status: 'started', startedAt });
+  }
+}
+
+module.exports = { DurableTaskResumeStore };