@pellux/goodvibes-tui 0.22.0 → 0.24.0

package/src/cli/management.ts

@@ -1,20 +1,12 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import net from 'node:net';
-import { spawn } from 'node:child_process';
-import { networkInterfaces } from 'node:os';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
 import type { ConfigManager, ConfigKey, GoodVibesConfig } from '../config/index.ts';
 import { CONFIG_SCHEMA } from '../config/index.ts';
 import { formatProviderModel, getModelIdFromProviderModel } from '../config/provider-model.ts';
-import { bootstrapRuntime } from '../runtime/bootstrap.ts';
-import { createRuntimeServices } from '../runtime/services.ts';
-import { createRuntimeStore } from '../runtime/store/index.ts';
-import type { RuntimeServices } from '../runtime/services.ts';
 import { SecretsManager } from '../config/secrets.ts';
-import { RuntimeEventBus, type TurnEvent } from '@/runtime/index.ts';
-import { createShellPathService } from '@/runtime/index.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { listProviderRuntimeSnapshots } from '@pellux/goodvibes-sdk/platform/providers';
+import type { CanonicalModel } from '@pellux/goodvibes-sdk/platform/providers';
 import { BUILTIN_SECRET_PROVIDER_SOURCES, describeSecretRef, isSecretRefInput, resolveSecretRef } from '@pellux/goodvibes-sdk/platform/config';
 import { getSubscriptionProviderConfig, listAvailableSubscriptionProviders } from '@pellux/goodvibes-sdk/platform/config';
 import { beginOpenAICodexLogin, exchangeOpenAICodexCode } from '@pellux/goodvibes-sdk/platform/config';
@@ -31,105 +23,46 @@ import { handleServiceCommand } from './service-command.ts';
 import { handleBundleCommand } from './bundle-command.ts';
 import { buildListenerTestResult, formatListenerTestResult, handleSurfacesCommand } from './surface-command.ts';
 import { buildControlPlaneStatusResult, formatControlPlaneStatus, handleSecrets, handleSessions, handleTasks, renderPairing, renderRemote, renderSubscriptions, renderWeb } from './management-commands.ts';
+import {
+  yesNo,
+  formatJsonOrText,
+  hasCommandFlag,
+  withRuntimeServices,
+  runNonInteractiveAgent,
+  isPresentConfigValue,
+  urlHostForBindHost,
+  probeTcp,
+  readAuthPaths,
+  exitCodeForText,
+  splitCommandOption,
+  readOptionValue,
+  readOptionValues,
+  commandValues,
+  readPassword,
+} from './management-utils.ts';
 
 interface CliCommandResult {
   readonly handled: boolean;
   readonly exitCode: number;
 }
 
