@geraldmaron/construct 1.2.2 → 1.3.0

package/lib/chat/present.mjs

@@ -1,246 +0,0 @@
-/**
- * lib/chat/present.mjs — headless formatters for construct chat surfaces.
- *
- * Shared by Ink TUI, linear renderer, and dashboard web cockpit. Keeps route
- * rows, tool grouping, usage ledgers, and SSE overlay serialization identical
- * across surfaces.
- */
-
-import { formatTokens, formatUsageFooter } from './tui/usage.mjs';
-
-export function summarizeToolCalls(tools = []) {
-  const groups = new Map();
-  for (const t of tools) {
-    const title = t.title || t.kind || 'tool';
-    if (!groups.has(title)) {
-      groups.set(title, { title, count: 0, status: 'completed', refs: [] });
-    }
-    const g = groups.get(title);
-    g.count += 1;
-    if (t.status === 'failed') g.status = 'failed';
-    else if (t.status === 'pending' && g.status !== 'failed') g.status = 'pending';
-    else if (t.status === 'in_progress' && g.status === 'completed') g.status = 'in_progress';
-    const ref = t.input?.path || t.input?.pattern || t.input?.glob || t.input?.name;
-    if (ref) {
-      const s = String(ref);
-      if (!g.refs.includes(s)) g.refs.push(s);
-    }
-  }
-  return [...groups.values()];
-}
-
-export function summarizeSources(sources = []) {
-  if (!sources?.length) {
-    return { total: 0, byTool: {}, refs: [] };
-  }
-  const byTool = {};
-  const refs = [];
-  for (const s of sources) {
-    if (typeof s === 'string') {
-      if (!refs.includes(s)) refs.push(s);
-      continue;
-    }
-    byTool[s.tool] = (byTool[s.tool] || 0) + 1;
-    if (s.ref && !refs.includes(s.ref)) refs.push(s.ref);
-  }
-  return { total: sources.length, byTool, refs };
-}
-
-export function formatRefsInline(refs, { max = 3 } = {}) {
-  if (!refs?.length) return '';
-  if (refs.length <= max) return refs.join(', ');
-  const shown = refs.slice(0, max);
-  return `${shown.join(', ')} +${refs.length - max} more`;
-}
-
-export function formatSourceToolCounts(byTool) {
-  const entries = Object.entries(byTool || {});
-  if (!entries.length) return '';
-  return entries.map(([tool, n]) => `${tool} ${n}`).join('  ');
-}
-
-export function contextRows(overlay, { layers = null } = {}) {
-  if (!overlay) return [];
-  const rows = [];
-  if (overlay.intent) rows.push({ label: 'intent', value: overlay.intent });
-  if (overlay.workCategory) rows.push({ label: 'category', value: overlay.workCategory });
-  if (overlay.track) rows.push({ label: 'track', value: overlay.track });
-  if (overlay.specialists?.length && layers?.specialists !== false) {
-    rows.push({ label: 'route', value: overlay.specialists.join(' → ') });
-  }
-  if (overlay.externalResearch?.required) {
-    const shape = overlay.externalResearch.shape ? ` (${overlay.externalResearch.shape})` : '';
-    rows.push({ label: 'research', value: `required${shape}` });
-  }
-  return rows;
-}
-
-export function splitSourceLines(refs, { limit = 4 } = {}) {
-  if (!refs?.length) return { lines: ['none yet'], hidden: 0, total: 0 };
-  const shown = refs.slice(0, limit);
-  return {
-    lines: shown,
-    hidden: Math.max(0, refs.length - limit),
-    total: refs.length,
-  };
-}
-
-export function toolGroupLabel(group) {
-  const count = group.count > 1 ? ` ×${group.count}` : '';
-  const refs = formatRefsInline(group.refs, { max: 2 });
-  return refs ? `${group.title}${count}  ${refs}` : `${group.title}${count}`;
-}
-
-export function toolStatusGlyph(status) {
-  if (status === 'completed') return '✓';
-  if (status === 'failed') return '✗';
-  if (status === 'in_progress') return '›';
-  return '·';
-}
-
-/**
- * @param {Record<string, unknown> | null | undefined} overlay
- * @param {{ layers?: Record<string, boolean> | null }} [options]
- * @returns {{
- *   chain: string[],
- *   intent: string | null,
- *   track: string | null,
- *   gates: Array<{ label: string, value: string }>,
- *   summary: string | null,
- *   chainLine: string | null,
- * } | null}
- */
-export function formatRouteStrip(overlay, { layers = null } = {}) {
-  if (!overlay) return null;
-  const showSpecialists = layers?.specialists !== false;
-  const chain = showSpecialists && Array.isArray(overlay.specialists)
-    ? [...overlay.specialists]
-    : [];
-  const intent = overlay.intent || null;
-  const track = overlay.track || null;
-  const gates = formatGateRows(overlay);
-  const summary = overlay.dispatchSummary || null;
-  const chainLine = showSpecialists
-    ? (chain.length ? chain.join(' → ') : 'direct')
-    : null;
-  return { chain, intent, track, gates, summary, chainLine };
-}
-
-/**
- * @param {Record<string, unknown> | null | undefined} overlay
- * @param {{ layers?: Record<string, boolean> | null }} [options]
- */
-export function formatRouteLogLine(overlay, { layers = null } = {}) {
-  const strip = formatRouteStrip(overlay, { layers });
-  if (!strip) return '';
-  const parts = [];
-  if (strip.intent) parts.push(`intent=${strip.intent}`);
-  if (strip.track) parts.push(`track=${strip.track}`);
-  if (strip.chainLine) parts.push(strip.chainLine);
-  return parts.join(' · ');
-}
-
-export function formatRiskFlags(riskFlags = {}) {
-  return Object.entries(riskFlags)
-    .filter(([, v]) => v)
-    .map(([k]) => k);
-}
-
-export function formatContractChain(chain = []) {
-  return chain.map((edge) => `${edge.producer} → ${edge.consumer}${edge.stage ? ` (${edge.stage})` : ''}`);
-}
-
-export function formatGateRows(overlay) {
-  if (!overlay) return [];
-  const rows = [];
-  if (overlay.externalResearch?.required) {
-    const detail = overlay.externalResearch.shape || overlay.externalResearch.reason || 'yes';
-    rows.push({ label: 'research', value: `required (${detail})` });
-  }
-  if (overlay.framingChallenge?.required) {
-    rows.push({ label: 'framing', value: 'challenge required' });
-  }
-  if (overlay.docAuthoring?.docType) {
-    rows.push({ label: 'doc', value: `${overlay.docAuthoring.docType} → ${overlay.docAuthoring.owner || 'unknown'}` });
-  }
-  if (overlay.artifactReview?.requiredReviewers?.length) {
-    rows.push({
-      label: 'reviewers',
-      value: overlay.artifactReview.requiredReviewers.join(', '),
-    });
-  }
-  return rows;
-}
-
-export function contextMeterBar(used, size, width = 18) {
-  const ratio = size > 0 ? Math.max(0, Math.min(1, used / size)) : 0;
-  const filled = Math.round(ratio * width);
-  return {
-    bar: '█'.repeat(filled) + '░'.repeat(Math.max(0, width - filled)),
-    ratio,
-    percent: `${Math.round(ratio * 100)}%`,
-    label: `${formatTokens(used) || '0'}/${formatTokens(size) || '?'}`,
-  };
-}
-
-export function sessionUsageSummary(session) {
-  const t = session?.usage?.tokens || session?.tokens || {};
-  const parts = [];
-  if (t.total) parts.push(`${formatTokens(t.total)} tok`);
-  const cost = session?.usage?.cost?.amount ?? session?.cost?.amount;
-  if (cost > 0) parts.push(`~$${cost.toFixed(cost < 1 ? 3 : 2)}`);
-  const turns = session?.usage?.turns ?? session?.turns;
-  if (turns) parts.push(`${turns} turn${turns === 1 ? '' : 's'}`);
-  return parts.join(' · ') || 'no tokens yet';
-}
-
-export function formatTurnUsageLine(usage) {
-  return formatUsageFooter(usage, {}).replace(/^\[usage\] /, '');
-}
-
-export function overlayToSsePayload(overlay) {
-  if (!overlay) return null;
-  return {
-    type: 'overlay',
-    intent: overlay.intent || null,
-    workCategory: overlay.workCategory || null,
-    track: overlay.track || null,
-    specialists: overlay.specialists || [],
-    externalResearch: overlay.externalResearch || null,
-    riskFlags: overlay.riskFlags || null,
-    contractChain: overlay.contractChain || [],
-    framingChallenge: overlay.framingChallenge || null,
-    dispatchSummary: overlay.dispatchSummary || null,
-    dispatchReasons: overlay.dispatchReasons || null,
-    triggers: overlay.triggers || [],
-    docAuthoring: overlay.docAuthoring || null,
-    artifactReview: overlay.artifactReview || null,
-    sessionTurnIndex: overlay.sessionTurnIndex ?? 0,
-    priorIntent: overlay.priorIntent ?? null,
-    workingBranch: overlay.workingBranch ?? null,
-  };
-}
-
-export function sessionMetaToSsePayload({ session, layers, workingBranch, oracle, ctx = null }) {
-  return {
-    type: 'session_meta',
-    model: session?.model || null,
-    demoLabel: session?.demoGuide ? (session.demoTitle || 'scripted') : null,
-    modelMode: session?.modelMode || 'pinned',
-    sandbox: session?.sandbox || null,
-    permissionMode: session?.permissionMode || null,
-    layers: layers || {},
-    workingBranch: workingBranch || null,
-    ctx,
-    oracle: oracle ? {
-      visible: oracle.visible,
-      summary: oracle.summary,
-      topGaps: (oracle.topGaps || []).map((g) => ({ id: g.id, detail: g.detail || g.message || '' })),
-    } : null,
-    usage: session?.usage ? {
-      turns: session.usage.turns,
-      tokens: { ...session.usage.tokens },
-      cost: session.usage.cost ? { ...session.usage.cost } : null,
-    } : null,
-  };
-}

