@pellux/goodvibes-tui 1.27.0 → 2.0.1

package/src/config/index.ts

@@ -1,88 +0,0 @@
-/**
- * Config system barrel export.
- *
- * Provides:
- * - ConfigManager class and all schema types
- * - Pure helpers that derive values from an explicit ConfigManager instance
- */
-
-export { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
-export type { DeepReadonly } from '@pellux/goodvibes-sdk/platform/config';
-export type { GoodVibesConfig, ConfigKey, ConfigValue, ConfigSetting, PermissionMode, PermissionAction, PermissionsToolConfig, NotificationsConfig } from '@pellux/goodvibes-sdk/platform/config';
-export { DEFAULT_CONFIG, CONFIG_SCHEMA } from '@pellux/goodvibes-sdk/platform/config';
-export { ConfigError } from '@pellux/goodvibes-sdk/platform/types';
-
-import { readFileSync } from 'fs';
-import { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
-import type { GoodVibesConfig } from '@pellux/goodvibes-sdk/platform/config';
-import { logger } from '@pellux/goodvibes-sdk/platform/utils';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
-import { getProviderIdFromModel } from './provider-model.ts';
-
-export function getConfigSnapshot(configManager: Pick<ConfigManager, 'getRaw'>): Readonly<GoodVibesConfig> {
-  return configManager.getRaw();
-}
-
-export function getConfiguredModelId(configManager: Pick<ConfigManager, 'get'>): string {
-  return configManager.get('provider.model');
-}
-
-export function getConfiguredProviderId(configManager: Pick<ConfigManager, 'get'>): string {
-  return getProviderIdFromModel(configManager.get('provider.model'));
-}
-
-export function getConfiguredEmbeddingProviderId(configManager: Pick<ConfigManager, 'get'>): string {
-  return configManager.get('provider.embeddingProvider');
-}
-
-export function isAutoApproveEnabled(configManager: Pick<ConfigManager, 'get'>): boolean {
-  return configManager.get('behavior.autoApprove');
-}
-
-/**
- * True when the current permission posture effectively auto-approves everything:
- * auto-approve on, permission mode `allow-all`, or a `custom` mode whose every
- * tool action is `allow`. Drives the footer's danger indicator.
- */
-export function isEffectiveDangerMode(configManager: Pick<ConfigManager, 'get' | 'getCategory'>): boolean {
-  if (configManager.get('behavior.autoApprove')) return true;
-  const permMode = configManager.get('permissions.mode');
-  if (permMode === 'allow-all') return true;
-  if (permMode === 'custom') {
-    const tools = configManager.getCategory('permissions').tools;
-    if (Object.values(tools).every((action) => action === 'allow')) return true;
-  }
-  return false;
-}
-
-export function getWorkingDirectory(configManager: Pick<ConfigManager, 'getWorkingDirectory'>): string | null {
-  return configManager.getWorkingDirectory();
-}
-
-export function getConfiguredSystemPrompt(configManager: Pick<ConfigManager, 'get'>): string | undefined {
-  const file = configManager.get('provider.systemPromptFile');
-  if (!file) return undefined;
-  try {
-    return readFileSync(file, 'utf-8');
-  } catch (err) {
-    logger.debug('systemPrompt file read failed (non-fatal)', { file, error: summarizeError(err) });
-    return undefined;
-  }
-}
-
-export { getConfiguredApiKeys, resolveApiKeys } from '@pellux/goodvibes-sdk/platform/config';
-
-// Client-side credential-status read (honest-degrade, status-only). When the
-// TUI acts as a client of an adopted external daemon it reads provider/model/secret
-// STATUS from that daemon's `credentials.get`, never from its own surfaceRoot store.
-export {
-  credentialReadModeFromHostMode,
-  deriveCredentialAvailability,
-  readClientCredentialStatus,
-} from './credential-availability.ts';
-export type {
-  CredentialAvailability,
-  CredentialReadMode,
-  CredentialStatusEntry,
-  CredentialStatusOutcome,
-} from './credential-availability.ts';

package/src/config/provider-model.ts

@@ -1,23 +0,0 @@
-import { DEFAULT_CONFIG } from '@pellux/goodvibes-sdk/platform/config';
-
-export function getProviderIdFromModel(model: unknown): string {
-  const raw = String(model ?? '').trim();
-  if (!raw) return getProviderIdFromModel(DEFAULT_CONFIG.provider.model);
-  const separator = raw.indexOf(':');
-  return separator > 0 ? raw.slice(0, separator) : raw;
-}
-
-export function getModelIdFromProviderModel(model: unknown): string {
-  const raw = String(model ?? '').trim();
-  if (!raw) return String(DEFAULT_CONFIG.provider.model);
-  const separator = raw.indexOf(':');
-  return separator > 0 ? raw.slice(separator + 1) : raw;
-}
-
-export function formatProviderModel(providerId: string, modelId: string): string {
-  const provider = providerId.trim();
-  const model = modelId.trim();
-  if (!provider) return model;
-  if (!model) return `${provider}:`;
-  return model.includes(':') ? model : `${provider}:${model}`;
-}

package/src/config/read-versioned.ts

@@ -1,228 +0,0 @@
-import { existsSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
-
-/**
- * The suffix every quarantined file in this codebase gets. Exported so the
- * other producer of these files (the transcript journal's corrupt-tail
- * quarantine) and the reclaim sweep below all agree on one spelling.
- */
-export const UNRECOGNIZED_SUFFIX = '.unrecognized';
-
-/**
- * A migration function that transforms data from version N to N+1.
- * Receives the raw parsed object and must return the upgraded object.
- */
-export type VersionMigration = (data: Record<string, unknown>) => Record<string, unknown>;
-
-export interface ReadVersionedOptions {
-  /**
-   * The version number this reader expects. When the file version equals
-   * `currentVersion`, no migrations are run. When it is lower, migrations
-   * are applied stepwise. When it is higher or unrecognised, `onUnknown`
-   * behaviour fires.
-   */
-  readonly currentVersion: number;
-
-  /**
-   * Optional stepwise migrations indexed by the FROM version.
-   * `migrations[1]` upgrades version-1 data to version-2 data.
-   * Applied in ascending order until `currentVersion` is reached.
-   */
-  readonly migrations?: Readonly<Record<number, VersionMigration>>;
-
-  /**
-   * What to do when the file version is unrecognised (higher than
-   * `currentVersion` or missing/non-numeric).
-   *
-   * `'quarantine'` — rename the file to `<path>.unrecognized` and return null.
-   */
-  readonly onUnknown: 'quarantine';
-}
-
-/**
- * Migration-aware, quarantine-on-failure versioned file reader.
- *
- * Parse flow:
- *   1. If the file does not exist → return null.
- *   2. If JSON is corrupt → quarantine to `<path>.unrecognized`, return null.
- *   3. If the version field is missing or higher than currentVersion →
- *      quarantine, return null.
- *   4. If the version is lower than currentVersion → apply stepwise migrations.
- *      If no migration exists for a version gap, or a migration throws,
- *      quarantine and return null.
- *   5. Return the (possibly migrated) object. Callers are responsible for
- *      narrowing the returned value — this helper handles versioning and
- *      corruption only, not schema validation.
- */
-export function readVersioned<T extends { version: number }>(
-  path: string,
-  options: ReadVersionedOptions,
-): T | null {
-  if (!existsSync(path)) return null;
-
-  let raw: unknown;
-  try {
-    raw = JSON.parse(readFileSync(path, 'utf-8'));
-  } catch {
-    quarantine(path);
-    return null;
-  }
-
-  if (!isPlainObject(raw)) {
-    quarantine(path);
-    return null;
-  }
-
-  const fileVersion = raw['version'];
-  if (typeof fileVersion !== 'number' || !Number.isFinite(fileVersion)) {
-    quarantine(path);
-    return null;
-  }
-
-  if (fileVersion > options.currentVersion) {
-    // Produced by a newer process — quarantine rather than corrupt.
-    quarantine(path);
-    return null;
-  }
-
-  let data: Record<string, unknown> = raw;
-
-  if (fileVersion < options.currentVersion) {
-    const migrations = options.migrations ?? {};
-    for (let v = fileVersion; v < options.currentVersion; v++) {
-      const migrate = migrations[v];
-      if (!migrate) {
-        // No migration path for this version gap — quarantine.
-        quarantine(path);
-        return null;
-      }
-      try {
-        data = migrate(data);
-      } catch {
-        quarantine(path);
-        return null;
-      }
-    }
-  }
-
-  return data as T;
-}
-
-// ─── Internal helpers ─────────────────────────────────────────────────────────
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function quarantine(path: string): void {
-  try {
-    renameSync(path, `${path}${UNRECOGNIZED_SUFFIX}`);
-  } catch {
-    // Best-effort — if rename fails (e.g. race), proceed silently.
-  }
-}
-
-// ─── Quarantine reclaim ───────────────────────────────────────────────────────
-//
-// Quarantining renames a bad file out of the way so a human can inspect it,
-// and until now nothing ever removed the result — every corrupt config file
-// and every torn journal tail left a `.unrecognized` file behind permanently.
-// Forensic value is real, so the retention window below is deliberately long,
-// but "keep forever" is a leak.
-
-/**
- * How long a quarantined file is kept before it is reclaimed: 30 days
- * (2_592_000_000 ms). These files exist so a person can look at what went
- * wrong, so the window is a month rather than the hours-to-days retention the
- * live durability artefacts get — long enough to survive a holiday, short
- * enough that a recurring corruption cannot fill a disk.
- */
-export const QUARANTINE_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
-
-/**
- * Hard ceiling on quarantined files kept per swept directory, newest kept.
- * The age rule alone cannot bound a fast repeating corruption (a boot loop
- * quarantining the same file every restart), so a count cap runs alongside it.
- */
-export const QUARANTINE_MAX_FILES_PER_DIR = 50;
-
-export interface QuarantineReapResult {
-  /** Quarantined files examined across every directory. */
-  readonly scanned: number;
-  /** Quarantined files deleted. */
-  readonly reaped: number;
-}
-
-export interface QuarantineReapOptions {
-  readonly now?: () => number;
-  /** Override the age window (tests). */
-  readonly maxAgeMs?: number;
-  /** Override the per-directory count cap (tests). */
-  readonly maxFilesPerDir?: number;
-}
-
-/**
- * Delete `.unrecognized` quarantine files that are past the retention window,
- * plus any beyond the per-directory count cap (newest kept).
- *
- * Each directory is scanned non-recursively; a missing or unreadable directory
- * contributes nothing and is not an error. Idempotent, and safe to run
- * concurrently from several processes — a file another sweeper already
- * unlinked (ENOENT) counts as reclaimed rather than failing the sweep.
- */
-export function reapQuarantinedFiles(
-  directories: readonly string[],
-  options: QuarantineReapOptions = {},
-): QuarantineReapResult {
-  const now = options.now?.() ?? Date.now();
-  const maxAgeMs = options.maxAgeMs ?? QUARANTINE_RETENTION_MS;
-  const maxFilesPerDir = options.maxFilesPerDir ?? QUARANTINE_MAX_FILES_PER_DIR;
-
-  let scanned = 0;
-  let reaped = 0;
-
-  for (const dir of new Set(directories)) {
-    let names: string[];
-    try {
-      names = readdirSync(dir).filter((name) => name.endsWith(UNRECOGNIZED_SUFFIX));
-    } catch {
-      continue;
-    }
-    scanned += names.length;
-
-    const survivors: { readonly path: string; readonly mtimeMs: number }[] = [];
-    for (const name of names) {
-      const path = join(dir, name);
-      let mtimeMs: number;
-      try {
-        mtimeMs = statSync(path).mtimeMs;
-      } catch {
-        // Vanished under us (another sweeper) — nothing left to reclaim.
-        continue;
-      }
-      if (now - mtimeMs > maxAgeMs) {
-        if (unlinkQuarantined(path)) reaped++;
-        continue;
-      }
-      survivors.push({ path, mtimeMs });
-    }
-
-    if (survivors.length > maxFilesPerDir) {
-      survivors.sort((a, b) => a.mtimeMs - b.mtimeMs); // oldest first
-      for (const victim of survivors.slice(0, survivors.length - maxFilesPerDir)) {
-        if (unlinkQuarantined(victim.path)) reaped++;
-      }
-    }
-  }
-
-  return { scanned, reaped };
-}
-
-function unlinkQuarantined(path: string): boolean {
-  try {
-    unlinkSync(path);
-    return true;
-  } catch (err) {
-    return (err as NodeJS.ErrnoException | undefined)?.code === 'ENOENT';
-  }
-}

package/src/core/alert-gating.ts

@@ -1,67 +0,0 @@
-/**
- * alert-gating — shared config + focus gating logic for the unfocused-user
- * alert classes (budget-breach, long-task, agent/chain failure,
- * awaiting-approval). Each alert class has its own on/off config key
- * (default true); a single master key, `behavior.notifyOnlyWhenUnfocused`
- * (default true), decides whether any of them additionally require the
- * terminal to be unfocused-or-unknown before firing.
- *
- * Extracted so every alert-class module (long-task-notifier.ts,
- * budget-breach-notifier.ts, approval-alert.ts, and the agent/chain-failure
- * wiring in turn-event-wiring.ts) shares one implementation of "should this
- * fire right now" instead of re-deriving the same two config reads and the
- * same focus check.
- */
-import type { FocusTracker } from './focus-tracker.ts';
-
-/** Minimal config-read surface every gating check needs. */
-export type ConfigGet = (key: string) => unknown;
-
-/** Read a TUI-local synthetic boolean setting, defaulting when absent/invalid. */
-export function readBooleanConfig(configGet: ConfigGet, key: string, defaultValue: boolean): boolean {
-  const raw = configGet(key);
-  if (typeof raw === 'boolean') return raw;
-  if (raw === undefined || raw === null) return defaultValue;
-  // Tolerate string/number forms the same way the rest of the config layer does
-  // (settings-modal writes real booleans, but env/file edits may not).
-  if (raw === 'true' || raw === 1) return true;
-  if (raw === 'false' || raw === 0) return false;
-  return defaultValue;
-}
-
-/** `behavior.notifyOnlyWhenUnfocused` — master gate, default on. */
-export function readNotifyOnlyWhenUnfocused(configGet: ConfigGet): boolean {
-  return readBooleanConfig(configGet, 'behavior.notifyOnlyWhenUnfocused', true);
-}
-
-/**
- * Decide whether a given alert class should fire right now.
- *
- * `classConfigKey` is the per-class on/off switch (e.g.
- * 'behavior.notifyOnBudgetBreach'); default true when absent. When that key
- * is off, the class never fires regardless of focus. When it's on, the
- * result additionally depends on the master `notifyOnlyWhenUnfocused` gate:
- * if that master gate is off, the class fires unconditionally (today's
- * pre-focus-tracking behavior); if on (the default), it only fires when the
- * terminal is unfocused or focus state was never observed (see
- * FocusTracker.shouldAlertWhenUnfocused).
- */
-export function shouldFireAlert(
-  focusTracker: Pick<FocusTracker, 'shouldAlertWhenUnfocused'>,
-  configGet: ConfigGet,
-  classConfigKey: string,
-): boolean {
-  if (!readBooleanConfig(configGet, classConfigKey, true)) return false;
-  if (!readNotifyOnlyWhenUnfocused(configGet)) return true;
-  return focusTracker.shouldAlertWhenUnfocused();
-}
-
-/**
- * notifyCompletion (SDK platform/utils) only rings the bell above 5s of
- * "duration" and only pops a desktop notification above 30s — a heuristic
- * tuned for long-running-turn notifications. The alert classes in this
- * directory are point-in-time events with no natural duration, so they pass
- * this constant as the `durationMs` argument to force both the bell and the
- * desktop popup unconditionally.
- */
-export const FORCE_NOTIFY_DURATION_MS = 30_001;

package/src/core/consolidation-receipt.ts

@@ -1,41 +0,0 @@
-// ---------------------------------------------------------------------------
-// consolidation-receipt.ts — the one-line notice for an idle-time memory
-// consolidation run.
-//
-// The SDK's MemoryConsolidationScheduler runs at idle and produces a
-// MemoryConsolidationRunReceipt (merged / archived / decayed / proposed). This
-// formats it into the same one-line shape every other attach-time receipt
-// uses, so a run that changed something surfaces on the next attach like a
-// crash/update/migration receipt. A pure no-op run yields null — no noise.
-//
-// A run that PROPOSED something (a contradiction or cross-scope-duplicate
-// awaiting human judgment — never auto-applied) names where to actually look:
-// the Memory modal's Proposals tab (`/memory`, then the Proposals tab —
-// memory-modal.ts's proposalsTab()), which lists each proposal's kind,
-// reason, and affected record ids and jumps to them in the Review Queue.
-// Without this pointer the receipt line was the only trace a proposal ever
-// existed — a count with nowhere to go.
-// ---------------------------------------------------------------------------
-
-import type { MemoryConsolidationRunReceipt } from '@pellux/goodvibes-sdk/platform/state';
-
-/**
- * A one-line receipt for a consolidation run that changed something, or null
- * when the run merged/archived/decayed/proposed nothing (a quiet idle pass —
- * no notice, matching the check-in "stayed quiet" discipline).
- */
-export function formatConsolidationReceipt(receipt: MemoryConsolidationRunReceipt): string | null {
-  const merged = receipt.merged.length;
-  const archived = receipt.archived.length;
-  const decayed = receipt.decayed.length;
-  const proposed = receipt.proposed.length;
-  if (merged + archived + decayed + proposed === 0) return null;
-  const parts: string[] = [];
-  if (merged) parts.push(`${merged} merged`);
-  if (archived) parts.push(`${archived} archived`);
-  if (decayed) parts.push(`${decayed} decayed`);
-  if (proposed) parts.push(`${proposed} proposed`);
-  const base = `Memory consolidation: ${parts.join(', ')} (scanned ${receipt.scanned}).`;
-  if (proposed === 0) return base;
-  return `${base} Review the ${proposed} proposed change${proposed === 1 ? '' : 's'} with /memory (Proposals tab).`;
-}

package/src/core/focus-tracker.ts

@@ -1,41 +0,0 @@
-/**
- * focus-tracker — tracks whether the terminal window currently has OS-level
- * input focus, using the terminal focus-reporting protocol (DECSET ?1004h,
- * enabled at terminal setup in main.ts). The SDK's InputTokenizer already
- * parses the resulting `\x1b[I` (focus-in) / `\x1b[O` (focus-out) sequences
- * into `{ type: 'focus', action }` tokens (platform/core/tokenizer.ts); this
- * module is the single place those tokens land (consumed in
- * src/input/handler-feed.ts's feedInputTokens()).
- *
- * Honest degradation: a terminal that does not implement focus reporting
- * (or a multiplexer that swallows the sequences) never sends focus tokens.
- * In that case `isFocused()` stays `null` forever — "unknown", never a
- * guessed `true`/`false`. Callers that gate a user-facing behavior on focus
- * (e.g. the unfocused-alert notifiers in this directory) must treat `null`
- * the same as "not focused" per the fallback rule: alerts fire when the
- * terminal is definitely unfocused OR when focus state was never observed.
- */
-export class FocusTracker {
-  private focused: boolean | null = null;
-
-  /** True/false once at least one focus token has arrived; null if none ever has. */
-  isFocused(): boolean | null {
-    return this.focused;
-  }
-
-  /** Called from the input pipeline on every focus token. */
-  setFocused(value: boolean): void {
-    this.focused = value;
-  }
-
-  /**
-   * The alert-gating rule shared by every unfocused-alert notifier: fire
-   * when the terminal is known to be unfocused, or when focus was never
-   * observed (honest fallback — never silently suppress on an unknown
-   * terminal). Only `isFocused() === true` (a real, observed focus-in with
-   * no observed focus-out since) suppresses an alert.
-   */
-  shouldAlertWhenUnfocused(): boolean {
-    return this.focused !== true;
-  }
-}

package/src/core/history.ts

@@ -1,45 +0,0 @@
-import { type Line, createEmptyLine } from '../types/grid.ts';
-
-/**
- * InfiniteBuffer - Manages the complete conversation history as a list of lines.
- */
-export class InfiniteBuffer {
-  private lines: Line[] = [];
-
-  public addLine(line: Line): void {
-    this.lines.push(line);
-  }
-
-  public addLines(lines: Line[]): void {
-    this.lines.push(...lines);
-  }
-
-  public getLineCount(): number {
-    return this.lines.length;
-  }
-
-  public getAllLines(): Line[] {
-    return this.lines;
-  }
-
-  public getSnapshot(startLine: number, height: number, width: number): Line[] {
-    const end = Math.min(this.lines.length, startLine + height);
-    const slice = this.lines.slice(startLine, end);
-
-    while (slice.length < height) {
-      slice.unshift(createEmptyLine(width));
-    }
-
-    return slice;
-  }
-
-  public clear(): void {
-    this.lines = [];
-  }
-
-  public truncateToLine(lineIndex: number): void {
-    if (lineIndex >= 0 && lineIndex < this.lines.length) {
-      this.lines.length = lineIndex;
-    }
-  }
-}

package/src/core/memory-status.ts

@@ -1,118 +0,0 @@
-// ---------------------------------------------------------------------------
-// memory-status.ts — the surface-facing projection of the daemon's memory
-// governance (ops.memory.get + OPS_MEMORY_PRESSURE).
-//
-// The SDK's MemoryGovernor owns the policy: it samples RSS/heap against a
-// budget, sheds memory by tier (trimming registered caches, pausing deferrable
-// background jobs), refuses new expensive work at the critical tier, and trips
-// on a genuine leak before the OS OOM-kills it. This module is the read-only
-// projection the /health memory (doctor) surface renders from — the snapshot
-// rows — and the attention line OPS_MEMORY_PRESSURE produces when the tier
-// changes or the tripwire fires.
-//
-// Pure formatting only (no I/O): the command fetches the typed verb response
-// over the operator invoke seam (memory-diagnostics-gateway.ts) and hands it
-// here, so these builders are unit-testable against fixture shapes.
-// ---------------------------------------------------------------------------
-
-import type { OperatorMethodOutput } from '@pellux/goodvibes-sdk';
-import type { OpsEvent } from '@/runtime/index.ts';
-
-/** ops.memory.get output — the full governor snapshot. */
-export type MemoryGovernorSnapshotResult = OperatorMethodOutput<'ops.memory.get'>;
-/** The OPS_MEMORY_PRESSURE event payload (a tier change or a tripwire firing). */
-export type MemoryPressurePayload = Extract<OpsEvent, { type: 'OPS_MEMORY_PRESSURE' }>;
-
-/** Human MB (the governor already reports MB as numbers; round to 1 decimal). */
-export function formatMb(mb: number | null | undefined): string {
-  if (mb === null || mb === undefined || !Number.isFinite(mb)) return 'unknown';
-  return `${mb >= 100 ? Math.round(mb) : Math.round(mb * 10) / 10} MB`;
-}
-
-/** Human byte size for a cache footprint estimate. */
-export function formatMemoryBytes(bytes: number | null | undefined): string {
-  if (bytes === null || bytes === undefined || !Number.isFinite(bytes) || bytes < 0) return 'size n/a';
-  if (bytes < 1024) return `${bytes} B`;
-  const units = ['KB', 'MB', 'GB'];
-  let value = bytes / 1024;
-  let unit = 0;
-  while (value >= 1024 && unit < units.length - 1) {
-    value /= 1024;
-    unit += 1;
-  }
-  return `${value >= 10 ? value.toFixed(0) : value.toFixed(1)} ${units[unit]}`;
-}
-
-/** A plain-language note for the current tier (the governor's posture at this tier). */
-export function memoryTierNote(tier: MemoryGovernorSnapshotResult['tier']): string {
-  switch (tier) {
-    case 'normal': return 'footprint is comfortably within budget';
-    case 'elevated': return 'trimming caches to a floor and running gc';
-    case 'high': return 'flushing caches and pausing deferrable background jobs';
-    case 'critical': return 'refusing new expensive work until the footprint recovers';
-    default: return '';
-  }
-}
-
-/**
- * The /health memory (doctor) rows — the honest account of the daemon defending
- * its footprint. Order: tier + posture, budget vs RSS, heap, tier thresholds,
- * per-cache footprints the governor can shrink, which deferrable jobs are
- * paused, and the leak-tripwire state.
- */
-export function memoryStatusLines(snapshot: MemoryGovernorSnapshotResult): string[] {
-  const lines: string[] = [];
-  lines.push(`  tier: ${snapshot.tier} — ${memoryTierNote(snapshot.tier)}`);
-  if (snapshot.refusingExpensiveWork) {
-    lines.push('  expensive work: REFUSED (critical tier) — new ingestion / reindex / voice install is declined until RSS recovers');
-  }
-  lines.push(`  budget: ${formatMb(snapshot.rssMb)} rss / ${formatMb(snapshot.budgetMb)} budget (${Math.round(snapshot.usedPct)}%)`);
-  const heap = snapshot.heapTotalMb !== undefined
-    ? `${formatMb(snapshot.heapUsedMb)} used / ${formatMb(snapshot.heapTotalMb)} total`
-    : formatMb(snapshot.heapUsedMb);
-  lines.push(`  heap: ${heap}`);
-  lines.push(`  tiers: elevated ${snapshot.thresholds.elevatedPct}% · high ${snapshot.thresholds.highPct}% · critical ${snapshot.thresholds.criticalPct}%`);
-
-  if (snapshot.caches.length === 0) {
-    lines.push('  caches: none registered');
-  } else {
-    lines.push(`  caches: ${snapshot.caches.length}`);
-    for (const cache of snapshot.caches) {
-      const size = cache.estimatedBytes !== undefined ? `, ~${formatMemoryBytes(cache.estimatedBytes)}` : '';
-      lines.push(`    ${cache.id} (${cache.name}): ${cache.entries} entries${size}`);
-    }
-  }
-
-  lines.push(snapshot.pausedJobs.length === 0
-    ? '  paused jobs: none'
-    : `  paused jobs: ${snapshot.pausedJobs.join(', ')}`);
-
-  if (snapshot.tripwire.armed) {
-    lines.push(`  tripwire: ARMED — watching for a sustained >${snapshot.tripwire.rateMbPerSec} MB/s post-flush leak (held ${Math.round(snapshot.tripwire.sustainedSec)}s)`);
-  } else {
-    lines.push('  tripwire: disarmed (no post-flush leak growth under watch)');
-  }
-  return lines;
-}
-
-/**
- * The attention line OPS_MEMORY_PRESSURE produces: a one-liner naming the new
- * tier and the RSS/budget, plus a distinct escalation when the leak tripwire
- * fires (the daemon is about to exit for a clean supervisor restart). Returned
- * as a single string so the notice/attention surface can push it directly.
- */
-export function memoryPressureLine(event: MemoryPressurePayload): string {
-  const base = `memory pressure: ${event.previousTier} → ${event.tier} (${formatMb(event.rssMb)} rss / ${formatMb(event.budgetMb)} budget, ${Math.round(event.usedPct)}%)`;
-  if (event.tripwire) {
-    return `${base} — leak tripwire fired (${event.tripwire.rateMbPerSec} MB/s sustained ${Math.round(event.tripwire.sustainedSec)}s); the daemon will exit for a clean restart`;
-  }
-  if (event.note) return `${base} — ${event.note}`;
-  return base;
-}
-
-/** Severity for the notice feed: critical tier (or a tripwire) is critical; high is a warning. */
-export function memoryPressureLevel(event: MemoryPressurePayload): 'info' | 'warning' | 'critical' {
-  if (event.tripwire || event.tier === 'critical') return 'critical';
-  if (event.tier === 'high') return 'warning';
-  return 'info';
-}

package/src/core/orchestrator.ts

@@ -1,7 +0,0 @@
-// Thin TUI wrapper — re-exports the SDK Orchestrator unchanged.
-// The SDK class already contains all behaviour including getSpinner().
-export {
-  Orchestrator,
-  type OrchestratorOptions,
-  type OrchestratorUserInputOptions,
-} from '@pellux/goodvibes-sdk/platform/core';