@pellux/goodvibes-tui 0.18.11 → 0.18.13

package/src/runtime/transports/remote-events.ts

@@ -1,16 +0,0 @@
-export type {
-  DomainEventConnector,
-  DomainEvents as RemoteDomainEvents,
-  SerializedEventEnvelope as SerializedRuntimeEnvelope,
-  RemoteRuntimeEvents,
-  RuntimeEventConnectorOptions,
-} from '@pellux/goodvibes-sdk/transport-realtime';
-export {
-  buildEventSourceUrl,
-  buildWebSocketUrl,
-  createEventSourceConnector,
-  createRemoteDomainEvents,
-  createRemoteRuntimeEvents,
-  createWebSocketConnector,
-} from '@pellux/goodvibes-sdk/transport-realtime';
-export { createRemoteUiRuntimeEvents } from '@pellux/goodvibes-sdk/platform/runtime/transports/ui-runtime-events';

package/src/runtime/transports/shared.ts

@@ -1,39 +0,0 @@
-export type { DomainEventConnector, SerializedRuntimeEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/transports/remote-events';
-export {
-  buildEventSourceUrl,
-  buildWebSocketUrl,
-  createEventSourceConnector,
-  createRemoteRuntimeEvents,
-  createRemoteUiRuntimeEvents,
-  createWebSocketConnector,
-} from '@pellux/goodvibes-sdk/platform/runtime/transports/remote-events';
-export type { TransportPaths } from '@pellux/goodvibes-sdk/platform/runtime/transports/transport-paths';
-export { buildUrl, createTransportPaths, normalizeBaseUrl } from '@pellux/goodvibes-sdk/platform/runtime/transports/transport-paths';
-export type { BackoffPolicy, ResolvedBackoffPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/backoff';
-export { computeBackoffDelay, normalizeBackoffPolicy, sleepWithSignal } from '@pellux/goodvibes-sdk/platform/runtime/transports/backoff';
-export type { AuthTokenResolver, HeaderResolver, MaybePromise } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-auth';
-export { mergeHeaders, resolveAuthToken, resolveHeaders } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-auth';
-export type {
-  HttpJsonRequestOptions,
-  HttpRetryPolicy,
-  HttpJsonTransport,
-  HttpJsonTransportOptions,
-  JsonObject,
-  JsonValue,
-  ResolvedContractRequest,
-  TransportJsonError,
-} from '@pellux/goodvibes-sdk/platform/runtime/transports/http-json-transport';
-export {
-  createFetch,
-  createHttpJsonTransport,
-  createJsonInit,
-  createJsonRequestInit,
-  readJsonBody,
-  requestJson,
-} from '@pellux/goodvibes-sdk/platform/runtime/transports/http-json-transport';
-export type { ResolvedHttpRetryPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-retry';
-export { DEFAULT_HTTP_RETRY_POLICY, getHttpRetryDelay, isRetryableHttpStatus, isRetryableNetworkError, normalizeHttpRetryPolicy, resolveHttpRetryPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/http-retry';
-export type { ServerSentEventHandlers, ServerSentEventOptions } from '@pellux/goodvibes-sdk/platform/runtime/transports/sse-stream';
-export { isAbortError, openServerSentEventStream } from '@pellux/goodvibes-sdk/platform/runtime/transports/sse-stream';
-export type { StreamReconnectPolicy, ResolvedStreamReconnectPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/stream-reconnect';
-export { DEFAULT_STREAM_RECONNECT_POLICY, getStreamReconnectDelay, normalizeStreamReconnectPolicy } from '@pellux/goodvibes-sdk/platform/runtime/transports/stream-reconnect';

package/src/runtime/transports/ui-runtime-events.ts

@@ -1,35 +0,0 @@
-import type {
-  AgentEvent,
-  OpsEvent,
-  PlannerEvent,
-  ProviderEvent,
-  RuntimeEventDomain,
-  SessionEvent,
-  ToolEvent,
-  TurnEvent,
-  WorkflowEvent,
-} from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { UiEventFeed, UiRuntimeEvents } from '@pellux/goodvibes-sdk/platform/runtime/ui-events';
-import type { DomainEventConnector } from '@pellux/goodvibes-sdk/platform/runtime/transports/domain-events';
-import { createRemoteRuntimeEvents, type RemoteRuntimeEvents } from '@pellux/goodvibes-sdk/platform/runtime/transports/runtime-events-client';
-
-type RuntimeEventRecord = { readonly type: string };
-
-function asUiEvents(runtimeEvents: RemoteRuntimeEvents<RuntimeEventRecord>): UiRuntimeEvents {
-  return {
-    sessions: runtimeEvents.session as UiEventFeed<SessionEvent>,
-    turns: runtimeEvents.turn as UiEventFeed<TurnEvent>,
-    tools: runtimeEvents.tools as UiEventFeed<ToolEvent>,
-    providers: runtimeEvents.providers as UiEventFeed<ProviderEvent>,
-    agents: runtimeEvents.agents as UiEventFeed<AgentEvent>,
-    workflows: runtimeEvents.workflows as UiEventFeed<WorkflowEvent>,
-    planner: runtimeEvents.planner as UiEventFeed<PlannerEvent>,
-    ops: runtimeEvents.ops as UiEventFeed<OpsEvent>,
-  };
-}
-
-export function createRemoteUiRuntimeEvents(
-  connect: DomainEventConnector<RuntimeEventDomain, RuntimeEventRecord>,
-): UiRuntimeEvents {
-  return asUiEvents(createRemoteRuntimeEvents(connect));
-}

package/src/runtime/ui-read-models-core.ts

@@ -1,95 +0,0 @@
-import type { RuntimeServices } from './services.ts';
-import type { RuntimeTask } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/tasks';
-import type { RuntimeAgent } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/agents';
-import type { SessionDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/session';
-import type { TurnState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/conversation';
-import { createStoreBackedReadModel, listProviderIds } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-model-helpers';
-import type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
-
-export interface UiProvidersSnapshot {
-  readonly providerIds: readonly string[];
-}
-
-export interface UiSessionSnapshot {
-  readonly session: SessionDomainState;
-  readonly totalTurns: number;
-  readonly messageCount: number;
-  readonly estimatedContextTokens: number;
-  readonly contextWindow: number;
-  readonly turnState: TurnState;
-  readonly streamToolPreview?: string;
-  readonly contextWarningActive: boolean;
-  readonly pendingApproval: boolean;
-  readonly denialCount: number;
-}
-
-export interface UiAgentsSnapshot {
-  readonly active: readonly RuntimeAgent[];
-  readonly totalSpawned: number;
-  readonly totalCompleted: number;
-  readonly totalFailed: number;
-}
-
-export interface UiTasksSnapshot {
-  readonly tasks: readonly RuntimeTask[];
-}
-
-export interface UiCoreReadModels {
-  readonly providers: UiReadModel<UiProvidersSnapshot>;
-  readonly session: UiReadModel<UiSessionSnapshot>;
-  readonly agents: UiReadModel<UiAgentsSnapshot>;
-  readonly tasks: UiReadModel<UiTasksSnapshot>;
-}
-
-export function createCoreReadModels(runtimeServices: RuntimeServices): UiCoreReadModels {
-  const { runtimeStore } = runtimeServices;
-
-  return {
-    providers: {
-      getSnapshot() {
-        return {
-          providerIds: listProviderIds(runtimeServices),
-        };
-      },
-      subscribe(listener) {
-        return runtimeServices.runtimeBus.on('PROVIDERS_CHANGED', listener);
-      },
-    },
-    session: createStoreBackedReadModel(runtimeServices, () => {
-      const state = runtimeStore.getState();
-      return {
-        session: state.session,
-        totalTurns: state.conversation.totalTurns,
-        messageCount: state.conversation.messageCount,
-        estimatedContextTokens: state.conversation.estimatedContextTokens,
-        contextWindow: state.model.tokenLimits.contextWindow,
-        turnState: state.conversation.turnState,
-        streamToolPreview: state.conversation.stream.partialToolPreview,
-        contextWarningActive: state.conversation.contextWarningActive,
-        pendingApproval: state.permissions.awaitingDecision,
-        denialCount: state.permissions.denialCount,
-      };
-    }),
-    agents: createStoreBackedReadModel(runtimeServices, () => {
-      const state = runtimeStore.getState().agents;
-      const active = state.activeAgentIds
-        .map((id) => state.agents.get(id))
-        .filter((agent): agent is RuntimeAgent => agent !== undefined);
-      return {
-        active,
-        totalSpawned: state.totalSpawned,
-        totalCompleted: state.totalCompleted,
-        totalFailed: state.totalFailed,
-      };
-    }),
-    tasks: createStoreBackedReadModel(runtimeServices, () => {
-      const tasksState = runtimeStore.getState().tasks;
-      const tasks = [...tasksState.tasks.values()].sort((a, b) => {
-        const aTime = a.startedAt ?? a.queuedAt;
-        const bTime = b.startedAt ?? b.queuedAt;
-        return bTime - aTime || a.title.localeCompare(b.title);
-      });
-      return { tasks };
-    }),
-  };
-}

package/src/runtime/ui-read-models-operations.ts

@@ -1,203 +0,0 @@
-import type { ControlPlaneRecentEvent, SharedApprovalRecord, SharedSessionRecord } from '@pellux/goodvibes-sdk/platform/control-plane/index';
-import type { RuntimeServices } from './services.ts';
-import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation/jobs';
-import type { AutomationRun } from '@pellux/goodvibes-sdk/platform/automation/runs';
-import type { AutomationRouteBinding } from '@pellux/goodvibes-sdk/platform/automation/routes';
-import type { WatcherRecord } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/watchers';
-import type { OrchestrationGraphRecord } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/orchestration';
-import type { RuntimeCommunicationRecord } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/communication';
-import type { ControlPlaneClientRecord } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/control-plane';
-import type { AcpConnection } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/acp';
-import { combineSubscriptions, createStoreBackedReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-model-helpers';
-import type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
-
-export interface UiAutomationSnapshot {
-  readonly jobs: readonly AutomationJob[];
-  readonly runs: readonly AutomationRun[];
-  readonly totalJobs: number;
-  readonly totalRuns: number;
-  readonly activeRunIds: readonly string[];
-  readonly totalFailed: number;
-  readonly sourceCount: number;
-  readonly deliveryTotals: {
-    readonly succeeded: number;
-    readonly failed: number;
-    readonly deadLettered: number;
-  };
-}
-
-export interface UiRoutesSnapshot {
-  readonly bindings: readonly AutomationRouteBinding[];
-  readonly bindingIdsBySurface: Readonly<Record<string, readonly string[]>>;
-  readonly totalBindings: number;
-  readonly activeBindingIds: readonly string[];
-  readonly totalResolved: number;
-  readonly totalFailures: number;
-}
-
-export interface UiWatchersSnapshot {
-  readonly watchers: readonly WatcherRecord[];
-  readonly totalWatchers: number;
-  readonly activeWatcherIds: readonly string[];
-  readonly totalDegraded: number;
-  readonly totalLagged: number;
-}
-
-export interface UiOrchestrationSnapshot {
-  readonly graphs: readonly OrchestrationGraphRecord[];
-  readonly totalGraphs: number;
-  readonly activeGraphIds: readonly string[];
-  readonly totalCompletedGraphs: number;
-  readonly totalFailedGraphs: number;
-  readonly recursionGuardTrips: number;
-}
-
-export interface UiCommunicationSnapshot {
-  readonly records: readonly RuntimeCommunicationRecord[];
-  readonly totalSent: number;
-  readonly totalDelivered: number;
-  readonly totalBlocked: number;
-}
-
-export interface UiControlPlaneSnapshot {
-  readonly connectionState: string;
-  readonly activeClientIds: readonly string[];
-  readonly requestCount: number;
-  readonly errorCount: number;
-  readonly host: string;
-  readonly port: number;
-  readonly clients: readonly ControlPlaneClientRecord[];
-  readonly approvals: readonly SharedApprovalRecord[];
-  readonly sessions: readonly SharedSessionRecord[];
-  readonly recentEvents: readonly ControlPlaneRecentEvent[];
-}
-
-export interface UiOperationsReadModels {
-  readonly automation: UiReadModel<UiAutomationSnapshot>;
-  readonly routes: UiReadModel<UiRoutesSnapshot>;
-  readonly watchers: UiReadModel<UiWatchersSnapshot>;
-  readonly orchestration: UiReadModel<UiOrchestrationSnapshot>;
-  readonly communication: UiReadModel<UiCommunicationSnapshot>;
-  readonly controlPlane: UiReadModel<UiControlPlaneSnapshot>;
-}
-
-export interface UiOperationsReadModelOptions {
-  readonly getControlPlaneRecentEvents?: (limit: number) => readonly ControlPlaneRecentEvent[];
-}
-
-export function createOperationsReadModels(
-  runtimeServices: RuntimeServices,
-  options: UiOperationsReadModelOptions = {},
-): UiOperationsReadModels {
-  const { runtimeStore } = runtimeServices;
-
-  return {
-    automation: createStoreBackedReadModel(runtimeServices, () => {
-      const state = runtimeStore.getState();
-      const jobs = state.automation.jobIds
-        .map((id) => state.automation.jobs.get(id))
-        .filter((job): job is AutomationJob => job !== undefined)
-        .sort((a, b) => (b.nextRunAt ?? 0) - (a.nextRunAt ?? 0) || a.name.localeCompare(b.name));
-      const runs = state.automation.runIds
-        .map((id) => state.automation.runs.get(id))
-        .filter((run): run is AutomationRun => run !== undefined)
-        .sort((a, b) => b.queuedAt - a.queuedAt || a.id.localeCompare(b.id));
-      return {
-        jobs,
-        runs,
-        totalJobs: state.automation.totalJobs,
-        totalRuns: state.automation.totalRuns,
-        activeRunIds: state.automation.activeRunIds,
-        totalFailed: state.automation.totalFailed,
-        sourceCount: state.automation.sourceIds.length,
-        deliveryTotals: {
-          succeeded: state.deliveries.totalSucceeded,
-          failed: state.deliveries.totalFailed,
-          deadLettered: state.deliveries.totalDeadLettered,
-        },
-      };
-    }),
-    routes: createStoreBackedReadModel(runtimeServices, () => {
-      const state = runtimeStore.getState().routes;
-      const bindings = state.bindingIds
-        .map((id) => state.bindings.get(id))
-        .filter((binding): binding is AutomationRouteBinding => binding !== undefined)
-        .sort((a, b) => b.lastSeenAt - a.lastSeenAt || a.id.localeCompare(b.id));
-      return {
-        bindings,
-        bindingIdsBySurface: state.bindingIdsBySurface,
-        totalBindings: state.totalBindings,
-        activeBindingIds: state.activeBindingIds,
-        totalResolved: state.totalResolved,
-        totalFailures: state.totalFailures,
-      };
-    }),
-    watchers: createStoreBackedReadModel(runtimeServices, () => {
-      const state = runtimeStore.getState().watchers;
-      const watchers = state.watcherIds
-        .map((id) => state.watchers.get(id))
-        .filter((watcher): watcher is WatcherRecord => watcher !== undefined)
-        .sort((a, b) => (b.lastHeartbeatAt ?? 0) - (a.lastHeartbeatAt ?? 0) || a.id.localeCompare(b.id));
-      return {
-        watchers,
-        totalWatchers: state.watcherIds.length,
-        activeWatcherIds: state.activeWatcherIds,
-        totalDegraded: state.totalDegraded,
-        totalLagged: state.totalLagged,
-      };
-    }),
-    orchestration: createStoreBackedReadModel(runtimeServices, () => {
-      const state = runtimeStore.getState().orchestration;
-      const graphs = [...state.graphs.values()].sort((a, b) => b.createdAt - a.createdAt);
-      return {
-        graphs,
-        totalGraphs: state.totalGraphs,
-        activeGraphIds: state.activeGraphIds,
-        totalCompletedGraphs: state.totalCompletedGraphs,
-        totalFailedGraphs: state.totalFailedGraphs,
-        recursionGuardTrips: state.recursionGuardTrips,
-      };
-    }),
-    communication: createStoreBackedReadModel(runtimeServices, () => {
-      const state = runtimeStore.getState().communication;
-      const records = state.recentRecordIds
-        .map((id) => state.records.get(id))
-        .filter((record): record is RuntimeCommunicationRecord => record !== undefined)
-        .sort((a, b) => b.timestamp - a.timestamp);
-      return {
-        records,
-        totalSent: state.totalSent,
-        totalDelivered: state.totalDelivered,
-        totalBlocked: state.totalBlocked,
-      };
-    }),
-    controlPlane: {
-      getSnapshot() {
-        const state = runtimeStore.getState().controlPlane;
-        const clients = state.clientIds
-          .map((id) => state.clients.get(id))
-          .filter((client): client is ControlPlaneClientRecord => client !== undefined)
-          .sort((a, b) => (b.lastSeenAt ?? 0) - (a.lastSeenAt ?? 0) || a.id.localeCompare(b.id));
-        return {
-          connectionState: state.connectionState,
-          activeClientIds: state.activeClientIds,
-          requestCount: state.requestCount,
-          errorCount: state.errorCount,
-          host: state.host,
-          port: state.port,
-          clients,
-          approvals: runtimeServices.approvalBroker.listApprovals(6),
-          sessions: runtimeServices.sessionBroker.listSessions(6),
-          recentEvents: options.getControlPlaneRecentEvents?.(6) ?? [],
-        };
-      },
-      subscribe(listener) {
-        const unsubs = [
-          runtimeStore.subscribe(listener),
-          runtimeServices.approvalBroker.subscribe(listener),
-        ];
-        return combineSubscriptions(...unsubs);
-      },
-    },
-  };
-}

package/src/runtime/worktree/registry.ts

@@ -1,252 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, isAbsolute, join, resolve } from 'node:path';
-import { GitService } from '@pellux/goodvibes-sdk/platform/git/service';
-
-export type ManagedWorktreeState = 'active' | 'paused' | 'kept' | 'discard' | 'cleanup-pending';
-export type ManagedWorktreeKind = 'agent' | 'orchestrator' | 'manual';
-
-export interface ManagedWorktreeMeta {
-  readonly path: string;
-  readonly kind: ManagedWorktreeKind;
-  readonly state: ManagedWorktreeState;
-  readonly ownerId?: string;
-  readonly sessionId?: string;
-  readonly taskId?: string;
-  readonly updatedAt: number;
-}
-
-interface WorktreeStore {
-  readonly version: 1;
-  readonly records: Record<string, ManagedWorktreeMeta>;
-}
-
-export interface WorktreeStatusRecord extends ManagedWorktreeMeta {
-  readonly branch: string;
-  readonly head: string;
-}
-
-export interface WorktreeOwnershipSummary {
-  readonly total: number;
-  readonly active: number;
-  readonly paused: number;
-  readonly kept: number;
-  readonly discard: number;
-  readonly cleanupPending: number;
-  readonly sessionAttached: number;
-  readonly taskAttached: number;
-  readonly agentOwned: number;
-  readonly orchestratorOwned: number;
-  readonly manualOwned: number;
-}
-
-export interface WorktreeAttachmentReview {
-  readonly targetKind: 'session' | 'task';
-  readonly targetId: string;
-  readonly total: number;
-  readonly active: number;
-  readonly paused: number;
-  readonly kept: number;
-  readonly discard: number;
-  readonly cleanupPending: number;
-  readonly records: readonly ManagedWorktreeMeta[];
-}
-
-export interface WorktreeRegistryPaths {
-  readonly workingDirectory: string;
-}
-
-function getStorePath(workingDirectory: string): string {
-  return join(workingDirectory, '.goodvibes', 'tui', 'worktrees.json');
-}
-
-function defaultStore(): WorktreeStore {
-  return { version: 1, records: {} };
-}
-
-function normalizePath(path: string, workingDirectory: string): string {
-  return resolve(workingDirectory, path);
-}
-
-function readStore(workingDirectory: string): WorktreeStore {
-  try {
-    return JSON.parse(readFileSync(getStorePath(workingDirectory), 'utf-8')) as WorktreeStore;
-  } catch {
-    return defaultStore();
-  }
-}
-
-export function listPersistedWorktreeMeta(options: WorktreeRegistryPaths): ManagedWorktreeMeta[] {
-  return Object.values(readStore(options.workingDirectory).records).sort((a, b) => a.path.localeCompare(b.path));
-}
-
-export function getPersistedWorktreeMeta(path: string, options: WorktreeRegistryPaths): ManagedWorktreeMeta | null {
-  const normalized = normalizePath(path, options.workingDirectory);
-  return readStore(options.workingDirectory).records[normalized] ?? null;
-}
-
-export function reviewWorktreeAttachments(
-  targetKind: 'session' | 'task',
-  targetId: string,
-  options: WorktreeRegistryPaths,
-): WorktreeAttachmentReview {
-  const records = listPersistedWorktreeMeta(options).filter((record) => (
-    targetKind === 'session' ? record.sessionId === targetId : record.taskId === targetId
-  ));
-  return records.reduce<WorktreeAttachmentReview>((summary, record) => ({
-    ...summary,
-    total: summary.total + 1,
-    active: summary.active + (record.state === 'active' ? 1 : 0),
-    paused: summary.paused + (record.state === 'paused' ? 1 : 0),
-    kept: summary.kept + (record.state === 'kept' ? 1 : 0),
-    discard: summary.discard + (record.state === 'discard' ? 1 : 0),
-    cleanupPending: summary.cleanupPending + (record.state === 'cleanup-pending' ? 1 : 0),
-    records: [...summary.records, record],
-  }), {
-    targetKind,
-    targetId,
-    total: 0,
-    active: 0,
-    paused: 0,
-    kept: 0,
-    discard: 0,
-    cleanupPending: 0,
-    records: [],
-  });
-}
-
-export function summarizeWorktreeOwnership(records: readonly ManagedWorktreeMeta[]): WorktreeOwnershipSummary {
-  return records.reduce<WorktreeOwnershipSummary>((summary, record) => ({
-    total: summary.total + 1,
-    active: summary.active + (record.state === 'active' ? 1 : 0),
-    paused: summary.paused + (record.state === 'paused' ? 1 : 0),
-    kept: summary.kept + (record.state === 'kept' ? 1 : 0),
-    discard: summary.discard + (record.state === 'discard' ? 1 : 0),
-    cleanupPending: summary.cleanupPending + (record.state === 'cleanup-pending' ? 1 : 0),
-    sessionAttached: summary.sessionAttached + (record.sessionId ? 1 : 0),
-    taskAttached: summary.taskAttached + (record.taskId ? 1 : 0),
-    agentOwned: summary.agentOwned + (record.kind === 'agent' ? 1 : 0),
-    orchestratorOwned: summary.orchestratorOwned + (record.kind === 'orchestrator' ? 1 : 0),
-    manualOwned: summary.manualOwned + (record.kind === 'manual' ? 1 : 0),
-  }), {
-    total: 0,
-    active: 0,
-    paused: 0,
-    kept: 0,
-    discard: 0,
-    cleanupPending: 0,
-    sessionAttached: 0,
-    taskAttached: 0,
-    agentOwned: 0,
-    orchestratorOwned: 0,
-    manualOwned: 0,
-  });
-}
-
-function writeStore(store: WorktreeStore, workingDirectory: string): void {
-  const storePath = getStorePath(workingDirectory);
-  mkdirSync(dirname(storePath), { recursive: true });
-  writeFileSync(storePath, `${JSON.stringify(store, null, 2)}\n`, 'utf-8');
-}
-
-function classifyWorktreePath(path: string, workingDirectory: string): Pick<ManagedWorktreeMeta, 'kind' | 'ownerId'> {
-  const normalized = normalizePath(path, workingDirectory);
-  const agentMatch = normalized.match(/[/\\]\.goodvibes[/\\]\.worktrees[/\\]agent-([^/\\]+)$/);
-  if (agentMatch) {
-    return { kind: 'agent', ownerId: agentMatch[1] };
-  }
-  if (normalized.includes(`${join('.goodvibes', '.worktrees')}`)) {
-    return { kind: 'orchestrator' };
-  }
-  return { kind: 'manual' };
-}
-
-export class WorktreeRegistry {
-  private readonly git: GitService;
-  private readonly workingDirectory: string;
-
-  public constructor(workingDirectory: string) {
-    this.workingDirectory = workingDirectory;
-    this.git = new GitService(workingDirectory);
-  }
-
-  public async list(): Promise<WorktreeStatusRecord[]> {
-    const store = readStore(this.workingDirectory);
-    const listed = await this.git.worktreeList();
-    const present = new Set(listed.map((entry) => normalizePath(entry.path, this.workingDirectory)));
-    const records: WorktreeStatusRecord[] = listed.map((entry) => {
-      const path = normalizePath(entry.path, this.workingDirectory);
-      const meta = store.records[path];
-      const classified = classifyWorktreePath(path, this.workingDirectory);
-      return {
-        path,
-        branch: entry.branch,
-        head: entry.head,
-        kind: meta?.kind ?? classified.kind,
-        state: meta?.state ?? 'active',
-        ...(meta?.ownerId ?? classified.ownerId ? { ownerId: meta?.ownerId ?? classified.ownerId } : {}),
-        ...(meta?.sessionId ? { sessionId: meta.sessionId } : {}),
-        ...(meta?.taskId ? { taskId: meta.taskId } : {}),
-        updatedAt: meta?.updatedAt ?? Date.now(),
-      };
-    });
-    const nextRecords: Record<string, ManagedWorktreeMeta> = {};
-    for (const record of records) {
-      nextRecords[record.path] = {
-        path: record.path,
-        kind: record.kind,
-        state: record.state,
-        ...(record.ownerId ? { ownerId: record.ownerId } : {}),
-        ...(record.sessionId ? { sessionId: record.sessionId } : {}),
-        ...(record.taskId ? { taskId: record.taskId } : {}),
-        updatedAt: record.updatedAt,
-      };
-    }
-    for (const [path, meta] of Object.entries(store.records)) {
-      if (!present.has(path) && meta.state === 'kept') nextRecords[path] = meta;
-    }
-    writeStore({ version: 1, records: nextRecords }, this.workingDirectory);
-    return records.sort((a, b) => a.path.localeCompare(b.path));
-  }
-
-  public attach(path: string, target: { sessionId?: string; taskId?: string }): void {
-    const store = readStore(this.workingDirectory);
-    const normalized = normalizePath(path, this.workingDirectory);
-    const existing = store.records[normalized];
-    const classified = classifyWorktreePath(normalized, this.workingDirectory);
-    store.records[normalized] = {
-      path: normalized,
-      kind: existing?.kind ?? classified.kind,
-      state: existing?.state ?? 'active',
-      ...(existing?.ownerId ?? classified.ownerId ? { ownerId: existing?.ownerId ?? classified.ownerId } : {}),
-      ...(target.sessionId ? { sessionId: target.sessionId } : {}),
-      ...(target.taskId ? { taskId: target.taskId } : {}),
-      updatedAt: Date.now(),
-    };
-    writeStore(store, this.workingDirectory);
-  }
-
-  public setState(path: string, state: ManagedWorktreeState): void {
-    const store = readStore(this.workingDirectory);
-    const normalized = normalizePath(path, this.workingDirectory);
-    const existing = store.records[normalized];
-    const classified = classifyWorktreePath(normalized, this.workingDirectory);
-    store.records[normalized] = {
-      path: normalized,
-      kind: existing?.kind ?? classified.kind,
-      state,
-      ...(existing?.ownerId ?? classified.ownerId ? { ownerId: existing?.ownerId ?? classified.ownerId } : {}),
-      ...(existing?.sessionId ? { sessionId: existing.sessionId } : {}),
-      ...(existing?.taskId ? { taskId: existing.taskId } : {}),
-      updatedAt: Date.now(),
-    };
-    writeStore(store, this.workingDirectory);
-  }
-
-  public async cleanup(path: string): Promise<void> {
-    const normalized = isAbsolute(path) ? path : normalizePath(path, this.workingDirectory);
-    await this.git.worktreeRemove(normalized);
-    const store = readStore(this.workingDirectory);
-    delete store.records[normalized];
-    writeStore(store, this.workingDirectory);
-  }
-}

package/src/sessions/manager.ts

@@ -1,14 +0,0 @@
-export type {
-  SessionInfo,
-  SessionMeta,
-} from '@pellux/goodvibes-sdk/platform/sessions/manager';
-
-import { SessionManager as SdkSessionManager } from '@pellux/goodvibes-sdk/platform/sessions/manager';
-
-export class SessionManager extends SdkSessionManager {
-  constructor(baseDir: string) {
-    super(baseDir, {
-      surfaceRoot: 'tui',
-    });
-  }
-}