@pellux/goodvibes-sdk 0.18.14 → 0.18.16

package/dist/_internal/platform/runtime/bootstrap-runtime-events.d.ts

@@ -0,0 +1,30 @@
+import type { ConfigManager } from '../config/manager.js';
+import type { ConversationFollowUpItem } from '../core/conversation-follow-ups.js';
+import type { RuntimeEventBus } from './events/index.js';
+import type { createDomainDispatch } from './store/index.js';
+import type { WrfcController } from '../agents/wrfc-controller.js';
+import type { AgentManager } from '../tools/agent/index.js';
+export interface HostRuntimeMessageRouter {
+    low(message: string): void;
+    high(message: string): void;
+    wrfc(message: string): void;
+}
+export interface HostRuntimeEventBridgeOptions {
+    readonly runtimeBus: RuntimeEventBus;
+    readonly domainDispatch: ReturnType<typeof createDomainDispatch>;
+    readonly getSystemMessageRouter: () => HostRuntimeMessageRouter | null;
+    readonly queueConversationFollowUp?: (item: ConversationFollowUpItem) => void;
+    readonly requestRender: () => void;
+    readonly configManager: ConfigManager;
+    readonly agentManager: AgentManager;
+    readonly wrfcController: WrfcController;
+}
+export declare function registerHostRuntimeEvents(options: HostRuntimeEventBridgeOptions): {
+    unsubs: Array<() => void>;
+    agentStatusIntervalRef: {
+        value: ReturnType<typeof setInterval> | null;
+    };
+};
+export type BootstrapRuntimeEventBridgeOptions = HostRuntimeEventBridgeOptions;
+export declare const registerBootstrapRuntimeEvents: typeof registerHostRuntimeEvents;
+//# sourceMappingURL=bootstrap-runtime-events.d.ts.map

package/dist/_internal/platform/runtime/bootstrap-runtime-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap-runtime-events.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/runtime/bootstrap-runtime-events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,oCAAoC,CAAC;AACnF,OAAO,KAAK,EAA6B,eAAe,EAAiB,MAAM,mBAAmB,CAAC;AACnG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAI5D,MAAM,WAAW,wBAAwB;IACvC,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IACrC,QAAQ,CAAC,cAAc,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;IACjE,QAAQ,CAAC,sBAAsB,EAAE,MAAM,wBAAwB,GAAG,IAAI,CAAC;IACvE,QAAQ,CAAC,yBAAyB,CAAC,EAAE,CAAC,IAAI,EAAE,wBAAwB,KAAK,IAAI,CAAC;IAC9E,QAAQ,CAAC,aAAa,EAAE,MAAM,IAAI,CAAC;IACnC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;CACzC;AAoED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,6BAA6B,GACrC;IAAE,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAAC,sBAAsB,EAAE;QAAE,KAAK,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,GAAG,IAAI,CAAA;KAAE,CAAA;CAAE,CAoKzG;AAED,MAAM,MAAM,kCAAkC,GAAG,6BAA6B,CAAC;AAC/E,eAAO,MAAM,8BAA8B,kCAA4B,CAAC"}

package/dist/_internal/platform/runtime/bootstrap-runtime-events.js

