blun-king-cli 9.1.587 → 9.1.588

package/bin/cognitive-work-focus.cjs

@@ -1,180 +0,0 @@
-'use strict';
-
-const crypto = require('node:crypto');
-
-const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
-const STATUSES = new Set(['active', 'paused', 'blocked']);
-const EPISTEMIC_STATES = new Set([
-  'verified', 'credible_unverified', 'hypothesis', 'uncertain_memory', 'stale', 'unknown', 'legacy_unknown',
-]);
-const TRIGGER_KINDS = new Set([
-  'immediate', 'external_event', 'time', 'dependency', 'user_decision',
-]);
-const TRIGGER_KEYS = new Set(['kind', 'condition']);
-const NEXT_TRIGGER = new Map([
-  ['active', 'Continue the active goal from its last verified state.'],
-  ['paused', 'Wait until the goal is explicitly resumed.'],
-  ['blocked', 'Resolve the current blocker before continuing.'],
-]);
-
-function bounded(value, max = 512) {
-  const text = String(value ?? '').replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim();
-  if (!text) return '';
-  return text.length <= max ? text : `${text.slice(0, max - 3).trimEnd()}...`;
-}
-
-function buildCognitiveWorkFocus(goal, { decisionFreshness } = {}) {
-  if (!goal || typeof goal !== 'object' || Array.isArray(goal)) return null;
-  const goalId = String(goal.goalId ?? '').trim();
-  const objective = bounded(goal.objective);
-  const completionCriterion = bounded(goal.completionCriterion)
-    || 'Goal completion must be supported by verified evidence.';
-  const status = String(goal.status ?? '');
-  const turnsUsed = Number(goal.turnsUsed);
-  if (!SAFE_ID_RE.test(goalId) || !objective || !STATUSES.has(status)
-      || !Number.isSafeInteger(turnsUsed) || turnsUsed < 0) return null;
-
-  const focusScope = `goal:${goalId}`;
-  if (!SAFE_ID_RE.test(focusScope)) return null;
-  const checkpoint = goal.actionCheckpoint && typeof goal.actionCheckpoint === 'object'
-    ? goal.actionCheckpoint
-    : null;
-  const checkpointPhase = bounded(checkpoint?.phase, 32);
-  const lastVerified = bounded(checkpoint?.lastVerified);
-  const nextAction = bounded(checkpoint?.nextAction);
-  const checkpointEvidence = bounded(checkpoint?.expectedEvidence);
-  const checkpointEpistemicState = bounded(checkpoint?.epistemicState, 32);
-  const rawNextTrigger = checkpoint?.nextTrigger;
-  let triggerKind = '';
-  let triggerCondition = '';
-  if (rawNextTrigger !== undefined) {
-    if (!rawNextTrigger || typeof rawNextTrigger !== 'object' || Array.isArray(rawNextTrigger)
-        || Object.keys(rawNextTrigger).length !== TRIGGER_KEYS.size
-        || Object.keys(rawNextTrigger).some((key) => !TRIGGER_KEYS.has(key))) return null;
-    triggerKind = String(rawNextTrigger.kind ?? '').trim();
-    triggerCondition = bounded(rawNextTrigger.condition);
-    if (!TRIGGER_KINDS.has(triggerKind) || !triggerCondition
-        || checkpointPhase === 'wait' && triggerKind === 'immediate'
-        || checkpointPhase !== 'wait' && triggerKind !== 'immediate') return null;
-  }
-  const hasExplicitTrigger = Boolean(triggerKind && triggerCondition);
-  const triggerValue = hasExplicitTrigger
-    ? `${triggerKind.replaceAll('_', ' ')} - ${triggerCondition}`
-    : nextAction;
-  const problemFrame = checkpoint?.problemFrame && typeof checkpoint.problemFrame === 'object'
-    && !Array.isArray(checkpoint.problemFrame) ? checkpoint.problemFrame : null;
-  const frameMissingKnowledge = Array.isArray(problemFrame?.missingKnowledge)
-    ? problemFrame.missingKnowledge.slice(0, 5).map((item) => bounded(item, 256)).filter(Boolean)
-    : [];
-  const frameCandidates = Array.isArray(problemFrame?.candidateActions)
-    ? problemFrame.candidateActions.slice(0, 5).map((item) => bounded(item, 256)).filter(Boolean)
-    : [];
-  const frameSuccessCriterion = bounded(problemFrame?.successCriterion);
-  const frameSelectedAction = bounded(problemFrame?.selectedAction, 256);
-  const frameSelectionReason = bounded(problemFrame?.selectionReason);
-  const frameSupportChoice = bounded(problemFrame?.supportChoice, 256);
-  const frameRisk = bounded(problemFrame?.risk);
-  const frameReversibility = bounded(problemFrame?.reversibility);
-  const frameDecisionBasis = Array.isArray(problemFrame?.decisionBasis)
-    && problemFrame.decisionBasis.length >= 1 && problemFrame.decisionBasis.length <= 5
-    && problemFrame.decisionBasis.every((item) => /^[a-f0-9]{16}$/u.test(String(item)))
-    && new Set(problemFrame.decisionBasis).size === problemFrame.decisionBasis.length
-    ? [...problemFrame.decisionBasis] : [];
-  const hasProblemFrame = problemFrame !== null && frameSuccessCriterion
-    && frameMissingKnowledge.length > 0 && frameCandidates.length > 0
-    && frameSelectedAction && frameSelectionReason && frameSupportChoice
-    && frameRisk && frameReversibility;
-  const hasCheckpoint = checkpoint !== null && checkpointPhase && lastVerified
-    && nextAction && checkpointEvidence;
-  const epistemicState = hasCheckpoint && EPISTEMIC_STATES.has(checkpointEpistemicState)
-    ? checkpointEpistemicState : hasCheckpoint ? 'legacy_unknown' : 'verified';
-  const decisionFreshnessStatus = frameDecisionBasis.length > 0
-    && ['current', 'stale', 'unknown'].includes(decisionFreshness?.status)
-    ? decisionFreshness.status : frameDecisionBasis.length > 0 ? 'unknown' : '';
-  const staleDecision = decisionFreshnessStatus === 'stale' || decisionFreshnessStatus === 'unknown';
-  const replanKnowledgeGap = 'Re-evaluate the selected action against current durable evidence.';
-  const replanTrigger = 'Re-evaluate the selected action against the current durable evidence.';
-  const replanEvidence = 'A replacement action is bound to current durable evidence refs.';
-  const knowledgeGapValue = staleDecision ? `${replanKnowledgeGap} ${frameMissingKnowledge.join(' | ')}`
-    : hasProblemFrame ? frameMissingKnowledge.join(' | ') : 'none';
-  const decisionThread = hasProblemFrame ? [
-    ...(staleDecision ? [`Decision basis ${decisionFreshnessStatus}; replan before executing the selected action.`] : []),
-    `Goal is ${status}`,
-    `Phase ${checkpointPhase}`,
-    `Last verified: ${bounded(lastVerified, 80)}`,
-    `Decision: ${bounded(frameSelectedAction, 64)}`,
-    `Why: ${bounded(frameSelectionReason, 64)}`,
-    `Support: ${bounded(frameSupportChoice, 64)}`,
-    `Risk: ${bounded(frameRisk, 64)}`,
-    `Reversible: ${bounded(frameReversibility, 64)}`,
-  ].join('; ') : '';
-  const digest = crypto.createHash('sha256')
-    .update([
-      goalId, objective, completionCriterion, status, String(turnsUsed),
-      hasCheckpoint ? checkpointPhase : '',
-      hasCheckpoint ? lastVerified : '',
-      hasCheckpoint ? nextAction : '',
-      hasCheckpoint ? checkpointEvidence : '',
-      hasExplicitTrigger ? triggerKind : '',
-      hasExplicitTrigger ? triggerCondition : '',
-      epistemicState,
-      hasProblemFrame ? frameSuccessCriterion : '',
-      hasProblemFrame ? frameMissingKnowledge.join('\0') : '',
-      hasProblemFrame ? frameCandidates.join('\0') : '',
-      hasProblemFrame ? frameSelectedAction : '',
-      hasProblemFrame ? frameSelectionReason : '',
-      hasProblemFrame ? frameSupportChoice : '',
-      hasProblemFrame ? frameRisk : '',
-      hasProblemFrame ? frameReversibility : '',
-      hasProblemFrame ? frameDecisionBasis.join('\0') : '',
-      decisionFreshnessStatus,
-    ].join('\0'))
-    .digest('hex').slice(0, 40);
-  const keyRoot = `goal:${goalId}`;
-  return {
-    snapshotId: `goalfocus-${digest}`,
-    focusScope,
-    observations: [
-      { domain: 'goal', key: `${keyRoot}:objective`, value: objective, confidence: 1, epistemicState, scope: focusScope },
-      {
-        domain: 'open_thread', key: `${keyRoot}:status`,
-        value: bounded(hasCheckpoint
-          ? hasProblemFrame ? decisionThread : [
-            `Goal is ${status}. Phase ${checkpointPhase}. Last verified: ${lastVerified}`,
-            `Next action: ${nextAction}`,
-          ].join(' ')
-          : `Goal is ${status}.`),
-        confidence: 1,
-        epistemicState: staleDecision ? decisionFreshnessStatus : epistemicState,
-        scope: focusScope,
-      },
-      {
-        domain: 'knowledge_gap', key: `${keyRoot}:knowledge-gaps`,
-        value: knowledgeGapValue,
-        confidence: 1,
-        epistemicState: hasProblemFrame || staleDecision ? 'unknown' : 'verified',
-        scope: focusScope,
-      },
-      {
-        domain: 'next_trigger', key: `${keyRoot}:next`,
-        value: status === 'active' && hasCheckpoint
-          ? staleDecision ? replanTrigger : triggerValue
-          : NEXT_TRIGGER.get(status),
-        confidence: 1,
-        epistemicState: staleDecision ? decisionFreshnessStatus : epistemicState,
-        scope: focusScope,
-      },
-      {
-        domain: 'expected_evidence', key: `${keyRoot}:evidence`,
-        value: status === 'active' && hasCheckpoint
-          ? staleDecision ? replanEvidence : checkpointEvidence
-          : completionCriterion,
-        confidence: 1,
-        epistemicState: staleDecision ? decisionFreshnessStatus : epistemicState,
-        scope: focusScope,
-      },
-    ],
-  };
-}
-
-module.exports = { buildCognitiveWorkFocus };

