@geraldmaron/construct 1.2.2 → 1.3.0

package/lib/chat/context-continuation.mjs

@@ -1,253 +0,0 @@
-/**
- * lib/chat/context-continuation.mjs — the deterministic context-continuation
- * contract (construct-6zga.1.9).
- *
- * A chat session's context is an ordered set of layers — static instructions,
- * role guidance, the task packet, validated evidence, tool results, the
- * conversation summary, optional learned patterns, plus the protected state
- * (user constraints, approvals, unresolved blockers). When context pressure
- * crosses the capability profile's compaction trigger (the execution policy's
- * continuation budget, never a model-name fixed limit), the session must compact
- * without silent loss: it produces a structured continuation packet that retains
- * required state verbatim, references reconstructible layers by source id for
- * re-derivation, elides compactible layers with a truthful marker, and — when the
- * required state alone exceeds the budget — yields a user-visible blocker instead
- * of dropping anything. The packet carries source ids and token accounting so a
- * reader can re-verify it, and rehydrateContinuation feeds the same layer set back
- * through the composer on every surface. Reference shape:
- * schemas/continuation-packet.schema.json.
- */
-
-export const CONTINUATION_PACKET_SCHEMA_VERSION = 1;
-
-export const CONTEXT_LAYER_KINDS = Object.freeze([
-  'static-instructions',
-  'role-guidance',
-  'task-packet',
-  'validated-evidence',
-  'tool-results',
-  'conversation-summary',
-  'learned-patterns',
-  'user-constraints',
-  'approvals',
-  'blockers',
-]);
-
-export const COMPACTION_ELIGIBILITY = Object.freeze(['required', 'reconstructible', 'compactible']);
-
-export const LAYER_DISPOSITIONS = Object.freeze(['retained', 'referenced', 'elided']);
-
-// The protected layers carry state the loop must never silently drop: user
-// constraints, approvals, the current task packet, evidence provenance, and
-// unresolved blockers. Reconstructible layers can be re-derived from a durable
-// source by id, so the packet references rather than stores them. Compactible
-// layers are conversation history that compacts lossily but is never silently
-// lost — an elided one keeps a truthful marker of what was removed.
-
-const DEFAULT_ELIGIBILITY = Object.freeze({
-  'user-constraints': 'required',
-  approvals: 'required',
-  'task-packet': 'required',
-  'validated-evidence': 'required',
-  blockers: 'required',
-  'static-instructions': 'reconstructible',
-  'role-guidance': 'reconstructible',
-  'learned-patterns': 'reconstructible',
-  'conversation-summary': 'compactible',
-  'tool-results': 'compactible',
-});
-
-function estimateTextTokens(text) {
-  return Math.ceil(String(text || '').length / 4);
-}
-
-function sumTokens(layers) {
-  return layers.reduce((total, l) => total + (Number.isFinite(l.tokens) ? l.tokens : 0), 0);
-}
-
-/**
- * Normalize a raw layer set into a deterministic inventory: assign each layer an
- * id, a known kind, its compaction eligibility (explicit or kind-defaulted), and a
- * token count. Order is preserved so callers control retention priority.
- */
-export function classifyContextLayers(layers = [], { estimateTokens = estimateTextTokens } = {}) {
-  const list = Array.isArray(layers) ? layers : [];
-  return list.map((raw, index) => {
-    const kind = CONTEXT_LAYER_KINDS.includes(raw?.kind) ? raw.kind : 'conversation-summary';
-    const eligibility = COMPACTION_ELIGIBILITY.includes(raw?.eligibility)
-      ? raw.eligibility
-      : (DEFAULT_ELIGIBILITY[kind] || 'compactible');
-    const content = typeof raw?.content === 'string' ? raw.content : '';
-    const tokens = Number.isFinite(raw?.tokens) ? raw.tokens : estimateTokens(content);
-    return {
-      id: raw?.id || `${kind}-${index}`,
-      kind,
-      eligibility,
-      sourceId: raw?.sourceId ?? null,
-      tokens,
-      content,
-    };
-  });
-}
-
-function retainedLayer(layer) {
-  return { id: layer.id, kind: layer.kind, eligibility: layer.eligibility, disposition: 'retained', tokens: layer.tokens, sourceId: layer.sourceId, content: layer.content };
-}
-
-function referencedLayer(layer) {
-  return { id: layer.id, kind: layer.kind, eligibility: layer.eligibility, disposition: 'referenced', tokens: layer.tokens, sourceId: layer.sourceId, content: null };
-}
-
-function elidedLayer(layer) {
-  return { id: layer.id, kind: layer.kind, eligibility: layer.eligibility, disposition: 'elided', tokens: layer.tokens, sourceId: layer.sourceId, content: null };
-}
-
-/**
- * Compact a classified inventory to the continuation budget. Required layers are
- * retained verbatim; a reconstructible layer with a source id is referenced for
- * re-derivation (and costs no budget), while one without a source id falls back to
- * the compactible pool so it is never lost. Compactible layers fill the remaining
- * budget in order and are elided with a marker once it is spent. When the required
- * state alone exceeds the budget the result is a truthful blocker — nothing is
- * dropped to make room for it.
- */
-export function compactContext(inventory = [], { triggerTokens = null } = {}) {
-  const layers = classifyContextLayers(inventory);
-  const required = layers.filter((l) => l.eligibility === 'required');
-  const reconstructible = layers.filter((l) => l.eligibility === 'reconstructible');
-  const compactible = layers.filter((l) => l.eligibility === 'compactible');
-
-  const requiredTokens = sumTokens(required);
-  const budget = Number.isFinite(triggerTokens) && triggerTokens > 0 ? triggerTokens : Infinity;
-
-  const referenced = [];
-  const pressurePool = [...compactible];
-  for (const layer of reconstructible) {
-    if (layer.sourceId) referenced.push(referencedLayer(layer));
-    else pressurePool.push(layer);
-  }
-
-  const blocked = requiredTokens > budget;
-  const blocker = blocked
-    ? { reason: 'required-state-exceeds-budget', requiredTokens, budgetTokens: budget, overflowTokens: requiredTokens - budget }
-    : null;
-
-  const retainedCompactible = [];
-  const elided = [];
-  let used = 0;
-  const remaining = blocked ? 0 : budget - requiredTokens;
-  for (const layer of pressurePool) {
-    if (!blocked && used + layer.tokens <= remaining) {
-      retainedCompactible.push(retainedLayer(layer));
-      used += layer.tokens;
-    } else {
-      elided.push(elidedLayer(layer));
-    }
-  }
-
-  const packetLayers = [
-    ...required.map(retainedLayer),
-    ...referenced,
-    ...retainedCompactible,
-    ...elided,
-  ];
-
-  return buildContinuationPacket({
-    layers: packetLayers,
-    requiredState: required.map((l) => ({ id: l.id, kind: l.kind, sourceId: l.sourceId, tokens: l.tokens })),
-    budget,
-    requiredTokens,
-    blocker,
-  });
-}
-
-/**
- * Assemble a structured, JSON-serializable continuation packet from a compaction
- * result. Token accounting balances the retained, referenced, and elided layers
- * against the budget so the packet is independently re-verifiable.
- */
-export function buildContinuationPacket({ layers = [], requiredState = [], budget = Infinity, requiredTokens = 0, blocker = null } = {}) {
-  const retainedTokens = sumTokens(layers.filter((l) => l.disposition === 'retained'));
-  const elidedTokens = sumTokens(layers.filter((l) => l.disposition === 'elided'));
-  const referencedCount = layers.filter((l) => l.disposition === 'referenced').length;
-
-  return {
-    schemaVersion: CONTINUATION_PACKET_SCHEMA_VERSION,
-    budget: {
-      triggerTokens: Number.isFinite(budget) ? budget : null,
-      requiredTokens,
-      retainedTokens,
-      elidedTokens,
-      referencedCount,
-    },
-    layers,
-    requiredState,
-    blocker,
-  };
-}
-
-/**
- * Re-derive the ordered layer set a composer needs to resume a session. Required
- * and retained layers return their stored content; a referenced layer is re-derived
- * through resolveSource(sourceId) so reconstructible context returns intact; an
- * elided layer returns a truthful marker of what was removed. The same call backs
- * terminal, web, export, and resume — one rehydration path, no surface drift.
- */
-export function rehydrateContinuation(packet, { resolveSource = null } = {}) {
-  const layers = Array.isArray(packet?.layers) ? packet.layers : [];
-  return layers.map((layer) => {
-    if (layer.disposition === 'referenced') {
-      const content = typeof resolveSource === 'function' ? resolveSource(layer.sourceId, layer) : null;
-      return { id: layer.id, kind: layer.kind, content: typeof content === 'string' ? content : null, resolved: typeof content === 'string', sourceId: layer.sourceId };
-    }
-    if (layer.disposition === 'elided') {
-      return { id: layer.id, kind: layer.kind, content: null, elided: true, tokens: layer.tokens, sourceId: layer.sourceId };
-    }
-    return { id: layer.id, kind: layer.kind, content: layer.content ?? '' };
-  });
-}
-
-/**
- * Read the continuation budget from a compiled execution policy
- * (lib/models/execution-policy.mjs). Capability-profile driven, never a model-name
- * fixed limit (construct-6zga.1.2 AC4).
- */
-export function continuationBudgetFromPolicy(policy) {
-  const c = policy && typeof policy === 'object' ? policy.continuation : null;
-  return {
-    triggerTokens: Number.isFinite(c?.compactionTriggerTokens) ? c.compactionTriggerTokens : null,
-    triggerRatio: Number.isFinite(c?.compactionTriggerRatio) ? c.compactionTriggerRatio : null,
-  };
-}
-
-/**
- * Hand-rolled validator (no ajv — Construct stays dependency-free at startup).
- * Beyond shape, it enforces the no-silent-loss invariant: every required layer is
- * retained unless the packet carries a blocker.
- */
-export function validateContinuationPacket(packet) {
-  const errors = [];
-  if (!packet || typeof packet !== 'object') return { valid: false, errors: ['packet is not an object'] };
-  if (packet.schemaVersion !== CONTINUATION_PACKET_SCHEMA_VERSION) errors.push(`schemaVersion must be ${CONTINUATION_PACKET_SCHEMA_VERSION}`);
-
-  if (!Array.isArray(packet.layers)) errors.push('layers must be an array');
-  else {
-    for (const layer of packet.layers) {
-      if (!CONTEXT_LAYER_KINDS.includes(layer?.kind)) errors.push(`layer.kind invalid: ${layer?.kind}`);
-      if (!COMPACTION_ELIGIBILITY.includes(layer?.eligibility)) errors.push(`layer.eligibility invalid: ${layer?.eligibility}`);
-      if (!LAYER_DISPOSITIONS.includes(layer?.disposition)) errors.push(`layer.disposition invalid: ${layer?.disposition}`);
-    }
-  }
-
-  if (!Array.isArray(packet.requiredState)) errors.push('requiredState must be an array');
-  if (!packet.budget || typeof packet.budget !== 'object') errors.push('budget missing');
-  else if (!Number.isInteger(packet.budget.requiredTokens) || packet.budget.requiredTokens < 0) errors.push('budget.requiredTokens invalid');
-
-  const hasBlocker = packet.blocker && typeof packet.blocker === 'object';
-  if (Array.isArray(packet.layers) && !hasBlocker) {
-    const droppedRequired = packet.layers.find((l) => l?.eligibility === 'required' && l?.disposition !== 'retained');
-    if (droppedRequired) errors.push(`required layer not retained without a blocker: ${droppedRequired.id}`);
-  }
-
-  return { valid: errors.length === 0, errors };
-}