@@ -0,0 +1,199 @@
+const AGENT_STATUS_INTERVAL_MS = 30_000;
+function withRouter(getSystemMessageRouter, action) {
+    const router = getSystemMessageRouter();
+    if (router)
+        action(router);
+}
+function buildCohortReport(agentManager, cohort) {
+    const agents = agentManager.listByCohort(cohort);
+    if (agents.length === 0)
+        return `[Agents] Cohort '${cohort}' complete (no agents found).`;
+    const completed = agents.filter((agent) => agent.status === 'completed').length;
+    const failed = agents.filter((agent) => agent.status === 'failed').length;
+    const cancelled = agents.filter((agent) => agent.status === 'cancelled').length;
+    const lines = [
+        `[Agents] Cohort '${cohort}' complete: ${completed} completed, ${failed} failed, ${cancelled} cancelled (${agents.length} total)`,
+    ];
+    for (const agent of agents) {
+        const durationSeconds = agent.completedAt !== undefined ? Math.round((agent.completedAt - agent.startedAt) / 1000) : 0;
+        const icon = agent.status === 'completed' ? '\u2713' : agent.status === 'failed' ? '\u2717' : '~';
+        const errorSuffix = agent.error ? ` \u2014 ${agent.error.slice(0, 60)}` : '';
+        lines.push(`  ${icon} ${agent.id.slice(-8)}: ${agent.status} in ${durationSeconds}s (${agent.toolCallCount} tool calls)${errorSuffix}`);
+    }
+    return lines.join('\n');
+}
+function buildCohortFollowUp(agentManager, cohort) {
+    const agents = agentManager.listByCohort(cohort);
+    const completed = agents.filter((agent) => agent.status === 'completed').length;
+    const failed = agents.filter((agent) => agent.status === 'failed').length;
+    const cancelled = agents.filter((agent) => agent.status === 'cancelled').length;
+    return {
+        key: `cohort:${cohort}:complete`,
+        summary: `Agent cohort "${cohort}" finished with ${completed} completed, ${failed} failed, and ${cancelled} cancelled out of ${agents.length} total agents.`,
+    };
+}
+function checkCohortCompletion(agentManager, wrfcController, record, getSystemMessageRouter, queueConversationFollowUp) {
+    if (!record?.cohort)
+        return;
+    const cohortAgents = agentManager.listByCohort(record.cohort);
+    const allAgentsDone = cohortAgents.every((agent) => agent.status !== 'running' && agent.status !== 'pending');
+    if (!allAgentsDone)
+        return;
+    const allChains = wrfcController.listChains();
+    const cohortAgentIds = new Set(cohortAgents.map((agent) => agent.id));
+    const cohortChains = allChains.filter((chain) => (chain.engineerAgentId && cohortAgentIds.has(chain.engineerAgentId))
+        || (chain.reviewerAgentId && cohortAgentIds.has(chain.reviewerAgentId))
+        || (chain.fixerAgentId && cohortAgentIds.has(chain.fixerAgentId)));
+    const terminalStates = new Set(['passed', 'failed']);
+    const allChainsDone = cohortChains.every((chain) => terminalStates.has(chain.state));
+    if (!allChainsDone)
+        return;
+    withRouter(getSystemMessageRouter, (router) => {
+        router.low(buildCohortReport(agentManager, record.cohort));
+    });
+    queueConversationFollowUp?.(buildCohortFollowUp(agentManager, record.cohort));
+}
+export function registerHostRuntimeEvents(options) {
+    const { runtimeBus, domainDispatch, getSystemMessageRouter, queueConversationFollowUp, requestRender, configManager, agentManager, wrfcController, } = options;
+    const unsubs = [];
+    unsubs.push(runtimeBus.onDomain('turn', (env) => {
+        domainDispatch.dispatchTurnEvent(env.payload);
+    }));
+    unsubs.push(runtimeBus.onDomain('agents', (env) => {
+        domainDispatch.dispatchAgentEvent(env.payload);
+    }));
+    unsubs.push(runtimeBus.onDomain('orchestration', (env) => {
+        domainDispatch.dispatchOrchestrationEvent(env.payload);
+    }));
+    unsubs.push(runtimeBus.onDomain('communication', (env) => {
+        domainDispatch.dispatchCommunicationEvent(env.payload);
+    }));
+    unsubs.push(runtimeBus.onDomain('compaction', (env) => {
+        domainDispatch.dispatchCompactionEvent(env.payload);
+    }));
+    unsubs.push(runtimeBus.onDomain('transport', (env) => {
+        domainDispatch.dispatchTransportEvent(env.payload);
+    }));
+    unsubs.push(runtimeBus.on('WORKFLOW_CASCADE_ABORTED', ({ payload }) => {
+        withRouter(getSystemMessageRouter, (router) => {
+            router.wrfc(`[WRFC] Cascade abort: ${payload.reason} (chain ${payload.chainId})`);
+        });
+        requestRender();
+    }));
+    unsubs.push(runtimeBus.on('MODEL_FALLBACK', ({ payload }) => {
+        withRouter(getSystemMessageRouter, (router) => {
+            router.high(`[Model] ${payload.from} exhausted across all providers. Automatically falling back to ${payload.to} via ${payload.provider}.`);
+        });
+        requestRender();
+    }));
+    unsubs.push(runtimeBus.on('WORKFLOW_CHAIN_CREATED', ({ payload }) => {
+        withRouter(getSystemMessageRouter, (router) => {
+            router.wrfc(`[WRFC] Chain ${payload.chainId} started: ${payload.task}`);
+        });
+        requestRender();
+    }));
+    unsubs.push(runtimeBus.on('WORKFLOW_REVIEW_COMPLETED', ({ payload }) => {
+        const icon = payload.passed ? '\u2713' : '\u2717';
+        const threshold = configManager.get('wrfc.scoreThreshold');
+        const suffix = payload.passed ? '' : ` - Minimum score is ${threshold}/10, spawning a fix agent ...`;
+        withRouter(getSystemMessageRouter, (router) => {
+            router.wrfc(`[WRFC] ${icon} Review ${payload.chainId.slice(0, 12)}: ${payload.score}/10${suffix}`);
+        });
+        requestRender();
+    }));
+    unsubs.push(runtimeBus.on('WORKFLOW_CHAIN_PASSED', ({ payload }) => {
+        withRouter(getSystemMessageRouter, (router) => {
+            router.wrfc(`[WRFC] \u2713 Chain ${payload.chainId.slice(0, 12)} PASSED \u2014 all gates clear`);
+        });
+        queueConversationFollowUp?.({
+            key: `wrfc:${payload.chainId}:passed`,
+            summary: `WRFC chain ${payload.chainId.slice(0, 12)} passed all gates.`,
+        });
+        const chain = wrfcController.getChain(payload.chainId);
+        if (chain?.engineerAgentId) {
+            const record = agentManager.getStatus(chain.engineerAgentId);
+            checkCohortCompletion(agentManager, wrfcController, record ?? null, getSystemMessageRouter, queueConversationFollowUp);
+        }
+        requestRender();
+    }));
+    unsubs.push(runtimeBus.on('WORKFLOW_CHAIN_FAILED', ({ payload }) => {
+        withRouter(getSystemMessageRouter, (router) => {
+            router.wrfc(`[WRFC] \u2717 Chain ${payload.chainId.slice(0, 12)} FAILED: ${payload.reason.slice(0, 80)}`);
+        });
+        queueConversationFollowUp?.({
+            key: `wrfc:${payload.chainId}:failed`,
+            summary: `WRFC chain ${payload.chainId.slice(0, 12)} failed: ${payload.reason.slice(0, 120)}`,
+        });
+        const chain = wrfcController.getChain(payload.chainId);
+        if (chain?.engineerAgentId) {
+            const record = agentManager.getStatus(chain.engineerAgentId);
+            checkCohortCompletion(agentManager, wrfcController, record ?? null, getSystemMessageRouter, queueConversationFollowUp);
+        }
+        requestRender();
+    }));
+    unsubs.push(runtimeBus.on('WORKFLOW_AUTO_COMMITTED', ({ payload }) => {
+        const suffix = payload.commitHash ? ` (${payload.commitHash.slice(0, 7)})` : '';
+        withRouter(getSystemMessageRouter, (router) => {
+            router.wrfc(`[WRFC] Auto-committed chain ${payload.chainId.slice(0, 12)}${suffix}`);
+        });
+        requestRender();
+    }));
+    unsubs.push(runtimeBus.on('WORKFLOW_GATE_RESULT', ({ payload }) => {
+        const icon = payload.passed ? '\u2713' : '\u2717';
+        withRouter(getSystemMessageRouter, (router) => {
+            router.wrfc(`[WRFC]   ${icon} Gate: ${payload.gate} ${payload.passed ? 'passed' : 'FAILED'}`);
+        });
+        requestRender();
+    }));
+    unsubs.push(runtimeBus.on('AGENT_STREAM_DELTA', () => {
+        requestRender();
+    }));
+    unsubs.push(runtimeBus.on('AGENT_PROGRESS', () => {
+        requestRender();
+    }));
+    unsubs.push(runtimeBus.on('AGENT_COMPLETED', ({ payload }) => {
+        const record = agentManager.getStatus(payload.agentId);
+        if (record) {
+            const durationSeconds = record.completedAt !== undefined ? Math.round((record.completedAt - record.startedAt) / 1000) : 0;
+            const taskSnippet = record.task.length > 50 ? `${record.task.slice(0, 50)}\u2026` : record.task;
+            withRouter(getSystemMessageRouter, (router) => {
+                router.low(`[Agents] \u2713 ${record.template} ${payload.agentId.slice(-8)}: "${taskSnippet}" \u2014 completed in ${durationSeconds}s (${record.toolCallCount} tool calls)`);
+            });
+            queueConversationFollowUp?.({
+                key: `agent:${payload.agentId}:completed`,
+                summary: `${record.template} agent ${payload.agentId.slice(-8)} completed "${taskSnippet}" in ${durationSeconds}s after ${record.toolCallCount} tool calls.`,
+            });
+        }
+        checkCohortCompletion(agentManager, wrfcController, record ?? null, getSystemMessageRouter, queueConversationFollowUp);
+        requestRender();
+    }));
+    unsubs.push(runtimeBus.on('AGENT_FAILED', ({ payload }) => {
+        const record = agentManager.getStatus(payload.agentId);
+        if (record && record.status !== 'cancelled') {
+            const durationSeconds = record.completedAt !== undefined ? Math.round((record.completedAt - record.startedAt) / 1000) : 0;
+            const taskSnippet = record.task.length > 50 ? `${record.task.slice(0, 50)}\u2026` : record.task;
+            withRouter(getSystemMessageRouter, (router) => {
+                router.low(`[Agents] \u2717 ${record.template} ${payload.agentId.slice(-8)}: "${taskSnippet}" \u2014 failed in ${durationSeconds}s: ${payload.error.slice(0, 80)}`);
+            });
+            queueConversationFollowUp?.({
+                key: `agent:${payload.agentId}:failed`,
+                summary: `${record.template} agent ${payload.agentId.slice(-8)} failed after ${durationSeconds}s while working on "${taskSnippet}": ${payload.error.slice(0, 120)}`,
+            });
+        }
+        checkCohortCompletion(agentManager, wrfcController, record ?? null, getSystemMessageRouter, queueConversationFollowUp);
+        requestRender();
+    }));
+    const agentStatusIntervalRef = { value: null };
+    agentStatusIntervalRef.value = setInterval(() => {
+        const running = agentManager.list().filter((agent) => agent.status === 'running');
+        if (running.length === 0)
+            return;
+        const lines = running.map((agent) => `  ${agent.id.slice(-8)}: ${agent.progress ?? agent.status}`);
+        withRouter(getSystemMessageRouter, (router) => {
+            router.low(`[Agents] ${running.length} running:\n${lines.join('\n')}`);
+        });
+        requestRender();
+    }, AGENT_STATUS_INTERVAL_MS);
+    return { unsubs, agentStatusIntervalRef };
+}
+export const registerBootstrapRuntimeEvents = registerHostRuntimeEvents;

