@geraldmaron/construct 1.2.2 → 1.3.0

package/lib/chat/commands.mjs

@@ -1,215 +0,0 @@
-/**
- * lib/chat/commands.mjs — in-session slash commands for `construct chat`.
- *
- * Owns the interactive control surface: changing the model, toggling transparency
- * layers, editing and persisting settings, and inspecting token usage — without
- * leaving the chat. Each command mutates the shared `session` object (which the
- * renderer reads per turn) and, for settings, writes through to the project config
- * via lib/chat/config.mjs. handle() returns false only for /exit so the REPL loop
- * stays the single owner of the readline lifecycle. Ink passes `onClear` instead of
- * ANSI clear-screen codes; both surfaces share `createCollectWriter` for capture.
- *
- * Model enumeration is delegated to the driver's optional listModels(); hosts that
- * cannot enumerate models degrade to a clear notice rather than failing.
- */
-
-import { saveChatConfig, LAYER_KEYS, PERMISSION_MODES, SANDBOX_LEVELS } from './config.mjs';
-import { exportTurns } from './export.mjs';
-import { formatUsagePanel } from './tui/usage.mjs';
-import { applySessionSetting } from './session-settings.mjs';
-import { commitPickerModel, promptModelPickerTerminal } from './model-picker.mjs';
-import { handleDemoCommand, registerDemoCommands } from './demo-guide.mjs';
-
-export const HELP = [
-  ['/help', 'show this help'],
-  ['/model [id]', 'show or set the model (no id opens a searchable picker)'],
-  ['/free', 'set OpenRouter free-router mode (--free equivalent)'],
-  ['/export [last|session]', 'write plain markdown answer to .cx/chat-sessions/exports/'],
-  ['/set <key> <on|off|value>', 'change a setting (thinking, tools, path, specialists, observability, permission, sandbox, model)'],
-  ['/settings', 'show current settings'],
-  ['/layers', 'show transparency layers'],
-  ['/usage', 'show session token and cost breakdown'],
-  ['/oracle', 'show Oracle overseer verdict and pending approvals'],
-  ['/host', 'show the active host'],
-  ['/clear', 'clear the screen'],
-  ['/inspect', 'toggle turn inspector panel (on/off/auto)'],
-  ['/exit', 'quit'],
-];
-
-function ask(rl, question) {
-  return new Promise((resolve) => rl.question(question, (answer) => resolve(answer)));
-}
-
-export function createCommands({ driver, host, hostId = host, version, cwd = process.cwd(), env = process.env, turnBlocksRef = null, demoGuide = null } = {}) {
-  async function handle(input, ctx) {
-    const { output, colors, layers, session, rl, onClear } = ctx;
-    const runtimeEnv = ctx.env || env;
-    const [cmd, ...rest] = input.trim().split(/\s+/);
-    const arg = rest.join(' ').trim();
-    const activeGuide = demoGuide || session?.demoGuide || null;
-
-    switch (cmd) {
-      case '/exit':
-      case '/quit':
-        return false;
-
-      case '/help':
-        output.write(`${colors.bold}commands${colors.reset}\n`);
-        for (const [name, desc] of registerDemoCommands(HELP, activeGuide)) {
-          output.write(`  ${colors.cyan}${name.padEnd(28)}${colors.reset}${colors.dim}${desc}${colors.reset}\n`);
-        }
-        break;
-
-      case '/demo':
-        handleDemoCommand(arg, { demoGuide: activeGuide, output, colors });
-        break;
-
-      case '/host': {
-        const mode = session.modelMode === 'free-router' ? 'free-router' : 'pinned';
-        output.write(`${colors.dim}engine:${colors.reset} ${host} (owned loop)${version ? ` (${version})` : ''}  ${colors.dim}model:${colors.reset} ${session.model || '(default)'}  ${colors.dim}mode:${colors.reset} ${mode}\n`);
-        output.write(`${colors.dim}construct runs the loop itself; switch models with /model${colors.reset}\n`);
-        break;
-      }
-
-      case '/models':
-      case '/model':
-        if (arg) {
-          commitPickerModel(session, { mode: 'pinned', modelId: arg }, { cwd, hostId, layers: session.layers });
-          output.write(`${colors.green}model set:${colors.reset} ${arg} ${colors.dim}(pinned, saved)${colors.reset}\n`);
-          break;
-        }
-        await promptModelPickerTerminal({
-          output,
-          colors,
-          session,
-          rl,
-          askFn: ctx.ask,
-          env: runtimeEnv,
-          cwd,
-          hostId,
-          layers: session.layers,
-        });
-        break;
-
-      case '/free': {
-        const { resolveFreeOpenRouterModel } = await import('../../apps/chat/engine/models.mjs');
-        const freeId = await resolveFreeOpenRouterModel({ env: runtimeEnv, tier: 'standard' });
-        if (!freeId) {
-          output.write(`${colors.red}OpenRouter free router needs OPENROUTER_API_KEY${colors.reset}\n`);
-          break;
-        }
-        commitPickerModel(session, { mode: 'free-router', modelId: freeId }, { cwd, hostId, layers: session.layers });
-        output.write(`${colors.green}model mode:${colors.reset} free-router → ${freeId} ${colors.dim}(saved)${colors.reset}\n`);
-        break;
-      }
-
-      case '/export': {
-        const scope = arg === 'session' ? 'session' : 'last';
-        const blocks = turnBlocksRef?.() || [];
-        const result = exportTurns(blocks, { scope, cwd });
-        if (!result.ok) output.write(`${colors.red}${result.error}${colors.reset}\n`);
-        else output.write(`${colors.green}exported${colors.reset} ${result.count} turn(s) to ${result.path}\n`);
-        break;
-      }
-
-      case '/set':
-        applySetting(output, colors, session, layers, rest);
-        break;
-
-      case '/settings':
-        showSettings(output, colors, session, layers);
-        break;
-
-      case '/layers':
-        output.write(`${colors.dim}layers:${colors.reset} ${LAYER_KEYS.map((k) => `${k}=${layers[k] ? 'on' : 'off'}`).join('  ')}\n`);
-        output.write(`${colors.dim}toggle with: /set <layer> on|off${colors.reset}\n`);
-        break;
-
-      case '/usage':
-        output.write(formatUsagePanel(session.usage, colors) + '\n');
-        break;
-
-      case '/oracle': {
-        const { readOracleDockState, formatOracleDockDetail } = await import('../intake/session-prelude.mjs');
-        const state = readOracleDockState({ cwd, env: runtimeEnv });
-        output.write(`${colors.bold}oracle${colors.reset}\n`);
-        output.write(`${formatOracleDockDetail(state)}\n`);
-        break;
-      }
-
-      case '/inspect': {
-        session.inspectorForced = session.inspectorForced === true ? false : session.inspectorForced === false ? null : true;
-        const label = session.inspectorForced === true ? 'on' : session.inspectorForced === false ? 'off' : 'auto';
-        output.write(`${colors.green}inspector:${colors.reset} ${label}\n`);
-        break;
-      }
-
-      case '/clear':
-        if (typeof onClear === 'function') onClear();
-        else output.write('\u001b[2J\u001b[H');
-        break;
-
-      default:
-        output.write(`${colors.dim}unknown command: ${cmd} \u2014 try /help${colors.reset}\n`);
-    }
-    return true;
-  }
-
-  function applySetting(output, colors, session, layers, parts) {
-    if (parts.length < 2) {
-      output.write(`${colors.dim}usage: /set <key> <value>  (keys: ${[...LAYER_KEYS, 'thinking', 'permission', 'sandbox', 'model', 'ascii', 'inspector'].join(', ')})${colors.reset}\n`);
-      output.write(`${colors.dim}or run /set alone in the Ink UI for a searchable picker${colors.reset}\n`);
-      return;
-    }
-    const [key, ...valueParts] = parts;
-    const value = valueParts.join(' ');
-    if (key === 'host') {
-      output.write(`${colors.dim}host can only be changed by relaunching: construct chat --host ${value}${colors.reset}\n`);
-      return;
-    }
-    const result = applySessionSetting(session, layers, key, value, { cwd, hostId });
-    if (!result.ok) { output.write(`${colors.red}${result.error}${colors.reset}\n`); return; }
-    output.write(`${colors.green}set:${colors.reset} ${result.key} = ${result.value} ${colors.dim}(saved)${colors.reset}\n`);
-  }
-
-  function showSettings(output, colors, session, layers) {
-    output.write(`${colors.bold}settings${colors.reset}\n`);
-    output.write(`  ${colors.cyan}host${colors.reset}        ${host}\n`);
-    output.write(`  ${colors.cyan}model${colors.reset}       ${session.model || '(host default)'} ${colors.dim}(${session.modelMode || 'pinned'})${colors.reset}\n`);
-    output.write(`  ${colors.cyan}thinking${colors.reset}    ${layers.thinking ? 'on' : 'off'}\n`);
-    output.write(`  ${colors.cyan}layers${colors.reset}      ${LAYER_KEYS.map((k) => `${k}=${layers[k] ? 'on' : 'off'}`).join('  ')}\n`);
-    const perm = session.permissionMode || 'allow_once';
-    output.write(`  ${colors.cyan}permission${colors.reset}  ${perm} ${colors.dim}(${PERMISSION_MODES.join('/')})${colors.reset}\n`);
-    output.write(`  ${colors.cyan}ascii${colors.reset}       ${session.ui?.ascii ? 'on' : 'off'} ${colors.dim}(glyph fallback for limited terminals)${colors.reset}\n`);
-    output.write(`  ${colors.cyan}inspector${colors.reset}   ${session.ui?.inspector || 'auto'} ${colors.dim}(off/auto/on — per-turn detail panel)${colors.reset}\n`);
-    output.write(`  ${colors.cyan}sandbox${colors.reset}     ${session.sandbox || '(host default)'} ${colors.dim}(${SANDBOX_LEVELS.join('/')})${colors.reset}\n`);
-    output.write(`  ${colors.dim}chat sandbox gates tools in this session; isolated project copies use \`construct sandbox create\`${colors.reset}\n`);
-  }
-
-  function persist(session, layers = session.layers) {
-    try {
-      saveChatConfig({
-        host: hostId,
-        model: session.modelMode === 'pinned' ? session.model : null,
-        modelMode: session.modelMode || 'pinned',
-        layers,
-        thinking: layers?.thinking,
-        permissionMode: session.permissionMode,
-        sandbox: session.sandbox,
-        ui: session.ui,
-      }, { cwd });
-    } catch { /* settings persistence is best-effort */ }
-  }
-
-  return { handle };
-}
-
-export function createCollectWriter() {
-  const parts = [];
-  return {
-    stream: { write(chunk) { parts.push(String(chunk)); } },
-    text() { return parts.join(''); },
-  };
-}
-
-export const PLAIN_COLORS = Object.freeze({ bold: '', dim: '', reset: '', cyan: '', green: '', red: '', yellow: '' });