package/bin/compaction-history-archive.cjs

@@ -1,166 +0,0 @@
-'use strict';
-
-const { randomUUID } = require('node:crypto');
-const { lstat, mkdir, readdir, unlink, writeFile } = require('node:fs/promises');
-const path = require('node:path');
-
-const COMPACTION_HISTORY_DIR = 'conversation-history';
-const COMPACTION_HISTORY_RETENTION_DAYS = 30;
-const MAX_COMPACTION_HISTORY_RETENTION_DAYS = 3650;
-const DAY_MS = 24 * 60 * 60 * 1000;
-const INLINE_MEDIA_NOTICE = '[inline media payload omitted; original remains in session wire]';
-
-async function archiveCompactionHistory(options = {}) {
-  const homedir = requiredString(options.homedir, 'homedir');
-  const messages = Array.isArray(options.messages) ? options.messages : [];
-  const now = finiteNumber(options.now, Date.now());
-  const id = safeFilePart(options.id || randomUUID());
-  const dir = path.join(homedir, COMPACTION_HISTORY_DIR);
-  const timestamp = new Date(now).toISOString().replace(/[:.]/g, '-');
-  const outputPath = path.join(dir, `compaction-${timestamp}-${id}.md`);
-
-  await mkdir(dir, { recursive: true, mode: 0o700 });
-  await sweepCompactionHistory({
-    homedir,
-    now,
-    retentionDays: options.retentionDays,
-  });
-  await writeFile(outputPath, serializeCompactionHistory(messages, { now }), {
-    encoding: 'utf8',
-    flag: 'wx',
-    mode: 0o600,
-  });
-  return outputPath;
-}
-
-async function sweepCompactionHistory(options = {}) {
-  const homedir = requiredString(options.homedir, 'homedir');
-  const now = finiteNumber(options.now, Date.now());
-  const retentionDays = options.retentionDays === undefined
-    ? resolveCompactionHistoryRetentionDays(process.env.BLUN_COMPACTION_HISTORY_RETENTION_DAYS)
-    : resolveCompactionHistoryRetentionDays(options.retentionDays);
-  const result = { deleted: 0, failed: 0 };
-  if (retentionDays === 0) return result;
-  const dir = path.join(homedir, COMPACTION_HISTORY_DIR);
-  let entries;
-  try {
-    entries = await readdir(dir, { withFileTypes: true });
-  } catch (error) {
-    if (error?.code !== 'ENOENT') result.failed += 1;
-    return result;
-  }
-  const cutoff = now - retentionDays * DAY_MS;
-  for (const entry of entries) {
-    if (!entry.isFile() || !/^compaction-.*\.md$/u.test(entry.name)) continue;
-    const candidate = path.join(dir, entry.name);
-    try {
-      const info = await lstat(candidate);
-      if (!info.isFile() || info.mtimeMs >= cutoff) continue;
-      await unlink(candidate);
-      result.deleted += 1;
-    } catch (error) {
-      if (error?.code !== 'ENOENT') result.failed += 1;
-    }
-  }
-  return result;
-}
-
-function resolveCompactionHistoryRetentionDays(value) {
-  if (value === undefined || value === null || value === '') {
-    return COMPACTION_HISTORY_RETENTION_DAYS;
-  }
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed < 0 || parsed > MAX_COMPACTION_HISTORY_RETENTION_DAYS) {
-    return COMPACTION_HISTORY_RETENTION_DAYS;
-  }
-  return parsed;
-}
-
-function serializeCompactionHistory(messages, options = {}) {
-  const now = finiteNumber(options.now, Date.now());
-  const lines = [
-    '# BLUN conversation history archive',
-    '',
-    `Archived at: ${new Date(now).toISOString()}`,
-    `Messages: ${messages.length}`,
-    '',
-    'This file contains the messages displaced by a full context compaction.',
-    'Inline media payloads are omitted here; the original session wire remains authoritative.',
-  ];
-
-  for (let index = 0; index < messages.length; index += 1) {
-    const message = sanitizeMessage(messages[index]);
-    lines.push(
-      '',
-      `## Message ${index + 1}: ${typeof message?.role === 'string' ? message.role : 'unknown'}`,
-      '',
-      '```json',
-      JSON.stringify(message, null, 2),
-      '```',
-    );
-  }
-  lines.push('');
-  return lines.join('\n');
-}
-
-function buildCompactionArchiveNotice(historyPath) {
-  return [
-    '<system-reminder>',
-    'The complete messages displaced by this compaction were archived locally.',
-    `history_path: ${historyPath}`,
-    'next_step: Use Read with history_path to recover exact details that the summary omitted.',
-    '</system-reminder>',
-  ].join('\n');
-}
-
-function sanitizeMessage(message) {
-  if (message === null || typeof message !== 'object') return message;
-  if (!Array.isArray(message.content)) return message;
-  return {
-    ...message,
-    content: message.content.map(sanitizeContentPart),
-  };
-}
-
-function sanitizeContentPart(part) {
-  if (part === null || typeof part !== 'object') return part;
-  if (part.type === 'image_url' && isInlineMediaUrl(part.imageUrl?.url)) {
-    return { type: 'text', text: INLINE_MEDIA_NOTICE };
-  }
-  if (part.type === 'audio_url' && isInlineMediaUrl(part.audioUrl?.url)) {
-    return { type: 'text', text: INLINE_MEDIA_NOTICE };
-  }
-  if (part.type === 'video_url' && isInlineMediaUrl(part.videoUrl?.url)) {
-    return { type: 'text', text: INLINE_MEDIA_NOTICE };
-  }
-  return part;
-}
-
-function isInlineMediaUrl(value) {
-  return typeof value === 'string' && /^data:(?:image|audio|video)\//i.test(value);
-}
-
-function requiredString(value, name) {
-  if (typeof value === 'string' && value.length > 0) return value;
-  throw new TypeError(`${name} must be a non-empty string`);
-}
-
-function safeFilePart(value) {
-  const cleaned = String(value).replace(/[^a-zA-Z0-9._-]+/g, '_').replace(/^_+|_+$/g, '').slice(0, 96);
-  return cleaned || randomUUID();
-}
-
-function finiteNumber(value, fallback) {
-  const number = Number(value);
-  return Number.isFinite(number) ? number : fallback;
-}
-
-module.exports = {
-  COMPACTION_HISTORY_DIR,
-  COMPACTION_HISTORY_RETENTION_DAYS,
-  archiveCompactionHistory,
-  buildCompactionArchiveNotice,
-  resolveCompactionHistoryRetentionDays,
-  serializeCompactionHistory,
-  sweepCompactionHistory,
-};

