@pellux/goodvibes-tui 0.18.11 → 0.18.13

package/src/runtime/bootstrap-services.ts

@@ -1,197 +0,0 @@
-import type { HookDispatcher } from '@pellux/goodvibes-sdk/platform/hooks/dispatcher';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { RuntimeServices } from './services.ts';
-import { DaemonServer } from '@pellux/goodvibes-sdk/platform/daemon/server';
-import { HttpListener } from '@pellux/goodvibes-sdk/platform/daemon/http-listener';
-import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
-import net from 'node:net';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-
-interface DaemonService {
-  enable(config: { daemon: boolean }, token?: string): boolean;
-  start(): Promise<void>;
-  stop(): Promise<void>;
-  listRecentControlPlaneEvents(limit: number): readonly import('../control-plane/gateway.ts').ControlPlaneRecentEvent[];
-}
-
-interface HttpListenerService {
-  enable(config: { httpListener: boolean }, token?: string): boolean;
-  start(): Promise<void>;
-  stop(): Promise<void>;
-}
-
-interface ServiceFactories {
-  createDaemonServer?: (
-    runtimeBus: RuntimeEventBus,
-    userAuth: RuntimeServices['localUserAuthManager'],
-    runtimeServices: RuntimeServices,
-  ) => DaemonService;
-  createHttpListener?: (
-    hookDispatcher: HookDispatcher,
-    userAuth: RuntimeServices['localUserAuthManager'],
-    configManager: RuntimeServices['configManager'],
-  ) => HttpListenerService;
-  startupTimeoutMs?: number;
-  probeDaemonPortInUse?: (host: string, port: number) => Promise<boolean>;
-  probeHttpListenerPortInUse?: (host: string, port: number) => Promise<boolean>;
-}
-
-export interface ExternalServicesHandle {
-  readonly daemonServer: DaemonService | null;
-  readonly httpListener: HttpListenerService | null;
-  listRecentControlPlaneEvents(limit: number): readonly import('../control-plane/gateway.ts').ControlPlaneRecentEvent[];
-  stop(): Promise<void>;
-}
-
-export interface ExternalServicesConfig {
-  get(
-    key:
-      | 'danger.daemon'
-      | 'danger.httpListener'
-      | 'controlPlane.host'
-      | 'controlPlane.port'
-      | 'httpListener.host'
-      | 'httpListener.port',
-  ): boolean | string | number;
-}
-const DEFAULT_SERVICE_START_TIMEOUT_MS = 1500;
-
-async function isTcpPortInUse(host: string, port: number, timeoutMs = 250): Promise<boolean> {
-  return await new Promise<boolean>((resolve) => {
-    const socket = new net.Socket();
-    let settled = false;
-    const finish = (result: boolean): void => {
-      if (settled) return;
-      settled = true;
-      socket.destroy();
-      resolve(result);
-    };
-    socket.setTimeout(timeoutMs);
-    socket.once('connect', () => finish(true));
-    socket.once('timeout', () => finish(false));
-    socket.once('error', () => finish(false));
-    socket.connect(port, host);
-  });
-}
-
-async function startWithTimeout(
-  label: string,
-  start: () => Promise<void>,
-  timeoutMs: number,
-  cleanup?: () => Promise<void>,
-): Promise<'started' | 'timed_out'> {
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  const startPromise = start().then(() => 'started' as const);
-  try {
-    const result = await Promise.race([
-      startPromise,
-      new Promise<'timed_out'>((resolve) => {
-        timer = setTimeout(() => resolve('timed_out'), timeoutMs);
-      }),
-    ]);
-    if (result === 'timed_out') {
-      logger.warn(`${label} startup timed out; continuing without it in this TUI instance`, { timeoutMs });
-      if (cleanup) {
-        void cleanup().catch((error) => {
-          logger.warn(`${label} cleanup after startup timeout failed`, { error: summarizeError(error) });
-        });
-        void startPromise.then(() => cleanup()).catch(() => {});
-      }
-    }
-    return result;
-  } finally {
-    if (timer !== null) clearTimeout(timer);
-  }
-}
-
-export async function startExternalServices(
-  config: ExternalServicesConfig,
-  runtimeBus: RuntimeEventBus,
-  hookDispatcher: HookDispatcher,
-  factories: ServiceFactories = {},
-  runtimeServices: RuntimeServices,
-): Promise<ExternalServicesHandle> {
-  const sharedUserAuth = runtimeServices.localUserAuthManager;
-  const createDaemonServer = factories.createDaemonServer ?? ((bus, userAuth, services): DaemonService =>
-    new DaemonServer({ runtimeBus: bus, userAuth, runtimeServices: services }));
-  const createHttpListener = factories.createHttpListener ?? ((dispatcher, userAuth, configManager): HttpListenerService =>
-    new HttpListener({ hookDispatcher: dispatcher, userAuth, configManager }));
-  const startupTimeoutMs = factories.startupTimeoutMs ?? DEFAULT_SERVICE_START_TIMEOUT_MS;
-  const daemonHost = String(config.get('controlPlane.host') ?? '127.0.0.1');
-  const daemonPort = Number(config.get('controlPlane.port') ?? 3421);
-  const httpListenerHost = String(config.get('httpListener.host') ?? '127.0.0.1');
-  const httpListenerPort = Number(config.get('httpListener.port') ?? 3422);
-  const probeDaemonPortInUse = factories.probeDaemonPortInUse ?? ((host: string, port: number) => isTcpPortInUse(host, port));
-  const probeHttpListenerPortInUse = factories.probeHttpListenerPortInUse ?? ((host: string, port: number) => isTcpPortInUse(host, port));
-
-  let daemonServer: DaemonService | null = null;
-  let httpListener: HttpListenerService | null = null;
-
-  if (config.get('danger.daemon') as boolean) {
-    if (await probeDaemonPortInUse(daemonHost, daemonPort)) {
-      logger.warn('Daemon server port already in use; continuing without local daemon in this TUI instance', {
-        host: daemonHost,
-        port: daemonPort,
-      });
-    } else {
-      daemonServer = createDaemonServer(runtimeBus, sharedUserAuth, runtimeServices);
-      daemonServer.enable({ daemon: true });
-      try {
-        const service = daemonServer;
-        const result = await startWithTimeout('Daemon server', () => service.start(), startupTimeoutMs, () => service.stop());
-        if (result === 'timed_out') {
-          daemonServer = null;
-        }
-      } catch (error) {
-        const message = summarizeError(error);
-        if (message.includes('EADDRINUSE') || message.includes('Address already in use')) {
-          logger.warn('Daemon server port already in use; continuing without local daemon in this TUI instance', { error: message });
-          daemonServer = null;
-        } else {
-          throw error;
-        }
-      }
-    }
-  }
-
-  if (config.get('danger.httpListener') as boolean) {
-    if (await probeHttpListenerPortInUse(httpListenerHost, httpListenerPort)) {
-      logger.warn('HTTP listener port already in use; continuing without local listener in this TUI instance', {
-        host: httpListenerHost,
-        port: httpListenerPort,
-      });
-    } else {
-      httpListener = createHttpListener(hookDispatcher, sharedUserAuth, runtimeServices.configManager);
-      httpListener.enable({ httpListener: true });
-      try {
-        const service = httpListener;
-        const result = await startWithTimeout('HTTP listener', () => service.start(), startupTimeoutMs, () => service.stop());
-        if (result === 'timed_out') {
-          httpListener = null;
-        }
-      } catch (error) {
-        const message = summarizeError(error);
-        if (message.includes('EADDRINUSE') || message.includes('Address already in use')) {
-          logger.warn('HTTP listener port already in use; continuing without local listener in this TUI instance', { error: message });
-          httpListener = null;
-        } else {
-          throw error;
-        }
-      }
-    }
-  }
-
-  return {
-    daemonServer,
-    httpListener,
-    listRecentControlPlaneEvents(limit: number): readonly import('../control-plane/gateway.ts').ControlPlaneRecentEvent[] {
-      return daemonServer?.listRecentControlPlaneEvents(limit) ?? [];
-    },
-    async stop(): Promise<void> {
-      await Promise.allSettled([
-        daemonServer?.stop(),
-        httpListener?.stop(),
-      ]);
-    },
-  };
-}