package/lib/chat/session-context.mjs

@@ -1,39 +0,0 @@
-/**
- * lib/chat/session-context.mjs — session-scoped context for planTurn routing.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { execSync } from 'node:child_process';
-
-export function buildPlanContext({ session, cwd = process.cwd(), turnBlocks = [], text = '' } = {}) {
-  const turns = turnBlocks.filter((item) => item.kind === 'turn');
-  const lastTurn = turns.length ? turns[turns.length - 1].block : null;
-
-  let workingBranch = null;
-  try {
-    workingBranch = execSync('git branch --show-current', { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || null;
-  } catch { /* not a git repo */ }
-
-  let projectSummary = null;
-  const contextPath = path.join(cwd, '.cx', 'context.md');
-  try {
-    if (fs.existsSync(contextPath)) {
-      projectSummary = fs.readFileSync(contextPath, 'utf8').slice(0, 500);
-    }
-  } catch { /* unreadable */ }
-
-  const trimmed = String(text).trim();
-  const vagueFollowUp = /^(tell me more|what about|continue|go on|explain|elaborate|and\?)/i.test(trimmed);
-  const projectQuestion = /\b(what is this project|what('s| is) this (repo|project|codebase)|describe this project)\b/i.test(trimmed);
-
-  return {
-    turnIndex: session?.usage?.turns ?? 0,
-    priorIntent: lastTurn?.overlay?.intent ?? null,
-    priorWorkCategory: lastTurn?.overlay?.workCategory ?? null,
-    workingBranch,
-    projectSummary,
-    vagueFollowUp: vagueFollowUp && (session?.usage?.turns ?? 0) > 0,
-    projectQuestion,
-  };
-}

package/lib/chat/session-persist.mjs

@@ -1,73 +0,0 @@
-/**
- * lib/chat/session-persist.mjs — JSONL transcript persistence for construct chat surfaces.
- *
- * Shared by CLI linear mode and dashboard owned-loop SSE so web/desktop resume
- * matches .cx/chat-sessions/ on disk.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { resolveProjectScopedPath } from '../project-root.mjs';
-import { deserializeBlock, serializeBlock, snapshotTurn } from './tui/turn-block.mjs';
-import { migrateEvidenceVerdict } from './evidence.mjs';
-
-export function chatSessionFilePath({ cwd, convId, host = 'construct-web' }) {
-  const dir = resolveProjectScopedPath('chat-sessions', { cwd });
-  return path.join(dir, `${convId}-${host}.jsonl`);
-}
-
-export function createChatPersister({ cwd, sessionId, resumePath = null, host = 'construct' }) {
-  try {
-    const dir = resolveProjectScopedPath('chat-sessions', { cwd });
-    fs.mkdirSync(dir, { recursive: true });
-    const file = resumePath || path.join(dir, `${new Date().toISOString().replace(/[:.]/g, '-')}-${host}-${sessionId}.jsonl`);
-    if (!resumePath) {
-      fs.appendFileSync(file, `${JSON.stringify({ type: 'session_start', host, sessionId, ts: new Date().toISOString() })}\n`);
-    }
-    const append = (row) => {
-      try {
-        fs.appendFileSync(file, `${JSON.stringify({ ...row, ts: new Date().toISOString() })}\n`);
-      } catch { /* log is best-effort */ }
-    };
-    return {
-      filePath: file,
-      event: (event) => append(event),
-      transcript: (role, text) => append({ type: 'transcript', role, text }),
-      transcriptBlock: (turn) => append(serializeBlock(turn)),
-    };
-  } catch {
-    return null;
-  }
-}
-
-export function loadPersistedTurns(filePath) {
-  if (!filePath || !fs.existsSync(filePath)) return { turns: [], turnBlocks: [] };
-  const turns = [];
-  const turnBlocks = [];
-  const lines = fs.readFileSync(filePath, 'utf8').split('\n').filter(Boolean);
-  for (const line of lines) {
-    try {
-      const row = JSON.parse(line);
-      const block = deserializeBlock(row);
-      if (!block) continue;
-      turnBlocks.push({ kind: 'turn', block });
-      const snap = snapshotTurn(block);
-      const evidence = migrateEvidenceVerdict(snap);
-      turns.push({
-        id: snap.id || `turn-${turns.length + 1}`,
-        userText: snap.userText || '',
-        assistant: snap.assistant || '',
-        thinking: snap.thinking || '',
-        tools: snap.tools || [],
-        overlay: snap.overlay || null,
-        sources: snap.sources || [],
-        usage: snap.usage || null,
-        evidence,
-        unverified: ['insufficient_evidence', 'uncited_evidence', 'partially_verified'].includes(evidence.status),
-        working: false,
-        system: false,
-      });
-    } catch { /* skip malformed rows */ }
-  }
-  return { turns, turnBlocks };
-}