-type Formatter = (value: unknown, text: string) => string;
-
-export function yesNo(value: unknown): string {
-  return value === true ? 'yes' : 'no';
-}
-
-export function formatJsonOrText(cli: GoodVibesCliParseResult): Formatter {
-  return (value, text) => cli.flags.outputFormat === 'json'
-    ? JSON.stringify(value, null, 2)
-    : text;
-}
-
-function exitCodeForText(output: string): number {
-  if (output.startsWith('Usage:') || output.startsWith('Invalid ')) return 2;
-  if (output.startsWith('Session not found:') || output.startsWith('Unknown task:') || output.startsWith('Task submit failed ')) return 1;
-  if (output.startsWith('No stored ') || output.startsWith('No pending ') || output.startsWith('No model ') || output.startsWith('No provider ') || output.startsWith('No auth ')) return 1;
-  if (output.startsWith('Unknown ')) return 1;
-  if (output === 'Bundle has no config object to import.') return 1;
-  return 0;
-}
-
-function splitCommandOption(token: string): { readonly name: string; readonly value: string | undefined } {
-  const index = token.indexOf('=');
-  if (index < 0) return { name: token, value: undefined };
-  return { name: token.slice(0, index), value: token.slice(index + 1) };
-}
-
-function readOptionValue(args: readonly string[], name: string): string | undefined {
-  for (let index = 0; index < args.length; index += 1) {
-    const token = args[index]!;
-    const split = splitCommandOption(token);
-    if (split.name !== name) continue;
-    if (split.value !== undefined) return split.value;
-    const next = args[index + 1];
-    if (next === undefined || next.startsWith('--')) return undefined;
-    return next;
-  }
-  return undefined;
-}
-
-function readOptionValues(args: readonly string[], name: string): string[] {
-  const values: string[] = [];
-  for (let index = 0; index < args.length; index += 1) {
-    const token = args[index]!;
-    const split = splitCommandOption(token);
-    if (split.name !== name) continue;
-    if (split.value !== undefined) {
-      values.push(split.value);
-      continue;
-    }
-    const next = args[index + 1];
-    if (next !== undefined && !next.startsWith('--')) values.push(next);
-  }
-  return values;
-}
-
-export function hasCommandFlag(args: readonly string[], name: string): boolean {
-  return args.some((arg) => splitCommandOption(arg).name === name);
-}
-
-function commandValues(args: readonly string[]): string[] {
-  const values: string[] = [];
-  for (let index = 0; index < args.length; index += 1) {
-    const token = args[index]!;
-    if (!token.startsWith('--')) {
-      values.push(token);
-      continue;
-    }
-    if (!token.includes('=') && args[index + 1] && !args[index + 1]!.startsWith('--')) index += 1;
-  }
-  return values;
-}
-
-function readPassword(args: readonly string[]): string | null {
-  const explicit = readOptionValue(args, '--password');
-  if (explicit !== undefined) return explicit;
-  if (hasCommandFlag(args, '--password-stdin')) return readFileSync(0, 'utf-8').trimEnd();
-  return process.env.GOODVIBES_AUTH_PASSWORD ?? null;
-}
-
-export function extractAuthorizationCode(input: string): string {
-  try {
-    const url = new URL(input);
-    return url.searchParams.get('code') ?? input;
-  } catch {
-    return input;
-  }
-}
-
-export function isPresentConfigValue(value: unknown): boolean {
-  if (typeof value === 'string') return value.trim().length > 0;
-  return value !== undefined && value !== null && value !== false;
-}
+export {
+  yesNo,
+  formatJsonOrText,
+  hasCommandFlag,
+  extractAuthorizationCode,
+  isPresentConfigValue,
+  getNestedValue,
+  urlHostForBindHost,
+  enableServicePosture,
+  enableEndpointLanDefault,
+  applyTargetEndpointFlagsOrDefault,
+  openBrowser,
+  probeTcp,
+  withRuntimeServices,
+  readAuthPaths,
+  runNonInteractiveAgent,
+} from './management-utils.ts';
 
 function inferProviderFromRegistryKey(modelKey: string): string {
   if (modelKey.includes(':')) return modelKey.split(':')[0] || 'openai';
@@ -137,236 +70,6 @@ function inferProviderFromRegistryKey(modelKey: string): string {
   return 'openai';
 }
 
-export function getNestedValue(source: unknown, key: string): unknown {
-  let cursor = source;
-  for (const part of key.split('.')) {
-    if (cursor == null || typeof cursor !== 'object') return undefined;
-    cursor = (cursor as Record<string, unknown>)[part];
-  }
-  return cursor;
-}
-
-function getLocalNetworkIp(): string {
-  try {
-    const nets = networkInterfaces();
-    for (const name of Object.keys(nets)) {
-      for (const netInfo of nets[name] ?? []) {
-        if (netInfo.family === 'IPv4' && !netInfo.internal) return netInfo.address;
-      }
-    }
-  } catch {
-    return '127.0.0.1';
-  }
-  return '127.0.0.1';
-}
-
-function connectHostForBindHost(host: string): string {
-  if (host === '0.0.0.0' || host === '::') return '127.0.0.1';
-  return host || '127.0.0.1';
-}
-
-export function urlHostForBindHost(host: string): string {
-  if (host === '0.0.0.0' || host === '::') return getLocalNetworkIp();
-  return host || '127.0.0.1';
-}
-
-export function enableServicePosture(config: ConfigManager): void {
-  config.setDynamic('service.enabled', true);
-  config.setDynamic('service.autostart', true);
-  config.setDynamic('service.restartOnFailure', true);
-}
-
-export function enableEndpointLanDefault(config: ConfigManager, endpoint: RuntimeEndpointId): void {
-  const binding = resolveRuntimeEndpointBinding(config, endpoint);
-  if (binding.hostMode === 'custom') return;
-  if (endpoint === 'controlPlane') {
-    config.setDynamic('controlPlane.hostMode', 'network');
-    config.setDynamic('controlPlane.host', '0.0.0.0');
-    config.setDynamic('controlPlane.allowRemote', true);
-    return;
-  }
-  if (endpoint === 'httpListener') {
-    config.setDynamic('httpListener.hostMode', 'network');
-    config.setDynamic('httpListener.host', '0.0.0.0');
-    return;
-  }
-  config.setDynamic('web.hostMode', 'network');
-  config.setDynamic('web.host', '0.0.0.0');
-}
-
-export function applyTargetEndpointFlagsOrDefault(
-  runtime: CliCommandRuntime,
-  endpoint: RuntimeEndpointId,
-): string | null {
-  const errors = applyRuntimeEndpointFlagOverrides(runtime.configManager, endpoint, runtime.cli.flags);
-  if (errors.length > 0) return errors.join('\n');
-  if (runtime.cli.flags.hostname === undefined) {
-    enableEndpointLanDefault(runtime.configManager, endpoint);
-  }
-  if (endpoint === 'controlPlane') {
-    const binding = resolveRuntimeEndpointBinding(runtime.configManager, endpoint);
-    runtime.configManager.setDynamic('controlPlane.allowRemote', binding.hostMode !== 'local');
-  }
-  return null;
-}
-
-export function openBrowser(url: string): string {
-  const platform = process.platform;
-  const command = platform === 'darwin' ? 'open' : platform === 'win32' ? 'cmd' : 'xdg-open';
-  const args = platform === 'win32' ? ['/c', 'start', '', url] : [url];
-  try {
-    const child = spawn(command, args, { detached: true, stdio: 'ignore' });
-    child.once('error', () => {});
-    child.unref();
-    return 'browser open requested';
-  } catch (error) {
-    return `browser open failed: ${summarizeError(error)}`;
-  }
-}
-
-export async function probeTcp(host: string, port: number, timeoutMs = 750): Promise<boolean> {
-  return await new Promise<boolean>((resolve) => {
-    const socket = net.createConnection({ host: connectHostForBindHost(host), port });
-    const finish = (value: boolean) => {
-      socket.removeAllListeners();
-      socket.destroy();
-      resolve(value);
-    };
-    socket.setTimeout(timeoutMs);
-    socket.once('connect', () => finish(true));
-    socket.once('timeout', () => finish(false));
-    socket.once('error', () => finish(false));
-  });
-}
-
-export async function withRuntimeServices<T>(
-  runtime: CliCommandRuntime,
-  fn: (services: RuntimeServices) => Promise<T> | T,
-): Promise<T> {
-  const runtimeBus = new RuntimeEventBus();
-  const runtimeStore = createRuntimeStore();
-  const services = createRuntimeServices({
-    configManager: runtime.configManager,
-    runtimeBus,
-    runtimeStore,
-    workingDir: runtime.workingDirectory,
-    homeDirectory: runtime.homeDirectory,
-  });
-  services.providerRegistry.initModelLimits();
-  services.benchmarkStore.initBenchmarks();
-  services.providerRegistry.initCatalog();
-  try {
-    await services.providerRegistry.ready();
-    return await fn(services);
-  } finally {
-    services.providerRegistry.stopWatching();
-  }
-}
-
-export function readAuthPaths(runtime: CliCommandRuntime) {
-  const shellPaths = createShellPathService({
-    workingDirectory: runtime.workingDirectory,
-    homeDirectory: runtime.homeDirectory,
-  });
-  const userStorePath = shellPaths.resolveUserPath('tui', 'auth-users.json');
-  const bootstrapCredentialPath = shellPaths.resolveUserPath('tui', 'auth-bootstrap.txt');
-  const operatorTokenPath = join(runtime.homeDirectory, '.goodvibes', 'daemon', 'operator-tokens.json');
-  return {
-    userStorePath,
-    userStorePresent: existsSync(userStorePath),
-    bootstrapCredentialPath,
-    bootstrapCredentialPresent: existsSync(bootstrapCredentialPath),
-    operatorTokenPath,
-    operatorTokenPresent: existsSync(operatorTokenPath),
-  };
-}
-
-export async function runNonInteractiveAgent(runtime: CliCommandRuntime): Promise<number> {
-  const prompt = runtime.cli.flags.prompt ?? runtime.cli.positionals.join(' ').trim();
-  if (!prompt) {
-    console.error('Usage: goodvibes run|exec [prompt]');
-    return 2;
-  }
-
-  const outputFormat = runtime.cli.flags.outputFormat;
-  const ctx = await bootstrapRuntime(process.stdout, {
-    configManager: runtime.configManager,
-    workingDir: runtime.workingDirectory,
-    homeDirectory: runtime.homeDirectory,
-  });
-
-  const events: TurnEvent[] = [];
-  let finalResponse = '';
-  let finalError = '';
-  let finalStopReason = '';
-  let exitCode = 0;
-
-  const done = new Promise<void>((resolve) => {
-    const unsubs = [
-      ctx.runtimeBus.on<Extract<TurnEvent, { type: 'STREAM_DELTA' }>>('STREAM_DELTA', ({ payload }) => {
-        events.push(payload);
-        if (outputFormat === 'stream-json') {
-          process.stdout.write(JSON.stringify({ type: payload.type, content: payload.content, accumulated: payload.accumulated }) + '\n');
-        }
-      }),
-      ctx.runtimeBus.on<Extract<TurnEvent, { type: 'TURN_COMPLETED' }>>('TURN_COMPLETED', ({ payload }) => {
-        events.push(payload);
-        finalResponse = payload.response;
-        finalStopReason = payload.stopReason;
-        for (const unsub of unsubs) unsub();
-        resolve();
-      }),
-      ctx.runtimeBus.on<Extract<TurnEvent, { type: 'TURN_ERROR' }>>('TURN_ERROR', ({ payload }) => {
-        events.push(payload);
-        finalError = payload.error;
-        finalStopReason = payload.stopReason;
-        exitCode = 1;
-        for (const unsub of unsubs) unsub();
-        resolve();
-      }),
-      ctx.runtimeBus.on<Extract<TurnEvent, { type: 'TURN_CANCEL' }>>('TURN_CANCEL', ({ payload }) => {
-        events.push(payload);
-        finalError = payload.reason ?? 'cancelled';
-        finalStopReason = payload.stopReason;
-        exitCode = 130;
-        for (const unsub of unsubs) unsub();
-        resolve();
-      }),
-    ];
-  });
-
-  try {
-    await ctx.orchestrator.handleUserInput(prompt);
-    await done;
-    if (outputFormat === 'json') {
-      process.stdout.write(JSON.stringify({
-        ok: exitCode === 0,
-        response: finalResponse,
-        error: finalError || undefined,
-        stopReason: finalStopReason,
-        sessionId: ctx.runtime.sessionId,
-        model: ctx.runtime.model,
-        provider: ctx.runtime.provider,
-        events: events.length,
-      }, null, 2) + '\n');
-    } else if (outputFormat !== 'stream-json') {
-      process.stdout.write((exitCode === 0 ? finalResponse : finalError) + '\n');
-    } else {
-      process.stdout.write(JSON.stringify({
-        type: exitCode === 0 ? 'TURN_COMPLETED' : 'TURN_ERROR',
-        ok: exitCode === 0,
-        response: finalResponse,
-        error: finalError || undefined,
-        stopReason: finalStopReason,
-      }) + '\n');
-    }
-  } finally {
-    const snapshot = ctx.conversation.toJSON() as Parameters<typeof ctx.shutdown>[0];
-    await ctx.shutdown(snapshot);
-  }
-  return exitCode;
-}
-
 async function renderProviders(runtime: CliCommandRuntime): Promise<string> {
   return await withRuntimeServices(runtime, async (services) => {
     const [sub = 'list', ...rest] = runtime.cli.commandArgs;
@@ -471,6 +174,40 @@ async function renderProviders(runtime: CliCommandRuntime): Promise<string> {
   });
 }
 
+/**
+ * Build the synthetic chain entry list for `goodvibes models chain` output.
+ * Pure transformation: accepts canonical model data and an optional lowercase filter key,
+ * returns a serializable array suitable for both JSON and text formatting.
+ *
+ * @internal exported for unit testing
+ */
+export function buildSyntheticChainEntries(
+  canonicalModels: readonly CanonicalModel[],
+  filterKey?: string,
+): Array<{
+  id: string;
+  tier: string;
+  backendCount: number;
+  keyedBackendCount: number;
+  backends: Array<{ position: number; provider: string; model: string; registryKey: string }>;
+}> {
+  const filtered = filterKey
+    ? canonicalModels.filter((m) => m.id.toLowerCase().includes(filterKey))
+    : canonicalModels;
+  return filtered.map((m) => ({
+    id: m.id,
+    tier: m.tier,
+    backendCount: m.backendCount,
+    keyedBackendCount: m.keyedBackendCount,
+    backends: m.backends.map((b, idx) => ({
+      position: idx,
+      provider: b.providerName,
+      model: b.modelId,
+      registryKey: b.registryKey ?? `${b.providerName}:${b.modelId}`,
+    })),
+  }));
+}
+
 async function renderModels(runtime: CliCommandRuntime): Promise<string> {
   return await withRuntimeServices(runtime, async (services) => {
     const [subOrFilter, ...rest] = runtime.cli.commandArgs;
@@ -544,23 +281,58 @@ async function renderModels(runtime: CliCommandRuntime): Promise<string> {
         ...recent.map((model) => `  ${model}`),
       ].join('\n'));
     }
+    if (subOrFilter === 'chain' || subOrFilter === 'chains') {
+      // List synthetic model fallback ladders — backend composition for each synthetic model.
+      const canonicalModels = services.providerRegistry.getSyntheticCanonicalModels();
+      if (canonicalModels.length === 0) {
+        return formatJsonOrText(runtime.cli)([], 'No synthetic models found in the current catalog.');
+      }
+      const filterKey = rest[0]?.toLowerCase();
+      const filtered = filterKey
+        ? canonicalModels.filter((m) => m.id.toLowerCase().includes(filterKey))
+        : canonicalModels;
+      const value = buildSyntheticChainEntries(filtered);
+      return formatJsonOrText(runtime.cli)(value, [
+        `GoodVibes synthetic model chains${filterKey ? ` (${filterKey})` : ''}`,
+        ...value.flatMap((m) => [
+          `  ${m.id}  [${m.tier}]  ${m.keyedBackendCount}/${m.backendCount} backends configured`,
+          ...m.backends.map((b) => `    ${b.position}. ${b.provider}/${b.model}`),
+        ]),
+      ].join('\n'));
+    }
     const filter = subOrFilter === 'list' ? rest[0]?.toLowerCase() : subOrFilter?.toLowerCase();
     const models = services.providerRegistry
       .getSelectableModels()
       .filter((model) => !filter || model.provider.toLowerCase() === filter || model.registryKey.toLowerCase().includes(filter))
       .slice(0, 200);
-    const value = models.map((model) => ({
-      registryKey: model.registryKey,
-      provider: model.provider,
-      ...classifyModelProvider(model.provider),
-      id: model.id,
-      displayName: model.displayName,
-      contextWindow: services.providerRegistry.getContextWindowForModel(model),
-      current: model.registryKey === current,
-    }));
+    const value = models.map((model) => {
+      const synthInfo = model.provider === 'synthetic'
+        ? services.providerRegistry.getSyntheticModelInfoFromCatalog(model.id)
+        : null;
+      return {
+        registryKey: model.registryKey,
+        provider: model.provider,
+        ...classifyModelProvider(model.provider),
+        id: model.id,
+        displayName: model.displayName,
+        contextWindow: services.providerRegistry.getContextWindowForModel(model),
+        current: model.registryKey === current,
+        ...(synthInfo !== null ? {
+          isSynthetic: true,
+          syntheticTier: synthInfo.tier,
+          syntheticBackends: synthInfo.backendCount,
+          syntheticConfiguredBackends: synthInfo.keyedBackendCount,
+        } : {}),
+      };
+    });
     return formatJsonOrText(runtime.cli)(value, [
       `GoodVibes models${filter ? ` (${filter})` : ''}`,
-      ...value.map((model) => `  ${model.current ? '*' : ' '} ${model.registryKey.padEnd(42)} setup=${model.setupClass} ctx=${model.contextWindow.toLocaleString()} ${model.displayName}`),
+      ...value.map((model) => {
+        const synthLabel = model.isSynthetic
+          ? ` [synthetic ${model.syntheticConfiguredBackends}/${model.syntheticBackends}p]`
+          : '';
+        return `  ${model.current ? '*' : ' '} ${model.registryKey.padEnd(42)} setup=${model.setupClass} ctx=${model.contextWindow.toLocaleString()}${synthLabel} ${model.displayName}`;
+      }),
     ].join('\n'));
   });
 }

