@geraldmaron/construct 1.2.3 → 1.3.1

package/apps/chat/engine/turn-controls.mjs

@@ -1,70 +0,0 @@
-/**
- * apps/chat/engine/turn-controls.mjs — resolve one turn's execution controls from
- * the compiled execution policy (construct-rv2x).
- *
- * The owned-loop engine (ai-sdk-agent.mjs) calls this once per turn to turn a
- * capability profile plus the turn overlay into the concrete knobs streamText
- * needs: the step cap, the output-token cap, caching eligibility, and the tool-
- * group / schema budget, plus the continuation/compaction budget the session uses
- * to decide when to compact context (construct-6zga.1.9). The capability profile
- * is resolved from the active model id, so a mid-session model switch re-derives
- * the envelope.
- *
- * Behavior preservation is the contract: this never throws and never returns a
- * tighter envelope than today for a hosted-direct model. hosted-direct keeps the
- * legacy step cap, the full tool set, and unbounded output; every other class
- * enforces its compiled budget. An explicit CX_CHAT_MAX_STEPS operator override
- * wins over the policy's step cap. Any failure in policy resolution falls back to
- * the legacy envelope (16 steps, full tool set, no cap, no caching) so a policy
- * bug can never break a chat turn.
- */
-
-import { resolveExecutionCapabilityProfile } from '../../../lib/models/execution-capability-profile.mjs';
-import { compilePolicyFromOverlay } from '../../../lib/models/execution-policy.mjs';
-import { continuationBudgetFromPolicy } from '../../../lib/chat/context-continuation.mjs';
-
-const LEGACY_STEP_CAP = 16;
-
-const LEGACY_CONTROLS = Object.freeze({
-  policy: null,
-  iterations: LEGACY_STEP_CAP,
-  outputCap: null,
-  cacheEligible: false,
-  allowedToolGroups: null,
-  maxToolSchemas: Infinity,
-  degraded: false,
-  continuation: Object.freeze({ triggerTokens: null, triggerRatio: null }),
-});
-
-function legacyControls() {
-  return { ...LEGACY_CONTROLS };
-}
-
-export function resolveTurnControls({ model = null, turnOverlay = null, env = {} } = {}) {
-  try {
-    const profile = resolveExecutionCapabilityProfile({ model });
-    const toolFailure = turnOverlay?.toolFailure === true;
-    const policy = compilePolicyFromOverlay({ profile, overlay: turnOverlay, toolFailure });
-
-    const envSteps = Number(env?.CX_CHAT_MAX_STEPS);
-    const iterations = envSteps > 0 ? Math.floor(envSteps) : policy.tools.maxToolIterations;
-
-    // hosted-direct is the mandated default path: keep today's unbounded output
-    // until live-probe evidence supersedes the compatibility_fallback tier. Every
-    // other class enforces its compiled output budget.
-    const outputCap = policy.source.capabilityClass === 'hosted-direct' ? null : policy.output.outputTokenBudget;
-
-    return {
-      policy,
-      iterations,
-      outputCap,
-      cacheEligible: policy.caching.eligible === true,
-      allowedToolGroups: policy.tools.allowedToolGroups,
-      maxToolSchemas: policy.tools.maxToolSchemas,
-      degraded: policy.degradedMode === true,
-      continuation: continuationBudgetFromPolicy(policy),
-    };
-  } catch {
-    return legacyControls();
-  }
-}

package/lib/boundary.mjs