package/src/runtime/compaction/index.ts

@@ -1 +0,0 @@
-export * from '@pellux/goodvibes-sdk/platform/runtime/compaction/index';

package/src/runtime/compaction/lifecycle.ts

@@ -1 +0,0 @@
-export * from '@pellux/goodvibes-sdk/platform/runtime/compaction/lifecycle';

package/src/runtime/compaction/manager.ts

@@ -1,474 +0,0 @@
-/**
- * manager.ts
- *
- * CompactionManager — orchestrates the full compaction lifecycle state machine.
- *
- * Responsibilities:
- * - Gate all compaction behind the `session-compaction` feature flag
- * - Drive state transitions (idle → checking_threshold → strategy → boundary_commit → done/failed)
- * - Select and execute the appropriate compaction strategy
- * - Create boundary commits with lineage tracking
- * - Emit CompactionEvents at each transition
- * - Expose the resume repair pipeline
- */
-
-import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { FeatureFlagManager } from '@pellux/goodvibes-sdk/platform/runtime/feature-flags/manager';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-import {
-  applyTransition,
-  selectStrategy,
-  strategyToState,
-} from '@pellux/goodvibes-sdk/platform/runtime/compaction/lifecycle';
-import {
-  runMicrocompact,
-  runCollapse,
-  runAutocompact,
-  runReactive,
-  createBoundaryCommit,
-  validateBoundaryCommit,
-} from '@pellux/goodvibes-sdk/platform/runtime/compaction/strategies/index';
-import { runResumeRepair } from '@pellux/goodvibes-sdk/platform/runtime/compaction/resume-repair';
-import type {
-  BoundaryCommit,
-  CompactionLifecycleResult,
-  CompactionLifecycleState,
-  CompactionStrategy,
-  CompactionTrigger,
-  StrategyInput,
-  StrategyOutput,
-} from '@pellux/goodvibes-sdk/platform/runtime/compaction/types';
-import type { ResumeRepairResult } from '@pellux/goodvibes-sdk/platform/runtime/compaction/types';
-import {
-  emitCompactionCheck,
-  emitCompactionDone,
-  emitCompactionFailed,
-  emitCompactionBoundaryCommit,
-  emitCompactionMicrocompact,
-  emitCompactionCollapse,
-  emitCompactionAutocompact,
-  emitCompactionReactive,
-  emitCompactionQualityScore,
-  emitCompactionStrategySwitch,
-} from '@pellux/goodvibes-sdk/platform/runtime/emitters/compaction';
-import { computeQualityScore, escalateStrategy, LOW_QUALITY_THRESHOLD } from '@pellux/goodvibes-sdk/platform/runtime/compaction/quality-score';
-import type { CompactionQualityScore } from '@pellux/goodvibes-sdk/platform/runtime/compaction/quality-score';
-import type { ProviderMessage } from '@pellux/goodvibes-sdk/platform/providers/interface';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-
-// ---------------------------------------------------------------------------
-// Manager options
-// ---------------------------------------------------------------------------
-
-/** Options for constructing a CompactionManager. */
-export interface CompactionManagerOptions {
-  /** Session ID for event correlation. */
-  sessionId: string;
-  /** Runtime event bus for emitting CompactionEvents. */
-  bus: RuntimeEventBus;
-  /** Feature flag manager — used to gate on `session-compaction`. */
-  flags: FeatureFlagManager;
-  /** Model context window size (tokens). */
-  contextWindow: number;
-  /** Threshold fraction at which compaction is triggered (default: 0.75). */
-  thresholdFraction?: number;
-}
-
-// ---------------------------------------------------------------------------
-// Manager
-// ---------------------------------------------------------------------------
-
-/**
- * CompactionManager — manages the full lifecycle of session context compaction.
- *
- * All compaction is gated behind the `session-compaction` feature flag.
- * When the flag is disabled, `compact()` is a no-op and returns the original
- * messages unchanged.
- *
- * Usage:
- * ```ts
- * const manager = createCompactionManager({ sessionId, bus, flags, contextWindow });
- * const result = await manager.compact({ messages, tokenCount: 45000, trigger: 'auto' });
- * ```
- */
-export class CompactionManager {
-  private readonly _sessionId: string;
-  private readonly _bus: RuntimeEventBus;
-  private readonly _flags: FeatureFlagManager;
-  private readonly _contextWindow: number;
-  private readonly _thresholdFraction: number;
-
-  /** Current state machine state. */
-  private _state: CompactionLifecycleState = 'idle';
-
-  /** Most recent boundary commit (null until first successful compaction). */
-  private _lastCommit: BoundaryCommit | null = null;
-
-  /** Emitter context used for all event emissions. */
-  private readonly _ctx: EmitterContext;
-
-  constructor(opts: CompactionManagerOptions) {
-    this._sessionId = opts.sessionId;
-    this._bus = opts.bus;
-    this._flags = opts.flags;
-    this._contextWindow = opts.contextWindow;
-    this._thresholdFraction = opts.thresholdFraction ?? 0.75;
-    this._ctx = {
-      sessionId: opts.sessionId,
-      source: 'compaction-manager',
-      traceId: crypto.randomUUID(),
-    };
-  }
-
-  // ── Public API ─────────────────────────────────────────────────────────────
-
-  /** Returns the current lifecycle state. */
-  get state(): CompactionLifecycleState {
-    return this._state;
-  }
-
-  /** Returns the most recent boundary commit, or null. */
-  get lastCommit(): BoundaryCommit | null {
-    return this._lastCommit;
-  }
-
-  /**
-   * Options for a compaction run.
-   */
-
-  /**
-   * Runs the compaction lifecycle for the given messages and trigger.
-   *
-   * If the `session-compaction` feature flag is disabled, returns the
-   * original messages unchanged with no events emitted.
-   *
-   * @param opts - Run options.
-   * @returns Lifecycle result, or null if gated/skipped.
-   */
-  async compact(opts: {
-    messages: ProviderMessage[];
-    tokenCount: number;
-    trigger: CompactionTrigger;
-    isPromptTooLong?: boolean;
-  }): Promise<CompactionLifecycleResult | null> {
-    // ── Feature flag gate ────────────────────────────────────────────────────
-    if (!this._flags.isEnabled('session-compaction')) {
-      logger.debug('[CompactionManager] session-compaction flag disabled; skipping', {
-        sessionId: this._sessionId,
-      });
-      return null;
-    }
-
-    const runStart = Date.now();
-    const { messages, tokenCount, trigger, isPromptTooLong } = opts;
-    const threshold = Math.floor(this._contextWindow * this._thresholdFraction);
-
-    // ── Transition: idle → checking_threshold ────────────────────────────────
-    this._transition('checking_threshold');
-
-    emitCompactionCheck(this._bus, this._ctx, {
-      sessionId: this._sessionId,
-      tokenCount,
-      threshold,
-    });
-
-    // ── Check threshold ──────────────────────────────────────────────────────
-    if (trigger === 'auto' && !isPromptTooLong && tokenCount < threshold) {
-      // Below threshold — go straight to done without compacting
-      this._transition('done');
-      this._transition('idle');
-      logger.debug('[CompactionManager] below threshold; no compaction needed', {
-        sessionId: this._sessionId,
-        tokenCount,
-        threshold,
-      });
-      return null;
-    }
-
-    // ── Select strategy ──────────────────────────────────────────────────────
-    let strategy = selectStrategy({
-      trigger,
-      currentTokens: tokenCount,
-      contextWindow: this._contextWindow,
-      isPromptTooLong,
-    });
-    const strategyState = strategyToState(strategy);
-
-    // ── Transition: checking_threshold → <strategy state> ────────────────────
-    this._transition(strategyState);
-
-    // ── Execute strategy ─────────────────────────────────────────────────────
-    let strategyOutput: StrategyOutput;
-    let qualityScore: CompactionQualityScore | null = null;
-    let strategySwitchReason: string | null = null;
-
-    const strategyInput: StrategyInput = {
-      sessionId: this._sessionId,
-      messages,
-      tokensBefore: tokenCount,
-      contextWindow: this._contextWindow,
-      strategy,
-      meta: isPromptTooLong !== undefined ? { isPromptTooLong } : undefined,
-    };
-
-    try {
-      strategyOutput = await this._runStrategy(strategy, strategyInput);
-    } catch (err) {
-      const error = summarizeError(err);
-      this._transition('failed');
-      emitCompactionFailed(this._bus, this._ctx, {
-        sessionId: this._sessionId,
-        strategy,
-        error,
-      });
-      this._transition('idle');
-      logger.error('[CompactionManager] strategy execution failed', {
-        sessionId: this._sessionId,
-        strategy,
-        error,
-      });
-      return null;
-    }
-
-    // ── Score quality and auto-switch if low ─────────────────────────────────
-    qualityScore = computeQualityScore(strategyInput, strategyOutput);
-
-    emitCompactionQualityScore(this._bus, this._ctx, {
-      sessionId: this._sessionId,
-      strategy,
-      score: qualityScore.score,
-      grade: qualityScore.grade,
-      compressionRatio: qualityScore.compressionRatio,
-      retentionScore: qualityScore.retentionScore,
-      isLowQuality: qualityScore.isLowQuality,
-      description: qualityScore.description,
-    });
-
-    if (qualityScore.isLowQuality) {
-      const escalated = escalateStrategy(strategy);
-      if (escalated !== strategy) {
-        const reason = `Quality score ${qualityScore.score.toFixed(2)} below threshold ${LOW_QUALITY_THRESHOLD}; escalating from ${strategy} to ${escalated}`;
-        strategySwitchReason = reason;
-
-        logger.warn('[CompactionManager] low quality score — switching strategy', {
-          sessionId: this._sessionId,
-          fromStrategy: strategy,
-          toStrategy: escalated,
-          score: qualityScore.score,
-          grade: qualityScore.grade,
-        });
-
-        emitCompactionStrategySwitch(this._bus, this._ctx, {
-          sessionId: this._sessionId,
-          fromStrategy: strategy,
-          toStrategy: escalated,
-          reason,
-          score: qualityScore.score,
-        });
-
-        // Force state to the escalated strategy state, bypassing normal transition
-        // validation. This is intentional: quality-correction reruns are not modelled
-        // in the standard state machine, and forcing the state allows _runStrategy to
-        // emit the correct strategy event while keeping lifecycle state consistent.
-        this._state = strategyToState(escalated);
-
-        const escalatedInput: StrategyInput = { ...strategyInput, strategy: escalated };
-        try {
-          const escalatedOutput = await this._runStrategy(escalated, escalatedInput);
-          // Re-score the escalated result
-          qualityScore = computeQualityScore(escalatedInput, escalatedOutput);
-          strategyOutput = escalatedOutput;
-          strategy = escalated;
-        } catch (err) {
-          const error = summarizeError(err);
-          logger.warn('[CompactionManager] escalated strategy also failed; using original output', {
-            sessionId: this._sessionId,
-            strategy: escalated,
-            error,
-          });
-          // Fall back to the original output — restore to the original strategy state
-          this._state = strategyToState(strategy);
-        }
-      } else {
-        // Already at ceiling strategy (collapse or reactive) — log but continue
-        logger.debug('[CompactionManager] low quality at ceiling strategy; no escalation possible', {
-          sessionId: this._sessionId,
-          strategy,
-          score: qualityScore.score,
-        });
-      }
-    }
-
-    // ── Transition: <strategy> → boundary_commit ─────────────────────────────
-    this._transition('boundary_commit');
-
-    // ── Create boundary commit ───────────────────────────────────────────────
-    const commit = createBoundaryCommit({
-      sessionId: this._sessionId,
-      strategyOutput,
-      parent: this._lastCommit,
-      tokensBefore: tokenCount,
-    });
-
-    const commitErrors = validateBoundaryCommit(commit);
-    if (commitErrors.length > 0) {
-      const error = commitErrors.join('; ');
-      this._transition('failed');
-      emitCompactionFailed(this._bus, this._ctx, {
-        sessionId: this._sessionId,
-        strategy,
-        error,
-      });
-      this._transition('idle');
-      logger.error('[CompactionManager] boundary commit validation failed', {
-        sessionId: this._sessionId,
-        errors: commitErrors,
-      });
-      return null;
-    }
-
-    emitCompactionBoundaryCommit(this._bus, this._ctx, {
-      sessionId: this._sessionId,
-      checkpointId: commit.checkpointId,
-    });
-
-    this._lastCommit = commit;
-
-    // ── Transition: boundary_commit → done ───────────────────────────────────
-    this._transition('done');
-    const durationMs = Date.now() - runStart;
-
-    emitCompactionDone(this._bus, this._ctx, {
-      sessionId: this._sessionId,
-      strategy,
-      tokensBefore: tokenCount,
-      tokensAfter: strategyOutput.tokensAfter,
-      durationMs,
-    });
-
-    // ── Transition: done → idle ───────────────────────────────────────────────
-    this._transition('idle');
-
-    return {
-      sessionId: this._sessionId,
-      strategy,
-      tokensBefore: tokenCount,
-      tokensAfter: strategyOutput.tokensAfter,
-      durationMs,
-      commit,
-      messages: strategyOutput.messages,
-      warnings: strategyOutput.warnings,
-      qualityScore,
-      strategySwitchReason,
-    };
-  }
-
-  /**
-   * Runs the session resume repair pipeline on the last boundary commit.
-   *
-   * If no commit exists, returns a result with the original messages and
-   * a warning action.
-   *
-   * @param overrideCommit - Optional commit to repair (defaults to lastCommit).
-   * @returns ResumeRepairResult.
-   */
-  repair(
-    overrideCommit?: BoundaryCommit,
-  ): ResumeRepairResult {
-    const commit = overrideCommit ?? this._lastCommit;
-    if (!commit) {
-      return {
-        sessionId: this._sessionId,
-        repaired: false,
-        actions: [
-          {
-            kind: 'no_commit',
-            description: 'No boundary commit available; nothing to repair.',
-            severity: 'info',
-          },
-        ],
-        messages: [],
-        safeToResume: false,
-        failReason: 'No boundary commit available for repair.',
-      };
-    }
-    return runResumeRepair({ commit });
-  }
-
-  // ── Private helpers ────────────────────────────────────────────────────────
-
-  /**
-   * Executes the selected strategy and emits the corresponding domain event.
-   */
-  private async _runStrategy(
-    strategy: CompactionStrategy,
-    input: StrategyInput,
-  ): Promise<StrategyOutput> {
-    switch (strategy) {
-      case 'microcompact': {
-        const output = runMicrocompact(input);
-        emitCompactionMicrocompact(this._bus, this._ctx, {
-          sessionId: this._sessionId,
-          turnCount: input.messages.length,
-          tokensBefore: input.tokensBefore,
-          tokensAfter: output.tokensAfter,
-        });
-        return output;
-      }
-      case 'collapse': {
-        const output = runCollapse(input);
-        emitCompactionCollapse(this._bus, this._ctx, {
-          sessionId: this._sessionId,
-          messageCount: input.messages.length,
-          tokensBefore: input.tokensBefore,
-          tokensAfter: output.tokensAfter,
-        });
-        return output;
-      }
-      case 'autocompact': {
-        const output = runAutocompact(input);
-        emitCompactionAutocompact(this._bus, this._ctx, {
-          sessionId: this._sessionId,
-          strategy: 'autocompact',
-          tokensBefore: input.tokensBefore,
-          tokensAfter: output.tokensAfter,
-        });
-        return output;
-      }
-      case 'reactive': {
-        const output = runReactive(input);
-        emitCompactionReactive(this._bus, this._ctx, {
-          sessionId: this._sessionId,
-          tokenCount: input.tokensBefore,
-          limit: this._contextWindow,
-        });
-        return output;
-      }
-      default: {
-        const _exhaustive: never = strategy;
-        throw new Error(`Unknown compaction strategy: ${_exhaustive}`);
-      }
-    }
-  }
-
-  /**
-   * Applies a state transition, throwing if invalid.
-   * Invalid transitions are logged and treated as internal errors.
-   */
-  private _transition(target: CompactionLifecycleState): void {
-    const result = applyTransition(this._state, target);
-    if (!result.ok) {
-      logger.error('[CompactionManager] invalid state transition', {
-        from: this._state,
-        to: target,
-        reason: result.reason,
-        sessionId: this._sessionId,
-      });
-      // Force to failed to avoid being stuck in an inconsistent state
-      this._state = 'failed';
-      return;
-    }
-    this._state = result.state;
-  }
-}

package/src/runtime/compaction/quality-score.ts

@@ -1 +0,0 @@
-export * from '@pellux/goodvibes-sdk/platform/runtime/compaction/quality-score';

package/src/runtime/compaction/resume-repair.ts

@@ -1 +0,0 @@
-export * from '@pellux/goodvibes-sdk/platform/runtime/compaction/resume-repair';

package/src/runtime/compaction/strategies/autocompact.ts

@@ -1 +0,0 @@
-export * from '@pellux/goodvibes-sdk/platform/runtime/compaction/strategies/autocompact';

package/src/runtime/compaction/strategies/boundary-commit.ts

@@ -1 +0,0 @@
-export * from '@pellux/goodvibes-sdk/platform/runtime/compaction/strategies/boundary-commit';

package/src/runtime/compaction/strategies/collapse.ts

@@ -1 +0,0 @@
-export * from '@pellux/goodvibes-sdk/platform/runtime/compaction/strategies/collapse';