package/src/cli/surface-command.ts

@@ -18,7 +18,7 @@ import {
   probeTcp,
   readAuthPaths,
   yesNo,
-} from './management.ts';
+} from './management-utils.ts';
 
 export const SURFACE_CONFIGS = [
   ['slack', 'Slack', ['surfaces.slack.signingSecret', 'surfaces.slack.botToken']],

package/src/core/context-auto-compact.ts

@@ -15,6 +15,9 @@ import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers'
 import type { SystemMessageRouter } from './system-message-router';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { getLastCompactionEvent } from '@pellux/goodvibes-sdk/platform/core';
+import type { CompactionContext } from '@pellux/goodvibes-sdk/platform/core';
+import { buildCompactionPreview, buildCompactionAfterNotice } from '../renderer/compaction-preview.ts';
 
 export interface AutoCompactDeps {
   readonly configManager: Pick<ConfigManager, 'get'>;
@@ -51,22 +54,52 @@ export async function maybeAutoCompact(deps: AutoCompactDeps): Promise<void> {
 
   try {
     logger.debug('auto-compact triggered', { usagePct, thresholdPct });
-    // Honest transcript notice — the user should always know when compaction
-    // runs automatically so they can understand any summary discontinuity.
-    deps.systemMessageRouter.routeSystemMessage(
-      `[Context] Auto-compacting conversation — usage reached ${usagePct}% (threshold ${thresholdPct}%). A summary will replace older turns to recover headroom.`,
-      'high',
-    );
+    // Pre-compact preview — uses buildCompactionPreview for an honest estimate.
+    const messages = deps.conversation.getMessagesForLLM();
+    const sessionMemoryStore = deps.conversation.getSessionMemoryStore();
+    const sessionMemories = sessionMemoryStore?.list() ?? [];
+    const pinnedMemoryCount = sessionMemories.length;
+    const preview = buildCompactionPreview({
+      messages,
+      contextWindow: deps.contextWindow,
+      pinnedMemoryCount,
+      trigger: 'auto',
+    });
+    deps.systemMessageRouter.routeSystemMessage(preview, 'high');
+    const eventBefore = getLastCompactionEvent();
+    const compactionCtx: CompactionContext = {
+      messages,
+      sessionMemories,
+      agents: [],
+      wrfcChains: [],
+      activePlan: null,
+      lineageEntries: [],
+      compactionCount: 0,
+      contextWindow: deps.contextWindow,
+      trigger: 'auto',
+      extractionModelId: deps.model,
+      extractionProvider: deps.provider,
+    };
     await deps.conversation.compact(
       deps.providerRegistry,
       deps.model,
       'auto',
       deps.provider,
+      compactionCtx,
     );
-    deps.systemMessageRouter.routeSystemMessage(
-      `[Context] Auto-compact complete — older turns summarised. Use /compact to compact again manually.`,
-      'low',
-    );
+    // Post-compact notice using real CompactionEvent figures.
+    const eventAfter = getLastCompactionEvent();
+    if (eventAfter !== null && eventAfter !== eventBefore) {
+      deps.systemMessageRouter.routeSystemMessage(
+        buildCompactionAfterNotice({ event: eventAfter, pinnedMemoryCount }),
+        'low',
+      );
+    } else {
+      deps.systemMessageRouter.routeSystemMessage(
+        '[Context] Auto-compact complete — older turns summarised. Use /compact to compact again manually.',
+        'low',
+      );
+    }
   } catch (err) {
     logger.error('auto-compact failed', { error: summarizeError(err) });
     deps.systemMessageRouter.routeSystemMessage(

package/src/core/conversation-rendering.ts

@@ -11,10 +11,13 @@ import { LAYOUT } from '../renderer/layout.ts';
 import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
 import { renderConversationCollapsedFragment, renderConversationEventLine } from '../renderer/conversation-surface.ts';
 import { GLYPHS } from '../renderer/ui-primitives.ts';
-import type { BlockMeta, ConversationMessageSnapshot } from './conversation';
+import type { BlockMeta } from './conversation-types.ts';
+import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
 import { parseDiffForApply } from '@pellux/goodvibes-sdk/platform/core';
 import { extractUserDisplayText } from '@pellux/goodvibes-sdk/platform/core';
-import type { SystemMessageKind } from './system-message-router.ts';
+// SystemMessageKind imported from runtime directly to avoid cycle:
+//   conversation-rendering.ts → system-message-router.ts → conversation.ts → conversation-rendering.ts
+import type { SystemMessageKind } from '@/runtime/index.ts';
 
 const T = DARK_THEME;
 

package/src/core/conversation-types.ts

@@ -0,0 +1,24 @@
+/**
+ * conversation-types.ts — shared TUI extension types for ConversationManager.
+ *
+ * Extracted from conversation.ts so that conversation-rendering.ts can import
+ * BlockMeta without creating a circular dependency:
+ *   conversation.ts ↔ conversation-rendering.ts
+ *
+ * Both files import from this module; conversation.ts re-exports BlockMeta for
+ * backward compatibility of all existing importers.
+ */
+
+import type { BlockMeta as SdkBlockMeta } from '@pellux/goodvibes-sdk/platform/core';
+
+/** TUI extends the SDK BlockMeta with rendering position fields. */
+export interface BlockMeta extends SdkBlockMeta {
+  /** Index of this block (increments per renderable block). */
+  blockIndex: number;
+  /** First rendered line index in the history buffer. */
+  startLine: number;
+  /** Number of rendered lines (when not collapsed). */
+  lineCount: number;
+  /** Stable key for collapse state persistence across rebuilds (e.g. msg_N). */
+  collapseKey: string;
+}

package/src/core/conversation.ts

@@ -5,11 +5,14 @@ import type { ToolCall, ToolResult } from '@pellux/goodvibes-sdk/platform/types'
 import type { ProviderMessage, ContentPart } from '@pellux/goodvibes-sdk/platform/providers';
 import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
 import type { TranscriptEventKind } from '@pellux/goodvibes-sdk/platform/core';
-import type { SystemMessageKind } from './system-message-router.ts';
+// SystemMessageKind imported from runtime directly to avoid cycle:
+//   conversation.ts → system-message-router.ts → conversation.ts
+import type { SystemMessageKind } from '@/runtime/index.ts';
 import {
   ConversationManager as SdkConversationManager,
   type BlockMeta as SdkBlockMeta,
 } from '@pellux/goodvibes-sdk/platform/core';
+import type { BlockMeta } from './conversation-types.ts';
 import {
   addConversationSplashScreen,
   appendConversationMessages,
@@ -38,17 +41,9 @@ export type {
 
 export type { SdkBlockMeta };
 
-/** TUI extends the SDK BlockMeta with rendering position fields. */
-export interface BlockMeta extends SdkBlockMeta {
-  /** Index of this block (increments per renderable block). */
-  blockIndex: number;
-  /** First rendered line index in the history buffer. */
-  startLine: number;
-  /** Number of rendered lines (when not collapsed). */
-  lineCount: number;
-  /** Stable key for collapse state persistence across rebuilds (e.g. msg_N). */
-  collapseKey: string;
-}
+// BlockMeta is defined in ./conversation-types.ts to avoid a circular dep
+// with conversation-rendering.ts; re-exported here for backward compatibility.
+export type { BlockMeta };
 
 // Import internal types needed for rendering helpers
 import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';