@pellux/goodvibes-tui 0.21.0 → 0.23.0

package/src/cli/management.ts

@@ -1,18 +1,9 @@
-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 { BUILTIN_SECRET_PROVIDER_SOURCES, describeSecretRef, isSecretRefInput, resolveSecretRef } from '@pellux/goodvibes-sdk/platform/config';
@@ -31,105 +22,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 +69,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;

package/src/cli/parser.ts

@@ -174,6 +174,7 @@ export function parseGoodVibesCli(
   const commandArgs: string[] = [];
   const positionals: string[] = [];
   const errors: string[] = [];
+  const warnings: string[] = [];
   let sawCommand = false;
   let passthrough = false;
 
@@ -292,6 +293,9 @@ export function parseGoodVibesCli(
       const consumed = getValue(argv, index, inlineValue, name, errors);
       index = consumed.nextIndex;
       flags = withFlag(flags, 'outputFormat', normalizeOutputFormat(consumed.value, name, errors));
+      if (name === '--output-format') {
+        warnings.push('--output-format is deprecated; use --output (or -o) instead.');
+      }
       continue;
     }
     if (name === '--config' || name === '-c') {
@@ -353,6 +357,18 @@ export function parseGoodVibesCli(
     errors.push(`Unknown command: ${rawCommand}`);
   }
 
+  // Session lifecycle conflict detection — only one of --continue / --resume / --fork may be used.
+  const sessionLifecycleFlags = [
+    flags.continueLast ? '--continue' : undefined,
+    flags.resume !== undefined ? '--resume' : undefined,
+    flags.fork !== undefined ? '--fork' : undefined,
+  ].filter((f): f is string => f !== undefined);
+  if (sessionLifecycleFlags.length > 1) {
+    errors.push(
+      `Conflicting session lifecycle flags: ${sessionLifecycleFlags.join(' and ')}. Use only one of --continue, --resume, or --fork.`,
+    );
+  }
+
   return {
     binary,
     command,
@@ -361,5 +377,6 @@ export function parseGoodVibesCli(
     positionals,
     flags,
     errors,
+    warnings,
   };
 }

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/cli/types.ts

@@ -68,6 +68,8 @@ export interface GoodVibesCliParseResult {
   readonly positionals: readonly string[];
   readonly flags: GoodVibesCliFlags;
   readonly errors: readonly string[];
+  /** Deprecation and soft-warning messages (non-fatal). Callers should surface these to users. */
+  readonly warnings: readonly string[];
 }
 
 export interface CliCommandRuntime {

package/src/config/goodvibes-home-audit.ts

@@ -117,6 +117,8 @@ const KNOWN_DYNAMIC_KEYS = [
   /^featureFlags(?:\.|$)/,
   /^notifications\.webhookUrls$/,
   /^wrfc\.gates$/,
+  // TUI-bridged setting awaiting SDK schema registration (handoff Item 5b)
+  /^tts\.speed$/,
 ];
 
 export const GOODVIBES_ALLOWED_WRITE_ROOTS = ['tui/', 'daemon/'] as const;

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

@@ -0,0 +1,110 @@
+/**
+ * Auto-compaction helper — TASK-058.
+ *
+ * Evaluates whether auto-compact should run after a turn completes and, if so,
+ * triggers compaction and posts an honest transcript notice.
+ *
+ * behavior.autoCompactThreshold: SDK schema range [10, 100], default 80.
+ * Auto-compact is active whenever the threshold is in its valid range (>0).
+ * The display/suggestion path (hint + meter) is always active regardless.
+ */
+
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { ConversationManager } from './conversation';
+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'>;
+  readonly conversation: ConversationManager;
+  readonly providerRegistry: ProviderRegistry;
+  readonly systemMessageRouter: SystemMessageRouter;
+  readonly model: string;
+  readonly provider: string;
+  readonly lastInputTokens: number;
+  readonly contextWindow: number;
+}
+
+/**
+ * Run after each TURN_COMPLETED event.
+ *
+ * Reads behavior.autoCompactThreshold from config (SDK default: 80, range [10, 100]).
+ * When usage is at or above the threshold, compacts the conversation and posts
+ * an honest transcript notice so the user understands any summary discontinuity.
+ *
+ * This function is intentionally non-throwing; failures are logged and
+ * surfaced via the system message router.
+ */
+export async function maybeAutoCompact(deps: AutoCompactDeps): Promise<void> {
+  // SDK schema default is 80; valid range is [10, 100]. The ?? 0 fallback is a
+  // defensive guard for missing/null values only — not a normal operating state.
+  const rawThreshold = Number(deps.configManager.get('behavior.autoCompactThreshold') ?? 0);
+  const thresholdPct = Number.isFinite(rawThreshold) ? rawThreshold : 0;
+
+  // Defensive guard: skip only when threshold is missing/non-positive (real config defaults to 80).
+  if (thresholdPct <= 0 || deps.contextWindow <= 0) return;
+
+  const usagePct = Math.min(100, Math.round((Math.max(0, deps.lastInputTokens) / deps.contextWindow) * 100));
+  if (usagePct < thresholdPct) return;
+
+  try {
+    logger.debug('auto-compact triggered', { usagePct, thresholdPct });
+    // 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,
+    );
+    // 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(
+      `[Context] Auto-compact failed: ${summarizeError(err)}. Use /compact to try manually.`,
+      'high',
+    );
+  }
+}

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