@geraldmaron/construct 1.2.3 → 1.3.0

package/lib/chat/tui/turn-block.mjs

@@ -1,284 +0,0 @@
-/**
- * lib/chat/tui/turn-block.mjs — discriminated turn blocks for construct chat.
- *
- * Each user prompt opens a TurnBlock: user message, policy overlay (turn_context),
- * optional thinking/tools streams, assistant answer, turn usage footer, and system
- * notices. Pure data — no React — so Ink and the linear renderer share one model.
- * Sources in turn_context are populated only from recorded tool events (no-fabrication).
- */
-
-import { formatUsageFooter } from './usage.mjs';
-import { deriveEvidenceVerdict, evidenceNotice, evidenceTarget, isSuccessfulEvidenceTool, migrateEvidenceVerdict } from '../evidence.mjs';
-
-export const BLOCK_TYPES = [
-  'user', 'turn_context', 'thinking', 'tool', 'assistant', 'turn_usage', 'system_notice',
-];
-
-export function createTurnBlock(userText) {
-  return {
-    id: `turn-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
-    userText: String(userText),
-    overlay: null,
-    thinking: '',
-    tools: [],
-    assistant: '',
-    usage: null,
-    sources: [],
-    evidence: null,
-    notices: [],
-    continuation: null,
-    closed: false,
-  };
-}
-
-export function overlayToContext(overlay) {
-  if (!overlay) return null;
-  return {
-    intent: overlay.intent || null,
-    workCategory: overlay.workCategory || null,
-    specialists: Array.isArray(overlay.specialists) ? [...overlay.specialists] : [],
-    externalResearch: overlay.externalResearch || null,
-    riskFlags: overlay.riskFlags || [],
-    track: overlay.track || null,
-    contractChain: Array.isArray(overlay.contractChain)
-      ? overlay.contractChain.map((edge) => ({ ...edge }))
-      : [],
-    dispatchReasons: overlay.dispatchReasons ? { ...overlay.dispatchReasons } : null,
-    triggers: Array.isArray(overlay.triggers)
-      ? overlay.triggers.map((t) => ({ ...t }))
-      : [],
-    dispatchSummary: overlay.dispatchSummary || null,
-  };
-}
-
-export function applyOverlayToTurn(turn, overlay) {
-  if (!turn || !overlay) return turn;
-  turn.overlay = overlayToContext(overlay);
-  return turn;
-}
-
-export function recordSource(turn, { tool, ref }) {
-  if (!turn || !tool || !ref) return;
-  const key = `${tool}:${ref}`;
-  if (turn.sources.some((s) => `${s.tool}:${s.ref}` === key)) return;
-  turn.sources.push({ tool, ref, ts: Date.now() });
-}
-
-export function sourceFromToolEvent(event) {
-  if (!event) return null;
-  const title = event.title || event.kind || '';
-  if (title === 'read' || title === 'grep' || title === 'glob') {
-    const path = evidenceTarget(event);
-    if (path) return { tool: title, ref: String(path) };
-  }
-  if (title === 'construct_tool') {
-    const name = event.input?.name;
-    if (name) return { tool: 'construct_tool', ref: String(name) };
-  }
-  return null;
-}
-
-export function turnBlocksFromTranscript(entries = []) {
-  const blocks = [];
-  let current = null;
-
-  for (const entry of entries) {
-    if (entry.kind && entry.block) {
-      blocks.push(entry.block);
-      if (entry.kind === 'turn') current = entry.block;
-      continue;
-    }
-    if (entry.role === 'you' || entry.role === 'user') {
-      current = createTurnBlock(entry.text);
-      blocks.push({ kind: 'turn', block: current });
-      continue;
-    }
-    if (!current) {
-      if (entry.role === 'construct') blocks.push({ kind: 'legacy', role: 'assistant', text: entry.text });
-      continue;
-    }
-    if (entry.role === 'thinking') current.thinking = entry.text;
-    else if (entry.role === 'construct') current.assistant = entry.text;
-  }
-  return blocks;
-}
-
-export function flattenTurnBlocks(blocks) {
-  const out = [];
-  for (const item of blocks) {
-    if (item.kind === 'legacy') {
-      out.push({ type: 'assistant', text: item.text });
-      continue;
-    }
-    if (item.kind !== 'turn') continue;
-    const t = item.block;
-    out.push({ type: 'user', text: t.userText });
-    if (t.overlay) out.push({ type: 'turn_context', overlay: t.overlay, sources: t.sources });
-    if (t.thinking) out.push({ type: 'thinking', text: t.thinking });
-    for (const tool of t.tools) out.push({ type: 'tool', ...tool });
-    if (t.assistant) out.push({ type: 'assistant', text: t.assistant });
-    if (t.usage) out.push({ type: 'turn_usage', usage: t.usage });
-    for (const n of t.notices) out.push({ type: 'system_notice', text: n });
-  }
-  return out;
-}
-
-export function serializeBlock(turn) {
-  return { type: 'transcript_block', block: snapshotTurn(turn) };
-}
-
-export function deserializeBlock(row) {
-  if (row?.type === 'transcript_block' && row.block) {
-    return { ...row.block, evidence: migrateEvidenceVerdict(row.block) };
-  }
-  if (row?.type === 'transcript' && row.role && row.text) {
-    return { legacy: true, role: row.role === 'you' ? 'user' : row.role, text: row.text };
-  }
-  return null;
-}
-
-export function restoreBlocksFromSessionLines(lines) {
-  const blocks = [];
-  let current = null;
-
-  for (const row of lines) {
-    const parsed = typeof row === 'string' ? (() => { try { return JSON.parse(row); } catch { return null; } })() : row;
-    if (!parsed) continue;
-
-    const des = deserializeBlock(parsed);
-    if (!des) continue;
-
-    if (des.legacy) {
-      if (des.role === 'user') {
-        current = createTurnBlock(des.text);
-        blocks.push({ kind: 'turn', block: current });
-      } else if (current && des.role === 'assistant') {
-        current.assistant = des.text;
-      } else {
-        blocks.push({ kind: 'legacy', role: 'assistant', text: des.text });
-      }
-      continue;
-    }
-
-    if (des.kind === 'user') {
-      current = createTurnBlock(des.userText || des.text || '');
-      blocks.push({ kind: 'turn', block: current });
-    } else if (des.kind === 'turn_snapshot') {
-      current = {
-        ...des,
-        tools: des.tools || [],
-        sources: des.sources || [],
-        evidence: migrateEvidenceVerdict(des),
-        notices: des.notices || [],
-        continuation: des.continuation || null,
-      };
-      blocks.push({ kind: 'turn', block: current });
-    }
-  }
-  return blocks;
-}
-
-export function snapshotTurn(turn) {
-  return {
-    kind: 'turn_snapshot',
-    id: turn.id,
-    userText: turn.userText,
-    overlay: turn.overlay,
-    thinking: turn.thinking,
-    tools: turn.tools,
-    assistant: turn.assistant,
-    usage: turn.usage,
-    sources: turn.sources,
-    evidence: turn.evidence,
-    notices: turn.notices,
-    continuation: turn.continuation || null,
-  };
-}
-
-export function applyEventToTurn(turn, event, state = null) {
-  if (!turn || !event) return turn;
-  switch (event.type) {
-    case 'thinking':
-      turn.thinking = state?.thinking ?? `${turn.thinking || ''}${event.text || ''}`;
-      break;
-    case 'text':
-      turn.assistant = state?.assistant ?? `${turn.assistant || ''}${event.text || ''}`;
-      break;
-    case 'tool_call': {
-      const existing = turn.tools.find((t) => t.id === event.id);
-      if (existing) {
-        existing.input = event.input ?? existing.input;
-      } else {
-        turn.tools.push({
-          id: event.id,
-          title: event.title || event.kind || 'tool',
-          status: 'pending',
-          input: event.input ?? null,
-        });
-      }
-      break;
-    }
-    case 'tool_update': {
-      const t = turn.tools.find((x) => x.id === event.id);
-      if (t) {
-        t.status = event.status || t.status;
-        t.content = event.content ?? t.content;
-        const src = sourceFromToolEvent(t);
-        if (isSuccessfulEvidenceTool(t) && src) recordSource(turn, src);
-      }
-      else turn.tools.push({ id: event.id, title: event.id, status: event.status || 'pending' });
-      break;
-    }
-    case 'usage':
-      turn.usage = event;
-      break;
-    case 'notice':
-      if (event.message && !turn.notices.includes(event.message)) turn.notices.push(event.message);
-      break;
-    case 'context_continuation':
-      if (event.packet) turn.continuation = event.packet;
-      break;
-    default:
-      break;
-  }
-  return turn;
-}
-
-export function formatTurnUsageLine(usage, colors = {}) {
-  return formatUsageFooter(usage, colors).replace(/^\[usage\] /, '');
-}
-
-export function finalizeTurn(turn, { evidenceVisible = true } = {}) {
-  if (!turn) return turn;
-  turn.closed = true;
-  turn.evidence = deriveEvidenceVerdict({ ...turn, evidenceVisible });
-  turn.sources = turn.evidence.records.map((record) => ({ tool: record.tool, ref: record.target, ts: Date.now() }));
-  const msg = evidenceNotice(turn.evidence);
-  if (msg) {
-    if (!turn.notices.includes(msg)) turn.notices.push(msg);
-  }
-  return turn;
-}
-
-export function turnBlocksToLegacyTranscript(blocks = []) {
-  const out = [];
-  for (const item of blocks) {
-    if (item.kind === 'legacy') {
-      out.push({ role: 'construct', text: item.text });
-      continue;
-    }
-    if (item.kind !== 'turn') continue;
-    const t = item.block;
-    out.push({ role: 'you', text: t.userText });
-    if (t.thinking) out.push({ role: 'thinking', text: t.thinking });
-    if (t.assistant) out.push({ role: 'construct', text: t.assistant });
-  }
-  return out;
-}
-
-export function shouldShowInspector({ uiInspector = 'off', turn = null, forced = null } = {}) {
-  if (forced != null) return forced;
-  const mode = uiInspector || 'off';
-  if (mode === 'on') return true;
-  return false;
-}

package/lib/chat/tui/turn-present.mjs

@@ -1,18 +0,0 @@
-/**
- * lib/chat/tui/turn-present.mjs — re-exports shared chat presenters for TUI.
- *
- * Implementation lives in lib/chat/present.mjs so Ink, linear, and web share
- * one formatting source.
- */
-
-export {
-  summarizeToolCalls,
-  summarizeSources,
-  formatRefsInline,
-  formatSourceToolCounts,
-  contextRows,
-  splitSourceLines,
-  toolGroupLabel,
-  formatRouteStrip,
-  formatRouteLogLine,
-} from '../present.mjs';

package/lib/chat/tui/turn-state.mjs

@@ -1,88 +0,0 @@
-/**
- * lib/chat/tui/turn-state.mjs — pure turn-state reduction for chat renderers.
- *
- * Reduces normalized driver events into renderable turn state with no React import.
- * Shared by linear mode, owned-loop SSE fallback, and functional tests.
- */
-
-import { addUsage } from './usage.mjs';
-import { isVisible } from '../transparency.mjs';
-
-export function createTurnState() {
-  return {
-    assistant: '',
-    thinking: '',
-    tools: [],
-    plan: [],
-    route: [],
-    permissions: [],
-    error: null,
-    rendered: false,
-    stopReason: null,
-    lastUsage: null,
-  };
-}
-
-export function applyTurnEvent(state, event, { session = null } = {}) {
-  switch (event?.type) {
-    case 'text':
-      state.assistant += event.text || '';
-      state.rendered = true;
-      break;
-    case 'thinking':
-      state.thinking += event.text || '';
-      state.rendered = true;
-      break;
-    case 'plan':
-      state.plan = Array.isArray(event.entries) ? event.entries : [];
-      state.rendered = true;
-      break;
-    case 'tool_call': {
-      state.tools.push({
-        id: event.id,
-        title: event.title || event.kind || 'tool',
-        status: 'pending',
-        input: event.input ?? null,
-      });
-      state.rendered = true;
-      break;
-    }
-    case 'tool_update': {
-      const existing = state.tools.find((t) => t.id === event.id);
-      if (existing) existing.status = event.status || existing.status;
-      else state.tools.push({ id: event.id, title: event.id || 'tool', status: event.status || 'pending' });
-      state.rendered = true;
-      break;
-    }
-    case 'usage':
-      if (session) addUsage(session.usage, event);
-      state.lastUsage = event;
-      break;
-    case 'permission': {
-      const title = event.toolCall?.title || event.toolCall?.callID || 'tool';
-      state.permissions.push({ title, detail: event.options?.length ? `${event.options.length} options` : 'decision' });
-      state.rendered = true;
-      break;
-    }
-    case 'error':
-      state.error = event.message || 'error';
-      state.rendered = true;
-      break;
-    case 'done':
-      state.stopReason = event.stopReason || 'end_turn';
-      break;
-    default:
-      break;
-  }
-  return state;
-}
-
-export async function runTurnInto(driver, text, opts, { session = null, layers = null, onUpdate = () => {} } = {}) {
-  const state = createTurnState();
-  for await (const event of driver.prompt(text, opts)) {
-    if (layers && !isVisible(event, layers)) continue;
-    applyTurnEvent(state, event, { session });
-    onUpdate(state, event);
-  }
-  return state;
-}

package/lib/chat/tui/usage.mjs

@@ -1,122 +0,0 @@
-/**
- * lib/chat/tui/usage.mjs — truthful token/cost accounting for `construct chat`.
- *
- * Formats a single turn's usage event into a compact footer and accumulates usage
- * across a session for the `/usage` panel. Every field is optional and only printed
- * when the host actually reported it: there are no fabricated or estimated splits
- * (no-fabrication rule). `input` tokens are labeled "prompt" since, under the
- * delegate-the-loop model, that is the only honest "prompt section" the host exposes;
- * a per-specialist breakdown is shown only when the host emits per-sub-agent usage.
- */
-
-export function createSessionUsage() {
-  return {
-    turns: 0,
-    tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, total: 0 },
-    cost: { amount: 0, currency: 'USD' },
-    bySubAgent: new Map(),
-    history: [],
-  };
-}
-
-function addInto(target, tokens = {}) {
-  if (!target || typeof target !== 'object') return;
-  for (const key of Object.keys(target)) {
-    if (Number.isFinite(tokens[key])) target[key] += tokens[key];
-  }
-}
-
-export function addUsage(session, event) {
-  // A usage event must never crash a turn. Accept only a well-formed accumulator
-  // (the shape from createSessionUsage); anything else — a stray session object, a
-  // restored partial — is a safe no-op rather than a thrown error mid-stream.
-  if (!session || !event || !session.tokens) return;
-  session.turns = (session.turns || 0) + 1;
-  addInto(session.tokens, event.tokens || {});
-  if (event.cost && Number.isFinite(event.cost.amount) && session.cost) {
-    session.cost.amount += event.cost.amount;
-    if (event.cost.currency) session.cost.currency = event.cost.currency;
-  }
-  if (event.subAgent && event.tokens && session.bySubAgent?.get) {
-    const prev = session.bySubAgent.get(event.subAgent) || { input: 0, output: 0, total: 0 };
-    addInto(prev, event.tokens);
-    session.bySubAgent.set(event.subAgent, prev);
-  }
-  if (Array.isArray(session.history)) {
-    session.history.push({ tokens: event.tokens || null, cost: event.cost || null, model: event.model || null });
-  }
-}
-
-export function formatTokens(n) {
-  if (!Number.isFinite(n)) return null;
-  if (n < 1000) return String(n);
-  if (n < 1000000) return `${(n / 1000).toFixed(n < 10000 ? 1 : 0)}k`;
-  return `${(n / 1000000).toFixed(1)}M`;
-}
-
-function formatCost(cost) {
-  if (!cost || !Number.isFinite(cost.amount)) return null;
-  if (cost.amount === 0) return '$0';
-  const digits = cost.amount < 0.01 ? 4 : cost.amount < 1 ? 3 : 2;
-  return `~$${cost.amount.toFixed(digits)}`;
-}
-
-// Builds an ordered list of "label value" parts from whatever the host reported.
-
-function usageParts(event) {
-  const t = event.tokens || {};
-  const parts = [];
-  if (Number.isFinite(t.input)) parts.push(`prompt ${formatTokens(t.input)}`);
-  if (Number.isFinite(t.output)) parts.push(`output ${formatTokens(t.output)}`);
-  if (Number.isFinite(t.reasoning) && t.reasoning > 0) parts.push(`reasoning ${formatTokens(t.reasoning)}`);
-  if (Number.isFinite(t.cacheRead) && t.cacheRead > 0) parts.push(`cache\u2193 ${formatTokens(t.cacheRead)}`);
-  if (Number.isFinite(t.cacheWrite) && t.cacheWrite > 0) parts.push(`cache\u2191 ${formatTokens(t.cacheWrite)}`);
-  if (Number.isFinite(t.total)) parts.push(`total ${formatTokens(t.total)}`);
-  const cost = formatCost(event.cost);
-  if (cost) parts.push(cost);
-  if (event.context && Number.isFinite(event.context.used) && Number.isFinite(event.context.size)) {
-    parts.push(`ctx ${formatTokens(event.context.used)}/${formatTokens(event.context.size)}`);
-  }
-  if (event.model) parts.push(`model ${event.model}`);
-  return parts;
-}
-
-export function formatUsageFooter(event, colors = {}) {
-  const dim = colors.dim || '';
-  const reset = colors.reset || '';
-  const parts = usageParts(event);
-  if (!parts.length) return `${dim}[usage] (host reported no token counts)${reset}`;
-  return `${dim}[usage] ${parts.join(' \u00b7 ')}${reset}`;
-}
-
-// Multi-line detailed panel for the `/usage` command: session totals, per-sub-agent
-// attribution when present, and a short per-turn history.
-
-export function formatUsagePanel(session, colors = {}) {
-  const dim = colors.dim || '';
-  const bold = colors.bold || '';
-  const reset = colors.reset || '';
-  const lines = [];
-  lines.push(`${bold}session usage${reset} ${dim}(${session.turns} turn${session.turns === 1 ? '' : 's'})${reset}`);
-
-  const t = session.tokens;
-  const totalParts = [];
-  if (t.input) totalParts.push(`prompt ${formatTokens(t.input)}`);
-  if (t.output) totalParts.push(`output ${formatTokens(t.output)}`);
-  if (t.reasoning) totalParts.push(`reasoning ${formatTokens(t.reasoning)}`);
-  if (t.cacheRead) totalParts.push(`cache\u2193 ${formatTokens(t.cacheRead)}`);
-  if (t.cacheWrite) totalParts.push(`cache\u2191 ${formatTokens(t.cacheWrite)}`);
-  if (t.total) totalParts.push(`total ${formatTokens(t.total)}`);
-  const cost = formatCost(session.cost);
-  if (cost) totalParts.push(cost);
-  lines.push(totalParts.length ? `  ${totalParts.join(' \u00b7 ')}` : `  ${dim}no token counts reported yet${reset}`);
-
-  if (session.bySubAgent.size) {
-    lines.push(`${dim}  by sub-agent:${reset}`);
-    for (const [name, st] of session.bySubAgent) {
-      lines.push(`    ${name}: prompt ${formatTokens(st.input)} \u00b7 output ${formatTokens(st.output)} \u00b7 total ${formatTokens(st.total)}`);
-    }
-  }
-
-  return lines.join('\n');
-}

package/lib/chat/web-commands.mjs

@@ -1,146 +0,0 @@
-/**
- * lib/chat/web-commands.mjs — slash-command handler for dashboard web chat.
- *
- * Mirrors lib/chat/commands.mjs without readline. Returns plain-text output
- * and optional side effects (clear, open picker) for the web cockpit.
- */
-
-import { HELP } from './commands.mjs';
-import { LAYER_KEYS, loadChatConfig } from './config.mjs';
-import { formatUsagePanel } from './tui/usage.mjs';
-import { applySessionSetting } from './session-settings.mjs';
-import { commitPickerModel } from './model-picker.mjs';
-import { resolveFreeOpenRouterModel } from '../../apps/chat/engine/models.mjs';
-import { exportTurns } from './export.mjs';
-import { readOracleDockState, formatOracleDockDetail } from '../intake/session-prelude.mjs';
-import { handleDemoCommand } from './demo-guide.mjs';
-
-export { HELP };
-
-export async function handleWebChatCommand(input, {
-  runtime = null,
-  cwd = process.cwd(),
-  turnBlocks = [],
-  version = null,
-} = {}) {
-  const text = String(input || '').trim();
-  if (!text.startsWith('/')) {
-    return { ok: false, error: 'not a command' };
-  }
-
-  const [cmd, ...rest] = text.split(/\s+/);
-  const arg = rest.join(' ').trim();
-  const session = runtime?.session || {};
-  const layers = runtime?.layers || {};
-
-  switch (cmd) {
-    case '/help': {
-      const lines = ['commands'];
-      for (const [name, desc] of HELP) lines.push(`  ${name.padEnd(28)}${desc}`);
-      return { ok: true, output: lines.join('\n') };
-    }
-
-    case '/host': {
-      const mode = session.modelMode === 'free-router' ? 'free-router' : 'pinned';
-      const lines = [
-        `engine: construct (owned loop)${version ? ` (${version})` : ''}  model: ${session.model || '(default)'}  mode: ${mode}`,
-        'construct runs the loop itself; switch models with /model',
-      ];
-      return { ok: true, output: lines.join('\n') };
-    }
-
-    case '/models':
-    case '/model':
-      if (arg) {
-        commitPickerModel(session, { mode: 'pinned', modelId: arg }, { cwd, layers });
-        return { ok: true, output: `model set: ${arg} (pinned, saved)`, sessionMeta: true };
-      }
-      return { ok: true, picker: 'model' };
-
-    case '/free': {
-      const freeId = await resolveFreeOpenRouterModel({ env: runtime?.env || process.env, tier: 'standard' });
-      if (!freeId) return { ok: true, output: 'OpenRouter free router needs OPENROUTER_API_KEY' };
-      commitPickerModel(session, { mode: 'free-router', modelId: freeId }, { cwd, layers });
-      return { ok: true, output: `model mode: free-router → ${freeId} (saved)`, sessionMeta: true };
-    }
-
-    case '/set':
-      if (!rest.length) return { ok: true, picker: 'set' };
-      return applySetCommand(session, layers, rest, { cwd });
-
-    case '/settings': {
-      const { config } = loadChatConfig({ cwd });
-      const lines = [
-        'settings',
-        `  model: ${session.modelMode === 'free-router' ? `free-router → ${session.model || '?'}` : (session.model || '(default)')}`,
-        `  permission: ${session.permissionMode || config.permissionMode || 'allow_once'}`,
-        `  sandbox: ${session.sandbox || config.sandbox || 'workspace-write'}`,
-        `  layers: ${LAYER_KEYS.map((k) => `${k}=${layers[k] !== false ? 'on' : 'off'}`).join('  ')}`,
-      ];
-      return { ok: true, output: lines.join('\n') };
-    }
-
-    case '/layers':
-      return {
-        ok: true,
-        output: [
-          `layers: ${LAYER_KEYS.map((k) => `${k}=${layers[k] !== false ? 'on' : 'off'}`).join('  ')}`,
-          'toggle with: /set <layer> on|off',
-        ].join('\n'),
-      };
-
-    case '/usage':
-      return { ok: true, output: formatUsagePanel(session.usage || { turns: 0, tokens: {}, cost: { amount: 0 } }) };
-
-    case '/oracle': {
-      const state = readOracleDockState({ cwd, env: runtime?.env || process.env });
-      return { ok: true, output: `oracle\n${formatOracleDockDetail(state)}` };
-    }
-
-    case '/export': {
-      const scope = arg === 'session' ? 'session' : 'last';
-      const result = exportTurns(turnBlocks, { scope, cwd });
-      if (!result.ok) return { ok: true, output: result.error || 'export failed' };
-      return { ok: true, output: `exported ${result.count} turn(s) to ${result.path}` };
-    }
-
-    case '/clear':
-      return { ok: true, clear: true };
-
-    case '/demo': {
-      const guide = runtime?.session?.demoGuide;
-      if (!guide) {
-        return { ok: true, output: 'No active demo. Launch with `construct demo <name>` or set CONSTRUCT_DEMO.' };
-      }
-      const chunks = [];
-      const output = { write: (text) => { chunks.push(String(text)); } };
-      handleDemoCommand(arg, {
-        demoGuide: guide,
-        output,
-        colors: { dim: '', reset: '', bold: '', green: '' },
-      });
-      return { ok: true, output: chunks.join('').trim() || 'demo command complete' };
-    }
-
-    case '/inspect':
-      return { ok: true, output: 'inspector toggle is Ink-only; web shows full inline detail by default' };
-
-    case '/exit':
-    case '/quit':
-      return { ok: true, output: 'exit is terminal-only — close the tab or navigate away' };
-
-    default:
-      return { ok: true, output: `unknown command: ${cmd} — try /help` };
-  }
-}
-
-function applySetCommand(session, layers, rest, { cwd }) {
-  const [key, ...valueParts] = rest;
-  if (!key) return { ok: true, picker: 'set' };
-  const rawValue = valueParts.join(' ').trim();
-  if (!rawValue) return { ok: true, output: `usage: /set ${key} <on|off|value>` };
-
-  const result = applySessionSetting(session, layers, key, rawValue, { cwd, hostId: 'construct' });
-  if (!result.ok) return { ok: true, output: result.error || 'invalid setting' };
-  return { ok: true, output: `${result.key}: ${result.value}`, sessionMeta: true, layers: { ...layers } };
-}