package/bin/compaction-history-startup.cjs

@@ -1,50 +0,0 @@
-'use strict';
-
-const { sweepCompactionHistory } = require('./compaction-history-archive.cjs');
-
-function startCompactionHistoryStartupSweep(options = {}) {
-  const sweep = typeof options.sweep === 'function'
-    ? options.sweep
-    : sweepCompactionHistory;
-  const sweepOptions = { homedir: options.homedir };
-  if (options.now !== undefined) sweepOptions.now = options.now;
-  if (options.retentionDays !== undefined) sweepOptions.retentionDays = options.retentionDays;
-
-  return Promise.resolve()
-    .then(() => sweep(sweepOptions))
-    .then((result) => {
-      const normalized = normalizeSweepResult(result);
-      if (normalized.deleted > 0 || normalized.failed > 0) {
-        safeLog(options.logger, 'info', 'compaction history startup sweep completed', normalized);
-      }
-      return normalized;
-    })
-    .catch((error) => {
-      const result = { deleted: 0, failed: 1 };
-      safeLog(options.logger, 'warn', 'compaction history startup sweep failed', {
-        error: error instanceof Error ? error.message : String(error),
-      });
-      return result;
-    });
-}
-
-function normalizeSweepResult(result) {
-  return {
-    deleted: nonNegativeInteger(result?.deleted),
-    failed: nonNegativeInteger(result?.failed),
-  };
-}
-
-function nonNegativeInteger(value) {
-  return Number.isInteger(value) && value >= 0 ? value : 0;
-}
-
-function safeLog(logger, level, message, properties) {
-  try {
-    logger?.[level]?.(message, properties);
-  } catch {}
-}
-
-module.exports = {
-  startCompactionHistoryStartupSweep,
-};

