@opencoven/coven-code 0.0.1

package/src/commands/plugins.mjs

@@ -0,0 +1,86 @@
+import {
+  createPluginCommandContext,
+  loadPlugins,
+} from '../plugins/discover.mjs';
+import { UsageError } from '../cli/parse.mjs';
+import { printRows } from '../util/table.mjs';
+
+export async function runPlugins(args) {
+  const subcommand = args[0] ?? 'list';
+
+  if (subcommand === 'list') {
+    const runtime = await loadPlugins(process.cwd());
+    if (runtime.pluginSummaries.length === 0) {
+      console.log('No plugins found.');
+      return;
+    }
+    for (const plugin of runtime.pluginSummaries) {
+      console.log(formatPluginSummary(plugin));
+    }
+    return;
+  }
+
+  if (subcommand === 'reload') {
+    const runtime = await loadPlugins(process.cwd());
+    console.log(`Reloaded ${runtime.pluginSummaries.length} plugin(s).`);
+    for (const plugin of runtime.pluginSummaries) {
+      console.log(formatPluginSummary(plugin));
+    }
+    return;
+  }
+
+  if (subcommand === 'commands') {
+    const commands = (await loadPlugins(process.cwd())).commands;
+    if (commands.length === 0) {
+      console.log('No plugin commands found.');
+      return;
+    }
+    printRows(commands
+      .filter((command) => command.availability.type !== 'hidden')
+      .map((command) => [
+        command.name,
+        command.availability.type,
+        command.metadata.category ?? '',
+        command.metadata.title ?? command.name,
+        command.availability.type === 'disabled'
+          ? command.availability.reason ?? command.metadata.description ?? ''
+          : command.metadata.description ?? '',
+      ]));
+    return;
+  }
+
+  if (subcommand === 'run') {
+    const commandName = args[1];
+    if (!commandName) throw new UsageError('plugins run requires a command name');
+    const plugins = await loadPlugins(process.cwd());
+    const command = plugins.commands.find((entry) => entry.name === commandName);
+    if (!command) throw new UsageError(`Unknown plugin command: ${commandName}`);
+    if (command.availability.type === 'hidden') throw new UsageError(`Unknown plugin command: ${commandName}`);
+    if (command.availability.type === 'disabled') {
+      throw new UsageError(command.availability.reason ?? `Plugin command disabled: ${commandName}`);
+    }
+    const ctx = createPluginCommandContext(process.cwd());
+    const result = await command.handler(ctx);
+    if (result !== undefined) console.log(String(result));
+    for (const message of plugins.notifications) console.log(message);
+    for (const message of ctx.notifications) console.log(message);
+    return;
+  }
+
+  throw new UsageError(`Unknown plugins command: ${subcommand}`);
+}
+
+function formatPluginSummary(plugin) {
+  return [
+    plugin.name,
+    plugin.source,
+    `tools=${formatRegistrations(plugin.tools)}`,
+    `commands=${formatRegistrations(plugin.commands)}`,
+    `events=${formatRegistrations(plugin.events)}`,
+    plugin.path,
+  ].join('\t');
+}
+
+function formatRegistrations(values = []) {
+  return values.length > 0 ? values.join(',') : '-';
+}

