@golba98/codexa 1.0.1 → 1.0.3

package/src/ui/timelineMeasure.ts

@@ -25,6 +25,7 @@ import { selectVisibleRunActivity } from "./runActivityView.js";
 import { getTextUnits, getTextWidth, wrapPlainText, wrapCommandText, splitTextAtColumn } from "./textLayout.js";
 import type { RenderTimelineItem } from "./Timeline.js";
 import { normalizePlanReviewMarkdown } from "../core/planStorage.js";
+import { selectLogoVariant, LOGO_LARGE_MIN_COLS } from "./logoVariants.js";
 
 // ─── Exported types ───────────────────────────────────────────────────────────
 
@@ -40,7 +41,10 @@ export type TimelineTone =
   | "borderSubtle"
   | "borderActive"
   | "panel"
-  | "star";
+  | "star"
+  | "logoPrimary"
+  | "logoSecondary"
+  | "logoShadow";
 
 export interface TimelineRowSpan {
   text: string;
@@ -95,14 +99,8 @@ const MAX_VISIBLE_PROGRESS_ENTRIES = 3;
 const COMPACT_PROCESSING_BODY_LINE_CAP = 4;
 const COMPACT_STREAMING_TAIL_CAP = 6;
 const VISIBLE_THINKING_SOURCES = new Set(["reasoning", "todo"]);
-const INTRO_WORDMARK = [
-  " ██████╗ ██████╗ ██████╗ ███████╗██╗  ██╗ █████╗ ",
-  "██╔════╝██╔═══██╗██╔══██╗██╔════╝╚██╗██╔╝██╔══██╗",
-  "██║     ██║   ██║██║  ██║█████╗   ╚███╔╝ ███████║",
-  "██║     ██║   ██║██║  ██║██╔══╝   ██╔██╗ ██╔══██║",
-  "╚██████╗╚██████╔╝██████╔╝███████╗██╔╝ ██╗██║  ██║",
-  " ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝",
-];
+// Logo rows for the intro item — selected dynamically from logoVariants.ts so
+// the dead-code intro path stays consistent with the live TopHeader rendering.
 
 // Matches sentence-ending punctuation followed (optionally after whitespace) by
 // a capital letter starting a new word. Requires [A-Z] to be followed by [a-z]
@@ -1562,9 +1560,10 @@ export function buildIntroRows(item: Extract<RenderTimelineItem, { type: "intro"
   }
 
   const logoRows = startupHeaderMode === "large"
-    ? INTRO_WORDMARK
-    : ["CODEXA"];
-  const logoWidth = logoRows.reduce((maxWidth, line) => Math.max(maxWidth, getTextWidth(line)), 0);
+    ? selectLogoVariant(safeWidth)
+    : selectLogoVariant(0); // text-only fallback for compact mode
+  const effectiveLogoRows = logoRows.length > 0 ? logoRows : ["CODEXA"];
+  const logoWidth = effectiveLogoRows.reduce((maxWidth, line) => Math.max(maxWidth, getTextWidth(line)), 0);
   const workspaceName = getWorkspaceDisplayName(intro.workspaceLabel);
   const metaLines = [
     `Codexa v${intro.version}`,
@@ -1577,19 +1576,25 @@ export function buildIntroRows(item: Extract<RenderTimelineItem, { type: "intro"
     && safeWidth >= logoWidth + gapWidth + widestMetaLine;
 
   if (canRenderSideBySide) {
-    const metaStartRow = Math.max(0, Math.floor((logoRows.length - metaLines.length) / 2));
-    const rowCount = Math.max(logoRows.length, metaStartRow + metaLines.length);
+    const metaStartRow = Math.max(0, Math.floor((effectiveLogoRows.length - metaLines.length) / 2));
+    const rowCount = Math.max(effectiveLogoRows.length, metaStartRow + metaLines.length);
     const metaWidth = Math.max(1, safeWidth - logoWidth - gapWidth);
 
     for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
-      const logoLine = logoRows[rowIndex] ?? "";
+      const logoLine = effectiveLogoRows[rowIndex] ?? "";
       const logoPadding = Math.max(0, logoWidth - getTextWidth(logoLine));
       const metaIndex = rowIndex - metaStartRow;
       const metaLine = metaIndex >= 0 && metaIndex < metaLines.length
         ? sanitizeTerminalOutput(metaLines[metaIndex]!)
         : "";
+      let logoTone: TimelineTone = "logoPrimary";
+      if (effectiveLogoRows.length === 6) {
+        if (rowIndex === 2 || rowIndex === 3) logoTone = "logoSecondary";
+        else if (rowIndex === 4 || rowIndex === 5) logoTone = "logoShadow";
+      }
+      // No bold on logo spans — bold on block/box-drawing chars causes spacing artifacts.
       const spans = [
-        createSpan(`${logoLine}${" ".repeat(logoPadding)}`, "accent", { bold: true }),
+        createSpan(`${logoLine}${" ".repeat(logoPadding)}`, logoTone),
         createSpan(" ".repeat(gapWidth)),
       ];
 
@@ -1604,10 +1609,15 @@ export function buildIntroRows(item: Extract<RenderTimelineItem, { type: "intro"
       ));
     }
   } else {
-    logoRows.forEach((line, index) => {
+    effectiveLogoRows.forEach((line, index) => {
+      let logoTone: TimelineTone = "logoPrimary";
+      if (effectiveLogoRows.length === 6) {
+        if (index === 2 || index === 3) logoTone = "logoSecondary";
+        else if (index === 4 || index === 5) logoTone = "logoShadow";
+      }
       rows.push(createRow(
         `${item.key}-logo-${index}`,
-        [createSpan(clampVisualText(line, safeWidth), "accent", { bold: true })],
+        [createSpan(clampVisualText(line, safeWidth), logoTone)],
         safeWidth,
       ));
     });
@@ -2965,7 +2975,7 @@ export function buildTimelineSnapshot(
     let builtRows: TimelineRow[];
 
     if (item.type === "intro") {
-      const cacheKey = `i:${item.key}:${innerWidth}:${item.intro.version}:${item.intro.layoutMode}:${item.intro.startupHeaderMode ?? ""}:${item.intro.authLabel}:${item.intro.workspaceLabel}`;
+      const cacheKey = `i:${item.key}:${innerWidth}:${item.intro.version}:${item.intro.layoutMode}:${item.intro.startupHeaderMode ?? ""}:${item.intro.authLabel}:${item.intro.workspaceLabel}:v${LOGO_LARGE_MIN_COLS}`;
       const cached = _staticRowCache.get(cacheKey);
       if (cached) {
         renderDebug.traceEvent("timeline", "rowGeneration", {

package/scripts/audit-codexa-capabilities.mjs

@@ -1,466 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * audit-codexa-capabilities.mjs
- * 
- * Lightweight Codexa capability audit checker.
- * Performs static analysis on source to report feature availability.
- * 
- * Usage: node scripts/audit-codexa-capabilities.mjs
- */
-
-import { existsSync, readFileSync } from "fs";
-import { join, resolve } from "path";
-import { fileURLToPath } from "url";
-
-const __dirname = import.meta.dirname ?? 
-  resolve(new URL(import.meta.url).pathname, "..", "..");
-
-const repoRoot = resolve(__dirname, "..");
-
-const checks = {
-  entrypoint() {
-    const path = join(repoRoot, "bin", "codexa.js");
-    const exists = existsSync(path);
-    return {
-      pass: exists,
-      evidence: exists ? [path] : [],
-      reason: exists 
-        ? "Entry wrapper spawns Bun runtime to execute app"
-        : "Entry wrapper not found"
-    };
-  },
-
-  cliHelpVersion() {
-    const launchArgsPath = join(repoRoot, "src", "config", "launchArgs.ts");
-    const launcherPath = join(repoRoot, "bin", "codexa.js");
-    if (!existsSync(launchArgsPath) || !existsSync(launcherPath)) {
-      return { pass: false, evidence: [], reason: "launch arg parser or launcher not found" };
-    }
-    
-    const launchArgsContent = readFileSync(launchArgsPath, "utf-8");
-    const launcherContent = readFileSync(launcherPath, "utf-8");
-    const combined = `${launchArgsContent}\n${launcherContent}`;
-    const hasHelp = /--help/.test(combined) && /["']-h["']/.test(combined);
-    const hasVersion = /--version/.test(combined) && /["']-v["']/.test(combined);
-    const exitsBeforeInk = /process\.exit\(0\)/.test(launcherContent) && !/render\(/.test(launcherContent);
-    const readsPackageVersion = /package\.json/.test(launcherContent) && /version/.test(launcherContent);
-    
-    return {
-      pass: hasHelp && hasVersion && exitsBeforeInk && readsPackageVersion,
-      evidence: [launchArgsPath, launcherPath],
-      reason: hasHelp && hasVersion && exitsBeforeInk && readsPackageVersion
-        ? "--help/-h and --version/-v exit from launcher before Ink and version reads package.json"
-        : `Missing evidence: ${[
-          hasHelp ? null : "help flags",
-          hasVersion ? null : "version flags",
-          exitsBeforeInk ? null : "early exit before Ink",
-          readsPackageVersion ? null : "package.json version read",
-        ].filter(Boolean).join(", ")}`
-    };
-  },
-
-  initialPromptArgument() {
-    const path = join(repoRoot, "src", "config", "launchArgs.ts");
-    const appPath = join(repoRoot, "src", "app.tsx");
-    
-    if (!existsSync(path) || !existsSync(appPath)) {
-      return { pass: false, evidence: [], reason: "Required files not found" };
-    }
-
-    const launchContent = readFileSync(path, "utf-8");
-    const appContent = readFileSync(appPath, "utf-8");
-    
-    const hasExtraction = /initialPrompt/.test(launchContent) && /promptArgs/.test(launchContent);
-    const hasUsage = /launchArgs\.initialPrompt/.test(appContent)
-      && /initialPromptSubmittedRef/.test(appContent)
-      && /startPromptRun\(initialPrompt,\s*initialPrompt\)/.test(appContent);
-    
-    return {
-      pass: hasExtraction && hasUsage,
-      evidence: [path, appPath],
-      reason: hasExtraction && hasUsage
-        ? "Initial prompt support present"
-        : "Passthrough args stored but not used for initial prompt"
-    };
-  },
-
-  interactiveMode() {
-    const indexPath = join(repoRoot, "src", "index.tsx");
-    if (!existsSync(indexPath)) {
-      return { pass: false, evidence: [], reason: "src/index.tsx not found" };
-    }
-
-    const content = readFileSync(indexPath, "utf-8");
-    const hasTTY = /isTTY|TTY|isatty/.test(content);
-    const hasInk = /render\(|<App/.test(content);
-    
-    return {
-      pass: hasTTY && hasInk,
-      evidence: [indexPath],
-      reason: hasTTY && hasInk
-        ? "Interactive mode with TTY detection and Ink UI present"
-        : "TTY or UI setup missing"
-    };
-  },
-
-  modelPicker() {
-    const paths = [
-      join(repoRoot, "src", "ui", "ModelPicker.tsx"),
-      join(repoRoot, "src", "config", "settings.ts")
-    ];
-    
-    const exist = paths.filter(p => existsSync(p));
-    const hasModels = exist.some(p => 
-      /AVAILABLE_MODELS/.test(readFileSync(p, "utf-8"))
-    );
-    
-    return {
-      pass: exist.length === 2 && hasModels,
-      evidence: exist,
-      reason: exist.length === 2 && hasModels
-        ? "Model picker UI and model enumeration present"
-        : `Missing components: ${exist.length}/2`
-    };
-  },
-
-  configLoading() {
-    const paths = [
-      join(repoRoot, "src", "config", "layeredConfig.ts"),
-      join(repoRoot, "src", "config", "persistence.ts"),
-      join(repoRoot, "src", "config", "runtimeConfig.ts")
-    ];
-    
-    const exist = paths.filter(p => existsSync(p));
-    return {
-      pass: exist.length === paths.length,
-      evidence: exist,
-      reason: exist.length === 3
-        ? "Layered config resolution, persistence, and runtime config present"
-        : `Found ${exist.length}/3 config modules`
-    };
-  },
-
-  agentsmdSupport() {
-    const loaderPath = join(repoRoot, "src", "core", "projectInstructions.ts");
-    const appPath = join(repoRoot, "src", "app.tsx");
-    const promptPath = join(repoRoot, "src", "core", "codexPrompt.ts");
-    const providerPath = join(repoRoot, "src", "core", "providers", "codexSubprocess.ts");
-    
-    const paths = [loaderPath, appPath, promptPath, providerPath];
-    const existing = paths.filter(p => existsSync(p));
-    if (existing.length !== paths.length) {
-      return {
-        pass: false,
-        evidence: existing,
-        reason: `Found ${existing.length}/4 AGENTS.md support files`
-      };
-    }
-    
-    const loaderContent = readFileSync(loaderPath, "utf-8");
-    const appContent = readFileSync(appPath, "utf-8");
-    const promptContent = readFileSync(promptPath, "utf-8");
-    const providerContent = readFileSync(providerPath, "utf-8");
-    const discoversAgents = /AGENTS\.md/.test(loaderContent) && /\.codex/.test(loaderContent);
-    const appLoadsAgents = /loadProjectInstructions/.test(appContent) && /projectInstructions/.test(appContent);
-    const promptInjectsAgents = /Project instructions:/.test(promptContent) && /projectInstructions/.test(promptContent);
-    const providerPassesAgents = /projectInstructions/.test(providerContent) && /buildCodexPrompt/.test(providerContent);
-
-    return {
-      pass: discoversAgents && appLoadsAgents && promptInjectsAgents && providerPassesAgents,
-      evidence: paths,
-      reason: discoversAgents && appLoadsAgents && promptInjectsAgents && providerPassesAgents
-        ? "AGENTS.md/.codex/AGENTS.md discovery, app loading, and prompt injection present"
-        : `Missing evidence: ${[
-          discoversAgents ? null : "discovery",
-          appLoadsAgents ? null : "app loading",
-          promptInjectsAgents ? null : "prompt injection",
-          providerPassesAgents ? null : "provider pass-through",
-        ].filter(Boolean).join(", ")}`
-    };
-  },
-
-  commandExecution() {
-    const path = join(repoRoot, "src", "core", "process", "CommandRunner.ts");
-    if (!existsSync(path)) {
-      return { pass: false, evidence: [], reason: "CommandRunner.ts not found" };
-    }
-
-    const content = readFileSync(path, "utf-8");
-    const hasRun = /runCommand|spawn/.test(content);
-    const hasOutput = /stdout|stderr/.test(content);
-    
-    return {
-      pass: hasRun && hasOutput,
-      evidence: [path],
-      reason: hasRun && hasOutput
-        ? "Shell command execution with output capture present"
-        : "Command execution incomplete"
-    };
-  },
-
-  fileEditingLayer() {
-    const paths = [
-      join(repoRoot, "src", "core", "workspaceActivity.ts"),
-      join(repoRoot, "src", "core", "workspaceGuard.ts")
-    ];
-    
-    const exist = paths.filter(p => existsSync(p));
-    const content = exist.map(p => readFileSync(p, "utf-8")).join("");
-    const hasTracking = /createWorkspaceActivityTracker|modified|created|deleted/.test(content);
-    const hasGuard = /isPathInsideWorkspace|workspaceGuard/.test(content);
-    
-    return {
-      pass: exist.length === 2 && hasTracking && hasGuard,
-      evidence: exist,
-      reason: hasTracking && hasGuard
-        ? "File activity tracking and workspace guard present"
-        : exist.length < 2 ? "Activity or guard module missing" : "Tracking/guard logic incomplete"
-    };
-  },
-
-  diffRenderer() {
-    const rendererPath = join(repoRoot, "src", "ui", "diffRenderer.ts");
-    const testPath = join(repoRoot, "src", "ui", "diffRenderer.test.ts");
-    const markdownPath = join(repoRoot, "src", "ui", "Markdown.tsx");
-    const timelinePath = join(repoRoot, "src", "ui", "timelineMeasure.ts");
-    const paths = [rendererPath, testPath, markdownPath, timelinePath];
-    const existing = paths.filter(p => existsSync(p));
-
-    if (existing.length !== paths.length) {
-      return {
-        pass: false,
-        evidence: existing,
-        reason: `Found ${existing.length}/4 diff renderer files/integrations`
-      };
-    }
-
-    const rendererContent = readFileSync(rendererPath, "utf-8");
-    const testContent = readFileSync(testPath, "utf-8");
-    const markdownContent = readFileSync(markdownPath, "utf-8");
-    const timelineContent = readFileSync(timelinePath, "utf-8");
-    const exportsUtility = /export\s+function\s+isUnifiedDiff/.test(rendererContent)
-      && /export\s+function\s+renderUnifiedDiff/.test(rendererContent)
-      && /export\s+function\s+maybeRenderDiff/.test(rendererContent)
-      && /DiffRenderLine/.test(rendererContent);
-    const detectsUnifiedDiff = /DIFF_GIT_HEADER_PATTERN/.test(rendererContent)
-      && /HUNK_HEADER_PATTERN/.test(rendererContent)
-      && /OLD_FILE_HEADER_PATTERN/.test(rendererContent)
-      && /NEW_FILE_HEADER_PATTERN/.test(rendererContent);
-    const hasFocusedTests = /isUnifiedDiff/.test(testContent)
-      && /renderUnifiedDiff/.test(testContent)
-      && /ANSI|control/i.test(testContent)
-      && /normal text|normal prose/i.test(testContent);
-    const markdownIntegrated = /diffRenderer/.test(markdownContent) && /maybeRenderDiff/.test(markdownContent);
-    const timelineIntegrated = /diffRenderer/.test(timelineContent) && /maybeRenderDiff/.test(timelineContent);
-    
-    return {
-      pass: exportsUtility && detectsUnifiedDiff && hasFocusedTests && markdownIntegrated && timelineIntegrated,
-      evidence: paths,
-      reason: exportsUtility && detectsUnifiedDiff && hasFocusedTests && markdownIntegrated && timelineIntegrated
-        ? "Unified diff renderer utility, tests, and UI integrations present"
-        : `Missing evidence: ${[
-          exportsUtility ? null : "utility exports",
-          detectsUnifiedDiff ? null : "unified diff detection",
-          hasFocusedTests ? null : "focused tests",
-          markdownIntegrated ? null : "Markdown integration",
-          timelineIntegrated ? null : "timeline integration",
-        ].filter(Boolean).join(", ")}`
-    };
-  },
-
-  approvalSandboxLogic() {
-    const paths = [
-      join(repoRoot, "src", "core", "workspaceGuard.ts"),
-      join(repoRoot, "src", "config", "runtimeConfig.ts")
-    ];
-    
-    const exist = paths.filter(p => existsSync(p));
-    const content = exist.map(p => readFileSync(p, "utf-8")).join("");
-    const hasSandbox = /sandbox|approval|permission|writable.*root/.test(content);
-    
-    return {
-      pass: exist.length === 2 && hasSandbox,
-      evidence: exist,
-      reason: hasSandbox
-        ? "Sandbox configuration and approval logic present"
-        : "Approval or sandbox logic missing"
-    };
-  },
-
-  sessionHistoryPersistence() {
-    const paths = [
-      join(repoRoot, "src", "session", "types.ts"),
-      join(repoRoot, "src", "session", "appSession.ts"),
-      join(repoRoot, "src", "config", "persistence.ts")
-    ];
-    
-    const exist = paths.filter(p => existsSync(p));
-    return {
-      pass: exist.length === 3,
-      evidence: exist,
-      reason: exist.length === 3
-        ? "Session event types, state management, and persistence present"
-        : `Found ${exist.length}/3 session modules`
-    };
-  },
-
-  debugLogging() {
-    const debugPath = join(repoRoot, "src", "core", "inputDebug.ts");
-    const envPath = join(repoRoot, "bin", "codexa.js");
-    
-    const debugExists = existsSync(debugPath);
-    const envContent = existsSync(envPath) ? readFileSync(envPath, "utf-8") : "";
-    const hasEnvDebug = /CODEXA_DEBUG|debug/.test(envContent);
-    
-    return {
-      pass: debugExists || hasEnvDebug,
-      evidence: [debugExists ? debugPath : envPath].filter(p => existsSync(p)),
-      reason: debugExists && hasEnvDebug
-        ? "Debug logging module and environment variable support present"
-        : debugExists || hasEnvDebug
-        ? "Partial debug support"
-        : "Debug logging not found"
-    };
-  },
-
-  windowsPowerShellHandling() {
-    const launcherPath = join(repoRoot, "bin", "codexa.js");
-    if (!existsSync(launcherPath)) {
-      return { pass: false, evidence: [], reason: "Launcher not found" };
-    }
-
-    const content = readFileSync(launcherPath, "utf-8");
-    const hasWinDetect = /win32|platform|windows/i.test(content);
-    const hasExeResolution = /bun\.exe|bun\.cmd|shell|spawn/.test(content);
-    
-    return {
-      pass: hasWinDetect && hasExeResolution,
-      evidence: [launcherPath],
-      reason: hasWinDetect && hasExeResolution
-        ? "Windows platform detection and executable resolution present"
-        : "Windows-specific handling incomplete"
-    };
-  },
-
-  resizeHandling() {
-    const indexPath = join(repoRoot, "src", "index.tsx");
-    if (!existsSync(indexPath)) {
-      return { pass: false, evidence: [], reason: "src/index.tsx not found" };
-    }
-
-    const content = readFileSync(indexPath, "utf-8");
-    const hasResize = /resize|onResize|RESIZE/.test(content);
-    const hasRepaint = /repaint|recalculate|calculateLayout/.test(content);
-    
-    return {
-      pass: hasResize && hasRepaint,
-      evidence: [indexPath],
-      reason: hasResize && hasRepaint
-        ? "Terminal resize event handling and UI recalculation present"
-        : "Resize handling incomplete"
-    };
-  },
-
-  streamingHandler() {
-    const paths = [
-      join(repoRoot, "src", "core", "providers", "codexSubprocess.ts"),
-      join(repoRoot, "src", "core", "codex.ts")
-    ];
-    
-    const exist = paths.filter(p => existsSync(p));
-    const content = exist.map(p => readFileSync(p, "utf-8")).join("");
-    const hasStreaming = /stream|emit|chunk|line|onLine/.test(content);
-    
-    return {
-      pass: exist.length > 0 && hasStreaming,
-      evidence: exist,
-      reason: hasStreaming
-        ? "Streaming response handler present"
-        : "Streaming implementation not found"
-    };
-  },
-
-  interruptCancelHandling() {
-    const indexPath = join(repoRoot, "src", "index.tsx");
-    const appPath = join(repoRoot, "src", "app.tsx");
-    
-    const paths = [indexPath, appPath].filter(p => existsSync(p));
-    const content = paths.map(p => readFileSync(p, "utf-8")).join("");
-    const hasSignals = /SIGINT|SIGTERM|signal|cancel/.test(content);
-    const hasCancel = /cancel|abort|kill/.test(content);
-    
-    return {
-      pass: hasSignals && hasCancel,
-      evidence: paths,
-      reason: hasSignals && hasCancel
-        ? "Signal handling and cancellation logic present"
-        : "Interrupt/cancel handling incomplete"
-    };
-  }
-};
-
-function statusSymbol(pass) {
-  return pass ? "✓" : "✗";
-}
-
-function statusLabel(pass) {
-  return pass ? "PASS" : "MISSING";
-}
-
-function formatName(name) {
-  return name
-    .replace(/([A-Z])/g, " $1")
-    .replace(/^./, str => str.toUpperCase());
-}
-
-console.log("\n" + "=".repeat(80));
-console.log("CODEXA CAPABILITY AUDIT REPORT");
-console.log("=".repeat(80));
-console.log(`Repository: ${repoRoot}\n`);
-
-const results = [];
-
-for (const [name, checkFn] of Object.entries(checks)) {
-  const result = checkFn();
-  results.push({ name, ...result });
-  
-  const symbol = statusSymbol(result.pass);
-  const status = statusLabel(result.pass);
-  const formattedName = formatName(name);
-  
-  console.log(`${symbol} ${status.padEnd(8)} | ${formattedName}`);
-  console.log(`           ${result.reason}`);
-  if (result.evidence.length > 0) {
-    console.log(`           Evidence: ${result.evidence.map(e => e.replace(repoRoot, ".")).join(", ")}`);
-  }
-  console.log();
-}
-
-const total = results.length;
-const passed = results.filter(r => r.pass).length;
-const missing = total - passed;
-const pctComplete = Math.round((passed / total) * 100);
-
-console.log("=".repeat(80));
-console.log("CAPABILITY SUMMARY");
-console.log("=".repeat(80));
-console.log(`Total checks:        ${total}`);
-console.log(`Passed:              ${passed} (${pctComplete}%)`);
-console.log(`Missing/Partial:     ${missing} (${100 - pctComplete}%)`);
-console.log();
-
-const missingFeatures = results.filter(r => !r.pass).map(r => formatName(r.name));
-
-if (missingFeatures.length > 0) {
-  console.log("TOP MISSING FEATURES:");
-  missingFeatures.forEach((f, i) => {
-    console.log(`  ${i + 1}. ${f}`);
-  });
-  console.log();
-}
-
-console.log("=".repeat(80));
-console.log();
-
-process.exit(passed === total ? 0 : 1);

package/scripts/smoke-terminal-bench.mjs

@@ -1,35 +0,0 @@
-#!/usr/bin/env node
-
-import { spawn } from "node:child_process";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const scriptDir = dirname(fileURLToPath(import.meta.url));
-const repoRoot = dirname(scriptDir);
-const binPath = join(repoRoot, "bin", "codexa.js");
-const prompt = "Print the current directory, list files, and stop.";
-
-const child = spawn(
-  process.execPath,
-  [binPath, "exec", prompt],
-  {
-    cwd: process.cwd(),
-    stdio: "inherit",
-    env: {
-      ...process.env,
-    },
-  },
-);
-
-child.on("error", (error) => {
-  console.error(`[smoke-terminal-bench] failed to launch: ${error.message}`);
-  process.exit(1);
-});
-
-child.on("close", (code, signal) => {
-  if (signal) {
-    console.error(`[smoke-terminal-bench] terminated by ${signal}`);
-    process.exit(1);
-  }
-  process.exit(code ?? 0);
-});