package/lib/chat/session-restore.mjs

@@ -1,71 +0,0 @@
-/**
- * lib/chat/session-restore.mjs — resume prior construct chat sessions from jsonl.
- *
- * Session timelines persist under .cx/chat-sessions/*.jsonl. Transcript rows use
- * { type: 'transcript_block', block } for turn fidelity or legacy { type:
- * 'transcript', role, text }; usage events replay into the shared usage
- * accumulator so /usage and the session dock stay truthful after --resume.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { resolveProjectScopedPath } from '../project-root.mjs';
-import { createSessionUsage, addUsage } from './tui/usage.mjs';
-import { restoreBlocksFromSessionLines, turnBlocksToLegacyTranscript } from './tui/turn-block.mjs';
-import { rehydrateContinuation } from './context-continuation.mjs';
-import { createContinuationResolver } from './continuation-source.mjs';
-
-export function sessionDir({ cwd = process.cwd() } = {}) {
-  return resolveProjectScopedPath('chat-sessions', { cwd, ensureDir: false });
-}
-
-export function listSessionFiles({ cwd = process.cwd() } = {}) {
-  const dir = sessionDir({ cwd });
-  if (!dir || !fs.existsSync(dir)) return [];
-  return fs.readdirSync(dir)
-    .filter((name) => name.endsWith('.jsonl'))
-    .map((name) => path.join(dir, name))
-    .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
-}
-
-export function resolveResumePath({ cwd = process.cwd(), resume = null } = {}) {
-  if (resume == null || resume === false) return null;
-  if (typeof resume === 'string' && resume !== 'true' && resume !== '') {
-    const direct = path.resolve(resume);
-    return fs.existsSync(direct) ? direct : null;
-  }
-  return listSessionFiles({ cwd })[0] || null;
-}
-
-export function restoreFromSession(filePath, { cwd = process.cwd() } = {}) {
-  const turnBlocks = [];
-  const usage = createSessionUsage();
-  if (!filePath || !fs.existsSync(filePath)) {
-    return { turnBlocks, transcript: [], usage, sessionFile: null, continuations: [] };
-  }
-
-  const lines = fs.readFileSync(filePath, 'utf8').split('\n').filter((l) => l.trim());
-  for (const line of lines) {
-    let event;
-    try { event = JSON.parse(line); } catch { continue; }
-    if (event.type === 'usage') addUsage(usage, event);
-  }
-
-  const blocks = restoreBlocksFromSessionLines(lines);
-  for (const item of blocks) {
-    if (item.kind === 'turn' || item.kind === 'legacy') turnBlocks.push(item);
-  }
-
-  // Resume rehydrates any persisted continuation packet through the one shared
-  // resolver (AC3), so a resumed session reconstructs the same reconstructible
-  // layers — via the same composer — that the live and export surfaces use.
-  const resolver = createContinuationResolver({ cwd });
-  const continuations = [];
-  for (const item of turnBlocks) {
-    const packet = item?.block?.continuation;
-    if (packet) continuations.push({ packet, layers: rehydrateContinuation(packet, { resolveSource: resolver.resolveSource }) });
-  }
-
-  const transcript = turnBlocksToLegacyTranscript(turnBlocks);
-  return { turnBlocks, transcript, usage, sessionFile: filePath, continuations };
-}

package/lib/chat/session-settings.mjs

@@ -1,53 +0,0 @@
-/**
- * lib/chat/session-settings.mjs — apply validated chat settings to session + config.
- *
- * Shared by slash commands and Ink list pickers so /set and picker commits stay aligned.
- */
-
-import { saveChatConfig, validateSetting } from './config.mjs';
-
-export function applySessionSetting(session, layers, key, rawValue, { cwd, hostId = 'construct' } = {}) {
-  const result = validateSetting(key, rawValue);
-  if (!result.ok) return result;
-
-  const targetKey = result.key || key;
-  if (targetKey.startsWith('layers.')) {
-    const layer = targetKey.slice('layers.'.length);
-    layers[layer] = result.value;
-    session.layers = { ...layers };
-  } else if (targetKey === 'thinking') {
-    layers.thinking = result.value;
-    session.layers = { ...layers };
-    session.thinking = result.value;
-  } else if (targetKey === 'model') {
-    session.model = result.value;
-    session.modelMode = 'pinned';
-    session.savedModel = result.value;
-    session.modelNotice = null;
-  } else if (targetKey === 'permissionMode') {
-    session.permissionMode = result.value;
-  } else if (targetKey === 'sandbox') {
-    session.sandbox = result.value;
-  } else if (targetKey === 'ui.ascii') {
-    session.ui = { ...(session.ui || { ascii: false, inspector: 'auto', theme: 'auto' }), ascii: result.value };
-  } else if (targetKey === 'ui.inspector') {
-    session.ui = { ...(session.ui || { ascii: false, inspector: 'auto', theme: 'auto' }), inspector: result.value };
-  } else if (targetKey === 'ui.theme') {
-    session.ui = { ...(session.ui || { ascii: false, inspector: 'auto', theme: 'auto' }), theme: result.value };
-  }
-
-  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 { /* persistence is best-effort */ }
-
-  return { ok: true, key: targetKey, value: result.value };
-}