package/bin/compaction-model-policy.cjs

@@ -1,31 +0,0 @@
-'use strict';
-
-function resolveCompactionModelAlias(configuredAlias, activeAlias) {
-  if (typeof configuredAlias === 'string' && configuredAlias.trim().length > 0) {
-    return configuredAlias.trim();
-  }
-  return activeAlias;
-}
-
-function normalizeCompactionModelSelection(value) {
-  if (typeof value !== 'string') return undefined;
-  const normalized = value.trim();
-  if (normalized.length === 0) return undefined;
-  if (['clear', 'default', 'inherit'].includes(normalized.toLowerCase())) return null;
-  return normalized;
-}
-
-function clearCompactionModelConfig(config) {
-  const loopControl = { ...(config?.loopControl ?? {}) };
-  delete loopControl.compactionModel;
-  return {
-    ...config,
-    loopControl,
-  };
-}
-
-module.exports = {
-  clearCompactionModelConfig,
-  normalizeCompactionModelSelection,
-  resolveCompactionModelAlias,
-};

package/bin/compaction-stage-policy.cjs

@@ -1,21 +0,0 @@
-"use strict";
-
-const DEFAULT_COMPACTION_STAGE_MAX_TOKENS = 64_000;
-const DEFAULT_COMPACTION_MAX_COMPLETION_TOKENS = 16_384;
-
-function capCompactionStageTarget(safeRequestLimitTokens) {
-  if (!Number.isFinite(safeRequestLimitTokens) || safeRequestLimitTokens <= 0) return 0;
-  return Math.min(Math.floor(safeRequestLimitTokens), DEFAULT_COMPACTION_STAGE_MAX_TOKENS);
-}
-
-function capCompactionCompletionTokens(maxContextTokens) {
-  if (!Number.isFinite(maxContextTokens) || maxContextTokens <= 0) return undefined;
-  return Math.min(Math.floor(maxContextTokens), DEFAULT_COMPACTION_MAX_COMPLETION_TOKENS);
-}
-
-module.exports = {
-  DEFAULT_COMPACTION_MAX_COMPLETION_TOKENS,
-  DEFAULT_COMPACTION_STAGE_MAX_TOKENS,
-  capCompactionCompletionTokens,
-  capCompactionStageTarget,
-};