@@ -1,127 +0,0 @@
-/**
- * lib/boundary.mjs — Authenticated parent/child boundary registration.
- *
- * Verifies a parent Construct instance is reachable, validates an HMAC
- * signature over `childInstanceId|nonce` when a shared secret is configured,
- * and persists the binding to boundary.json in the XDG config dir (mode 0600). A
- * different parent rotates the registration only when explicitly allowed via
- * CONSTRUCT_BOUNDARY_ALLOW_OVERRIDE=1; prior configs are archived alongside
- * the active one. Exposed as a standalone module so the dashboard endpoint
- * and the functional tests share the same logic.
- */
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { createHmac, timingSafeEqual, randomBytes } from 'node:crypto';
-import { request as httpRequest } from 'node:http';
-import { request as httpsRequest } from 'node:https';
-import { configDir } from './config/xdg.mjs';
-
-export const BOUNDARY_VERSION = '1.0';
-
-function boundaryDir(home = homedir()) {
-  return configDir(home);
-}
-
-export function boundaryConfigPath(home = homedir()) {
-  return join(boundaryDir(home), 'boundary.json');
-}
-
-export async function registerBoundary({
-  parentInstance,
-  parentUrl,
-  childInstanceId,
-  nonce,
-  signature,
-  sharedSecret = null,
-  home = homedir(),
-  allowOverride = process.env.CONSTRUCT_BOUNDARY_ALLOW_OVERRIDE === '1',
-  probe = probeParent,
-}) {
-  if (!parentInstance || !parentUrl) {
-    return { ok: false, status: 400, error: 'parentInstance and parentUrl are required' };
-  }
-  if (!childInstanceId) {
-    return { ok: false, status: 400, error: 'childInstanceId is required' };
-  }
-
-  if (sharedSecret) {
-    if (!nonce || !signature) {
-      return { ok: false, status: 401, error: 'nonce and signature are required when a shared secret is configured' };
-    }
-    const expected = createHmac('sha256', sharedSecret).update(`${childInstanceId}|${nonce}`).digest('hex');
-    const a = Buffer.from(expected, 'hex');
-    let b;
-    try { b = Buffer.from(String(signature), 'hex'); } catch { return { ok: false, status: 401, error: 'invalid signature encoding' }; }
-    if (a.length !== b.length || !timingSafeEqual(a, b)) {
-      return { ok: false, status: 401, error: 'signature mismatch' };
-    }
-  }
-
-  const reachable = await probe(parentUrl);
-  if (!reachable.ok) {
-    return { ok: false, status: 502, error: `parent unreachable: ${reachable.error}` };
-  }
-
-  const dir = boundaryDir(home);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  const cfgPath = boundaryConfigPath(home);
-
-  let prior = null;
-  if (existsSync(cfgPath)) {
-    try { prior = JSON.parse(readFileSync(cfgPath, 'utf8')); } catch { prior = null; }
-  }
-
-  if (prior && prior.parentInstance && prior.parentInstance !== parentInstance) {
-    if (!allowOverride) {
-      return {
-        ok: false,
-        status: 409,
-        error: `child already bound to parent '${prior.parentInstance}'; set CONSTRUCT_BOUNDARY_ALLOW_OVERRIDE=1 to rotate`,
-      };
-    }
-    const archivePath = join(dir, `boundary.${Date.now()}.json`);
-    try { writeFileSync(archivePath, JSON.stringify(prior, null, 2)); } catch { /* archive is best effort */ }
-  }
-
-  const config = {
-    parentInstance,
-    parentUrl,
-    childInstanceId,
-    registeredAt: new Date().toISOString(),
-    rotatedFrom: prior?.parentInstance || null,
-    nonce: nonce || randomBytes(16).toString('hex'),
-    boundaryVersion: BOUNDARY_VERSION,
-  };
-
-  writeFileSync(cfgPath, JSON.stringify(config, null, 2), { mode: 0o600 });
-  return { ok: true, config, path: cfgPath };
-}
-
-export function probeParent(parentUrl) {
-  return new Promise((resolve) => {
-    let parsed;
-    try { parsed = new URL(parentUrl); } catch { return resolve({ ok: false, error: 'invalid URL' }); }
-    if (!/^https?:$/.test(parsed.protocol)) return resolve({ ok: false, error: 'unsupported protocol' });
-    const fn = parsed.protocol === 'https:' ? httpsRequest : httpRequest;
-    const req = fn({
-      method: 'HEAD',
-      protocol: parsed.protocol,
-      hostname: parsed.hostname,
-      port: parsed.port,
-      path: parsed.pathname || '/',
-      timeout: 3000,
-    }, (response) => {
-      resolve({ ok: response.statusCode < 500 });
-      response.resume();
-    });
-    req.on('timeout', () => { req.destroy(); resolve({ ok: false, error: 'timeout' }); });
-    req.on('error', (err) => resolve({ ok: false, error: err.message }));
-    req.end();
-  });
-}
-
-export function signBoundaryRequest({ childInstanceId, nonce, sharedSecret }) {
-  return createHmac('sha256', sharedSecret).update(`${childInstanceId}|${nonce}`).digest('hex');
-}

package/lib/certification/dashboard-api.mjs