package/lib/chat/config.mjs

@@ -1,142 +0,0 @@
-/**
- * lib/chat/config.mjs — persisted settings for `construct chat`.
- *
- * Settings are layered: built-in DEFAULTS < global (~/.cx/chat-config.json) <
- * project (<project>/.cx/chat-config.json). Reads merge all three; writes always go
- * to the project file (resolveProjectScopedPath falls back to ~/.cx when there is no
- * project root), so a user's global preferences seed every project while per-project
- * overrides stay local. Only the known, validated keys are persisted.
- *
- * Exposed settings: host, model, transparency layers, thinking, permissionMode,
- * sandbox, ui (ascii, inspector). Validation lives here so the command layer and the launcher
- * share one source of truth for allowed values.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { resolveProjectScopedPath } from '../project-root.mjs';
-import { doctorRoot } from '../config/xdg.mjs';
-
-export const LAYER_KEYS = ['thinking', 'path', 'specialists', 'tools', 'observability'];
-export const PERMISSION_MODES = ['ask', 'allow_once', 'allow_always', 'reject'];
-export const SANDBOX_LEVELS = ['read-only', 'workspace-write', 'danger-full-access'];
-
-export const INSPECTOR_MODES = ['off', 'auto', 'on'];
-export const THEME_MODES = ['auto', 'light', 'dark'];
-export const MODEL_MODES = ['pinned', 'free-router'];
-
-export const DEFAULTS = Object.freeze({
-  host: null,
-  model: null,
-  modelMode: 'pinned',
-  layers: Object.freeze(Object.fromEntries(LAYER_KEYS.map((k) => [k, true]))),
-  thinking: true,
-  permissionMode: 'allow_once',
-  sandbox: null,
-  ui: Object.freeze({ ascii: false, inspector: 'off', theme: 'auto' }),
-});
-
-const CONFIG_BASENAME = 'chat-config.json';
-
-function readJson(file) {
-  try {
-    if (!fs.existsSync(file)) return null;
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function mergeConfig(base, override) {
-  if (!override || typeof override !== 'object') return base;
-  const out = { ...base };
-  for (const key of Object.keys(DEFAULTS)) {
-    if (override[key] == null) continue;
-    if (key === 'layers' && typeof override.layers === 'object') {
-      out.layers = { ...base.layers, ...override.layers };
-    } else if (key === 'ui' && typeof override.ui === 'object') {
-      out.ui = { ...base.ui, ...override.ui };
-    } else {
-      out[key] = override[key];
-    }
-  }
-  return out;
-}
-
-export function globalConfigPath() {
-  return path.join(doctorRoot(), CONFIG_BASENAME);
-}
-
-export function projectConfigPath({ cwd = process.cwd() } = {}) {
-  return resolveProjectScopedPath(CONFIG_BASENAME, { cwd, ensureDir: false });
-}
-
-export function loadChatConfig({ cwd = process.cwd() } = {}) {
-  let config = { ...DEFAULTS, layers: { ...DEFAULTS.layers } };
-  config = mergeConfig(config, readJson(globalConfigPath()));
-  const projectPath = projectConfigPath({ cwd });
-  config = mergeConfig(config, readJson(projectPath));
-  return { config, path: projectPath };
-}
-
-export function saveChatConfig(config, { cwd = process.cwd() } = {}) {
-  const target = resolveProjectScopedPath(CONFIG_BASENAME, { cwd, ensureDir: true });
-  const persisted = {};
-  for (const key of Object.keys(DEFAULTS)) {
-    if (config[key] == null) continue;
-    persisted[key] = key === 'layers' ? { ...config.layers } : key === 'ui' ? { ...config.ui } : config[key];
-  }
-  fs.writeFileSync(target, `${JSON.stringify(persisted, null, 2)}\n`);
-  return target;
-}
-
-// Validates and coerces a single `key value` setting change. Returns
-// { ok, value, error } so the command layer can report precisely.
-
-export function validateSetting(key, rawValue) {
-  switch (key) {
-    case 'host':
-      return { ok: true, value: String(rawValue) };
-    case 'model':
-      return { ok: true, value: String(rawValue) };
-    case 'thinking': {
-      const v = parseBool(rawValue);
-      return v == null ? { ok: false, error: 'thinking must be on/off' } : { ok: true, value: v };
-    }
-    case 'permissionMode':
-    case 'permission':
-      return PERMISSION_MODES.includes(rawValue)
-        ? { ok: true, key: 'permissionMode', value: rawValue }
-        : { ok: false, error: `permission must be one of: ${PERMISSION_MODES.join(', ')}` };
-    case 'sandbox':
-      return SANDBOX_LEVELS.includes(rawValue)
-        ? { ok: true, value: rawValue }
-        : { ok: false, error: `sandbox must be one of: ${SANDBOX_LEVELS.join(', ')}` };
-    case 'ascii': {
-      const v = parseBool(rawValue);
-      return v == null ? { ok: false, error: 'ascii must be on/off' } : { ok: true, key: 'ui.ascii', value: v };
-    }
-    case 'inspector':
-      return INSPECTOR_MODES.includes(String(rawValue).toLowerCase())
-        ? { ok: true, key: 'ui.inspector', value: String(rawValue).toLowerCase() }
-        : { ok: false, error: `inspector must be one of: ${INSPECTOR_MODES.join(', ')}` };
-    case 'theme':
-      return THEME_MODES.includes(String(rawValue).toLowerCase())
-        ? { ok: true, key: 'ui.theme', value: String(rawValue).toLowerCase() }
-        : { ok: false, error: `theme must be one of: ${THEME_MODES.join(', ')}` };
-    default:
-      if (LAYER_KEYS.includes(key)) {
-        const v = parseBool(rawValue);
-        return v == null ? { ok: false, error: `${key} must be on/off` } : { ok: true, key: `layers.${key}`, value: v };
-      }
-      return { ok: false, error: `unknown setting: ${key}` };
-  }
-}
-
-function parseBool(v) {
-  if (v === true || v === false) return v;
-  const s = String(v).toLowerCase();
-  if (['on', 'true', '1', 'yes', 'show'].includes(s)) return true;
-  if (['off', 'false', '0', 'no', 'hide'].includes(s)) return false;
-  return null;
-}

package/lib/chat/context-compactor.mjs

@@ -1,250 +0,0 @@
-/**
- * lib/chat/context-compactor.mjs — the live bridge between the owned-loop's
- * message history and the deterministic context-continuation contract
- * (lib/chat/context-continuation.mjs, construct-6zga.1.10).
- *
- * The owned-loop engine keeps an ordered array of provider messages (the AI SDK
- * `messages[]`: the user turns it pushed plus the assistant/tool messages the model
- * produced). When a turn's reported context crosses the capability profile's
- * compaction trigger, this module maps that live history onto the contract's layer
- * inventory, runs compactContext, and — crucially — rebuilds a *provider-valid*
- * message array from the result. Provider validity is the constraint the pure
- * contract module does not own: the rebuilt array must begin with a user message,
- * keep tool-call/tool-result pairs intact, and never place two same-role turns
- * adjacently. The rebuild satisfies all three by collapsing the compacted prefix
- * into a single user "continuation" message (task + every user constraint verbatim,
- * plus one real summary of the elided assistant/tool work) followed by an
- * assistant-led verbatim suffix of the most recent turns.
- *
- * No silent loss: user text (task, constraints, approvals) is always carried
- * verbatim into the recap; only the model's own assistant reasoning and tool
- * results are summarized. When required state alone exceeds the budget the contract
- * returns a blocker and this module compacts nothing — it surfaces the blocker as a
- * user-visible notice instead.
- *
- * Pure except for the injected async `summarize`, so the rebuild logic is tested
- * without the AI SDK or a network call.
- */
-
-import { compactContext, validateContinuationPacket } from './context-continuation.mjs';
-
-function estimateTextTokens(text) {
-  return Math.ceil(String(text || '').length / 4);
-}
-
-// AI SDK messages carry content either as a plain string (the user turns the
-// engine pushes) or as an array of typed parts (assistant/tool messages from the
-// model). Flatten both to text for token accounting and summarization, naming
-// tool calls and results so an elided run still reads as what it did.
-
-function partToText(part) {
-  if (typeof part === 'string') return part;
-  if (typeof part?.text === 'string') return part.text;
-  if (part?.type === 'tool-call') return `[tool ${part.toolName || 'call'} ${safeJson(part.input ?? part.args)}]`;
-  if (part?.type === 'tool-result') return `[result ${part.toolName || ''} ${safeJson(part.output ?? part.result)}]`.trim();
-  if (typeof part?.content === 'string') return part.content;
-  return '';
-}
-
-function safeJson(value) {
-  if (value == null) return '';
-  if (typeof value === 'string') return value;
-  try { return JSON.stringify(value); } catch { return String(value); }
-}
-
-export function messageText(message) {
-  if (typeof message?.content === 'string') return message.content;
-  if (Array.isArray(message?.content)) return message.content.map(partToText).filter(Boolean).join('\n');
-  return '';
-}
-
-function messageRole(message) {
-  return message?.role || 'user';
-}
-
-// A segment is one turn-unit: a head message (user or assistant) plus any tool
-// messages that belong to it. Segmenting on tool boundaries is what lets the
-// rebuild keep every tool-call/tool-result pair together — a tool message never
-// becomes the head of a kept suffix, so the provider never sees an orphan result.
-
-export function segmentMessages(messages = []) {
-  const segments = [];
-  let current = null;
-  messages.forEach((message, index) => {
-    const role = messageRole(message);
-    if (role === 'tool' && current) {
-      current.indices.push(index);
-      current.hasTools = true;
-      return;
-    }
-    current = { firstIndex: index, indices: [index], head: role, hasTools: role === 'tool' };
-    segments.push(current);
-  });
-  return segments;
-}
-
-// Map the live segments onto the contract inventory. The system prompt is a
-// reconstructible layer (re-derived each turn by the composer, referenced by
-// source id). The first user segment is the task packet and every other user
-// segment is a user constraint — both required, kept verbatim. Assistant segments
-// are compactible; ordering them newest-first means compactContext fills the budget
-// with the most recent turns and elides the oldest, so the kept suffix is the
-// recent contiguous tail.
-
-export function buildInventory({ systemText = '', segments = [], messages = [], estimateTokens = estimateTextTokens } = {}) {
-  const layers = [];
-  if (systemText) {
-    layers.push({ id: 'static-instructions', kind: 'static-instructions', eligibility: 'reconstructible', sourceId: 'prompt:system', tokens: estimateTokens(systemText), content: systemText });
-  }
-
-  let seenUser = false;
-  const required = [];
-  const compactible = [];
-  for (const segment of segments) {
-    const text = segment.indices.map((i) => messageText(messages[i])).join('\n');
-    const tokens = estimateTokens(text);
-    if (segment.head === 'user') {
-      const kind = seenUser ? 'user-constraints' : 'task-packet';
-      seenUser = true;
-      required.push({ id: `seg-${segment.firstIndex}`, kind, eligibility: 'required', sourceId: null, tokens, content: text, firstIndex: segment.firstIndex });
-    } else {
-      const kind = segment.hasTools ? 'tool-results' : 'conversation-summary';
-      compactible.push({ id: `seg-${segment.firstIndex}`, kind, eligibility: 'compactible', sourceId: null, tokens, content: text, firstIndex: segment.firstIndex });
-    }
-  }
-
-  compactible.sort((a, b) => b.firstIndex - a.firstIndex);
-  return [...layers, ...required, ...compactible];
-}
-
-// Rebuild a provider-valid message array from the compaction packet. The cut index
-// is the earliest message belonging to a retained (recent) compactible segment,
-// nudged forward to land on an assistant message so the recap (a single user
-// message) is followed by an assistant turn. Everything before the cut collapses
-// into the recap: user text verbatim, assistant/tool work as the summary.
-
-export function rebuildMessages({ messages = [], segments = [], packet = null, summaryText = '' } = {}) {
-  const dispositionByFirstIndex = new Map();
-  for (const layer of packet?.layers || []) {
-    const match = /^seg-(\d+)$/.exec(layer.id || '');
-    if (match) dispositionByFirstIndex.set(Number(match[1]), layer.disposition);
-  }
-
-  const retainedFirstIndices = segments
-    .filter((s) => s.head !== 'user' && dispositionByFirstIndex.get(s.firstIndex) === 'retained')
-    .map((s) => s.firstIndex);
-
-  const lastAssistantIndex = (() => {
-    for (let i = messages.length - 1; i >= 0; i--) {
-      if (messageRole(messages[i]) === 'assistant') return i;
-    }
-    return messages.length;
-  })();
-
-  let cut = retainedFirstIndices.length ? Math.min(...retainedFirstIndices) : lastAssistantIndex;
-  while (cut < messages.length && messageRole(messages[cut]) !== 'assistant') cut++;
-  if (cut >= messages.length) cut = lastAssistantIndex;
-
-  const userVerbatim = [];
-  for (let i = 0; i < cut; i++) {
-    if (messageRole(messages[i]) === 'user') userVerbatim.push(messageText(messages[i]));
-  }
-
-  const recap = buildRecapText({ userVerbatim, summaryText, packet });
-  return [{ role: 'user', content: recap }, ...messages.slice(cut)];
-}
-
-export function buildRecapText({ userVerbatim = [], summaryText = '', packet = null } = {}) {
-  const elidedTokens = packet?.budget?.elidedTokens || 0;
-  const lines = [
-    '[Context continuation — earlier turns were compacted to fit the model context budget. Nothing required was dropped.]',
-    '',
-    '== Task & constraints (verbatim) ==',
-    ...userVerbatim.filter(Boolean),
-  ];
-  if (summaryText) {
-    lines.push('', `== Summary of prior assistant work & tool results (~${elidedTokens} tokens compacted) ==`, summaryText);
-  }
-  return lines.join('\n');
-}
-
-function fallbackSummary(elidedSegments, messages) {
-  const count = elidedSegments.reduce((n, s) => n + s.indices.length, 0);
-  const tail = elidedSegments.slice(-1).map((s) => messageText(messages[s.firstIndex]))[0] || '';
-  const clipped = tail.length > 280 ? `${tail.slice(0, 277)}...` : tail;
-  return `Compacted ${count} earlier message(s) without a model summary. Most recent elided turn began: ${clipped}`.trim();
-}
-
-export function shouldCompact({ contextTokens = 0, triggerTokens = null } = {}) {
-  return Number.isFinite(triggerTokens) && triggerTokens > 0 && contextTokens >= triggerTokens;
-}
-
-/**
- * The orchestrator the engine calls once per turn. Returns the compaction outcome:
- * `compacted` with a rebuilt message array and a notice, a `blocker` with a notice
- * and no mutation when required state exceeds the budget, or an inert result when
- * there is no pressure or nothing safe to elide. The packet is always returned for
- * persistence and re-verification.
- */
-export async function maybeCompact({
-  messages = [],
-  systemText = '',
-  triggerTokens = null,
-  contextTokens = 0,
-  summarize = null,
-  estimateTokens = estimateTextTokens,
-} = {}) {
-  if (!shouldCompact({ contextTokens, triggerTokens })) return { compacted: false, packet: null, notice: null, blocker: null };
-
-  const segments = segmentMessages(messages);
-  if (segments.length <= 2) return { compacted: false, packet: null, notice: null, blocker: null };
-
-  const inventory = buildInventory({ systemText, segments, messages, estimateTokens });
-  const packet = compactContext(inventory, { triggerTokens });
-
-  if (packet.blocker) {
-    const { requiredTokens, budgetTokens, overflowTokens } = packet.blocker;
-    return {
-      compacted: false,
-      packet,
-      blocker: packet.blocker,
-      notice: `Context pressure: required context (~${requiredTokens} tokens) exceeds the model budget (~${budgetTokens}) by ~${overflowTokens}. Nothing was dropped — reduce scope or start a new session.`,
-    };
-  }
-
-  const elidedSegments = segments.filter((s) => {
-    const layer = packet.layers.find((l) => l.id === `seg-${s.firstIndex}`);
-    return layer && layer.disposition === 'elided';
-  });
-  if (!elidedSegments.length) return { compacted: false, packet, notice: null, blocker: null };
-
-  const elidedText = elidedSegments
-    .sort((a, b) => a.firstIndex - b.firstIndex)
-    .map((s) => s.indices.map((i) => messageText(messages[i])).join('\n'))
-    .join('\n\n');
-
-  let summaryText = '';
-  if (typeof summarize === 'function') {
-    try {
-      const out = await summarize(elidedText, {
-        segmentCount: elidedSegments.length,
-        tokens: packet.budget.elidedTokens,
-      });
-      summaryText = typeof out === 'string' ? out.trim() : '';
-    } catch { summaryText = ''; }
-  }
-  if (!summaryText) summaryText = fallbackSummary(elidedSegments, messages);
-
-  const newMessages = rebuildMessages({ messages, segments, packet, summaryText });
-
-  const elidedMessageCount = elidedSegments.reduce((n, s) => n + s.indices.length, 0);
-  return {
-    compacted: true,
-    messages: newMessages,
-    packet,
-    blocker: null,
-    notice: `Context compacted: summarized ${elidedMessageCount} earlier message(s) (~${packet.budget.elidedTokens} tokens) to stay within the model's ~${triggerTokens}-token budget. Task, constraints, and recent turns kept verbatim.`,
-  };
-}
-
-export { estimateTextTokens, validateContinuationPacket };