@geraldmaron/construct 1.1.1 → 1.2.0

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

@@ -0,0 +1,284 @@
+/**
+ * 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

@@ -0,0 +1,18 @@
+/**
+ * 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

@@ -0,0 +1,88 @@
+/**
+ * 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

@@ -0,0 +1,122 @@
+/**
+ * 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

@@ -0,0 +1,146 @@
+/**
+ * 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 } };
+}