package/dist/_internal/platform/runtime/bootstrap-services.d.ts

@@ -0,0 +1,40 @@
+import type { HookDispatcher } from '../hooks/dispatcher.js';
+import type { RuntimeEventBus } from './events/index.js';
+import type { RuntimeServices } from './services.js';
+interface DaemonService {
+    enable(config: {
+        daemon: boolean;
+    }, token?: string): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    listRecentControlPlaneEvents(limit: number): readonly import('../control-plane/gateway.js').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 HostServicesHandle {
+    readonly daemonServer: DaemonService | null;
+    readonly httpListener: HttpListenerService | null;
+    listRecentControlPlaneEvents(limit: number): readonly import('../control-plane/gateway.js').ControlPlaneRecentEvent[];
+    stop(): Promise<void>;
+}
+export interface HostServicesConfig {
+    get(key: 'danger.daemon' | 'danger.httpListener' | 'controlPlane.host' | 'controlPlane.port' | 'httpListener.host' | 'httpListener.port'): boolean | string | number;
+}
+export declare function startHostServices(config: HostServicesConfig, runtimeBus: RuntimeEventBus, hookDispatcher: HookDispatcher, factories: ServiceFactories | undefined, runtimeServices: RuntimeServices): Promise<HostServicesHandle>;
+export type ExternalServicesHandle = HostServicesHandle;
+export type ExternalServicesConfig = HostServicesConfig;
+export declare const startExternalServices: typeof startHostServices;
+export {};
+//# sourceMappingURL=bootstrap-services.d.ts.map

package/dist/_internal/platform/runtime/bootstrap-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap-services.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/runtime/bootstrap-services.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAOrD,UAAU,aAAa;IACrB,MAAM,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,OAAO,6BAA6B,EAAE,uBAAuB,EAAE,CAAC;CACvH;AAED,UAAU,mBAAmB;IAC3B,MAAM,CAAC,MAAM,EAAE;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACnE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED,UAAU,gBAAgB;IACxB,kBAAkB,CAAC,EAAE,CACnB,UAAU,EAAE,eAAe,EAC3B,QAAQ,EAAE,eAAe,CAAC,sBAAsB,CAAC,EACjD,eAAe,EAAE,eAAe,KAC7B,aAAa,CAAC;IACnB,kBAAkB,CAAC,EAAE,CACnB,cAAc,EAAE,cAAc,EAC9B,QAAQ,EAAE,eAAe,CAAC,sBAAsB,CAAC,EACjD,aAAa,EAAE,eAAe,CAAC,eAAe,CAAC,KAC5C,mBAAmB,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,oBAAoB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACxE,0BAA0B,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC/E;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,YAAY,EAAE,aAAa,GAAG,IAAI,CAAC;IAC5C,QAAQ,CAAC,YAAY,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAClD,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,OAAO,6BAA6B,EAAE,uBAAuB,EAAE,CAAC;IACtH,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED,MAAM,WAAW,kBAAkB;IACjC,GAAG,CACD,GAAG,EACC,eAAe,GACf,qBAAqB,GACrB,mBAAmB,GACnB,mBAAmB,GACnB,mBAAmB,GACnB,mBAAmB,GACtB,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;CAC9B;AAmDD,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,eAAe,EAC3B,cAAc,EAAE,cAAc,EAC9B,SAAS,EAAE,gBAAgB,YAAK,EAChC,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,kBAAkB,CAAC,CAoF7B;AAED,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,CAAC;AACxD,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,CAAC;AACxD,eAAO,MAAM,qBAAqB,0BAAoB,CAAC"}

package/dist/_internal/platform/runtime/bootstrap-services.js

@@ -0,0 +1,136 @@
+import { DaemonServer } from '../daemon/server.js';
+import { HttpListener } from '../daemon/http-listener.js';
+import { logger } from '../utils/logger.js';
+import net from 'node:net';
+import { summarizeError } from '../utils/error-display.js';
+const DEFAULT_SERVICE_START_TIMEOUT_MS = 1500;
+async function isTcpPortInUse(host, port, timeoutMs = 250) {
+    return await new Promise((resolve) => {
+        const socket = new net.Socket();
+        let settled = false;
+        const finish = (result) => {
+            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, start, timeoutMs, cleanup) {
+    let timer = null;
+    const startPromise = start().then(() => 'started');
+    try {
+        const result = await Promise.race([
+            startPromise,
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve('timed_out'), timeoutMs);
+            }),
+        ]);
+        if (result === 'timed_out') {
+            logger.warn(`${label} startup timed out; continuing without it in this host 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 startHostServices(config, runtimeBus, hookDispatcher, factories = {}, runtimeServices) {
+    const sharedUserAuth = runtimeServices.localUserAuthManager;
+    const createDaemonServer = factories.createDaemonServer ?? ((bus, userAuth, services) => new DaemonServer({ runtimeBus: bus, userAuth, runtimeServices: services }));
+    const createHttpListener = factories.createHttpListener ?? ((dispatcher, userAuth, configManager) => 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, port) => isTcpPortInUse(host, port));
+    const probeHttpListenerPortInUse = factories.probeHttpListenerPortInUse ?? ((host, port) => isTcpPortInUse(host, port));
+    let daemonServer = null;
+    let httpListener = null;
+    if (config.get('danger.daemon')) {
+        if (await probeDaemonPortInUse(daemonHost, daemonPort)) {
+            logger.warn('Daemon server port already in use; continuing without local daemon in this host 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 host instance', { error: message });
+                    daemonServer = null;
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+    }
+    if (config.get('danger.httpListener')) {
+        if (await probeHttpListenerPortInUse(httpListenerHost, httpListenerPort)) {
+            logger.warn('HTTP listener port already in use; continuing without local listener in this host 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 host instance', { error: message });
+                    httpListener = null;
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+    }
+    return {
+        daemonServer,
+        httpListener,
+        listRecentControlPlaneEvents(limit) {
+            return daemonServer?.listRecentControlPlaneEvents(limit) ?? [];
+        },
+        async stop() {
+            await Promise.allSettled([
+                daemonServer?.stop(),
+                httpListener?.stop(),
+            ]);
+        },
+    };
+}
+export const startExternalServices = startHostServices;

package/dist/_internal/platform/runtime/compaction/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * src/runtime/compaction/index.ts
+ *
+ * Barrel re-export for the session compaction lifecycle engine.
+ *
+ * Main entry point: `createCompactionManager()`
+ *
+ * Usage:
+ * ```ts
+ * import { createCompactionManager } from '../runtime/compaction/index.js';
+ *
+ * const manager = createCompactionManager({ sessionId, bus, flags, contextWindow });
+ * const result = await manager.compact({ messages, tokenCount, trigger: 'auto' });
+ * ```
+ */
+import { CompactionManager } from './manager.js';
+import type { CompactionManagerOptions } from './manager.js';
+export { CompactionManager };
+export type { CompactionManagerOptions };
+export type { CompactionLifecycleState, CompactionStrategy, CompactionTrigger, StrategyInput, StrategyOutput, BoundaryCommit, CompactionLifecycleResult, RepairAction, RepairSeverity, ResumeRepairResult, } from './types.js';
+export type { BoundaryCommitOptions } from './strategies/boundary-commit.js';
+export { canTransition, reachableFrom, applyTransition, isTerminal, isCompacting, selectStrategy, strategyToState, } from './lifecycle.js';
+export type { TransitionResult, StrategySelectionParams } from './lifecycle.js';
+export { runResumeRepair } from './resume-repair.js';
+export type { ResumeRepairOptions } from './resume-repair.js';
+export { runMicrocompact, runCollapse, runAutocompact, runReactive, createBoundaryCommit, validateBoundaryCommit, computeQualityScore, describeScore, escalateStrategy, LOW_QUALITY_THRESHOLD, } from './strategies/index.js';
+export type { CompactionQualityScore, CompactionQualityGrade, SemanticRetentionSignals, } from './strategies/index.js';
+/**
+ * Factory function for creating a CompactionManager instance.
+ *
+ * Convenience wrapper over `new CompactionManager(opts)` for symmetry
+ * with other runtime subsystem factories.
+ *
+ * NOTE: This factory is not yet wired to a consumer in the bootstrap layer.
+ * Integration with the session bootstrap pipeline is the next step — the
+ * CompactionManager will be instantiated per-session during session init
+ * and attached to the session context for lifecycle event routing.
+ *
+ * @param opts - Manager options (see CompactionManagerOptions).
+ * @returns A new CompactionManager instance.
+ */
+export declare function createCompactionManager(opts: CompactionManagerOptions): CompactionManager;
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/runtime/compaction/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/compaction/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAE7D,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAC7B,YAAY,EAAE,wBAAwB,EAAE,CAAC;AAEzC,YAAY,EACV,wBAAwB,EACxB,kBAAkB,EAClB,iBAAiB,EACjB,aAAa,EACb,cAAc,EACd,cAAc,EACd,yBAAyB,EACzB,YAAY,EACZ,cAAc,EACd,kBAAkB,GACnB,MAAM,YAAY,CAAC;AAEpB,YAAY,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAE7E,OAAO,EACL,aAAa,EACb,aAAa,EACb,eAAe,EACf,UAAU,EACV,YAAY,EACZ,cAAc,EACd,eAAe,GAChB,MAAM,gBAAgB,CAAC;AAExB,YAAY,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAEhF,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,EACL,eAAe,EACf,WAAW,EACX,cAAc,EACd,WAAW,EACX,oBAAoB,EACpB,sBAAsB,EACtB,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EACV,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,wBAAwB,GAC7B,iBAAiB,CAEnB"}

package/dist/_internal/platform/runtime/compaction/index.js

@@ -0,0 +1,37 @@
+/**
+ * src/runtime/compaction/index.ts
+ *
+ * Barrel re-export for the session compaction lifecycle engine.
+ *
+ * Main entry point: `createCompactionManager()`
+ *
+ * Usage:
+ * ```ts
+ * import { createCompactionManager } from '../runtime/compaction/index.js';
+ *
+ * const manager = createCompactionManager({ sessionId, bus, flags, contextWindow });
+ * const result = await manager.compact({ messages, tokenCount, trigger: 'auto' });
+ * ```
+ */
+import { CompactionManager } from './manager.js';
+export { CompactionManager };
+export { canTransition, reachableFrom, applyTransition, isTerminal, isCompacting, selectStrategy, strategyToState, } from './lifecycle.js';
+export { runResumeRepair } from './resume-repair.js';
+export { runMicrocompact, runCollapse, runAutocompact, runReactive, createBoundaryCommit, validateBoundaryCommit, computeQualityScore, describeScore, escalateStrategy, LOW_QUALITY_THRESHOLD, } from './strategies/index.js';
+/**
+ * Factory function for creating a CompactionManager instance.
+ *
+ * Convenience wrapper over `new CompactionManager(opts)` for symmetry
+ * with other runtime subsystem factories.
+ *
+ * NOTE: This factory is not yet wired to a consumer in the bootstrap layer.
+ * Integration with the session bootstrap pipeline is the next step — the
+ * CompactionManager will be instantiated per-session during session init
+ * and attached to the session context for lifecycle event routing.
+ *
+ * @param opts - Manager options (see CompactionManagerOptions).
+ * @returns A new CompactionManager instance.
+ */
+export function createCompactionManager(opts) {
+    return new CompactionManager(opts);
+}

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

@@ -0,0 +1,63 @@
+/**
+ * lifecycle.ts
+ *
+ * Compaction lifecycle state machine for the compaction engine.
+ *
+ * Provides:
+ * - Valid transition map for the 9-state machine
+ * - Pure transition helpers (no side-effects)
+ * - Strategy selection logic based on trigger and token pressure
+ */
+import type { CompactionLifecycleState, CompactionStrategy, CompactionTrigger } from './types.js';
+/**
+ * Returns whether a transition from `from` to `to` is valid.
+ */
+export declare function canTransition(from: CompactionLifecycleState, to: CompactionLifecycleState): boolean;
+/**
+ * Returns all states reachable from `from`.
+ */
+export declare function reachableFrom(from: CompactionLifecycleState): ReadonlySet<CompactionLifecycleState>;
+/** Discriminated result of `applyTransition`. */
+export type TransitionResult = {
+    ok: true;
+    state: CompactionLifecycleState;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Validates and applies a state transition.
+ *
+ * @returns `{ ok: true, state }` on success, `{ ok: false, reason }` on rejection.
+ */
+export declare function applyTransition(current: CompactionLifecycleState, target: CompactionLifecycleState): TransitionResult;
+/** Returns true if the state is a terminal completion state (done | failed). */
+export declare function isTerminal(state: CompactionLifecycleState): boolean;
+/** Returns true if the state represents active compaction work in progress. */
+export declare function isCompacting(state: CompactionLifecycleState): boolean;
+/** Parameters for selecting a compaction strategy. */
+export interface StrategySelectionParams {
+    /** What triggered compaction. */
+    trigger: CompactionTrigger;
+    /** Estimated tokens currently in context. */
+    currentTokens: number;
+    /** Model context window size. */
+    contextWindow: number;
+    /** Whether a prompt-too-long error was the immediate cause. */
+    isPromptTooLong?: boolean;
+}
+/**
+ * Selects the appropriate compaction strategy based on trigger and token pressure.
+ *
+ * Selection priority:
+ * 1. `reactive`     — any prompt-too-long error (emergency, must shrink now)
+ * 2. `microcompact` — token pressure < 50% of context window (light touch)
+ * 3. `autocompact`  — token pressure 50–85% (standard auto-compaction)
+ * 4. `collapse`     — token pressure > 85% or manual trigger (aggressive shrink)
+ */
+export declare function selectStrategy(params: StrategySelectionParams): CompactionStrategy;
+/**
+ * Maps a chosen CompactionStrategy to its corresponding lifecycle state.
+ */
+export declare function strategyToState(strategy: CompactionStrategy): CompactionLifecycleState;
+//# sourceMappingURL=lifecycle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/compaction/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AA+BlG;;GAEG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,wBAAwB,EAC9B,EAAE,EAAE,wBAAwB,GAC3B,OAAO,CAET;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,wBAAwB,GAC7B,WAAW,CAAC,wBAAwB,CAAC,CAEvC;AAED,iDAAiD;AACjD,MAAM,MAAM,gBAAgB,GACxB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAE,KAAK,EAAE,wBAAwB,CAAA;CAAE,GAC9C;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,wBAAwB,EACjC,MAAM,EAAE,wBAAwB,GAC/B,gBAAgB,CAQlB;AAMD,gFAAgF;AAChF,wBAAgB,UAAU,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAEnE;AAED,+EAA+E;AAC/E,wBAAgB,YAAY,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAQrE;AAMD,sDAAsD;AACtD,MAAM,WAAW,uBAAuB;IACtC,iCAAiC;IACjC,OAAO,EAAE,iBAAiB,CAAC;IAC3B,6CAA6C;IAC7C,aAAa,EAAE,MAAM,CAAC;IACtB,iCAAiC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,+DAA+D;IAC/D,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,uBAAuB,GAC9B,kBAAkB,CAiBpB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,kBAAkB,GAC3B,wBAAwB,CAW1B"}