@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/runtime/integration/helpers.js

@@ -0,0 +1,540 @@
+import { buildProviderAccountSnapshot } from '../provider-accounts/registry.js';
+import { getSettingsControlPlaneSnapshot } from '../settings/control-plane.js';
+import { checkRecoveryFile, readLastSessionPointer } from '../session-persistence.js';
+import { listPersistedWorktreeMeta, summarizeWorktreeOwnership } from '../worktree/registry.js';
+import { inspectInboundTls, inspectOutboundTls } from '../network/index.js';
+const EVENT_DOMAINS = [
+    'session',
+    'turn',
+    'tools',
+    'permissions',
+    'tasks',
+    'agents',
+    'workflows',
+    'orchestration',
+    'communication',
+    'planner',
+    'plugins',
+    'mcp',
+    'transport',
+    'compaction',
+    'ui',
+    'ops',
+];
+function serializeEnvelope(envelope) {
+    return {
+        type: envelope.type,
+        timestamp: envelope.ts,
+        traceId: envelope.traceId,
+        sessionId: envelope.sessionId,
+        source: envelope.source,
+        payload: envelope.payload,
+    };
+}
+export class IntegrationHelperService {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    getRuntimeStore() {
+        return this.context.runtimeStore;
+    }
+    getContext() {
+        return this.context;
+    }
+    buildReview() {
+        const state = this.context.runtimeStore.getState();
+        const panelSnapshots = this.listPanels();
+        return {
+            apiFamilies: [
+                'session lifecycle',
+                'approvals',
+                'tasks and agents',
+                'remote state',
+                'health and diagnostics',
+                'panel targeting',
+                'event subscriptions',
+            ],
+            routes: [
+                'GET /api/review',
+                'GET /api/session',
+                'GET /api/tasks',
+                'GET /api/automation',
+                'GET /api/sessions',
+                'GET /api/deliveries',
+                'GET /api/control-plane',
+                'GET /api/control-plane/auth',
+                'GET /api/control-plane/clients',
+                'GET /api/control-plane/events?domains=session,tasks',
+                'GET /api/control-plane/whoami',
+                'GET /api/control-plane/web',
+                'GET /api/v1/telemetry',
+                'GET /api/v1/telemetry/events',
+                'GET /api/v1/telemetry/errors',
+                'GET /api/v1/telemetry/traces',
+                'GET /api/v1/telemetry/metrics',
+                'GET /api/v1/telemetry/stream',
+                'GET /api/v1/telemetry/otlp/v1/traces',
+                'GET /api/v1/telemetry/otlp/v1/logs',
+                'GET /api/v1/telemetry/otlp/v1/metrics',
+                'GET /api/routes',
+                'GET /api/routes/bindings',
+                'POST /api/routes/bindings',
+                'GET /api/surfaces',
+                'GET /api/channels/accounts',
+                'GET /api/channels/accounts/:surface',
+                'GET /api/channels/accounts/:surface/:accountId',
+                'POST /api/channels/accounts/:surface/actions/:action',
+                'POST /api/channels/accounts/:surface/:accountId/actions/:action',
+                'GET /api/channels/capabilities',
+                'GET /api/channels/capabilities/:surface',
+                'GET /api/channels/tools',
+                'GET /api/channels/tools/:surface',
+                'GET /api/channels/agent-tools',
+                'GET /api/channels/agent-tools/:surface',
+                'POST /api/channels/tools/:surface/:toolId',
+                'GET /api/channels/actions',
+                'GET /api/channels/actions/:surface',
+                'POST /api/channels/actions/:surface/:actionId',
+                'POST /api/channels/targets/:surface/resolve',
+                'POST /api/channels/authorize/:surface',
+                'GET /api/watchers',
+                'GET /api/service/status',
+                'POST /api/service/install',
+                'POST /api/service/uninstall',
+                'GET /api/approvals',
+                'GET /api/remote',
+                'GET /api/health',
+                'GET /api/accounts',
+                'GET /api/providers',
+                'GET /api/providers/:providerId',
+                'GET /api/providers/:providerId/usage',
+                'GET /api/settings',
+                'GET /api/local-auth',
+                'GET /api/continuity',
+                'GET /api/worktrees',
+                'GET /api/intelligence',
+                'GET /api/panels',
+                'POST /api/panels/open',
+                'GET /api/events?domains=session,tasks',
+            ],
+            sessions: state.session.id ? 1 : 0,
+            tasks: state.tasks.tasks.size,
+            pendingApprovals: state.permissions.awaitingDecision ? 1 : 0,
+            remoteContracts: this.context.remoteRunnerRegistry.listContracts().length,
+            panels: panelSnapshots.length,
+        };
+    }
+    getSessionSnapshot() {
+        const state = this.context.runtimeStore.getState();
+        return {
+            id: state.session.id,
+            title: this.context.getConversationTitle?.() ?? '',
+            status: state.session.status,
+            recoveryState: state.session.recoveryState,
+            projectRoot: state.session.projectRoot,
+            isResumed: state.session.isResumed,
+            resumedFromId: state.session.resumedFromId,
+            compactionState: state.session.compactionState,
+            lastCompactedAt: state.session.lastCompactedAt,
+            lineage: state.session.lineage,
+        };
+    }
+    getTaskSnapshot() {
+        const state = this.context.runtimeStore.getState();
+        return {
+            queued: state.tasks.queuedIds.length,
+            running: state.tasks.runningIds.length,
+            blocked: state.tasks.blockedIds.length,
+            totals: {
+                created: state.tasks.totalCreated,
+                completed: state.tasks.totalCompleted,
+                failed: state.tasks.totalFailed,
+                cancelled: state.tasks.totalCancelled,
+            },
+            tasks: [...state.tasks.tasks.values()].map((task) => ({
+                id: task.id,
+                kind: task.kind,
+                title: task.title,
+                status: task.status,
+                owner: task.owner,
+                parentTaskId: task.parentTaskId,
+                queuedAt: task.queuedAt,
+                startedAt: task.startedAt,
+                endedAt: task.endedAt,
+                error: task.error,
+            })),
+        };
+    }
+    getAutomationSnapshot() {
+        const jobs = this.context.automationManager.listJobs();
+        const runs = this.context.automationManager.listRuns().slice(0, 50);
+        return {
+            totals: {
+                jobs: jobs.length,
+                enabled: jobs.filter((job) => job.enabled).length,
+                paused: jobs.filter((job) => !job.enabled).length,
+                runs: runs.length,
+            },
+            jobs: jobs.map((job) => ({
+                id: job.id,
+                name: job.name,
+                enabled: job.enabled,
+                status: job.status,
+                schedule: job.schedule,
+                nextRunAt: job.nextRunAt,
+                lastRunAt: job.lastRunAt,
+                runCount: job.runCount,
+                failureCount: job.failureCount,
+            })),
+            recentRuns: runs.map((run) => ({
+                id: run.id,
+                jobId: run.jobId,
+                status: run.status,
+                trigger: run.triggeredBy.kind,
+                queuedAt: run.queuedAt,
+                startedAt: run.startedAt,
+                endedAt: run.endedAt,
+                agentId: run.agentId,
+                error: run.error,
+            })),
+        };
+    }
+    getRouteSnapshot() {
+        const state = this.context.runtimeStore.getState();
+        return {
+            totalBindings: state.routes.bindingIds.length,
+            activeBindings: state.routes.activeBindingIds.length,
+            recentBindings: state.routes.recentBindingIds.length,
+            bindings: [...state.routes.bindings.values()].map((binding) => ({
+                id: binding.id,
+                kind: binding.kind,
+                surfaceKind: binding.surfaceKind,
+                surfaceId: binding.surfaceId,
+                externalId: binding.externalId,
+                threadId: binding.threadId,
+                channelId: binding.channelId,
+                sessionId: binding.sessionId,
+                jobId: binding.jobId,
+                runId: binding.runId,
+                lastSeenAt: binding.lastSeenAt,
+            })),
+        };
+    }
+    getApprovalSnapshot() {
+        const state = this.context.runtimeStore.getState();
+        const approvals = this.context.approvalBroker.listApprovals(50);
+        return {
+            awaitingDecision: state.permissions.awaitingDecision,
+            mode: state.permissions.mode,
+            lastDecision: state.permissions.lastDecision,
+            approvalCount: state.permissions.approvalCount,
+            denialCount: state.permissions.denialCount,
+            cachedChecks: state.permissions.cachedChecks,
+            totalChecks: state.permissions.totalChecks,
+            approvals,
+        };
+    }
+    getSessionBrokerSnapshot() {
+        const sessions = this.context.sessionBroker.listSessions(50);
+        return {
+            totals: {
+                sessions: sessions.length,
+                active: sessions.filter((session) => session.status === 'active').length,
+                closed: sessions.filter((session) => session.status === 'closed').length,
+            },
+            sessions,
+        };
+    }
+    getDeliverySnapshot() {
+        const state = this.context.runtimeStore.getState();
+        const attempts = [...state.deliveries.deliveryAttempts.values()]
+            .sort((a, b) => (b.startedAt ?? b.endedAt ?? 0) - (a.startedAt ?? a.endedAt ?? 0))
+            .slice(0, 100);
+        return {
+            totals: {
+                queued: state.deliveries.totalQueued,
+                started: state.deliveries.totalStarted,
+                succeeded: state.deliveries.totalSucceeded,
+                failed: state.deliveries.totalFailed,
+                deadLettered: state.deliveries.totalDeadLettered,
+            },
+            attempts,
+        };
+    }
+    getRemoteSnapshot() {
+        const state = this.context.runtimeStore.getState();
+        const remoteRegistry = this.context.remoteRunnerRegistry;
+        const supervisor = this.context.remoteSupervisor.getSnapshot(this.context.runtimeStore);
+        const contracts = remoteRegistry.listContracts();
+        const pools = remoteRegistry.listPools();
+        const artifacts = remoteRegistry.listArtifacts();
+        return {
+            daemon: {
+                transportState: state.daemon.transportState,
+                isRunning: state.daemon.isRunning,
+                reconnectAttempts: state.daemon.reconnectAttempts,
+                runningJobCount: state.daemon.runningJobCount,
+                lastError: state.daemon.lastError,
+            },
+            acp: {
+                transportState: state.acp.managerTransportState,
+                activeConnectionIds: state.acp.activeConnectionIds,
+                totalSpawned: state.acp.totalSpawned,
+                totalFailed: state.acp.totalFailed,
+                lastError: [...state.acp.connections.values()].find((connection) => connection.lastError)?.lastError,
+            },
+            registry: {
+                pools: pools.length,
+                contracts: contracts.length,
+                artifacts: artifacts.length,
+                poolEntries: pools.map((pool) => ({
+                    id: pool.id,
+                    label: pool.label,
+                    trustClass: pool.trustClass,
+                    preferredTemplate: pool.preferredTemplate,
+                    maxRunners: pool.maxRunners,
+                    runnerIds: pool.runnerIds,
+                })),
+                contractEntries: contracts.map((contract) => ({
+                    id: contract.id,
+                    runnerId: contract.runnerId,
+                    label: contract.label,
+                    template: contract.template,
+                    poolId: contract.poolId,
+                    taskId: contract.taskId,
+                    sourceTransport: contract.sourceTransport,
+                    trustClass: contract.trustClass,
+                    executionProtocol: contract.capabilityCeiling.executionProtocol,
+                    reviewMode: contract.capabilityCeiling.reviewMode,
+                    communicationLane: contract.capabilityCeiling.communicationLane,
+                    transportState: contract.transport.state,
+                    lastError: contract.transport.lastError,
+                })),
+                artifactEntries: artifacts.map((artifact) => ({
+                    id: artifact.id,
+                    runnerId: artifact.runnerId,
+                    createdAt: artifact.createdAt,
+                    status: artifact.task.status,
+                    summary: artifact.task.summary,
+                    error: artifact.task.error,
+                })),
+            },
+            supervisor: {
+                sessions: supervisor.sessions.length,
+                degraded: supervisor.degradedConnections,
+                capturedAt: supervisor.capturedAt,
+                entries: supervisor.sessions.map((entry) => ({
+                    runnerId: entry.runnerId,
+                    label: entry.label,
+                    transportState: entry.transportState,
+                    heartbeat: entry.heartbeat.status,
+                    taskId: entry.taskId,
+                })),
+            },
+            distributed: this.context.distributedRuntime.getSnapshot(),
+        };
+    }
+    getHealthSnapshot() {
+        const state = this.context.runtimeStore.getState();
+        const degradedDomains = [];
+        const providerProblems = [...state.providerHealth.providers.values()]
+            .filter((provider) => provider.status !== 'healthy' && provider.status !== 'unknown')
+            .map((provider) => provider.providerId);
+        const degradedMcpServers = [...state.mcp.servers.values()]
+            .filter((server) => server.status === 'degraded' || server.status === 'auth_required' || server.schemaFreshness === 'quarantined')
+            .map((server) => server.name);
+        const quarantinedServers = [...state.mcp.servers.values()]
+            .filter((server) => server.schemaFreshness === 'quarantined')
+            .map((server) => server.name);
+        if (providerProblems.length > 0)
+            degradedDomains.push('providerHealth');
+        if (degradedMcpServers.length > 0)
+            degradedDomains.push('mcp');
+        if (state.integrations.problemIds.length > 0)
+            degradedDomains.push('integrations');
+        if (state.daemon.transportState === 'degraded' || state.daemon.transportState === 'terminal_failure')
+            degradedDomains.push('daemon');
+        if (state.acp.managerTransportState === 'degraded' || state.acp.managerTransportState === 'terminal_failure')
+            degradedDomains.push('acp');
+        if (state.session.recoveryState === 'failed')
+            degradedDomains.push('session');
+        return {
+            overall: degradedDomains.length > 0 ? 'degraded' : 'healthy',
+            degradedDomains,
+            providerProblems,
+            mcpProblems: {
+                degraded: degradedMcpServers,
+                quarantined: quarantinedServers,
+            },
+            integrationProblems: state.integrations.problemIds,
+            ...(this.context.configManager ? {
+                network: {
+                    controlPlane: inspectInboundTls(this.context.configManager, 'controlPlane'),
+                    httpListener: inspectInboundTls(this.context.configManager, 'httpListener'),
+                    outbound: inspectOutboundTls(this.context.configManager),
+                },
+            } : {}),
+        };
+    }
+    async getAccountsSnapshot() {
+        const snapshot = await buildProviderAccountSnapshot({
+            providerRegistry: this.context.providerRegistry,
+            serviceRegistry: this.context.serviceRegistry,
+            subscriptionManager: this.context.subscriptionManager,
+            secretsManager: this.context.secretsManager,
+        });
+        return {
+            capturedAt: snapshot.capturedAt,
+            configuredCount: snapshot.configuredCount,
+            issueCount: snapshot.issueCount,
+            providers: snapshot.providers.map((provider) => ({
+                providerId: provider.providerId,
+                active: provider.active,
+                activeRoute: provider.activeRoute,
+                preferredRoute: provider.preferredRoute,
+                authFreshness: provider.authFreshness,
+                availableRoutes: provider.availableRoutes,
+                modelCount: provider.modelCount,
+                configured: provider.configured,
+                oauthReady: provider.oauthReady,
+                pendingLogin: provider.pendingLogin,
+                expiresAt: provider.expiresAt,
+                fallbackRoute: provider.fallbackRoute,
+                fallbackRisk: provider.fallbackRisk,
+                activeRouteReason: provider.activeRouteReason,
+                issues: provider.issues,
+                recommendedActions: provider.recommendedActions,
+                usageWindows: provider.usageWindows,
+            })),
+        };
+    }
+    getSettingsSnapshot() {
+        if (!this.context.configManager) {
+            return { available: false, reason: 'configManager unavailable' };
+        }
+        const snapshot = getSettingsControlPlaneSnapshot(this.context.configManager);
+        return {
+            available: true,
+            liveKeyCount: snapshot.liveKeyCount,
+            profileCount: snapshot.profileCount,
+            managedLockCount: snapshot.managedLockCount,
+            resolvedCounts: snapshot.resolvedCounts,
+            conflicts: snapshot.conflicts,
+            recentFailures: snapshot.recentFailures,
+            stagedManagedBundle: snapshot.stagedManagedBundle,
+            rollbackHistory: snapshot.rollbackHistory,
+        };
+    }
+    getLocalAuthSnapshot() {
+        const snapshot = this.context.localUserAuthManager.inspect();
+        return {
+            userStorePath: snapshot.userStorePath,
+            bootstrapCredentialPath: snapshot.bootstrapCredentialPath,
+            bootstrapCredentialPresent: snapshot.bootstrapCredentialPresent,
+            userCount: snapshot.userCount,
+            sessionCount: snapshot.sessionCount,
+            users: snapshot.users,
+            sessions: snapshot.sessions,
+        };
+    }
+    getContinuitySnapshot() {
+        const state = this.context.runtimeStore.getState();
+        const recovery = checkRecoveryFile({
+            workingDirectory: this.context.workingDirectory,
+            homeDirectory: this.context.homeDirectory,
+        });
+        return {
+            sessionId: state.session.id,
+            status: state.session.status,
+            recoveryState: state.session.recoveryState,
+            lastSessionPointer: readLastSessionPointer({
+                workingDirectory: this.context.workingDirectory,
+                homeDirectory: this.context.homeDirectory,
+            }),
+            recoveryFilePresent: Boolean(recovery),
+            recoveryFile: recovery ?? null,
+        };
+    }
+    getWorktreeSnapshot() {
+        const records = listPersistedWorktreeMeta({ workingDirectory: this.context.workingDirectory });
+        return {
+            summary: summarizeWorktreeOwnership(records),
+            records,
+        };
+    }
+    getIntelligenceSnapshot() {
+        const intelligence = this.context.runtimeStore.getState().intelligence;
+        return {
+            diagnosticsStatus: intelligence.diagnosticsStatus,
+            symbolSearchStatus: intelligence.symbolSearchStatus,
+            completionsStatus: intelligence.completionsStatus,
+            hoverStatus: intelligence.hoverStatus,
+            errorCount: intelligence.errorCount,
+            warningCount: intelligence.warningCount,
+            totalRequests: intelligence.totalRequests,
+            avgLatencyMs: intelligence.avgLatencyMs,
+        };
+    }
+    listPanels() {
+        const manager = this.context.panelManager;
+        const openIds = new Set([
+            ...manager.getTopPane().panels.map((panel) => panel.id),
+            ...manager.getBottomPane().panels.map((panel) => panel.id),
+        ]);
+        return manager
+            .getRegisteredTypes()
+            .map((registration) => ({
+            id: registration.id,
+            name: registration.name,
+            category: registration.category,
+            description: registration.description,
+            open: openIds.has(registration.id),
+        }))
+            .sort((a, b) => a.category.localeCompare(b.category) || a.name.localeCompare(b.name));
+    }
+    openPanel(id, pane) {
+        const manager = this.context.panelManager;
+        const known = manager.getRegisteredTypes().some((registration) => registration.id === id);
+        if (!known)
+            return false;
+        manager.open(id, pane);
+        manager.show();
+        return true;
+    }
+    createEventStream(request, domains) {
+        const selectedDomains = domains.length > 0 ? domains : EVENT_DOMAINS;
+        const encoder = new TextEncoder();
+        let teardown = () => { };
+        const stream = new ReadableStream({
+            start: (controller) => {
+                const unsubs = selectedDomains.map((domain) => this.context.runtimeBus.onDomain(domain, (envelope) => {
+                    controller.enqueue(encoder.encode(`event: ${domain}\ndata: ${JSON.stringify(serializeEnvelope(envelope))}\n\n`));
+                }));
+                const heartbeat = setInterval(() => {
+                    controller.enqueue(encoder.encode(': heartbeat\n\n'));
+                }, 15_000);
+                teardown = () => {
+                    clearInterval(heartbeat);
+                    for (const unsub of unsubs)
+                        unsub();
+                };
+                request.signal.addEventListener('abort', () => {
+                    teardown();
+                    controller.close();
+                }, { once: true });
+                controller.enqueue(encoder.encode(`event: ready\ndata: ${JSON.stringify({ domains: selectedDomains })}\n\n`));
+            },
+            cancel: () => {
+                teardown();
+            },
+        });
+        return new Response(stream, {
+            headers: {
+                'content-type': 'text/event-stream',
+                'cache-control': 'no-cache',
+                connection: 'keep-alive',
+            },
+        });
+    }
+}