package/lib/chat/continuation-source.mjs

@@ -1,58 +0,0 @@
-/**
- * lib/chat/continuation-source.mjs — the one resolveSource every surface shares to
- * rehydrate a continuation packet's reconstructible layers (construct-6zga.1.10).
- *
- * A continuation packet stores required state verbatim but references reconstructible
- * layers (static instructions, role guidance, learned patterns) by source id, so
- * rehydration must re-derive them rather than read stored content. One shared
- * resolver across terminal, web, export, and resume guarantees every surface
- * reconstructs identical context (AC3). Static-instructions and role-guidance
- * families re-derive through the same composer a live turn runs
- * (lib/chat/system-prompt.mjs); learned-patterns re-derive from the observation
- * store, prefetched once because rehydration runs synchronously.
- */
-
-import { buildSystemPrompt } from './system-prompt.mjs';
-
-function observationText(record) {
-  return [record?.summary, record?.content].filter(Boolean).join(' — ').trim();
-}
-
-export function createContinuationResolver({
-  systemText = null,
-  overlay = null,
-  capabilityTier = 'full',
-  cwd = process.cwd(),
-  learnedPatterns = null,
-} = {}) {
-  const composedSystem = typeof systemText === 'string' ? systemText : buildSystemPrompt({ overlay, capabilityTier });
-  const cache = new Map([['prompt:system', composedSystem]]);
-  if (typeof learnedPatterns === 'string') cache.set('learned-patterns', learnedPatterns);
-
-  function resolveSource(sourceId) {
-    if (sourceId == null) return null;
-    if (cache.has(sourceId)) return cache.get(sourceId);
-    if (sourceId.startsWith('prompt:') || sourceId.startsWith('role:')) return composedSystem;
-    if (sourceId === 'learned-patterns' || sourceId.startsWith('observation:')) return cache.get('learned-patterns') ?? null;
-    return null;
-  }
-
-  // Learned patterns live in the observation store and load asynchronously; a
-  // surface that wants them prefetches once, after which the synchronous
-  // resolveSource serves them from cache. A store miss leaves the layer null —
-  // rehydration reports it unresolved rather than inventing content.
-
-  async function loadLearnedPatterns(query, { limit = 5 } = {}) {
-    try {
-      const { searchObservations } = await import('../observation-store.mjs');
-      const results = await searchObservations(cwd, query, { limit });
-      const text = (results || []).map(observationText).filter(Boolean).map((line) => `- ${line}`).join('\n');
-      cache.set('learned-patterns', text);
-      return text;
-    } catch {
-      return cache.get('learned-patterns') ?? null;
-    }
-  }
-
-  return { resolveSource, loadLearnedPatterns, get systemText() { return composedSystem; } };
-}