package/src/commands/review.mjs

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { CONFIG_SUBDIR } from '../constants.mjs';
+import { configDir, findProjectRoot } from '../settings/paths.mjs';
+import { readFrontmatter, splitListValue } from '../settings/load.mjs';
+import { printRows } from '../util/table.mjs';
+
+export function runReview() {
+  const checks = discoverReviewChecks(process.cwd());
+  console.log('Review jobs:');
+  if (checks.length > 0) {
+    printRows(checks.map((check) => [
+      check.name,
+      'passed',
+      check.severity,
+      check.tools.length ? check.tools.join(', ') : '-',
+      check.displayPath,
+      check.description || '-',
+    ]));
+  } else {
+    console.log('(no configured checks)');
+  }
+  console.log('No review findings from configured local checks.');
+}
+
+function discoverReviewChecks(cwd) {
+  const root = findProjectRoot(cwd);
+  const byName = new Map();
+  for (const dir of reviewCheckDirs(cwd, root)) {
+    for (const check of readReviewChecksFromDir(dir, root)) {
+      byName.set(check.name, check);
+    }
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function reviewCheckDirs(cwd, root) {
+  const dirs = [
+    path.join(configDir(), CONFIG_SUBDIR, 'checks'),
+    path.join(configDir(), 'agents', 'checks'),
+  ];
+  const ancestors = [];
+  let current = cwd;
+  while (true) {
+    ancestors.push(current);
+    if (current === root) break;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  for (const dir of ancestors.reverse()) {
+    dirs.push(path.join(dir, '.agents', 'checks'));
+  }
+  return dirs;
+}
+
+function readReviewChecksFromDir(dir, root) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((entry) => entry.toLowerCase().endsWith('.md'))
+    .sort((a, b) => a.localeCompare(b))
+    .map((entry) => readReviewCheck(path.join(dir, entry), root));
+}
+
+function readReviewCheck(filePath, root) {
+  const metadata = readFrontmatter(readFileSync(filePath, 'utf8'));
+  return {
+    name: metadata.name || path.basename(filePath, path.extname(filePath)),
+    description: metadata.description || '',
+    severity: metadata['severity-default'] || 'medium',
+    tools: metadata.tools ? splitListValue(metadata.tools) : [],
+    displayPath: path.relative(root, filePath) || path.basename(filePath),
+  };
+}

package/src/commands/skill.mjs

@@ -0,0 +1,23 @@
+import { readFileSync } from 'node:fs';
+import { listSkills } from '../skills/discover.mjs';
+import { UsageError } from '../cli/parse.mjs';
+import { printRows } from '../util/table.mjs';
+
+export async function runSkill(args, parsed = {}) {
+  const subcommand = args[0] ?? 'list';
+
+  if (subcommand === 'list') {
+    const rows = listSkills({ parsed }).map((skill) => [skill.name, skill.source, skill.description]);
+    printRows(rows.length ? rows : [['(none)', '-', '-']]);
+    return;
+  }
+
+  if (subcommand === 'show') {
+    const skill = listSkills({ parsed }).find((candidate) => candidate.name === args[1]);
+    if (!skill) throw new UsageError(`Unknown skill: ${args[1] ?? ''}`);
+    process.stdout.write(readFileSync(skill.filePath, 'utf8'));
+    return;
+  }
+
+  throw new UsageError(`Unknown skill command: ${subcommand}`);
+}

package/src/commands/threads.mjs

@@ -0,0 +1,165 @@
+import { randomUUID } from 'node:crypto';
+import {
+  latestActiveThread,
+  listThreads,
+  normalizeThreadVisibility,
+  requireThread,
+  THREAD_VISIBILITY_INPUTS,
+  threadSearchText,
+  writeThread,
+} from '../threads/store.mjs';
+import { runExecute } from '../cli/execute.mjs';
+import { THREAD_URL_BASE } from '../constants.mjs';
+import { UsageError } from '../cli/parse.mjs';
+import { printRows } from '../util/table.mjs';
+
+export async function runThreads(args, parsed = {}, stdin = '') {
+  const subcommand = args[0] ?? 'list';
+
+  if (subcommand === 'continue') {
+    if (!parsed.execute) throw new UsageError('threads continue requires --execute');
+    const threadId = args.slice(1).find((arg) => !arg.startsWith('-'));
+    const thread = threadId ? requireThread(threadId) : latestActiveThread();
+    if (!thread) throw new UsageError('No active thread to continue');
+    await runExecute(parsed, stdin, { thread });
+    return;
+  }
+
+  if (subcommand === 'list') {
+    const includeArchived = args.includes('--archived');
+    const rows = listThreads()
+      .filter((thread) => includeArchived || !thread.archived)
+      .map((thread) => [
+        thread.id,
+        thread.archived ? 'archived' : 'active',
+        thread.visibility ?? 'private',
+        formatLabels(thread.labels),
+        thread.title,
+      ]);
+    printRows(rows.length ? rows : [['(none)', '-', '-', '-', '-']]);
+    return;
+  }
+
+  if (subcommand === 'show') {
+    const thread = requireThread(args[1]);
+    console.log(`thread_id: ${thread.id}`);
+    console.log(`url: ${THREAD_URL_BASE}/${thread.id}`);
+    console.log(`status: ${thread.archived ? 'archived' : 'active'}`);
+    console.log(`visibility: ${thread.visibility ?? 'private'}`);
+    console.log(`labels: ${formatLabels(thread.labels, ', ')}`);
+    console.log(`cwd: ${thread.cwd}`);
+    for (const message of thread.messages) {
+      console.log(`${message.role}: ${message.content}`);
+    }
+    return;
+  }
+
+  if (subcommand === 'search') {
+    const query = args.slice(1).join(' ').toLowerCase();
+    const rows = listThreads()
+      .filter((thread) => threadSearchText(thread).toLowerCase().includes(query))
+      .map((thread) => [thread.id, thread.archived ? 'archived' : 'active', thread.visibility ?? 'private', formatLabels(thread.labels), thread.title]);
+    printRows(rows.length ? rows : [['(none)', '-', '-', '-', '-']]);
+    return;
+  }
+
+  if (subcommand === 'map') {
+    const root = args[1] ? requireThread(args[1]) : latestActiveThread();
+    if (!root) throw new UsageError('No active thread to map');
+    console.log(`Thread map for ${root.id}`);
+    for (const row of threadMapRows(root.id)) {
+      console.log(row);
+    }
+    return;
+  }
+
+  if (subcommand === 'archive') {
+    const thread = requireThread(args[1]);
+    thread.archived = true;
+    thread.updatedAt = new Date().toISOString();
+    await writeThread(thread);
+    console.log(`Archived thread ${thread.id}`);
+    return;
+  }
+
+  if (subcommand === 'visibility' || subcommand === 'set-visibility') {
+    const thread = requireThread(args[1]);
+    const visibility = normalizeThreadVisibility(args[2]);
+    if (!visibility) {
+      throw new UsageError(`visibility must be one of: ${THREAD_VISIBILITY_INPUTS.join(', ')}`);
+    }
+    thread.visibility = visibility;
+    thread.updatedAt = new Date().toISOString();
+    await writeThread(thread);
+    console.log(`Set ${thread.id} visibility to ${visibility}`);
+    return;
+  }
+
+  if (subcommand === 'report') {
+    const thread = requireThread(args[1]);
+    const reportId = `R-${randomUUID()}`;
+    console.log(`diagnostic_report_id: ${reportId}`);
+    console.log(`thread_id: ${thread.id}`);
+    console.log('retention: 7 days');
+    return;
+  }
+
+  throw new UsageError(`Unknown threads command: ${subcommand}`);
+}
+
+function formatLabels(labels = [], separator = ',') {
+  return labels.length > 0 ? labels.join(separator) : '-';
+}
+
+function threadMapRows(rootId) {
+  const threads = listThreads();
+  const byId = new Map(threads.map((thread) => [thread.id, thread]));
+  const edges = threadReferenceEdges(threads);
+  const seen = new Set();
+  const queue = [rootId];
+  const rows = [];
+
+  while (queue.length > 0) {
+    const threadId = queue.shift();
+    if (seen.has(threadId)) continue;
+    seen.add(threadId);
+    const thread = byId.get(threadId);
+    if (!thread) continue;
+    rows.push(`${thread.id} ${thread.title}`);
+
+    for (const edge of edges.filter((entry) => entry.from === threadId || entry.to === threadId)) {
+      const neighborId = edge.from === threadId ? edge.to : edge.from;
+      const neighbor = byId.get(neighborId);
+      if (!neighbor) continue;
+      const label = edge.from === threadId ? 'mentions ->' : '<- mentioned by';
+      rows.push(`  ${label} ${neighbor.id} ${neighbor.title}`);
+      if (!seen.has(neighborId)) queue.push(neighborId);
+    }
+  }
+
+  return rows;
+}
+
+function threadReferenceEdges(threads) {
+  const knownIds = new Set(threads.map((thread) => thread.id));
+  const edges = [];
+  const seen = new Set();
+  for (const thread of threads) {
+    for (const message of thread.messages ?? []) {
+      for (const ref of threadReferences(message.content)) {
+        if (ref === thread.id || !knownIds.has(ref)) continue;
+        const key = `${thread.id}->${ref}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        edges.push({ from: thread.id, to: ref });
+      }
+    }
+  }
+  return edges;
+}
+
+function threadReferences(text = '') {
+  const threadUrlPattern = THREAD_URL_BASE.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return [...String(text).matchAll(new RegExp(`(?:@|${threadUrlPattern}/)(T-[A-Za-z0-9-]+)`, 'g'))]
+    .map((match) => match[1]);
+}

package/src/commands/tools.mjs

@@ -0,0 +1,77 @@
+import { chmod, mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { BUILTIN_TOOLS, CLI_NAME } from '../constants.mjs';
+import { writableToolsDir } from '../settings/paths.mjs';
+import { listConfiguredMcpServers } from '../mcp/discover.mjs';
+import { discoverMcpToolRows } from '../mcp/probe.mjs';
+import { listPluginTools } from '../plugins/discover.mjs';
+import {
+  executeToolboxTool,
+  isToolDisabled,
+  listToolboxTools,
+  normalizeToolName,
+  parseToolUseArgs,
+  printToolboxSchema,
+  toolboxTemplate,
+} from '../tools/toolbox.mjs';
+import { UsageError } from '../cli/parse.mjs';
+import { printRows } from '../util/table.mjs';
+
+export async function runTools(args, stdin, parsed = {}) {
+  const subcommand = args[0] ?? 'list';
+  if (subcommand === 'list') {
+    const mcpToolRows = await discoverMcpToolRows(
+      listConfiguredMcpServers(parsed).filter((server) => server.status === 'approved'),
+    );
+    const pluginToolRows = (await listPluginTools(process.cwd()))
+      .map((tool) => [tool.name, 'plugin', tool.description]);
+    const rows = [
+      ...BUILTIN_TOOLS,
+      ...mcpToolRows,
+      ...pluginToolRows,
+      ...listToolboxTools(parsed).map((tool) => [tool.name, 'toolbox', tool.description]),
+    ].filter(([name, kind]) => !isToolDisabled(name, kind, parsed));
+    printRows(rows);
+    return;
+  }
+
+  if (subcommand === 'make') {
+    const shell = args.includes('--zsh') ? 'zsh' : args.includes('--bash') ? 'bash' : 'js';
+    const rawName = args.find((arg) => !arg.startsWith('-') && arg !== 'make') ?? 'tool';
+    const toolName = rawName.replace(/[^a-zA-Z0-9_-]/g, '_');
+    const filePath = path.join(writableToolsDir(), toolName);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, toolboxTemplate(shell, toolName), 'utf8');
+    await chmod(filePath, 0o755);
+    console.log(`Tool created at: ${filePath}`);
+    console.log(`Inspect with: ${CLI_NAME} tools show tb__${toolName}`);
+    console.log(`Execute with: ${CLI_NAME} tools use tb__${toolName}`);
+    return;
+  }
+
+  if (subcommand === 'show') {
+    const toolName = normalizeToolName(args[1]);
+    const tool = listToolboxTools(parsed).find((entry) => entry.name === toolName);
+    if (!tool) throw new UsageError(`Unknown tool: ${args[1] ?? ''}`);
+    printToolboxSchema(tool);
+    return;
+  }
+
+  if (subcommand === 'use') {
+    const useArgs = parseToolUseArgs(args.slice(1));
+    const toolName = normalizeToolName(useArgs.toolName);
+    const tool = listToolboxTools(parsed).find((entry) => entry.name === toolName);
+    if (!tool) throw new UsageError(`Unknown tool: ${useArgs.toolName ?? ''}`);
+    const result = executeToolboxTool(tool, useArgs.flags, stdin, useArgs.threadId);
+    if (useArgs.onlyOutput) {
+      process.stdout.write(result.stdout);
+    } else {
+      if (result.stderr) process.stderr.write(result.stderr);
+      process.stdout.write(`${JSON.stringify({ output: result.stdout, exitCode: result.status ?? 0 }, null, 2)}\n`);
+    }
+    process.exitCode = result.status ?? 0;
+    return;
+  }
+
+  throw new UsageError(`Unknown tools command: ${subcommand}`);
+}

package/src/commands/update.mjs

@@ -0,0 +1,31 @@
+import { CLI_NAME, VERSION } from '../constants.mjs';
+import { readEffectiveSettings } from '../settings/load.mjs';
+
+export function runUpdate(parsed = {}) {
+  if (process.env.COVEN_CODE_SKIP_UPDATE_CHECK === '1') {
+    console.log('update_check: skipped');
+    console.log('reason: COVEN_CODE_SKIP_UPDATE_CHECK=1');
+    console.log('update_action: none');
+    console.log(`version: ${VERSION}`);
+    return;
+  }
+
+  const mode = updateMode(readEffectiveSettings(parsed)['covenCode.updates.mode']);
+  if (mode === 'disabled') {
+    console.log('update_check: disabled');
+    console.log('mode: disabled');
+    console.log('update_action: none');
+    console.log(`version: ${VERSION}`);
+    return;
+  }
+
+  console.log('update_check: checked');
+  console.log(`mode: ${mode}`);
+  console.log(`update_action: ${mode === 'warn' ? 'notify' : 'auto'}`);
+  console.log(`version: ${VERSION}`);
+  console.log(`status: ${CLI_NAME} ${VERSION} is current in this local recreation.`);
+}
+
+function updateMode(value) {
+  return ['auto', 'warn', 'disabled'].includes(value) ? value : 'auto';
+}

package/src/commands/usage.mjs

@@ -0,0 +1,34 @@
+import { listThreads } from '../threads/store.mjs';
+import { estimateTokenCount } from '../agent/local.mjs';
+import { readEffectiveSettings } from '../settings/load.mjs';
+
+export function runUsage(parsed = {}) {
+  const summary = localUsageSummary();
+  const showCosts = readEffectiveSettings(parsed)['covenCode.showCosts'] !== false;
+  if (showCosts) console.log('remote_balance: unavailable (local recreation)');
+  console.log(`threads: ${summary.threads}`);
+  console.log(`turns: ${summary.turns}`);
+  if (showCosts) {
+    console.log(`input_tokens_estimate: ${summary.inputTokens}`);
+    console.log(`output_tokens_estimate: ${summary.outputTokens}`);
+  }
+}
+
+function localUsageSummary() {
+  const threads = listThreads();
+  let turns = 0;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for (const thread of threads) {
+    const messages = Array.isArray(thread.messages) ? thread.messages : [];
+    for (const message of messages) {
+      if (message.role === 'user') {
+        turns += 1;
+        inputTokens += estimateTokenCount(message.content ?? '');
+      } else if (message.role === 'assistant') {
+        outputTokens += estimateTokenCount(message.content ?? '');
+      }
+    }
+  }
+  return { threads: threads.length, turns, inputTokens, outputTokens };
+}

package/src/constants.mjs

@@ -0,0 +1,46 @@
+export const VERSION = '0.0.0-recreate';
+export const PRODUCT_NAME = 'Coven Code';
+export const CLI_NAME = 'coven-code';
+export const PACKAGE_NAME = '@opencoven/coven-code';
+export const CONFIG_SUBDIR = 'coven-code';
+export const PROJECT_SUBDIR = '.coven-code';
+export const THREAD_URL_BASE = 'https://coven-code.local/threads';
+
+export const FILE_MENTION_MAX_LINES = 500;
+export const FILE_MENTION_MAX_LINE_LENGTH = 2048;
+export const REPL_HISTORY_LIMIT = 500;
+
+export const AGENT_MODES = ['smart', 'deep', 'rush', 'large'];
+
+export const BUILTIN_TOOLS = [
+  ['Bash', 'built-in', "Executes the given shell command in the user's default shell"],
+  ['Read', 'built-in', 'Reads a UTF-8 text file from disk'],
+  ['Grep', 'built-in', 'Searches files by regular expression'],
+  ['glob', 'built-in', 'Finds files by glob pattern'],
+  ['create_file', 'built-in', 'Creates a new file'],
+  ['edit_file', 'built-in', 'Edits an existing file'],
+  ['oracle', 'built-in', 'Asks for second-opinion review or reasoning'],
+  ['librarian', 'built-in', 'Researches code across repositories or the current workspace'],
+  ['Task', 'built-in', 'Runs an isolated subagent for delegated work'],
+  ['painter', 'built-in', 'Generates or edits local image artifacts'],
+  ['mermaid', 'built-in', 'Renders a Mermaid diagram from the provided code'],
+  ['look_at', 'built-in', 'Inspects images, PDFs, or media files with a goal'],
+  ['web_search', 'built-in', 'Searches the web for information'],
+  ['read_web_page', 'built-in', 'Reads and extracts text from a web page'],
+  ['undo_edit', 'built-in', 'Undoes the latest edit_file change'],
+  ['find_thread', 'built-in', 'Finds prior threads by keyword, file, or task context'],
+  ['finder', 'built-in', 'Finds prior threads by keyword, file, or task context'],
+  ['read_mcp_resource', 'built-in', 'Reads a resource from a configured MCP server'],
+];
+
+export const BUILTIN_PERMISSIONS = [
+  ['allow', 'Bash', 'ls'],
+  ['allow', 'Bash', 'git status'],
+  ['allow', 'Bash', 'git diff'],
+  ['allow', 'Bash', 'git log'],
+  ['allow', 'Bash', 'npm test'],
+  ['allow', 'Bash', 'cargo build'],
+  ['ask', 'Bash', 'git push'],
+  ['ask', 'Bash', 'rm -rf'],
+  ['ask', 'Bash', 'sudo'],
+];

package/src/main.mjs

@@ -0,0 +1,87 @@
+import { parseGlobalArgs, UsageError } from './cli/parse.mjs';
+import { printHelp } from './cli/help.mjs';
+import { runCommand } from './cli/dispatch.mjs';
+import { runExecute } from './cli/execute.mjs';
+import { runInteractive } from './cli/repl.mjs';
+import { runTuiInteractive } from './cli/tui.mjs';
+import { runIdeConnect } from './commands/ide.mjs';
+import { readStdin } from './util/shell.mjs';
+import { AGENT_MODES, VERSION } from './constants.mjs';
+import { latestActiveThread, requireThread } from './threads/store.mjs';
+import { reasoningEffortForMode } from './cli/reasoning.mjs';
+
+export { UsageError };
+
+export async function main() {
+  const args = process.argv.slice(2);
+  const parsed = parseGlobalArgs(args);
+  const stdin = readStdin();
+
+  if (parsed.help) {
+    printHelp();
+    return;
+  }
+
+  if (parsed.version) {
+    console.log(VERSION);
+    return;
+  }
+
+  if (parsed.ide) {
+    runIdeConnect(parsed.ide);
+    return;
+  }
+
+  const command = parsed.positionals[0];
+  if (command) {
+    await runCommand(command, parsed.positionals.slice(1), parsed, stdin);
+    return;
+  }
+
+  if (parsed.streamJson && !parsed.execute) {
+    throw new UsageError('--stream-json requires --execute');
+  }
+  if (parsed.streamJsonInput && !parsed.streamJson) {
+    throw new UsageError('--stream-json-input requires --stream-json');
+  }
+  if (parsed.continueThread && !parsed.execute) {
+    throw new UsageError('--continue requires --execute');
+  }
+  if (!AGENT_MODES.includes(parsed.mode)) {
+    throw new UsageError(`mode must be one of: ${AGENT_MODES.join(', ')}`);
+  }
+  parsed.reasoningEffort = reasoningEffortForMode(parsed.mode, parsed.reasoningEffort);
+
+  if (parsed.execute || (stdin.length > 0 && !process.stdout.isTTY && process.env.COVEN_CODE_TUI_SCRIPTED !== '1')) {
+    await runExecute(parsed, stdin, { thread: continuationThread(parsed) });
+    return;
+  }
+
+  if (process.env.COVEN_CODE_TUI_SCRIPTED === '1' || (process.stdout.isTTY && (process.stdin.isTTY || stdin.length > 0))) {
+    const runner = selectInteractiveRunner({
+      stdinIsTTY: Boolean(process.stdin.isTTY),
+      stdoutIsTTY: Boolean(process.stdout.isTTY),
+      env: process.env,
+    });
+    if (runner === 'tui') await runTuiInteractive(parsed, stdin);
+    else await runInteractive(parsed, stdin);
+    return;
+  }
+
+  printHelp();
+}
+
+export function selectInteractiveRunner({ stdinIsTTY, stdoutIsTTY, env }) {
+  if (env.COVEN_CODE_TUI_SCRIPTED === '1') return 'tui';
+  if (env.COVEN_CODE_REPL === '1') return 'repl';
+  if (stdinIsTTY && stdoutIsTTY) return 'tui';
+  return 'repl';
+}
+
+function continuationThread(parsed) {
+  if (!parsed.continueThread) return undefined;
+  if (typeof parsed.continueThread === 'string') return requireThread(parsed.continueThread);
+  const thread = latestActiveThread();
+  if (!thread) throw new UsageError('No active thread to continue');
+  return thread;
+}