package/dist/_internal/platform/runtime/lifecycle.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Lifecycle management for a GoodVibes runtime host.
+ *
+ * Handles ordered teardown: persist session, fire lifecycle hooks,
+ * stop background managers. Terminal teardown remains in main.ts.
+ */
+import type { HookDispatcher } from '../hooks/index.js';
+import type { ScheduleManager } from '@pellux/goodvibes-sdk/platform/tools/workflow/index';
+import type { ProviderRegistry } from '../providers/registry.js';
+export { saveSession } from './session-persistence.js';
+import { type SessionPersistenceOptions, type SessionSnapshot } from './session-persistence.js';
+import type { CrossSessionTaskRegistry } from '@pellux/goodvibes-sdk/platform/sessions/orchestration/index';
+/**
+ * Fire the session:start lifecycle hook.
+ * Non-fatal: errors are logged and swallowed.
+ */
+export declare function fireSessionStart(sessionId: string, hookDispatcher: Pick<HookDispatcher, 'fire'> | null): void;
+/**
+ * Ordered logical shutdown of all background runtime subsystems.
+ *
+ * Sequence:
+ * 1. Persist conversation to sessions store
+ * 2. Fire session:end and session:save lifecycle hooks
+ * 3. Destroy ScheduleManager (cancels pending scheduled tasks)
+ * 4. Stop provider registry file-watcher
+ *
+ * This function does NOT touch the terminal (alt-screen, raw mode, etc.) —
+ * that remains the responsibility of main.ts.
+ *
+ * @param sessionId  - Active session identifier.
+ * @param sessionData - Latest conversation to persist.
+ * @param model      - Active model identifier.
+ * @param provider   - Active provider identifier.
+ * @param title      - Conversation title (may be empty string).
+ */
+export declare function shutdownRuntime(sessionId: string, sessionData: SessionSnapshot, model: string, provider: string, title?: string, scheduleManager?: ScheduleManager | null, hookDispatcher?: Pick<HookDispatcher, 'fire'> | null, providerRegistry?: Pick<ProviderRegistry, 'stopWatching'> | null, sessionOrchestration?: Pick<CrossSessionTaskRegistry, 'dispose'> | null, persistenceOptions?: SessionPersistenceOptions): Promise<void>;
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/_internal/platform/runtime/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/runtime/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qDAAqD,CAAC;AAC3F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAe,KAAK,yBAAyB,EAAE,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC7G,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6DAA6D,CAAC;AAK5G;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,GAAG,IAAI,GAClD,IAAI,CAiBN;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,eAAe,EAC5B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,KAAK,SAAK,EACV,eAAe,CAAC,EAAE,eAAe,GAAG,IAAI,EACxC,cAAc,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,GAAG,IAAI,EACpD,gBAAgB,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,cAAc,CAAC,GAAG,IAAI,EAChE,oBAAoB,CAAC,EAAE,IAAI,CAAC,wBAAwB,EAAE,SAAS,CAAC,GAAG,IAAI,EACvE,kBAAkB,CAAC,EAAE,yBAAyB,GAC7C,OAAO,CAAC,IAAI,CAAC,CA+Bf"}