package/lib/chat/demo-guide.mjs

@@ -1,61 +0,0 @@
-/**
- * lib/chat/demo-guide.mjs — slash-command helpers for construct chat demo mode.
- */
-
-export function formatDemoStepLine(step, colors = {}) {
-  const dim = colors.dim || '';
-  const reset = colors.reset || '';
-  const bold = colors.bold || '';
-  const lines = [`${bold}Step ${step.index}${reset}: ${step.title || 'prompt'}`];
-  if (step.prompt) lines.push(`${step.prompt}`);
-  if (step.command) lines.push(`${dim}command: ${step.command}${reset}`);
-  return lines.join('\n');
-}
-
-export function formatDemoStepsList(guide, colors = {}) {
-  const dim = colors.dim || '';
-  const reset = colors.reset || '';
-  const bold = colors.bold || '';
-  const lines = [`${bold}Demo steps${reset}`];
-  guide.script.steps.forEach((step, i) => {
-    lines.push(`  ${i + 1}. ${step.title || step.prompt?.slice(0, 50) || 'step'}`);
-  });
-  lines.push(`${dim}Use /demo next for the next prompt${reset}`);
-  return lines.join('\n');
-}
-
-export function registerDemoCommands(HELP, demoGuide) {
-  if (!demoGuide) return HELP;
-  return [
-    ...HELP.slice(0, 1),
-    ['/demo [next|steps|reset]', 'walk the active demo script'],
-    ...HELP.slice(1),
-  ];
-}
-
-export function handleDemoCommand(arg, { demoGuide, output, colors }) {
-  if (!demoGuide) {
-    output.write(`${colors.dim}No active demo. Launch with \`construct demo <name>\`.${colors.reset}\n`);
-    return;
-  }
-  const action = (arg || 'steps').toLowerCase();
-  if (action === 'reset') {
-    demoGuide.reset();
-    output.write(`${colors.green}Demo reset to step 1.${colors.reset}\n`);
-    return;
-  }
-  if (action === 'next') {
-    const step = demoGuide.next();
-    if (!step) {
-      output.write(`${colors.dim}Demo complete — all steps shown.${colors.reset}\n`);
-      return;
-    }
-    output.write(`\n${formatDemoStepLine(step, colors)}\n\n`);
-    return;
-  }
-  output.write(`${formatDemoStepsList(demoGuide, colors)}\n`);
-  const peek = demoGuide.peek();
-  if (peek) {
-    output.write(`${colors.dim}Next: /demo next → ${peek.title || 'step'}${colors.reset}\n`);
-  }
-}

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 };
-}