blun-king-cli 9.1.587 → 9.1.588

package/bin/retry-checkpoint-policy.cjs

@@ -1,13 +0,0 @@
-'use strict';
-
-async function persistRetrySchedule(input = {}) {
-  const { dispatchRetrying, flush, event, signal } = input;
-  if (typeof dispatchRetrying !== 'function') throw new TypeError('persistRetrySchedule requires dispatchRetrying');
-  if (typeof flush !== 'function') throw new TypeError('persistRetrySchedule requires flush');
-  signal?.throwIfAborted?.();
-  await dispatchRetrying(event);
-  await flush();
-  signal?.throwIfAborted?.();
-}
-
-module.exports = { persistRetrySchedule };

package/bin/runtime-exit-ledger.cjs

@@ -1,144 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const DEFAULT_MAX_BYTES = 1024 * 1024;
-const DEFAULT_RETAIN_BYTES = 512 * 1024;
-const MAX_MESSAGE_CHARS = 2048;
-const MAX_STACK_CHARS = 8192;
-const MAX_DETAIL_CHARS = 2048;
-
-function runtimeExitLedgerPath(homeDir) {
-  return path.join(homeDir, 'diagnostics', 'runtime-exits.jsonl');
-}
-
-function replaceAllLiteral(value, needle, replacement) {
-  if (!needle) return value;
-  const lowerValue = process.platform === 'win32' ? value.toLowerCase() : value;
-  const lowerNeedle = process.platform === 'win32' ? needle.toLowerCase() : needle;
-  let result = '';
-  let cursor = 0;
-  for (;;) {
-    const index = lowerValue.indexOf(lowerNeedle, cursor);
-    if (index === -1) return `${result}${value.slice(cursor)}`;
-    result += `${value.slice(cursor, index)}${replacement}`;
-    cursor = index + needle.length;
-  }
-}
-
-function sanitizeExitText(input, maxChars = MAX_DETAIL_CHARS) {
-  let value = String(input ?? '');
-  const homes = new Set([
-    os.homedir(),
-    process.env.USERPROFILE,
-    process.env.HOME,
-  ].filter((entry) => typeof entry === 'string' && entry.length > 2));
-  for (const home of homes) {
-    value = replaceAllLiteral(value, path.normalize(home), '$HOME');
-    value = replaceAllLiteral(value, home.replaceAll('\\', '/'), '$HOME');
-  }
-  value = value
-    .replace(/[A-Za-z]:\\Users\\[^\\\s"']+/giu, '$HOME')
-    .replace(/\/home\/[^/\s"']+/gu, '$HOME')
-    .replace(/(Authorization\s*:\s*Bearer\s+)[^\s,;]+/giu, '$1<redacted>')
-    .replace(/\bsk-[A-Za-z0-9_-]{10,}\b/gu, '<redacted>')
-    .replace(/\b\d{6,}:[A-Za-z0-9_-]{20,}\b/gu, '<redacted>')
-    .replace(/((?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|secret|password)\s*[=:]\s*)[^\s,;}]+/giu, '$1<redacted>')
-    .replace(/(https?:\/\/[^\s/:@]+:)[^\s/@]+@/giu, '$1<redacted>@');
-  return value.length <= maxChars ? value : `${value.slice(0, maxChars)}...[truncated]`;
-}
-
-function normalizedError(error) {
-  if (error === undefined || error === null) return undefined;
-  if (error instanceof Error) {
-    return {
-      name: sanitizeExitText(error.name || error.constructor?.name || 'Error', 160),
-      message: sanitizeExitText(error.message || String(error), MAX_MESSAGE_CHARS),
-      stack: sanitizeExitText(error.stack || '', MAX_STACK_CHARS),
-    };
-  }
-  return {
-    name: typeof error === 'object' && typeof error.name === 'string'
-      ? sanitizeExitText(error.name, 160)
-      : 'NonErrorRejection',
-    message: sanitizeExitText(error, MAX_MESSAGE_CHARS),
-  };
-}
-
-function finiteInteger(value) {
-  return Number.isInteger(value) ? value : undefined;
-}
-
-function buildRuntimeExitRecord(input) {
-  const now = typeof input.now === 'function' ? input.now() : new Date();
-  const record = {
-    schemaVersion: 1,
-    ts: (now instanceof Date ? now : new Date(now)).toISOString(),
-    source: sanitizeExitText(input.source || 'unknown', 80),
-    kind: sanitizeExitText(input.kind || 'unknown', 120),
-    exitCode: finiteInteger(input.exitCode),
-    signal: input.signal ? sanitizeExitText(input.signal, 40) : undefined,
-    phase: input.phase ? sanitizeExitText(input.phase, 80) : undefined,
-    cliVersion: input.cliVersion ? sanitizeExitText(input.cliVersion, 80) : undefined,
-    profile: input.profile ? sanitizeExitText(input.profile, 120) : undefined,
-    sessionId: input.sessionId ? sanitizeExitText(input.sessionId, 240) : undefined,
-    lastTool: input.lastTool ? sanitizeExitText(input.lastTool, 240) : undefined,
-    pid: finiteInteger(input.pid ?? process.pid),
-    ppid: finiteInteger(input.ppid ?? process.ppid),
-    childPid: finiteInteger(input.childPid),
-    loaded: typeof input.loaded === 'boolean' ? input.loaded : undefined,
-    detail: input.detail ? sanitizeExitText(input.detail, MAX_DETAIL_CHARS) : undefined,
-    error: normalizedError(input.error),
-  };
-  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && value !== ''));
-}
-
-function trimLedger(filePath, maxBytes, retainBytes, incomingBytes) {
-  let size;
-  try {
-    size = fs.statSync(filePath).size;
-  } catch {
-    return;
-  }
-  if (size + incomingBytes <= maxBytes) return;
-  const contents = fs.readFileSync(filePath);
-  const keepFrom = Math.max(0, contents.length - Math.min(retainBytes, maxBytes - incomingBytes));
-  let lineStart = keepFrom;
-  if (lineStart > 0) {
-    const nextNewline = contents.indexOf(0x0a, lineStart);
-    lineStart = nextNewline === -1 ? contents.length : nextNewline + 1;
-  }
-  fs.writeFileSync(filePath, contents.subarray(lineStart), { mode: 0o600 });
-}
-
-function recordRuntimeExit(input = {}) {
-  try {
-    const homeDir = typeof input.homeDir === 'string' ? input.homeDir.trim() : '';
-    if (!homeDir) return false;
-    const filePath = runtimeExitLedgerPath(homeDir);
-    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
-    const line = `${JSON.stringify(buildRuntimeExitRecord(input))}\n`;
-    const incomingBytes = Buffer.byteLength(line);
-    const maxBytes = Math.max(1024, finiteInteger(input.maxBytes) ?? DEFAULT_MAX_BYTES);
-    const retainBytes = Math.max(0, finiteInteger(input.retainBytes) ?? DEFAULT_RETAIN_BYTES);
-    trimLedger(filePath, maxBytes, retainBytes, incomingBytes);
-    fs.appendFileSync(filePath, line, { encoding: 'utf8', mode: 0o600 });
-    try {
-      fs.chmodSync(filePath, 0o600);
-    } catch {}
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-module.exports = {
-  DEFAULT_MAX_BYTES,
-  DEFAULT_RETAIN_BYTES,
-  buildRuntimeExitRecord,
-  recordRuntimeExit,
-  runtimeExitLedgerPath,
-  sanitizeExitText,
-};

package/bin/scoped-cron-run-policy.cjs

@@ -1,358 +0,0 @@
-'use strict';
-
-const crypto = require('node:crypto');
-const path = require('node:path');
-
-const MAX_ALLOWED_TOOLS = 64;
-const MAX_TOOL_NAME_BYTES = 160;
-const MAX_RECEIPT_TOOL_NAMES = 64;
-const MAX_RECEIPT_OUTPUTS = 32;
-const MAX_LIST_LIMIT = 100;
-const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled', 'lost']);
-const ALL_STATUSES = new Set(['buffered', 'running', ...TERMINAL_STATUSES]);
-const TRANSITIONS = new Map([
-  ['buffered', new Set(['running', 'failed', 'cancelled', 'lost'])],
-  ['running', new Set(['completed', 'failed', 'cancelled', 'lost'])],
-]);
-const ERROR_CATEGORIES = new Set(['executor', 'provider', 'policy', 'unknown']);
-
-class ScopedCronRunError extends TypeError {
-  constructor(code, message) {
-    super(message);
-    this.name = 'ScopedCronRunError';
-    this.code = code;
-  }
-}
-
-function fail(code, message) {
-  throw new ScopedCronRunError(code, message);
-}
-
-function clone(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-
-function deepFreeze(value) {
-  if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
-  for (const child of Object.values(value)) deepFreeze(child);
-  return Object.freeze(value);
-}
-
-function assertOpaqueId(value, field) {
-  if (typeof value !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value)) {
-    fail('CRON_RUN_INVALID_ID', `${field} must be a bounded opaque identifier`);
-  }
-  return value;
-}
-
-function canonicalToolName(value, field) {
-  if (
-    typeof value !== 'string'
-    || value.length === 0
-    || Buffer.byteLength(value, 'utf8') > MAX_TOOL_NAME_BYTES
-    || /[*?[\]{}]/u.test(value)
-    || !/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/u.test(value)
-  ) {
-    fail('CRON_SCOPE_INVALID_TOOL', `${field} must be an exact canonical tool name`);
-  }
-  return value;
-}
-
-function canonicalToolNames(tools, field = 'tools') {
-  if (!Array.isArray(tools)) fail('CRON_SCOPE_INVALID_CATALOG', `${field} must be an array`);
-  const names = tools.map((entry) => canonicalToolName(
-    typeof entry === 'string' ? entry : entry && entry.name,
-    field,
-  ));
-  return [...new Set(names)];
-}
-
-function cronToolScopeDigest(names) {
-  return `sha256:${crypto.createHash('sha256').update(JSON.stringify(names)).digest('hex')}`;
-}
-
-function normalizeCronAllowedTools(input, effectiveTools) {
-  if (input === undefined) return Object.freeze({mode: 'legacy', names: null, digest: null});
-  if (!Array.isArray(input)) fail('CRON_SCOPE_NOT_ARRAY', 'allowed_tools must be an array');
-  if (input.length > MAX_ALLOWED_TOOLS) {
-    fail('CRON_SCOPE_TOO_MANY_TOOLS', `allowed_tools supports at most ${MAX_ALLOWED_TOOLS} entries`);
-  }
-  const catalog = new Set(canonicalToolNames(effectiveTools, 'effective tools'));
-  const names = [];
-  const seen = new Set();
-  for (const rawName of input) {
-    const name = canonicalToolName(rawName, 'allowed_tools entry');
-    if (!catalog.has(name)) fail('CRON_SCOPE_UNKNOWN_TOOL', `Unknown current tool: ${name}`);
-    if (seen.has(name)) continue;
-    seen.add(name);
-    names.push(name);
-  }
-  return deepFreeze({mode: 'scoped', names, digest: cronToolScopeDigest(names)});
-}
-
-function cronToolScopeForTask(task) {
-  if (!task || task.allowedTools === undefined) {
-    return Object.freeze({mode: 'legacy', names: null, digest: null});
-  }
-  if (!Array.isArray(task.allowedTools)) fail('CRON_SCOPE_INVALID_TASK', 'Persisted allowedTools must be an array');
-  const names = canonicalToolNames(task.allowedTools, 'persisted allowedTools');
-  const digest = cronToolScopeDigest(names);
-  if (task.toolScopeDigest !== digest) fail('CRON_SCOPE_DIGEST_MISMATCH', 'Persisted tool scope digest does not match');
-  return deepFreeze({mode: 'scoped', names, digest});
-}
-
-function isCronToolScope(value) {
-  if (!value || value.mode !== 'scoped' || !Array.isArray(value.names)) return false;
-  try {
-    const names = canonicalToolNames(value.names, 'tool scope');
-    return names.length === value.names.length && value.digest === cronToolScopeDigest(names);
-  } catch {
-    return false;
-  }
-}
-
-function filterToolsForCronScope(tools, scope) {
-  if (!Array.isArray(tools)) fail('CRON_SCOPE_INVALID_CATALOG', 'tools must be an array');
-  if (!scope || scope.mode === 'legacy') return tools;
-  if (!isCronToolScope(scope)) fail('CRON_SCOPE_INVALID_ORIGIN', 'Invalid cron tool scope');
-  const allowed = new Set(scope.names);
-  return tools.filter((tool) => tool && allowed.has(tool.name));
-}
-
-function inheritedCronToolScope(parentScope) {
-  if (!parentScope || parentScope.mode === 'legacy') return undefined;
-  if (!isCronToolScope(parentScope)) fail('CRON_SCOPE_INVALID_ORIGIN', 'Invalid inherited cron tool scope');
-  return deepFreeze({mode: 'scoped', names: [...parentScope.names], digest: parentScope.digest});
-}
-
-function isoTimestamp(value, field) {
-  if (typeof value !== 'string' || !Number.isFinite(Date.parse(value))) {
-    fail('CRON_RUN_INVALID_TIME', `${field} must be an ISO timestamp`);
-  }
-  return value;
-}
-
-function createCronRunReceipt(input) {
-  const digest = input.toolScopeDigest;
-  if (digest !== null && (typeof digest !== 'string' || !/^sha256:[a-f0-9]{64}$/u.test(digest))) {
-    fail('CRON_RUN_INVALID_DIGEST', 'toolScopeDigest is invalid');
-  }
-  if (!Number.isSafeInteger(input.coalescedCount) || input.coalescedCount < 1) {
-    fail('CRON_RUN_INVALID_COALESCE', 'coalescedCount must be a positive integer');
-  }
-  return deepFreeze({
-    runId: assertOpaqueId(input.runId, 'runId'),
-    jobId: assertOpaqueId(input.jobId, 'jobId'),
-    jobDeleted: false,
-    cron: String(input.cron),
-    recurring: input.recurring === true,
-    stale: input.stale === true,
-    coalescedCount: input.coalescedCount,
-    toolScopeDigest: digest,
-    status: 'buffered',
-    firedAt: isoTimestamp(input.firedAt, 'firedAt'),
-    startedAt: null,
-    endedAt: null,
-    turnId: null,
-    toolSummary: {calls: 0, errors: 0, names: [], excessNames: 0},
-    outputs: [],
-    finalMessageRef: null,
-  });
-}
-
-function summarizeCronToolCalls(toolCalls) {
-  if (!Array.isArray(toolCalls)) fail('CRON_RUN_INVALID_TOOLS', 'toolCalls must be an array');
-  const names = new Set();
-  let errors = 0;
-  for (const call of toolCalls) {
-    canonicalToolName(call && call.name, 'tool call name');
-    names.add(call.name);
-    if (call.isError === true) errors += 1;
-  }
-  const sorted = [...names].sort((left, right) => left.localeCompare(right));
-  return deepFreeze({
-    calls: toolCalls.length,
-    errors,
-    names: sorted.slice(0, MAX_RECEIPT_TOOL_NAMES),
-    excessNames: Math.max(0, sorted.length - MAX_RECEIPT_TOOL_NAMES),
-  });
-}
-
-function normalizeRelativeFilePath(value) {
-  if (typeof value !== 'string' || value.length === 0 || value.includes('\0')) return null;
-  const normalized = value.replaceAll('\\', '/');
-  if (normalized.startsWith('/') || /^[A-Za-z]:\//u.test(normalized) || normalized.startsWith('//')) return null;
-  const posix = path.posix.normalize(normalized);
-  if (posix === '.' || posix === '..' || posix.startsWith('../')) return null;
-  return posix;
-}
-
-function rootRelativeFile(absolutePath, root, rootRef, pathApi) {
-  const relative = pathApi.relative(pathApi.resolve(root), pathApi.resolve(absolutePath));
-  if (relative === '' || relative === '..' || relative.startsWith(`..${pathApi.sep}`) || pathApi.isAbsolute(relative)) return null;
-  const relativePath = normalizeRelativeFilePath(relative);
-  return relativePath === null ? null : {rootRef, relativePath};
-}
-
-function buildCronFileCandidate({toolName, toolCallId, display, workspaceRoot, additionalRoots = [], pathExists}) {
-  if (!['Write', 'Edit'].includes(toolName)) return null;
-  if (!display || display.kind !== 'file_io' || typeof display.path !== 'string') return null;
-  assertOpaqueId(toolCallId, 'toolCallId');
-  const pathApi = process.platform === 'win32' || /^[A-Za-z]:[\\/]/u.test(display.path) ? path.win32 : path;
-  let located = rootRelativeFile(display.path, workspaceRoot, 'root:workspace', pathApi);
-  if (located === null) {
-    for (let index = 0; index < additionalRoots.length; index += 1) {
-      located = rootRelativeFile(display.path, additionalRoots[index], `root:additional:${String(index + 1)}`, pathApi);
-      if (located !== null) break;
-    }
-  }
-  if (located === null) return null;
-  return deepFreeze({
-    ...located,
-    change: toolName === 'Edit' || pathExists === true ? 'modified' : 'created',
-    toolCallId,
-    kind: 'file',
-  });
-}
-
-function normalizeCronOutputs(outputs) {
-  if (!Array.isArray(outputs)) fail('CRON_RUN_INVALID_OUTPUTS', 'outputs must be an array');
-  const safe = [];
-  for (const output of outputs) {
-    if (safe.length >= MAX_RECEIPT_OUTPUTS) break;
-    if (!output || output.kind !== 'file') continue;
-    if (!/^root:(workspace|additional:[1-9][0-9]*)$/u.test(output.rootRef)) continue;
-    const relativePath = normalizeRelativeFilePath(output.relativePath);
-    if (relativePath === null || !['created', 'modified'].includes(output.change)) continue;
-    safe.push({
-      rootRef: output.rootRef,
-      relativePath,
-      change: output.change,
-      toolCallId: assertOpaqueId(output.toolCallId, 'toolCallId'),
-      kind: 'file',
-    });
-  }
-  return deepFreeze(safe);
-}
-
-function safeCronRunError(status, error) {
-  if (status !== 'failed') return undefined;
-  const category = error && ERROR_CATEGORIES.has(error.category) ? error.category : 'unknown';
-  const rawCode = error && typeof error.code === 'string' ? error.code : 'unspecified';
-  const code = /^[A-Za-z0-9._-]{1,64}$/u.test(rawCode) ? rawCode : 'redacted';
-  return {category, code};
-}
-
-function transitionCronRunReceipt(receipt, status, details = {}) {
-  const allowed = receipt && TRANSITIONS.get(receipt.status);
-  if (!allowed || !allowed.has(status)) {
-    fail('CRON_RUN_INVALID_TRANSITION', `Invalid cron run transition: ${String(receipt && receipt.status)} -> ${status}`);
-  }
-  if (status === 'running') {
-    if (!Number.isSafeInteger(details.turnId) || details.turnId < 0) {
-      fail('CRON_RUN_INVALID_TURN', 'turnId must be a non-negative integer');
-    }
-    return deepFreeze({
-      ...clone(receipt),
-      status,
-      startedAt: isoTimestamp(details.startedAt, 'startedAt'),
-      turnId: details.turnId,
-    });
-  }
-  const terminal = {
-    ...clone(receipt),
-    status,
-    endedAt: isoTimestamp(details.endedAt, 'endedAt'),
-    toolSummary: summarizeCronToolCalls(details.toolCalls || []),
-    outputs: normalizeCronOutputs(details.outputs || []),
-    finalMessageRef: typeof details.finalStepId === 'string' && details.finalStepId.length > 0
-      ? {stepId: assertOpaqueId(details.finalStepId, 'finalStepId')}
-      : null,
-  };
-  const error = safeCronRunError(status, details.error);
-  if (error !== undefined) terminal.error = error;
-  return deepFreeze(terminal);
-}
-
-function markCronJobDeleted(receipt) {
-  return deepFreeze({...clone(receipt), jobDeleted: true});
-}
-
-function isValidCronRunReceipt(value) {
-  if (!value || typeof value !== 'object') return false;
-  try {
-    assertOpaqueId(value.runId, 'runId');
-    assertOpaqueId(value.jobId, 'jobId');
-    isoTimestamp(value.firedAt, 'firedAt');
-    if (!ALL_STATUSES.has(value.status)) return false;
-    if (!Array.isArray(value.outputs) || !value.toolSummary || typeof value.toolSummary.calls !== 'number') return false;
-    if (value.status === 'running' && (!Number.isSafeInteger(value.turnId) || value.startedAt === null)) return false;
-    if (TERMINAL_STATUSES.has(value.status) && value.endedAt === null) return false;
-    return assertCronRunReceiptPrivacy(value);
-  } catch {
-    return false;
-  }
-}
-
-function publicCronRunList(receipts, {jobId, status, limit = 20} = {}) {
-  if (!Array.isArray(receipts)) fail('CRON_RUN_INVALID_LIST', 'receipts must be an array');
-  if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_LIST_LIMIT) {
-    fail('CRON_RUN_INVALID_LIMIT', `limit must be between 1 and ${MAX_LIST_LIMIT}`);
-  }
-  if (status !== undefined && !ALL_STATUSES.has(status)) fail('CRON_RUN_INVALID_STATUS', 'Unknown cron run status');
-  return receipts
-    .filter((receipt) => jobId === undefined || receipt.jobId === jobId)
-    .filter((receipt) => status === undefined || receipt.status === status)
-    .sort((left, right) => Date.parse(right.firedAt) - Date.parse(left.firedAt))
-    .slice(0, limit)
-    .map((receipt) => ({
-      runId: receipt.runId,
-      jobId: receipt.jobId,
-      status: receipt.status,
-      firedAt: receipt.firedAt,
-      startedAt: receipt.startedAt,
-      endedAt: receipt.endedAt,
-      coalescedCount: receipt.coalescedCount,
-      toolCalls: receipt.toolSummary.calls,
-      toolErrors: receipt.toolSummary.errors,
-      outputCount: receipt.outputs.length,
-      finalMessageAvailable: receipt.finalMessageRef !== null,
-    }));
-}
-
-function assertCronRunReceiptPrivacy(receipt, canaries = []) {
-  const serialized = JSON.stringify(receipt);
-  const forbidden = ['thoughts', 'reasoning', 'prompt', 'arguments', 'results', 'headers', 'approvalFeedback', 'rawError'];
-  for (const key of forbidden) {
-    if (new RegExp(`"${key}"\\s*:`, 'u').test(serialized)) {
-      fail('CRON_RUN_PRIVATE_FIELD', `Forbidden cron receipt field: ${key}`);
-    }
-  }
-  for (const canary of canaries) {
-    if (typeof canary === 'string' && canary.length > 0 && serialized.includes(canary)) {
-      fail('CRON_RUN_SECRET_LEAK', 'Cron receipt contains a secret canary');
-    }
-  }
-  return true;
-}
-
-module.exports = {
-  MAX_ALLOWED_TOOLS,
-  MAX_LIST_LIMIT,
-  MAX_RECEIPT_OUTPUTS,
-  ScopedCronRunError,
-  assertCronRunReceiptPrivacy,
-  buildCronFileCandidate,
-  createCronRunReceipt,
-  cronToolScopeDigest,
-  cronToolScopeForTask,
-  filterToolsForCronScope,
-  inheritedCronToolScope,
-  isCronToolScope,
-  isValidCronRunReceipt,
-  markCronJobDeleted,
-  normalizeCronAllowedTools,
-  publicCronRunList,
-  summarizeCronToolCalls,
-  transitionCronRunReceipt,
-};

package/bin/session-checkpoint-policy.cjs

@@ -1,25 +0,0 @@
-'use strict';
-
-const TOOL_ABORTED_BEFORE_DISPATCH = 'TOOL_ABORTED_BEFORE_DISPATCH';
-
-async function checkpointBeforeExternalSideEffect(options = {}) {
-  const flush = options.flush;
-  const signal = options.signal;
-  if (typeof flush !== 'function') {
-    throw new TypeError('checkpointBeforeExternalSideEffect requires flush');
-  }
-  await flush();
-  if (signal?.aborted === true) {
-    return {
-      allowed: false,
-      code: TOOL_ABORTED_BEFORE_DISPATCH,
-      error: 'Tool call aborted before dispatch while its durable checkpoint was being written.',
-    };
-  }
-  return { allowed: true };
-}
-
-module.exports = {
-  TOOL_ABORTED_BEFORE_DISPATCH,
-  checkpointBeforeExternalSideEffect,
-};

package/bin/session-compaction-policy.cjs

@@ -1,84 +0,0 @@
-'use strict';
-
-const MAX_SESSION_COMPACTION_FAILURES = 2;
-const CRON_COALESCE_WARNING_THRESHOLD = 3;
-const COMPACTION_RECOVERY_PROMPT_TIMEOUT_MS = 30_000;
-const DEFERRED_ACTIVE_SLASH_COMMANDS = new Set(['/clear', '/reload']);
-
-function boundedCount(value) {
-  return Number.isSafeInteger(value) ? Math.max(0, value) : 0;
-}
-
-function slashCommandDeliveryMode(text, activeTurn = false) {
-  if (typeof text !== 'string') return 'normal';
-  const trimmed = text.trimStart();
-  if (!trimmed.startsWith('/')) return 'normal';
-  const command = trimmed.split(/\s+/u, 1)[0].toLowerCase();
-  return activeTurn && DEFERRED_ACTIVE_SLASH_COMMANDS.has(command) ? 'deferred' : 'immediate';
-}
-
-function compactionFailureReason(error) {
-  const value = error && typeof error === 'object' ? error : {};
-  const details = value.details && typeof value.details === 'object' ? value.details : {};
-  const declared = String(details.reason ?? '');
-  const code = String(value.code ?? '');
-  const message = error instanceof Error ? error.message : String(error ?? '');
-  if (code === 'compaction.stalled' || declared === 'no_provider_data') return 'provider_stall';
-  if (declared === 'no_reduction' || /did not reduce/u.test(message)) return 'no_reduction';
-  if (details.statusCode === 402 || details.action === 'switch_model_and_retry') return 'provider_rejected';
-  return 'other';
-}
-
-function recordCompactionFailure(previousCount, error) {
-  const failures = boundedCount(previousCount) + 1;
-  const stopped = failures >= MAX_SESSION_COMPACTION_FAILURES;
-  const cause = error instanceof Error ? error.message : String(error || 'unknown failure');
-  return {
-    failures,
-    stopped,
-    reason: compactionFailureReason(error),
-    cause,
-    action: stopped ? 'Start a fresh session after saving any pending work.' : 'Retry compaction once.',
-  };
-}
-
-function resetCompactionFailures() {
-  return { failures: 0, stopped: false, reason: null, cause: null, action: null };
-}
-
-function pendingHistoryLimit(pendingTokens, maxContextTokens) {
-  const pending = Number.isFinite(pendingTokens) ? Math.max(0, Math.floor(pendingTokens)) : 0;
-  const maximum = Number.isFinite(maxContextTokens) ? Math.max(0, Math.floor(maxContextTokens)) : 0;
-  return {
-    pendingTokens: pending,
-    maxContextTokens: maximum,
-    exceeded: maximum > 0 && pending >= maximum,
-  };
-}
-
-function cronCompactionDecision(input = {}) {
-  const coalescedCount = Math.max(1, boundedCount(input.coalescedCount));
-  const history = pendingHistoryLimit(input.pendingTokens, input.maxContextTokens);
-  const stopped = input.sessionStopped === true || history.exceeded;
-  const warning = coalescedCount > CRON_COALESCE_WARNING_THRESHOLD
-    ? `Cron warning: ${coalescedCount} scheduled runs were coalesced. Check the session before continuing.`
-    : null;
-  const reason = input.sessionStopped === true
-    ? 'Cron stopped because compaction failed twice in this session. Start a fresh session after saving pending work.'
-    : history.exceeded
-      ? `Cron stopped because pending history reached the ${history.maxContextTokens} token context limit. Start a fresh session after saving pending work.`
-      : null;
-  return { allow: !stopped, stopped, warning, reason, history, coalescedCount };
-}
-
-module.exports = {
-  COMPACTION_RECOVERY_PROMPT_TIMEOUT_MS,
-  CRON_COALESCE_WARNING_THRESHOLD,
-  MAX_SESSION_COMPACTION_FAILURES,
-  compactionFailureReason,
-  cronCompactionDecision,
-  pendingHistoryLimit,
-  recordCompactionFailure,
-  resetCompactionFailures,
-  slashCommandDeliveryMode,
-};

package/bin/session-replay-policy.cjs

@@ -1,20 +0,0 @@
-'use strict';
-
-const SESSION_REPLAY_BATCH_RECORDS = 30;
-
-function shouldYieldSessionReplay(renderedRecords, totalRecords) {
-  if (!Number.isSafeInteger(renderedRecords) || renderedRecords < 1) return false;
-  if (!Number.isSafeInteger(totalRecords) || totalRecords < 1) return false;
-  return renderedRecords < totalRecords
-    && renderedRecords % SESSION_REPLAY_BATCH_RECORDS === 0;
-}
-
-function yieldSessionReplayControl(schedule = setImmediate) {
-  return new Promise((resolve) => schedule(resolve));
-}
-
-module.exports = {
-  SESSION_REPLAY_BATCH_RECORDS,
-  shouldYieldSessionReplay,
-  yieldSessionReplayControl,
-};

package/bin/session-replay-window-policy.cjs

@@ -1,40 +0,0 @@
-'use strict';
-
-function replayWindowStartIndex(records, activeTurnCount, startsTurn) {
-  if (
-    !Array.isArray(records)
-    || !Number.isSafeInteger(activeTurnCount)
-    || activeTurnCount <= 0
-    || typeof startsTurn !== 'function'
-  ) {
-    return 0;
-  }
-
-  let remainingTurns = activeTurnCount;
-  for (let index = records.length - 1; index >= 0; index -= 1) {
-    if (!startsTurn(records[index])) continue;
-    remainingTurns -= 1;
-    if (remainingTurns === 0) return index;
-  }
-  return 0;
-}
-
-function resolveReplayActiveTurnCount(options = {}) {
-  const savedActiveTurnCount = options.activeTurnCount;
-  if (
-    options.loadedExisting === true
-    && Number.isSafeInteger(options.totalLines)
-    && options.totalLines > 0
-    && Number.isSafeInteger(savedActiveTurnCount)
-    && savedActiveTurnCount > 0
-  ) {
-    return savedActiveTurnCount;
-  }
-
-  const fallbackTurnCount = options.fallbackTurnCount;
-  return Number.isSafeInteger(fallbackTurnCount) && fallbackTurnCount > 0
-    ? fallbackTurnCount
-    : undefined;
-}
-
-module.exports = { replayWindowStartIndex, resolveReplayActiveTurnCount };