@@ -1,71 +0,0 @@
-/**
- * lib/certification/dashboard-api.mjs — dashboard-safe certification status payload.
- *
- * Mirrors construct certify status for GET /api/certification/status without secrets.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-
-import { buildCertificationStatus } from './status.mjs';
-import { loadCertificationStatus } from './stale-impact.mjs';
-import { certificationRunDir, certificationRunsRoot, listCertificationRunIds, readCertificationRun } from './store.mjs';
-
-function findConstructRoot(startPath = process.cwd()) {
-  let current = path.resolve(startPath);
-  while (true) {
-    if (fs.existsSync(path.join(current, 'package.json'))) return current;
-    const parent = path.dirname(current);
-    if (parent === current) return path.resolve(startPath);
-    current = parent;
-  }
-}
-
-function buildStaleRows({ rootDir }) {
-  const { status } = loadCertificationStatus({ rootDir });
-  if (!status?.capabilities) return [];
-  return Object.entries(status.capabilities)
-    .filter(([, entry]) => entry.status === 'stale')
-    .map(([capabilityId, entry]) => ({
-      capabilityId,
-      staleSince: entry.staleSince ?? null,
-      staleReason: entry.staleReason ?? null,
-      stalePaths: entry.stalePaths ?? [],
-    }));
-}
-
-export function buildCertificationDashboard({ rootDir = process.cwd() } = {}) {
-  const root = findConstructRoot(rootDir);
-  const report = buildCertificationStatus({ rootDir: root });
-  const runs = [];
-  for (const runId of listCertificationRunIds({ rootDir: root }).slice(-20)) {
-    try {
-      const { run } = readCertificationRun(runId, { rootDir: root });
-      const dir = certificationRunDir(runId, root);
-      runs.push({
-        id: run.id,
-        scenarioId: run.scenarioId,
-        capabilityId: run.capabilityId,
-        status: run.verdict?.status ?? 'unknown',
-        createdAt: run.createdAt,
-        artifactPath: path.relative(root, path.join(dir, 'run.json')),
-      });
-    } catch { /* skip corrupt */ }
-  }
-  return {
-    generatedAt: report.generatedAt,
-    capabilities: report.capabilities,
-    specialists: report.specialists,
-    skills: report.skills,
-    artifactTypes: report.artifactTypes,
-    documentCategories: report.documentCategories,
-    demos: report.demos,
-    stale: buildStaleRows({ rootDir: root }),
-    runs,
-    runsDir: path.relative(root, certificationRunsRoot(root)),
-    artifactLinks: {
-      runsRoot: '.cx/certification/runs',
-      recentRunIds: runs.map((r) => r.id),
-    },
-  };
-}

package/lib/chat/cli.mjs