package/bin/compaction-transaction-policy.cjs

@@ -1,122 +0,0 @@
-'use strict';
-
-const { randomUUID } = require('node:crypto');
-
-function positiveInteger(value, label) {
-  if (!Number.isSafeInteger(value) || value < 0) {
-    throw new TypeError(`${label} must be a non-negative safe integer`);
-  }
-  return value;
-}
-
-function toolCallId(call) {
-  return typeof call?.id === 'string' && call.id.length > 0 ? call.id : undefined;
-}
-
-function assertBalancedToolPairs(messages, label = 'compaction history') {
-  const pending = new Set();
-  for (const message of messages) {
-    if (message?.role === 'assistant') {
-      for (const call of message.toolCalls ?? []) {
-        const id = toolCallId(call);
-        if (id === undefined) throw new Error(`${label} contains a tool call without an id`);
-        if (pending.has(id)) throw new Error(`${label} contains duplicate tool call id ${id}`);
-        pending.add(id);
-      }
-      continue;
-    }
-    if (message?.role !== 'tool') continue;
-    const id = typeof message.toolCallId === 'string' ? message.toolCallId : undefined;
-    if (id === undefined || !pending.delete(id)) {
-      throw new Error(`${label} contains an orphan tool result${id ? ` ${id}` : ''}`);
-    }
-  }
-  if (pending.size > 0) {
-    throw new Error(`${label} contains ${pending.size} tool call(s) without results`);
-  }
-  return true;
-}
-
-function createCompactionTransaction({ source, turnId, tokensBefore, messageCountBefore }) {
-  const transaction = {
-    id: randomUUID(),
-    source,
-    turnId: turnId ?? null,
-    tokensBefore: positiveInteger(tokensBefore, 'tokensBefore'),
-    messageCountBefore: positiveInteger(messageCountBefore, 'messageCountBefore'),
-    state: 'started',
-  };
-  return {
-    transaction,
-    record: {
-      type: 'compaction/start',
-      compaction_id: transaction.id,
-      source: transaction.source,
-      turn_id: transaction.turnId,
-      size_before: transaction.tokensBefore,
-      message_count_before: transaction.messageCountBefore,
-      unit: 'tokens',
-    },
-  };
-}
-
-function summarizeCompactionTransaction(transaction, input) {
-  if (transaction?.state !== 'started') {
-    throw new Error('compaction/summary requires exactly one open compaction/start');
-  }
-  if (typeof input.summary !== 'string' || input.summary.trim().length === 0) {
-    throw new Error('compaction/summary requires non-empty model-visible summary text');
-  }
-  assertBalancedToolPairs(input.historyBefore, 'history before compaction');
-  assertBalancedToolPairs(input.historyAfter, 'history after compaction');
-  transaction.state = 'summarized';
-  transaction.tokensAfter = positiveInteger(input.tokensAfter, 'tokensAfter');
-  transaction.messageCountAfter = positiveInteger(input.messageCountAfter, 'messageCountAfter');
-  return {
-    type: 'compaction/summary',
-    compaction_id: transaction.id,
-    source: transaction.source,
-    turn_id: transaction.turnId,
-    summary: input.summary,
-    shadowed_token_count: transaction.tokensBefore,
-    size_before: transaction.tokensBefore,
-    size_after: transaction.tokensAfter,
-    message_count_before: transaction.messageCountBefore,
-    message_count_after: transaction.messageCountAfter,
-    tool_pairing_balanced_before: true,
-    tool_pairing_balanced_after: true,
-    unit: 'tokens',
-  };
-}
-
-function endCompactionTransaction(transaction, { status, error } = {}) {
-  if (transaction?.state === 'ended') return undefined;
-  if (transaction?.state !== 'started' && transaction?.state !== 'summarized') {
-    throw new Error('compaction/end requires an open compaction/start');
-  }
-  const normalizedStatus = status ?? 'success';
-  if (normalizedStatus === 'success' && transaction.state !== 'summarized') {
-    throw new Error('successful compaction/end requires one compaction/summary');
-  }
-  if (!['success', 'cancelled', 'failed'].includes(normalizedStatus)) {
-    throw new Error(`unsupported compaction status ${normalizedStatus}`);
-  }
-  transaction.state = 'ended';
-  return {
-    type: 'compaction/end',
-    compaction_id: transaction.id,
-    source: transaction.source,
-    turn_id: transaction.turnId,
-    status: normalizedStatus,
-    ...(transaction.tokensAfter === undefined ? {} : { size_after: transaction.tokensAfter }),
-    ...(typeof error === 'string' && error.length > 0 ? { error } : {}),
-    unit: 'tokens',
-  };
-}
-
-module.exports = {
-  assertBalancedToolPairs,
-  createCompactionTransaction,
-  endCompactionTransaction,
-  summarizeCompactionTransaction,
-};

