@geraldmaron/construct 1.2.3 → 1.3.0

package/lib/chat/design-tokens.mjs

@@ -1,91 +0,0 @@
-/**
- * lib/chat/design-tokens.mjs — semantic chat tokens derived from brand primitives.
- *
- * Maps lib/brand-tokens.mjs ink ramp to dark/light chat surfaces for web CSS vars
- * and terminal semantic colours. Single source for cockpit theming across linear
- * and web/desktop surfaces.
- */
-
-import { INK, FONTS, STATUS } from '../brand-tokens.mjs';
-
-export const CHAT_DARK = Object.freeze({
-  bg: '#000000',
-  surface: '#0b0b0c',
-  border: INK.muted,
-  text: '#ededed',
-  muted: '#9a9a9e',
-  accent: '#ffffff',
-  accentAlt: INK.hairlineStrong,
-  ...STATUS,
-});
-
-export const CHAT_LIGHT = Object.freeze({
-  bg: '#f8f9fb',
-  surface: INK.surfaceAlt,
-  border: INK.hairlineStrong,
-  text: INK.ink,
-  muted: INK.muted,
-  accent: INK.inkStrong,
-  accentAlt: INK.muted,
-  ok: '#15803d',
-  warn: '#a16207',
-  danger: STATUS.danger,
-});
-
-const TERMINAL_DARK = Object.freeze({
-  text: { ink: 'white', code: '37' },
-  muted: { ink: 'gray', code: '90' },
-  accent: { ink: 'whiteBright', code: '97' },
-  accentAlt: { ink: 'gray', code: '90' },
-  brandAccent: { ink: 'whiteBright', code: '97' },
-  surface: { ink: 'gray', code: '90' },
-  surfaceMuted: { ink: 'gray', code: '90' },
-  border: { ink: 'gray', code: '90' },
-  ok: { ink: 'green', code: '32' },
-  warn: { ink: 'yellow', code: '33' },
-  danger: { ink: 'red', code: '31' },
-  badgeFg: { ink: 'black', code: '30' },
-});
-
-const TERMINAL_LIGHT = Object.freeze({
-  text: { ink: 'black', code: '30' },
-  muted: { ink: 'gray', code: '90' },
-  accent: { ink: 'black', code: '30' },
-  accentAlt: { ink: 'gray', code: '90' },
-  brandAccent: { ink: 'black', code: '30' },
-  surface: { ink: 'gray', code: '90' },
-  surfaceMuted: { ink: 'gray', code: '90' },
-  border: { ink: 'gray', code: '90' },
-  ok: { ink: 'green', code: '32' },
-  warn: { ink: 'rgb(161,98,7)', code: '33' },
-  danger: { ink: 'red', code: '31' },
-  badgeFg: { ink: 'white', code: '97' },
-});
-
-export function chatPalette(scheme = 'dark') {
-  return scheme === 'light' ? CHAT_LIGHT : CHAT_DARK;
-}
-
-export function chatCssVars(scheme = 'dark') {
-  const p = chatPalette(scheme);
-  return {
-    '--cx-chat-bg': p.bg,
-    '--cx-chat-surface': p.surface,
-    '--cx-chat-border': p.border,
-    '--cx-chat-text': p.text,
-    '--cx-chat-muted': p.muted,
-    '--cx-chat-accent': p.accent,
-    '--cx-chat-accent-alt': p.accentAlt,
-    '--cx-chat-warn': p.warn,
-    '--cx-chat-danger': p.danger,
-    '--cx-chat-ok': p.ok,
-    '--cx-chat-font': FONTS.sans,
-    '--cx-chat-mono': FONTS.mono,
-  };
-}
-
-export function chatTerminalSemantic(scheme = 'dark') {
-  return scheme === 'light' ? TERMINAL_LIGHT : TERMINAL_DARK;
-}
-
-export { FONTS, INK, STATUS };

package/lib/chat/desktop-binary.mjs