package/lib/chat/system-prompt.mjs

@@ -1,52 +0,0 @@
-/**
- * lib/chat/system-prompt.mjs — owned-loop system prompt for construct chat.
- *
- * Keeps a short Construct identity and research discipline without inlining the
- * full orchestrator persona. Turn-scoped policy text is injected per prompt by
- * the engine when an overlay is present.
- */
-
-export const CHAT_SYSTEM_BASE = `You are Construct — a transparent terminal coding agent operating inside a real repository.
-
-Rules:
-- Use read, grep, glob, and construct_tool before making load-bearing claims about this project.
-- For competitive, landscape, or research questions: consult repo files (docs/, ADR/, STRATEGY.md) and cite paths.
-- Call construct_tool with orchestration_policy or knowledge_search when routing or prior artifacts matter.
-- Mark any claim you cannot tie to a tool result as [unverified].
-- Prefer structured markdown answers: headings, short paragraphs, compact tables when useful.
-- Keep actions scoped to the user's request; use write/edit/shell only when asked.`;
-
-export const CHAT_SYSTEM_SMALL = `You are Construct in a local/small-model profile. Be concise.
-- One tool call at a time when possible; cite file paths for claims.
-- Use construct_tool for orchestration_policy when routing is non-trivial.
-- Mark unverified claims explicitly.`;
-
-// Per-turn routing policy belongs in the SYSTEM role, not the user message:
-// otherwise a weak model echoes it back as "the system told me…" in its visible
-// reasoning, and it compounds in the conversation history. These lines carry the
-// substance that improves answer quality (evidence discipline, the resolved
-// route) without exposing internal scaffolding to the user.
-
-export function turnPolicyLines(overlay) {
-  if (!overlay) return [];
-  const lines = [];
-  if (overlay.intent || overlay.workCategory) {
-    lines.push(`Classified intent: ${overlay.intent || 'unknown'}${overlay.workCategory ? ` (${overlay.workCategory})` : ''}.`);
-  }
-  if (overlay.specialists?.length) {
-    lines.push(`Resolved route (a policy overlay, not separate agents): ${overlay.specialists.join(' -> ')}.`);
-  }
-  if (overlay.externalResearch?.required) {
-    lines.push('Repo evidence is REQUIRED this turn: grep/read the relevant files and cite their paths. Do not write a long essay without it.');
-  }
-  if (overlay.assumptionsBlocked) {
-    lines.push('Do not infer the project’s purpose, architecture, or behavior from file names or prior knowledge — read the files first. Mark any claim you cannot tie to a tool result as [unverified].');
-  }
-  return lines;
-}
-
-export function buildSystemPrompt({ base = CHAT_SYSTEM_BASE, overlay = null, capabilityTier = 'full' } = {}) {
-  const effectiveBase = capabilityTier === 'full' ? base : CHAT_SYSTEM_SMALL;
-  const lines = turnPolicyLines(overlay);
-  return lines.length ? `${effectiveBase}\n\nTurn policy (internal — never restate this to the user):\n${lines.join('\n')}` : effectiveBase;
-}