@@ -1,333 +0,0 @@
-/**
- * lib/chat/cli.mjs — `construct chat` command handler (zero-dep launcher).
- *
- * ADR-0041: Construct owns the loop. This launcher stays in the zero-dep core and
- * only orchestrates — it loads project settings, resolves the model, builds the
- * owned-loop driver (apps/chat/engine, which lazy-imports the optional Vercel AI
- * SDK and provider packages), persists the normalized event timeline under
- * .cx/chat-sessions/, and then chooses a surface.
- *
- * Surface selection: desktop window (Tauri or Chromium app mode) is the default on
- * machines with a display; `--web` opens a browser tab; `--plain`, `--accessible`,
- * NO_COLOR, TERM=dumb, and non-TTY streams route to the linear renderer.
- * `--window` is an alias for the desktop path. `--no-window` forces a browser tab.
- *
- * `--list` reports the model catalog and which providers are configured; `--model`
- * pins the model for this launch; `--resume` restores the latest (or given) session
- * transcript from `.cx/chat-sessions/`; the `--no-*` flags override saved transparency
- * layers.
- */
-
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { resolveColors } from '../term-format.mjs';
-import { resolveLayers } from './transparency.mjs';
-import { runChatLoop } from './tui/render.mjs';
-import { createSessionUsage } from './tui/usage.mjs';
-import { loadChatConfig } from './config.mjs';
-import { loadConstructEnv } from '../env-config.mjs';
-import { createCommands } from './commands.mjs';
-import { resolveResumePath, restoreFromSession } from './session-restore.mjs';
-import { buildSystemPrompt } from './system-prompt.mjs';
-import { resolveExecutionCapabilityProfile } from '../models/execution-capability-profile.mjs';
-import { compileExecutionPolicy } from '../models/execution-policy.mjs';
-import { createChatPersister } from './session-persist.mjs';
-import { hasGuiDisplay } from './desktop-binary.mjs';
-import { createOwnedLoopDriver } from '../../apps/chat/engine/loop-driver.mjs';
-import { listChatModels, resolveChatModelSelectionAsync, resolveSessionModel } from '../../apps/chat/engine/models.mjs';
-import { resolveDemoGuideForChat } from '../demo-surface.mjs';
-
-const HERE = path.dirname(fileURLToPath(import.meta.url));
-const REPO_ROOT = path.resolve(HERE, '..', '..');
-
-function parseFlags(args) {
-  const flags = {
-    plain: false,
-    accessible: false,
-    web: false,
-    window: false,
-    noWindow: false,
-    list: false,
-    quiet: false,
-    free: false,
-    model: null,
-    resume: null,
-    ascii: null,
-    demo: null,
-  };
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === '--list') flags.list = true;
-    else if (arg === '--plain') flags.plain = true;
-    else if (arg === '--accessible') flags.accessible = true;
-    else if (arg === '--web') flags.web = true;
-    else if (arg === '--window') flags.window = true;
-    else if (arg === '--no-window') flags.noWindow = true;
-    else if (arg === '--quiet') flags.quiet = true;
-    else if (arg === '--free') flags.free = true;
-    else if (arg === '--ascii') flags.ascii = true;
-    else if (arg === '--resume') flags.resume = true;
-    else if (arg.startsWith('--resume=')) flags.resume = arg.slice('--resume='.length);
-    else if (arg === '--no-thinking') flags.thinking = false;
-    else if (arg === '--no-path') flags.path = false;
-    else if (arg === '--no-specialists') flags.specialists = false;
-    else if (arg === '--no-tools') flags.tools = false;
-    else if (arg === '--no-observability') flags.observability = false;
-    else if (arg === '--model') flags.model = args[++i] || null;
-    else if (arg.startsWith('--model=')) flags.model = arg.slice('--model='.length);
-    else if (arg === '--demo') flags.demo = args[++i] || null;
-    else if (arg.startsWith('--demo=')) flags.demo = arg.slice('--demo='.length);
-  }
-  return flags;
-}
-
-function printModels(output, env) {
-  const colors = resolveColors({ stream: output, env });
-  const models = listChatModels({ env });
-  const configured = models.filter((m) => m.configured);
-  output.write(`${colors.bold}Owned loop \u2014 model catalog${colors.reset}\n`);
-  if (!configured.length) {
-    output.write(`${colors.dim}No provider configured. Set a key (a value or an op:// reference) in ~/.construct/config.env, run \`construct creds login copilot\` for GitHub Copilot, or start Ollama locally.${colors.reset}\n`);
-  }
-  for (const m of models) {
-    const mark = m.configured ? `${colors.green}\u2713${colors.reset}` : `${colors.dim}\u00b7${colors.reset}`;
-    output.write(`  ${mark} ${m.id}${m.local ? `${colors.dim} (local)${colors.reset}` : ''}\n`);
-  }
-}
-
-function createPersister({ cwd, sessionId, resumePath = null }) {
-  return createChatPersister({ cwd, sessionId, resumePath, host: 'construct' });
-}
-
-function wantsLinearSurface({ flags, env, output, input }) {
-  if (flags.plain || flags.accessible) return true;
-  if (env.NO_COLOR || env.TERM === 'dumb') return true;
-  if (env.CX_CHAT_FORCE_LINEAR === '1') return true;
-  if (!output.isTTY || !input.isTTY) return true;
-  return false;
-}
-
-function resolveChatSurface({ flags, env, output, input }) {
-  if (wantsLinearSurface({ flags, env, output, input })) return 'linear';
-  if (flags.web || flags.noWindow) return 'web';
-  if (flags.window || env.CONSTRUCT_CHAT_WINDOW === '1' || hasGuiDisplay(env)) return 'desktop';
-  return 'headless';
-}
-
-// Desktop means the native construct-chat window: an existing binary, or Tauri
-// source that runDesktopChat builds on demand. A browser does not qualify;
-// `construct chat --web` is the explicit browser path.
-
-async function canLaunchDesktop(env, cwd = process.cwd()) {
-  const { hasGuiDisplay, resolveDesktopBinary } = await import('./desktop-binary.mjs');
-  if (!hasGuiDisplay(env)) return false;
-  if (resolveDesktopBinary()) return true;
-  const { hasDesktopSource } = await import('./desktop-build.mjs');
-  return hasDesktopSource(cwd);
-}
-
-function resolveAsciiMode({ flags, env, config }) {
-  if (flags.ascii === true) return true;
-  if (env.CX_CHAT_ASCII === '1') return true;
-  if (config.ui?.ascii) return true;
-  if (process.platform === 'win32' && !env.WT_SESSION && !env.WT_PROFILE_ID && env.TERM !== 'xterm-256color') {
-    return true;
-  }
-  return false;
-}
-
-function createPermissionHandler({ session, bridge }) {
-  return async (req) => {
-    const mode = session.permissionMode || 'allow_once';
-    if (mode === 'reject') return 'reject';
-    if (mode === 'allow_always') return 'allow_always';
-    if (mode === 'allow_once') return 'allow';
-    if (mode === 'ask' && bridge?.prompt) return bridge.prompt(req);
-    return 'allow';
-  };
-}
-
-export async function runChat(args = [], { env = process.env, cwd = process.cwd(), input = process.stdin, output = process.stdout, errorOutput = process.stderr } = {}) {
-  const flags = parseFlags(args);
-  if (!flags.demo && env.CONSTRUCT_DEMO) flags.demo = env.CONSTRUCT_DEMO;
-
-  const effectiveEnv = loadConstructEnv({ rootDir: cwd, env: flags.plain ? { ...env, NO_COLOR: '1' } : env, warn: false });
-
-  if (flags.list) { printModels(output, effectiveEnv); return 0; }
-
-  const { config } = loadChatConfig({ cwd });
-
-  let modelMode = config.modelMode || 'pinned';
-  if (flags.free) modelMode = 'free-router';
-
-  const savedModel = flags.model || (modelMode === 'pinned' ? config.model : null) || null;
-
-  let resolvedModel = savedModel;
-  if (modelMode === 'free-router') {
-    const sessionStub = { modelMode: 'free-router', failedModels: new Set() };
-    resolvedModel = await resolveSessionModel(sessionStub, { env: effectiveEnv, tier: 'standard' });
-    if (!resolvedModel && !flags.list) {
-      errorOutput.write('OpenRouter free router needs OPENROUTER_API_KEY in ~/.construct/config.env, or no free models are available.\n');
-      return 1;
-    }
-  }
-
-  // Saved layers seed the run; --no-* overrides win for this launch.
-  const layers = resolveLayers({ flags, env: effectiveEnv });
-  for (const key of Object.keys(config.layers)) {
-    if (flags[key] === undefined && config.layers[key] === false) layers[key] = false;
-  }
-  if (config.thinking === false && flags.thinking === undefined) layers.thinking = false;
-
-  const resumePath = resolveResumePath({ cwd, resume: flags.resume });
-  const restored = resumePath ? restoreFromSession(resumePath) : null;
-
-  const demoPack = flags.demo
-    ? resolveDemoGuideForChat(flags.demo, { cwd, repoRoot: REPO_ROOT })
-    : null;
-
-  const modelResolution = modelMode === 'free-router' && resolvedModel
-    ? { id: resolvedModel, source: 'free-router', notice: null, rejected: [] }
-    : await resolveChatModelSelectionAsync({
-      env: effectiveEnv,
-      requested: savedModel,
-    });
-
-  const session = {
-    model: modelResolution.id || resolvedModel,
-    savedModel: modelMode === 'pinned' ? (savedModel || modelResolution.id) : null,
-    modelMode,
-    modelNotice: modelResolution.notice || null,
-    failedModels: new Set(),
-    layers,
-    thinking: layers.thinking,
-    permissionMode: config.permissionMode || 'allow_once',
-    sandbox: config.sandbox || 'workspace-write',
-    ui: {
-      ascii: resolveAsciiMode({ flags, env: effectiveEnv, config }),
-      inspector: config.ui?.inspector || 'auto',
-      theme: config.ui?.theme || 'auto',
-    },
-    usage: restored?.usage || createSessionUsage(),
-    demoGuide: demoPack?.guide || null,
-    demoTitle: demoPack?.script?.title || null,
-  };
-
-  let surface = resolveChatSurface({ flags, env: effectiveEnv, output, input });
-
-  if (surface === 'headless') {
-    errorOutput.write('No graphical display available. Use `construct chat --plain` for terminal mode.\n');
-    return 1;
-  }
-
-  if (surface === 'desktop') {
-    if (!(await canLaunchDesktop(effectiveEnv, cwd))) {
-      errorOutput.write('No graphical display available. Use `construct chat --plain` for terminal mode, or `construct chat --web` for a browser tab.\n');
-      return 1;
-    }
-    try {
-      const { runDesktopChat } = await import('./desktop-launcher.mjs');
-      return runDesktopChat({ cwd, env: effectiveEnv, output, errorOutput });
-    } catch (err) {
-      errorOutput.write(`Desktop chat unavailable: ${err.message}\n`);
-      return 1;
-    }
-  }
-
-  if (surface === 'web') {
-    try {
-      const { runWebChat } = await import('./web-launcher.mjs');
-      return runWebChat({ cwd, env: effectiveEnv, output, errorOutput });
-    } catch (err) {
-      errorOutput.write(`Web chat unavailable: ${err.message}\n`);
-      return 1;
-    }
-  }
-
-  const permissionBridge = { prompt: null };
-  const handlers = {
-    getSandbox: () => session.sandbox,
-    getPermissionMode: () => session.permissionMode,
-    requestPermission: createPermissionHandler({ session, bridge: permissionBridge }),
-  };
-
-  const createAgent = async (opts) => {
-    const { createAiSdkAgent } = await import('../../apps/chat/engine/ai-sdk-agent.mjs');
-    return createAiSdkAgent(opts);
-  };
-
-  const driver = createOwnedLoopDriver({
-    env: effectiveEnv,
-    cwd,
-    model: session.model,
-    handlers,
-    systemPrompt: (() => {
-      const base = buildSystemPrompt({ capabilityTier: compileExecutionPolicy({ profile: resolveExecutionCapabilityProfile({ model: session.model }) }).prompt.systemPromptTier });
-      return demoPack?.systemOverlay ? `${base}\n\nDemo script:\n${demoPack.systemOverlay}` : base;
-    })(),
-    createAgent,
-  });
-
-  let started;
-  try {
-    started = await driver.start();
-  } catch (err) {
-    const hint = /Cannot find package|ERR_MODULE_NOT_FOUND|find module/i.test(err.message)
-      ? '\nThe owned loop needs its optional dependencies. Install them with:\n  npm install ai @ai-sdk/anthropic @ai-sdk/openai @ai-sdk/openai-compatible zod'
-      : '';
-    errorOutput.write(`Failed to start the owned loop: ${err.message}${hint}\n`);
-    try { driver.stop?.(); } catch { /* nothing started */ }
-    return 1;
-  }
-
-  const notices = [];
-  if (modelResolution.notice) notices.push(modelResolution.notice);
-  if (demoPack?.welcome) notices.push(demoPack.welcome);
-  if (!session.model) {
-    notices.push('no model resolved \u2014 set a provider key or run `construct creds login copilot`, then use /model');
-  }
-  if (flags.resume && !restored?.sessionFile) {
-    notices.push('no prior session found to resume \u2014 starting fresh');
-  } else if (restored?.sessionFile && (restored.turnBlocks?.length || restored.transcript.length)) {
-    const count = restored.turnBlocks?.length || restored.transcript.length;
-    notices.push(`resumed ${count} turn(s) from ${path.basename(restored.sessionFile)}`);
-  }
-
-  const persist = createPersister({ cwd, sessionId: started.sessionId, resumePath: restored?.sessionFile || null });
-  const commands = createCommands({
-    driver,
-    host: 'construct',
-    hostId: 'construct',
-    version: null,
-    cwd,
-    env: effectiveEnv,
-    turnBlocksRef: () => [],
-    demoGuide: demoPack?.guide || null,
-  });
-
-  try {
-    await runChatLoop({
-      driver,
-      host: 'construct',
-      version: null,
-      layers,
-      input,
-      env: effectiveEnv,
-      output,
-      persist,
-      commands,
-      session,
-      notices,
-      permissionBridge,
-      initialTranscript: restored?.transcript || [],
-      initialTurnBlocks: restored?.turnBlocks || [],
-      cwd,
-      flags,
-    });
-  } finally {
-    try { driver.stop?.(); } catch { /* already stopped */ }
-  }
-  return 0;
-}
-
-export { resolveChatSurface, wantsLinearSurface };