@@ -1,81 +0,0 @@
-/**
- * lib/chat/desktop-binary.mjs — resolve the Construct chat desktop window binary.
- *
- * Search order: CONSTRUCT_CHAT_DESKTOP_BIN, repo dev build, the bin/ subdir of
- * the XDG state dir, then packaged sidecar next to construct.
- */
-
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { stateDir } from '../config/xdg.mjs';
-
-const HERE = path.dirname(fileURLToPath(import.meta.url));
-const REPO_ROOT = path.resolve(HERE, '..', '..');
-
-function binaryName() {
-  return process.platform === 'win32' ? 'construct-chat.exe' : 'construct-chat';
-}
-
-function isReadableFile(filePath) {
-  try {
-    const stat = fs.statSync(filePath);
-    if (!stat.isFile()) return false;
-    fs.accessSync(filePath, fs.constants.R_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function isExecutable(filePath) {
-  try {
-    fs.accessSync(filePath, fs.constants.X_OK);
-    return fs.statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-
-function isLaunchableBinary(filePath) {
-  if (!filePath) return false;
-  if (isExecutable(filePath)) return true;
-  return isReadableFile(filePath) && /\.(mjs|cjs|js)$/i.test(filePath);
-}
-
-export function desktopBinaryCandidates({ repoRoot = REPO_ROOT, homeDir = os.homedir(), env = process.env } = {}) {
-  const name = binaryName();
-  const tauriRoot = path.join(repoRoot, 'apps', 'chat', 'desktop', 'src-tauri', 'target');
-  return [
-    env.CONSTRUCT_CHAT_DESKTOP_BIN,
-    path.join(tauriRoot, 'release', name),
-    path.join(tauriRoot, 'debug', name),
-    path.join(stateDir(homeDir), 'bin', name),
-    path.join(repoRoot, 'apps', 'chat', 'desktop', 'bin', name),
-  ].filter(Boolean);
-}
-
-export function resolveDesktopBinary(options = {}) {
-  for (const candidate of desktopBinaryCandidates(options)) {
-    if (isLaunchableBinary(candidate)) return candidate;
-  }
-  return null;
-}
-
-export function desktopBinaryInstallHint({ repoRoot = REPO_ROOT } = {}) {
-  return [
-    'Construct chat desktop window is not installed.',
-    'Install it with: construct install --scope=user',
-    `Or set CONSTRUCT_CHAT_DESKTOP_BIN to your construct-chat binary.`,
-    `Dev build: npm run build:chat-desktop (output: ${path.join(repoRoot, 'apps', 'chat', 'desktop', 'src-tauri', 'target', 'release', binaryName())})`,
-  ].join('\n');
-}
-
-export function hasGuiDisplay(env = process.env) {
-  if (env.CX_CHAT_NO_DISPLAY === '1') return false;
-  if (process.platform === 'win32') return true;
-  if (process.platform === 'darwin') return true;
-  return Boolean(env.DISPLAY || env.WAYLAND_DISPLAY);
-}

package/lib/chat/desktop-build.mjs

@@ -1,130 +0,0 @@
-/**
- * lib/chat/desktop-build.mjs — build the Construct chat desktop window from source.
- *
- * The native window is a Tauri (Rust) app at apps/chat/desktop/src-tauri, so a
- * build requires the Rust toolchain. Absent cargo, the rustup installer runs
- * first, then `cargo build --release` produces the binary at
- * target/release/construct-chat — exactly where resolveDesktopBinary looks.
- * Mirrors the build-chat-desktop job in .github/workflows/release.yml for
- * local, low-touch first-run setup.
- */
-
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { resolveDesktopBinary } from './desktop-binary.mjs';
-
-const HERE = path.dirname(fileURLToPath(import.meta.url));
-const REPO_ROOT = path.resolve(HERE, '..', '..');
-
-function srcTauriDir(repoRoot = REPO_ROOT) {
-  return path.join(repoRoot, 'apps', 'chat', 'desktop', 'src-tauri');
-}
-
-export function hasDesktopSource(repoRoot = REPO_ROOT) {
-  try {
-    return fs.statSync(path.join(srcTauriDir(repoRoot), 'Cargo.toml')).isFile();
-  } catch {
-    return false;
-  }
-}
-
-// rustup installs to ~/.cargo/bin, absent from a fresh shell's PATH until
-// ~/.cargo/env is sourced; prepend it for every child process here.
-
-export function cargoEnv(env = process.env, homeDir = os.homedir()) {
-  const cargoBin = path.join(homeDir, '.cargo', 'bin');
-  const sep = process.platform === 'win32' ? ';' : ':';
-  const currentPath = env.PATH || '';
-  const parts = currentPath.split(sep);
-  if (!parts.includes(cargoBin)) {
-    return { ...env, PATH: `${cargoBin}${sep}${currentPath}` };
-  }
-  return { ...env };
-}
-
-export function hasCargo(env = process.env, homeDir = os.homedir()) {
-  const probe = spawnSync('cargo', ['--version'], {
-    env: cargoEnv(env, homeDir),
-    stdio: 'ignore',
-  });
-  return probe.status === 0;
-}
-
-export function ensureRustToolchain({
-  env = process.env,
-  homeDir = os.homedir(),
-  output = process.stdout,
-  errorOutput = process.stderr,
-} = {}) {
-  if (hasCargo(env, homeDir)) return { ok: true };
-
-  if (process.platform === 'win32') {
-    return {
-      ok: false,
-      reason: 'Rust toolchain not found. Install it from https://rustup.rs and re-run.',
-    };
-  }
-
-  output.write('Installing the Rust toolchain (one-time setup for the Construct Chat window)…\n');
-  const installer = spawnSync(
-    'sh',
-    ['-c', "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain stable --profile minimal"],
-    { env, stdio: 'inherit' },
-  );
-
-  if (installer.status !== 0) {
-    return {
-      ok: false,
-      reason: 'Rust toolchain install failed. Install it manually from https://rustup.rs and re-run.',
-    };
-  }
-
-  if (!hasCargo(env, homeDir)) {
-    return {
-      ok: false,
-      reason: 'Rust installed but cargo is still not resolvable on PATH (~/.cargo/bin).',
-    };
-  }
-
-  return { ok: true };
-}
-
-export function buildDesktopBinary({
-  repoRoot = REPO_ROOT,
-  env = process.env,
-  homeDir = os.homedir(),
-  output = process.stdout,
-  errorOutput = process.stderr,
-} = {}) {
-  if (!hasDesktopSource(repoRoot)) {
-    return { ok: false, reason: `Tauri source not found at ${srcTauriDir(repoRoot)}` };
-  }
-
-  const toolchain = ensureRustToolchain({ env, homeDir, output, errorOutput });
-  if (!toolchain.ok) return { ok: false, reason: toolchain.reason };
-
-  output.write('Building the Construct Chat desktop window (cargo build --release)…\n');
-  const build = spawnSync('cargo', ['build', '--release'], {
-    cwd: srcTauriDir(repoRoot),
-    env: cargoEnv(env, homeDir),
-    stdio: 'inherit',
-  });
-
-  if (build.status !== 0) {
-    return { ok: false, reason: 'cargo build --release failed (see output above).' };
-  }
-
-  const binaryPath = resolveDesktopBinary({ repoRoot, homeDir });
-  if (!binaryPath) {
-    return {
-      ok: false,
-      reason: 'Build reported success but no binary resolved at target/release/construct-chat.',
-    };
-  }
-
-  output.write(`Built Construct Chat window: ${binaryPath}\n`);
-  return { ok: true, binaryPath };
-}

package/lib/chat/desktop-launcher.mjs

@@ -1,133 +0,0 @@
-/**
- * lib/chat/desktop-launcher.mjs — start dashboard and open Construct chat in the native window.
- *
- * Launch order when the construct-chat binary is missing: build it from the Tauri
- * source on disk (dev/branch path), else download the prebuilt release asset, else
- * fail loudly with remediation. Chrome app-mode is never an implicit substitute —
- * the native window is the contract, and `construct chat --web` is the explicit
- * browser path.
- */
-
-import { spawn } from 'node:child_process';
-import os from 'node:os';
-import { startDashboard, readDashboardState } from '../service-manager.mjs';
-import { hasGuiDisplay, resolveDesktopBinary } from './desktop-binary.mjs';
-import { buildDesktopBinary, hasDesktopSource } from './desktop-build.mjs';
-
-async function ensureDashboard({ cwd, env, errorOutput }) {
-  let dash = readDashboardState();
-  if (dash?.port) return dash;
-
-  const result = await startDashboard({
-    rootDir: cwd,
-    preferredPort: parseInt(env.PORT || env.DASHBOARD_PORT || '4242', 10),
-  });
-  if (result.started || result.reused) {
-    return { port: result.port, url: result.url || `http://127.0.0.1:${result.port}` };
-  }
-  errorOutput.write(`Failed to start dashboard: ${result.reason || 'unknown error'}\n`);
-  return null;
-}
-
-function waitForChild(child) {
-  return new Promise((resolve) => {
-    let settled = false;
-    const finish = (code) => {
-      if (settled) return;
-      settled = true;
-      resolve(code ?? 0);
-    };
-
-    if (child) {
-      child.on('exit', (code) => finish(code));
-      child.on('error', () => finish(1));
-    }
-
-    const onSignal = () => {
-      try { child?.kill('SIGTERM'); } catch { /* already exited */ }
-      finish(0);
-    };
-    process.once('SIGINT', onSignal);
-    process.once('SIGTERM', onSignal);
-
-    if (!child) finish(0);
-  });
-}
-
-function spawnDesktopBinary(bin, chatUrl, env) {
-  if (/\.(mjs|cjs|js)$/i.test(bin)) {
-    return spawn(process.execPath, [bin, '--url', chatUrl], {
-      env: { ...env, CONSTRUCT_CHAT_URL: chatUrl },
-      stdio: 'ignore',
-      detached: false,
-    });
-  }
-  return spawn(bin, ['--url', chatUrl], {
-    env: { ...env, CONSTRUCT_CHAT_URL: chatUrl },
-    stdio: 'ignore',
-    detached: false,
-  });
-}
-
-async function tryDownloadBinary(env) {
-  try {
-    const { downloadDesktopBinary } = await import('../install/desktop-binary-download.mjs');
-    const result = await downloadDesktopBinary({ homeDir: os.homedir(), env });
-    if (result.status === 'downloaded') return resolveDesktopBinary();
-  } catch {
-    /* fall through to loud failure below */
-  }
-  return null;
-}
-
-function resolveBinaryToLaunch({ cwd, env, output, errorOutput }) {
-  const existing = resolveDesktopBinary({ repoRoot: cwd, env });
-  if (existing) return existing;
-
-  if (hasDesktopSource(cwd)) {
-    const built = buildDesktopBinary({ repoRoot: cwd, env, output, errorOutput });
-    if (built.ok) return built.binaryPath;
-    errorOutput.write(`Could not build the Construct Chat window: ${built.reason}\n`);
-    return null;
-  }
-
-  return null;
-}
-
-export async function runDesktopChat({
-  cwd = process.cwd(),
-  env = process.env,
-  output = process.stdout,
-  errorOutput = process.stderr,
-  binaryPath = null,
-  dashOverride = null,
-} = {}) {
-  if (!hasGuiDisplay(env)) {
-    errorOutput.write('No graphical display available. Use `construct chat --plain` for terminal mode.\n');
-    return 1;
-  }
-
-  let bin = binaryPath || resolveBinaryToLaunch({ cwd, env, output, errorOutput });
-
-  if (!bin && !hasDesktopSource(cwd)) {
-    bin = await tryDownloadBinary(env);
-  }
-
-  if (!bin) {
-    errorOutput.write(
-      'The Construct Chat native window is unavailable.\n'
-      + 'Build it with: npm run build:chat-desktop (requires the Rust toolchain from https://rustup.rs)\n'
-      + 'Or open chat in a browser tab with: construct chat --web\n',
-    );
-    return 1;
-  }
-
-  const dash = dashOverride || await ensureDashboard({ cwd, env, errorOutput });
-  if (!dash) return 1;
-
-  const base = (dash.url || `http://127.0.0.1:${dash.port}`).replace(/\/$/, '');
-  const chatUrl = `${base}/chat/?surface=desktop`;
-
-  const child = spawnDesktopBinary(bin, chatUrl, env);
-  return waitForChild(child);
-}

package/lib/chat/evidence.mjs

@@ -1,145 +0,0 @@
-/** Per-turn evidence provenance for chat surfaces. */
-
-export const EVIDENCE_SCHEMA_VERSION = 1;
-
-const REPO_EVIDENCE_TOOLS = new Set(['read', 'grep', 'glob']);
-const GLOB_META_RE = /[*?\[\]{}]/;
-
-function freeze(value) {
-  if (Array.isArray(value)) value.forEach(freeze);
-  else if (value && typeof value === 'object') Object.values(value).forEach(freeze);
-  return Object.freeze(value);
-}
-
-function concreteTarget(value) {
-  if (typeof value !== 'string' || !value.trim() || GLOB_META_RE.test(value)) return null;
-  return value;
-}
-
-function toolResult(tool = {}) {
-  const result = tool.content ?? tool.result;
-  return result && typeof result === 'object' ? result : null;
-}
-
-function concreteTargets(tool = {}) {
-  const result = toolResult(tool);
-  const name = String(tool.title || tool.kind || '');
-  if (!result) return [];
-  if (name === 'read') return [concreteTarget(result.path || tool.input?.path)].filter(Boolean);
-
-  // grep/glob requests describe a search, not a source. Only the concrete files
-  // returned by a successful result become evidence records.
-  const matches = Array.isArray(result.matches) ? result.matches : [];
-  return [...new Set(matches.map((match) => concreteTarget(typeof match === 'string' ? match : match?.file || match?.path)).filter(Boolean))];
-}
-
-export function evidenceTarget(tool = {}) {
-  return concreteTargets(tool)[0] || null;
-}
-
-export function isSuccessfulEvidenceTool(tool = {}) {
-  if (!REPO_EVIDENCE_TOOLS.has(String(tool.title || tool.kind || ''))) return false;
-  if (tool.status !== 'completed') return false;
-  const result = toolResult(tool);
-  return Boolean(result && result.ok !== false && result.denied !== true && !result.error && concreteTargets(tool).length);
-}
-
-export function evidenceRecords(tools = [], { turnId = null } = {}) {
-  const records = [];
-  for (const tool of tools) {
-    if (!isSuccessfulEvidenceTool(tool)) continue;
-    for (const target of concreteTargets(tool)) {
-      records.push(freeze({
-        schemaVersion: EVIDENCE_SCHEMA_VERSION,
-        recordId: `${turnId || 'turn'}:${String(tool.id || '')}:${target}`,
-        turnId: turnId ? String(turnId) : null,
-        toolId: String(tool.id || ''),
-        tool: String(tool.title || tool.kind),
-        requestedTarget: String(tool.input?.path || tool.input?.glob || tool.input?.pattern || ''),
-        target,
-        sourceId: `repo:${target}`,
-        completion: 'completed',
-        result: 'success',
-      }));
-    }
-  }
-  return freeze(records);
-}
-
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-export function citationMatches(text, record) {
-  const target = String(record?.target || '');
-  const sourceId = String(record?.sourceId || '');
-  if (!target) return false;
-  const escapedTarget = escapeRegExp(target);
-  const targetPattern = new RegExp(`(^|[^A-Za-z0-9_./-])${escapedTarget}(?=$|[^A-Za-z0-9_./-])`);
-  const sourcePattern = sourceId
-    ? new RegExp(`\\[source:\\s*${escapeRegExp(sourceId)}\\s*\\]`, 'i')
-    : null;
-  return targetPattern.test(text) || Boolean(sourcePattern?.test(text));
-}
-
-function verdict({ status, records = [], citations = [], reasonCodes = [] }) {
-  return freeze({
-    schemaVersion: EVIDENCE_SCHEMA_VERSION,
-    status,
-    records: [...records],
-    citations: [...new Set(citations)],
-    reasonCodes: [...reasonCodes],
-  });
-}
-
-export function deriveEvidenceVerdict({ id = null, overlay = null, tools = [], assistant = '', evidenceVisible = true, migration = false } = {}) {
-  const required = overlay?.assumptionsBlocked || overlay?.externalResearch?.required;
-  const migrationCode = migration ? ['legacy_snapshot_without_evidence'] : [];
-  if (!required) return verdict({ status: 'not_applicable', reasonCodes: ['evidence_not_required', ...migrationCode] });
-  if (!evidenceVisible) return verdict({ status: 'insufficient_evidence', reasonCodes: ['evidence_layer_hidden', ...migrationCode] });
-
-  const records = evidenceRecords(tools, { turnId: id });
-  if (!records.length) return verdict({ status: 'insufficient_evidence', records, reasonCodes: ['no_successful_concrete_evidence', ...migrationCode] });
-  const text = String(assistant || '');
-  const citations = records.filter((record) => citationMatches(text, record)).map((record) => record.target);
-  if (!citations.length) return verdict({ status: 'uncited_evidence', records, citations, reasonCodes: ['evidence_not_cited', ...migrationCode] });
-  return verdict({
-    status: citations.length === records.length ? 'verified' : 'partially_verified',
-    records,
-    citations,
-    reasonCodes: [citations.length === records.length ? 'all_recorded_evidence_cited' : 'some_recorded_evidence_uncited', ...migrationCode],
-  });
-}
-
-export function migrateEvidenceVerdict(turn = {}) {
-  if (turn.evidence?.schemaVersion === EVIDENCE_SCHEMA_VERSION) return turn.evidence;
-  if (turn.evidence?.status) {
-    const records = (turn.evidence.records || []).map((record, index) => freeze({
-      schemaVersion: EVIDENCE_SCHEMA_VERSION,
-      recordId: record.recordId || `${turn.id || 'turn'}:${record.toolId || ''}:${record.target || index}`,
-      turnId: record.turnId || turn.id || null,
-      toolId: record.toolId || '',
-      tool: record.tool || 'unknown',
-      requestedTarget: record.requestedTarget || record.target || '',
-      target: record.target || '',
-      sourceId: record.sourceId || `repo:${record.target || ''}`,
-      completion: record.completion || 'completed',
-      result: record.result || 'success',
-    })).filter((record) => record.target);
-    return verdict({
-      status: turn.evidence.status,
-      records,
-      citations: turn.evidence.citations || [],
-      reasonCodes: [...(turn.evidence.reasonCodes || []), 'legacy_evidence_unversioned'],
-    });
-  }
-  return deriveEvidenceVerdict({ ...turn, migration: true });
-}
-
-export function evidenceNotice(verdict) {
-  if (!verdict || verdict.status === 'not_applicable' || verdict.status === 'verified') return null;
-  if (verdict.reasonCodes?.includes('evidence_layer_hidden')) return 'Evidence tools were hidden for this turn, so no source was verified';
-  if (verdict.status === 'uncited_evidence') return 'Evidence was read but the answer does not cite its recorded paths — treat claims as unverified';
-  if (verdict.status === 'partially_verified') return 'Only some recorded evidence paths are cited — treat uncited claims as unverified';
-  return 'Answer produced without successful recorded repo evidence — treat as unverified';
-}

package/lib/chat/export.mjs

@@ -1,74 +0,0 @@
-/**
- * lib/chat/export.mjs — plain markdown export for construct chat turns.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { resolveProjectScopedPath } from '../project-root.mjs';
-import { summarizeSources } from './tui/turn-present.mjs';
-import { rehydrateContinuation } from './context-continuation.mjs';
-import { createContinuationResolver } from './continuation-source.mjs';
-
-function exportDir({ cwd }) {
-  const base = resolveProjectScopedPath('chat-sessions', { cwd, ensureDir: true });
-  const dir = path.join(base, 'exports');
-  fs.mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-// Render a persisted continuation packet by rehydrating it through the one shared
-// resolver (AC3): reconstructible layers re-derive via the same composer a live
-// turn runs, elided layers report as summarized, and the budget accounting stays
-// re-verifiable in the export.
-
-function continuationToMarkdown(packet, { cwd }) {
-  if (!packet || typeof packet !== 'object') return '';
-  const resolver = createContinuationResolver({ cwd });
-  const layers = rehydrateContinuation(packet, { resolveSource: resolver.resolveSource });
-  const budget = packet.budget || {};
-  const lines = ['### context continuation', '',
-    `compacted to fit ~${budget.triggerTokens ?? 'n/a'} tokens — retained ${budget.retainedTokens ?? 0}, summarized ${budget.elidedTokens ?? 0}, referenced ${budget.referencedCount ?? 0}`];
-  if (packet.blocker) {
-    lines.push('', `blocker: ${packet.blocker.reason} (required ${packet.blocker.requiredTokens} > budget ${packet.blocker.budgetTokens})`);
-  }
-  const reconstructed = layers.filter((l) => l.sourceId || l.elided);
-  if (reconstructed.length) {
-    lines.push('', 'layers on rehydrate:');
-    for (const layer of reconstructed) {
-      if (layer.elided) lines.push(`- ${layer.kind}: summarized (elided)`);
-      else lines.push(`- ${layer.kind}: ${layer.resolved ? `re-derived from ${layer.sourceId}` : `unresolved (${layer.sourceId})`}`);
-    }
-  }
-  return lines.join('\n');
-}
-
-function turnToMarkdown(turn, { cwd = process.cwd() } = {}) {
-  const lines = [`## you`, '', turn.userText || '', ''];
-  const evidence = turn.evidence || null;
-  if (evidence) lines.push(`evidence: ${evidence.status}${evidence.reasonCodes?.length ? ` (${evidence.reasonCodes.join(', ')})` : ''}`, '');
-  const src = summarizeSources(evidence?.records?.map((record) => ({ tool: record.tool, ref: record.target })) || turn.sources || []);
-  if (src.total) {
-    lines.push(`sources: ${src.refs.join(', ')}`, '');
-  }
-  lines.push('## construct', '', turn.assistant || '(no answer)', '');
-  if (turn.continuation) {
-    const cont = continuationToMarkdown(turn.continuation, { cwd });
-    if (cont) lines.push('', cont, '');
-  }
-  return lines.join('\n');
-}
-
-export function exportTurns(turnBlocks, { scope = 'last', cwd = process.cwd() } = {}) {
-  const turns = turnBlocks.filter((item) => item.kind === 'turn').map((item) => item.block);
-  if (!turns.length) return { ok: false, error: 'no turns to export' };
-
-  let selected = turns;
-  if (scope === 'last') selected = [turns[turns.length - 1]];
-  else if (scope === 'turn' && turns.length) selected = [turns[turns.length - 1]];
-
-  const body = selected.map((turn) => turnToMarkdown(turn, { cwd })).join('\n---\n\n');
-  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
-  const file = path.join(exportDir({ cwd }), `${stamp}-${scope}-answer.md`);
-  fs.writeFileSync(file, `${body}\n`, 'utf8');
-  return { ok: true, path: file, count: selected.length };
-}