package/lib/chat/transparency.mjs

@@ -1,93 +0,0 @@
-/**
- * lib/chat/transparency.mjs — the transparency layer for `construct chat`.
- *
- * The terminal's differentiator is visibility into the loop, so this module
- * decides what the user sees and enriches the host stream with Construct's own
- * orchestration knowledge. It resolves which transparency layers are active
- * (thinking, planned path, specialist routing, tool calls, observability),
- * classifies each normalized driver event into a channel, and — before a turn
- * runs — derives the specialist path Construct's policy would route the request
- * through (orchestration-policy.mjs) so the planned route is shown alongside the
- * host's actual execution.
- *
- * Transparency-first by default: every layer is on unless explicitly disabled,
- * matching the surface's promise of maximum visibility with opt-out, not opt-in.
- */
-
-const LAYER_KEYS = ['thinking', 'path', 'specialists', 'tools', 'observability'];
-
-export function resolveLayers({ flags = {}, env = process.env } = {}) {
-  const layers = Object.fromEntries(LAYER_KEYS.map((k) => [k, true]));
-
-  if (flags.thinking === false || env.CX_CHAT_THINKING === '0') layers.thinking = false;
-  if (flags.path === false) layers.path = false;
-  if (flags.specialists === false) layers.specialists = false;
-  if (flags.tools === false) layers.tools = false;
-  if (flags.observability === false || flags.quiet === true) layers.observability = false;
-
-  return layers;
-}
-
-const CHANNEL_BY_TYPE = {
-  thinking: 'thinking',
-  text: 'message',
-  plan: 'path',
-  tool_call: 'tools',
-  tool_update: 'tools',
-  usage: 'observability',
-  specialist: 'specialists',
-  permission: 'permission',
-  error: 'error',
-  done: 'system',
-};
-
-export function channelFor(event) {
-  return CHANNEL_BY_TYPE[event?.type] || 'system';
-}
-
-// message, permission, error and system are structural and always shown; the
-// optional layers gate everything else so toggles change visibility without
-// changing the underlying event stream (which still flows to persistence).
-
-export function isVisible(event, layers) {
-  const channel = channelFor(event);
-  if (channel === 'message' || channel === 'permission' || channel === 'error' || channel === 'system') return true;
-  return Boolean(layers[channel]);
-}
-
-export async function planTurn(request, { env = process.env, context = null } = {}) {
-  try {
-    const { routeRequest } = await import('../orchestration-policy.mjs');
-    const route = routeRequest({ request, context: context || {} });
-    const projectQuestion = context?.projectQuestion
-      || /\b(what is this project|what('s| is) this (repo|project|codebase)|describe this project)\b/i.test(String(request));
-    const assumptionsBlocked = projectQuestion
-      || (context?.vagueFollowUp && !context?.priorIntent);
-
-    return {
-      intent: route.intent,
-      workCategory: route.workCategory,
-      specialists: route.specialists,
-      externalResearch: route.externalResearch,
-      riskFlags: route.riskFlags,
-      track: route.track,
-      contractChain: route.contractChain,
-      framingChallenge: route.framingChallenge,
-      dispatchSummary: route.dispatchSummary,
-      dispatchReasons: route.dispatchReasons,
-      triggers: route.triggers,
-      docAuthoring: route.docAuthoring,
-      artifactReview: route.artifactReview,
-      sessionTurnIndex: context?.turnIndex ?? 0,
-      priorIntent: context?.priorIntent ?? null,
-      workingBranch: context?.workingBranch ?? null,
-      assumptionsBlocked,
-    };
-  } catch {
-    return null;
-  }
-}
-
-// Per-turn policy is carried in the system prompt via lib/chat/system-prompt.mjs
-// `turnPolicyLines`/`buildSystemPrompt`, not prepended to the user message, so a
-// model cannot echo it back as user-visible reasoning.

package/lib/chat/tui/color-scheme.mjs

@@ -1,42 +0,0 @@
-/**
- * lib/chat/tui/color-scheme.mjs — terminal light/dark detection for construct chat.
- *
- * Resolves auto|light|dark from CX_CHAT_THEME, saved ui.theme, and COLORFGBG
- * (macOS Terminal, iTerm, Linux VTE, Windows Terminal). Falls back to dark when
- * the background cannot be inferred — set CX_CHAT_THEME=light on legacy Windows
- * conhost if needed.
- */
-
-const THEME_VALUES = new Set(['auto', 'light', 'dark']);
-
-export function schemeFromColorFgBg(value) {
-  const parts = String(value).split(';').map((p) => parseInt(p, 10)).filter((n) => !Number.isNaN(n));
-  if (!parts.length) return null;
-  const bg = parts.length >= 2 ? parts[1] : parts[parts.length - 1];
-  if (bg === 7 || bg === 15) return 'light';
-  if (bg >= 0 && bg <= 6) return 'dark';
-  if (bg === 8) return 'dark';
-  if (bg >= 9 && bg <= 14) return 'light';
-  return null;
-}
-
-export function detectTerminalColorScheme(env = process.env) {
-  const fromFgBg = env.COLORFGBG ? schemeFromColorFgBg(env.COLORFGBG) : null;
-  if (fromFgBg) return fromFgBg;
-  return 'dark';
-}
-
-export function resolveTerminalColorScheme(env = process.env, configTheme = null) {
-  const envTheme = String(env.CX_CHAT_THEME || env.CONSTRUCT_CHAT_THEME || '').trim().toLowerCase();
-  if (envTheme === 'light' || envTheme === 'dark') return envTheme;
-
-  const saved = String(configTheme || '').trim().toLowerCase();
-  if (saved === 'light' || saved === 'dark') return saved;
-
-  return detectTerminalColorScheme(env);
-}
-
-export function normalizeThemeSetting(value) {
-  const v = String(value || 'auto').trim().toLowerCase();
-  return THEME_VALUES.has(v) ? v : null;
-}