package/dist/_internal/platform/runtime/lifecycle.js

@@ -0,0 +1,94 @@
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+export { saveSession } from './session-persistence.js';
+import { saveSession } from './session-persistence.js';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+// ── Startup lifecycle ────────────────────────────────────────────────────────
+/**
+ * Fire the session:start lifecycle hook.
+ * Non-fatal: errors are logged and swallowed.
+ */
+export function fireSessionStart(sessionId, hookDispatcher) {
+    if (!hookDispatcher)
+        return;
+    try {
+        hookDispatcher.fire({
+            path: 'Lifecycle:session:start',
+            phase: 'Lifecycle',
+            category: 'session',
+            specific: 'start',
+            sessionId,
+            timestamp: Date.now(),
+            payload: { sessionId },
+        }).catch((err) => {
+            logger.debug('fireSessionStart hook error (non-fatal)', { error: summarizeError(err) });
+        });
+    }
+    catch (err) {
+        logger.debug('fireSessionStart sync error (non-fatal)', { error: summarizeError(err) });
+    }
+}
+// ── Shutdown lifecycle ───────────────────────────────────────────────────────
+/**
+ * Ordered logical shutdown of all background runtime subsystems.
+ *
+ * Sequence:
+ * 1. Persist conversation to sessions store
+ * 2. Fire session:end and session:save lifecycle hooks
+ * 3. Destroy ScheduleManager (cancels pending scheduled tasks)
+ * 4. Stop provider registry file-watcher
+ *
+ * This function does NOT touch the terminal (alt-screen, raw mode, etc.) —
+ * that remains the responsibility of main.ts.
+ *
+ * @param sessionId  - Active session identifier.
+ * @param sessionData - Latest conversation to persist.
+ * @param model      - Active model identifier.
+ * @param provider   - Active provider identifier.
+ * @param title      - Conversation title (may be empty string).
+ */
+export async function shutdownRuntime(sessionId, sessionData, model, provider, title = '', scheduleManager, hookDispatcher, providerRegistry, sessionOrchestration, persistenceOptions) {
+    // Step 1: persist conversation
+    saveSession(sessionId, sessionData, model, provider, title, persistenceOptions);
+    // Step 2: lifecycle hooks (fire-and-forget, best-effort before process exit)
+    const fireHook = (specific) => {
+        if (!hookDispatcher)
+            return;
+        try {
+            hookDispatcher.fire({
+                path: `Lifecycle:session:${specific}`,
+                phase: 'Lifecycle',
+                category: 'session',
+                specific,
+                sessionId,
+                timestamp: Date.now(),
+                payload: { sessionId },
+            }).catch((err) => { logger.debug('shutdownRuntime hook fire error (non-fatal)', { specific, error: summarizeError(err) }); });
+        }
+        catch (err) {
+            logger.debug('shutdownRuntime hook sync error (non-fatal)', { specific, error: summarizeError(err) });
+        }
+    };
+    fireHook('end');
+    fireHook('save');
+    // Step 3: stop ScheduleManager
+    try {
+        scheduleManager?.destroy();
+    }
+    catch (err) {
+        logger.debug('ScheduleManager.destroy failed (non-fatal)', { error: summarizeError(err) });
+    }
+    // Step 4: stop provider registry watcher
+    try {
+        providerRegistry?.stopWatching();
+    }
+    catch (err) {
+        logger.debug('providerRegistry.stopWatching failed (non-fatal)', { error: summarizeError(err) });
+    }
+    // Step 5: dispose cross-session orchestration registry if it is app-owned in this runtime
+    try {
+        sessionOrchestration?.dispose();
+    }
+    catch (err) {
+        logger.debug('sessionOrchestration.dispose failed (non-fatal)', { error: summarizeError(err) });
+    }
+}