package/bin/config-write-dedup-policy.cjs

@@ -1,27 +0,0 @@
-'use strict';
-
-const fs = require('node:fs/promises');
-
-async function configFileMatches(filePath, nextContent, fsImpl = fs) {
-  const content = Buffer.isBuffer(nextContent)
-    ? nextContent
-    : Buffer.from(String(nextContent), 'utf8');
-
-  try {
-    const stat = await fsImpl.lstat(filePath);
-    if (!stat.isFile() || stat.isSymbolicLink() || stat.size !== content.byteLength) {
-      return false;
-    }
-
-    const current = await fsImpl.readFile(filePath);
-    return Buffer.isBuffer(current)
-      ? current.equals(content)
-      : Buffer.from(current).equals(content);
-  } catch {
-    return false;
-  }
-}
-
-module.exports = {
-  configFileMatches,
-};

package/bin/context-budget-ledger.cjs

@@ -1,31 +0,0 @@
-'use strict';
-
-function wholeTokenCount(value) {
-  if (!Number.isFinite(value) || value <= 0) return 0;
-  return Math.floor(value);
-}
-
-function reconcileContextBudget(input = {}) {
-  const totalTokens = wholeTokenCount(input.totalTokens);
-  const maxTokens = Math.max(totalTokens, wholeTokenCount(input.maxTokens));
-  const conversationTokens = Math.min(totalTokens, wholeTokenCount(input.conversationTokens));
-  const toolTokens = Math.min(
-    totalTokens - conversationTokens,
-    wholeTokenCount(input.toolTokens),
-  );
-  const systemTokens = totalTokens - conversationTokens - toolTokens;
-
-  return {
-    systemTokens,
-    conversationTokens,
-    toolTokens,
-    freeTokens: maxTokens - totalTokens,
-    totalTokens,
-    maxTokens,
-  };
-}
-
-module.exports = {
-  reconcileContextBudget,
-  wholeTokenCount,
-};