@cleocode/runtime 2026.5.130 → 2026.5.132

package/dist/daemon/index.d.ts

@@ -0,0 +1,306 @@
+import { SubsystemDefinition, Subsystem, DaemonLifecycleHooks, HealthStatus, SupervisorIpcRequest, SupervisorIpcResponseEnvelope } from '@cleocode/contracts';
+export { DaemonLifecycleHooks, HealthStatus, Subsystem, SubsystemDefinition, SubsystemHealth, SubsystemLifecyclePhase, SubsystemState } from '@cleocode/contracts';
+
+/**
+ * `defineSubsystem()` — declare a supervised daemon subsystem.
+ *
+ * The single factory R4-R7 adapters call to express a long-running concern
+ * (Studio supervision, GC cron, web server, docs-viewer, runtime poller) as a
+ * uniform {@link Subsystem}. The returned descriptor is frozen so the registry
+ * can drive `start → healthProbe → shutdown` without the definition mutating
+ * underfoot.
+ *
+ * @packageDocumentation
+ * @module @cleocode/runtime/daemon
+ *
+ * @epic T11253 R2 — `@cleocode/runtime/daemon` submodule
+ * @task T11367 — defineSubsystem + lifecycle/health registry + IPC client
+ * @saga T11243 SG-RUNTIME-UNIFICATION
+ */
+
+/**
+ * Declare a daemon subsystem.
+ *
+ * Validates that the four required surfaces (`name`, `start`, `healthProbe`,
+ * `shutdown`) are present and that `name` is a non-empty string, then returns a
+ * frozen {@link Subsystem} ready to register with a `SubsystemRegistry`.
+ *
+ * @typeParam TContext - Opaque context threaded from `start` into `shutdown`
+ *   (e.g. a child handle or resolved config). Defaults to `void`.
+ * @param definition - The subsystem descriptor.
+ * @returns A frozen, registrable {@link Subsystem}.
+ * @throws {TypeError} When `name` is empty or a required method is missing.
+ *
+ * @example
+ * ```ts
+ * const studio = defineSubsystem({
+ *   name: 'studio',
+ *   start: () => supervisor.start(),
+ *   healthProbe: () => ({ child_id: 'studio', pid: supervisor.pid ?? 0,
+ *                         state: supervisor.status === 'running' ? 'running' : 'stopped',
+ *                         restart_count: 0 }),
+ *   shutdown: () => supervisor.stop(),
+ * });
+ * ```
+ */
+declare function defineSubsystem<TContext = void>(definition: SubsystemDefinition<TContext>): Subsystem<TContext>;
+
+/**
+ * Daemon subsystem log-routing primitive.
+ *
+ * `createSubsystemLogger(name)` is the **single** logging surface the
+ * `@cleocode/runtime/daemon` submodule exposes. It routes through the canonical
+ * pino factory `getLogger` (`packages/core/src/logger.ts`) — NOT raw
+ * `createWriteStream` and NOT `console.*` — so every daemon log line lands in
+ * the rotating, retention-managed CLEO log files with a consistent structured
+ * shape and a per-subsystem `subsystem` field.
+ *
+ * It supersedes the **5 ad-hoc logging conventions** the legacy daemons grew,
+ * which R4-R7 will migrate onto this primitive:
+ *
+ * 1. `sentient/daemon.ts` — `createWriteStream(sentient.log)` /
+ *    `createWriteStream(sentient.err)` + `process.stderr.write` lines.
+ * 2. `gc/daemon.ts` — `createWriteStream(gc.log)` / `createWriteStream(gc.err)`.
+ * 3. `web.ts` — `console.*`.
+ * 4. `docs-viewer.ts` — ad-hoc stdout/stderr writes.
+ * 5. the `runtime` services — bespoke per-service logging.
+ *
+ * ## Migration guidance for R4-R7 adapters
+ *
+ * Each adapter (Studio, GC, web, docs-viewer) replaces its bespoke sink with:
+ *
+ * ```ts
+ * import { createSubsystemLogger } from '@cleocode/runtime/daemon';
+ * const log = createSubsystemLogger('studio');
+ * log.info({ pid }, 'Studio started');   // not process.stderr.write(...)
+ * log.error({ err }, 'Studio crashed');  // not createWriteStream('sentient.err')
+ * ```
+ *
+ * Do not import pino directly and do not open file streams — the canonical
+ * factory owns rotation, retention, level, and the `projectHash` correlation
+ * field. Routing through it is what makes the daemon's logs observable via the
+ * same `cleo` log surface as the rest of the system.
+ *
+ * @packageDocumentation
+ * @module @cleocode/runtime/daemon
+ *
+ * @epic T11253 R2 — `@cleocode/runtime/daemon` submodule
+ * @task T11368 — log routing primitive (pino getLogger canonical sink)
+ * @saga T11243 SG-RUNTIME-UNIFICATION
+ */
+/**
+ * A structured log payload — a plain object of serializable fields merged into
+ * the emitted log record (e.g. `{ pid, err }`).
+ */
+type SubsystemLogFields = Record<string, unknown>;
+/**
+ * The narrow logging surface a daemon subsystem uses.
+ *
+ * Each method accepts an optional structured `fields` object followed by the
+ * message, mirroring pino's `(obj, msg)` call shape. This is intentionally
+ * smaller than the full pino `Logger` so the daemon submodule does not leak the
+ * pino type across its public boundary while still routing through the
+ * canonical pino sink.
+ */
+interface SubsystemLogger {
+    /** Log at `debug` level. */
+    debug: (fields: SubsystemLogFields, msg: string) => void;
+    /** Log at `info` level. */
+    info: (fields: SubsystemLogFields, msg: string) => void;
+    /** Log at `warn` level. */
+    warn: (fields: SubsystemLogFields, msg: string) => void;
+    /** Log at `error` level. */
+    error: (fields: SubsystemLogFields, msg: string) => void;
+}
+/**
+ * Create the single per-subsystem logger for the daemon submodule.
+ *
+ * Routes through the canonical pino factory `getLogger('daemon')` and namespaces
+ * the result with a per-subsystem child binding (`{ subsystem: name }`), so all
+ * daemon log lines share the `daemon` subsystem root while remaining
+ * individually attributable. Never opens a file stream and never writes to
+ * `console`.
+ *
+ * @param name - The logical subsystem name (e.g. `'studio'`, `'gc'`, `'web'`).
+ * @returns A {@link SubsystemLogger} bound to `name`.
+ *
+ * @example
+ * ```ts
+ * const log = createSubsystemLogger('studio');
+ * log.info({ pid: 4242, port: 3456 }, 'Studio started');
+ * ```
+ */
+declare function createSubsystemLogger(name: string): SubsystemLogger;
+
+/**
+ * `SubsystemRegistry` — drives the uniform daemon subsystem lifecycle.
+ *
+ * Aggregates {@link Subsystem}s declared via `defineSubsystem` and runs them
+ * through a uniform `start → healthProbe → shutdown` lifecycle, firing the
+ * typed {@link DaemonLifecycleHooks} in order. Health probes are aggregated
+ * into a {@link HealthStatus} that projects onto the FROZEN `supervisor-ipc`
+ * `MonitorResponse` the Rust supervisor consumes (AC4).
+ *
+ * Shutdown runs in reverse registration order (LIFO) so dependants stop before
+ * their dependencies — the conventional supervised-process teardown ordering.
+ *
+ * @packageDocumentation
+ * @module @cleocode/runtime/daemon
+ *
+ * @epic T11253 R2 — `@cleocode/runtime/daemon` submodule
+ * @task T11367 — defineSubsystem + lifecycle/health registry + IPC client
+ * @saga T11243 SG-RUNTIME-UNIFICATION
+ */
+
+/**
+ * The registry that owns and drives the daemon's subsystems.
+ *
+ * Construct with optional {@link DaemonLifecycleHooks}; register subsystems,
+ * then `startAll()` / `aggregateHealth()` / `shutdownAll()`.
+ */
+declare class SubsystemRegistry {
+    #private;
+    /**
+     * @param hooks - Optional lifecycle hooks fired around start/shutdown and on
+     *   any lifecycle error.
+     */
+    constructor(hooks?: DaemonLifecycleHooks);
+    /**
+     * Register a subsystem. Registration order defines start order; shutdown runs
+     * in reverse.
+     *
+     * @typeParam TContext - The subsystem's start→shutdown context type.
+     * @param subsystem - A subsystem produced by `defineSubsystem`.
+     * @throws {Error} When a subsystem with the same `name` is already registered.
+     */
+    register<TContext>(subsystem: Subsystem<TContext>): void;
+    /** The names of all registered subsystems, in registration order. */
+    get names(): readonly string[];
+    /**
+     * Start every registered subsystem in registration order.
+     *
+     * For each subsystem: awaits `start()`, stores the resolved context, then
+     * fires `onStart`. If `start()` throws, fires `onError` with phase `start`
+     * and re-throws — a failed start is surfaced, never swallowed.
+     *
+     * @throws The first subsystem `start()` error (after firing `onError`).
+     */
+    startAll(): Promise<void>;
+    /**
+     * Probe every registered subsystem and aggregate into a {@link HealthStatus}.
+     *
+     * A subsystem whose `healthProbe()` rejects does not abort the aggregate:
+     * `onError` fires with phase `healthProbe` and the subsystem is reported as a
+     * `stopped` row carrying the error in its `detail`, so the supervisor still
+     * receives a complete snapshot.
+     *
+     * @returns The aggregate health snapshot (projects onto `MonitorResponse`).
+     */
+    aggregateHealth(): Promise<HealthStatus>;
+    /**
+     * Shut down every started subsystem in reverse registration order (LIFO).
+     *
+     * Each subsystem's `shutdown(context)` is awaited and `onShutdown` fires. A
+     * throwing `shutdown` fires `onError` with phase `shutdown` but does NOT
+     * abort the teardown of the remaining subsystems — best-effort graceful
+     * shutdown of the whole daemon.
+     */
+    shutdownAll(): Promise<void>;
+}
+
+/**
+ * Typed NDJSON client for the FROZEN `supervisor-ipc` v1.0 contract.
+ *
+ * The Rust `cleo-supervisor` is the server; a CLEO daemon process is a client
+ * that sends {@link SupervisorIpcRequestEnvelope}s and receives
+ * {@link SupervisorIpcResponseEnvelope}s, one newline-delimited JSON
+ * (NDJSON) envelope per line. This module is a transport-agnostic codec: it
+ * encodes outbound envelopes to NDJSON lines and decodes inbound lines through
+ * the frozen Zod schemas. **Every inbound line is parsed** — a malformed or
+ * schema-violating frame is rejected with a typed {@link MalformedIpcFrameError}
+ * and never silently dropped (T11367 AC2).
+ *
+ * The codec does not own a socket — callers feed it raw lines from whatever
+ * transport (Unix socket, named pipe, test pair) they own, keeping the daemon
+ * submodule free of platform IO and trivially testable.
+ *
+ * @packageDocumentation
+ * @module @cleocode/runtime/daemon
+ *
+ * @epic T11253 R2 — `@cleocode/runtime/daemon` submodule
+ * @task T11367 — defineSubsystem + lifecycle/health registry + IPC client
+ * @saga T11243 SG-RUNTIME-UNIFICATION
+ */
+
+/**
+ * A typed error raised when an inbound NDJSON line cannot be decoded into a
+ * valid {@link SupervisorIpcResponseEnvelope}.
+ *
+ * Carries the offending raw `line` and the underlying `cause` (a JSON
+ * `SyntaxError` or a Zod validation error) so callers can log + correlate.
+ * Invalid frames are surfaced as this error — never silently dropped.
+ */
+declare class MalformedIpcFrameError extends Error {
+    /** The raw NDJSON line that failed to decode. */
+    readonly line: string;
+    /**
+     * @param line  - The offending raw NDJSON line.
+     * @param cause - The underlying JSON or Zod error.
+     */
+    constructor(line: string, cause: unknown);
+}
+/**
+ * A transport-agnostic codec for the FROZEN `supervisor-ipc` v1.0 wire format.
+ *
+ * Construct via {@link createSupervisorIpcClient}. The client is stateful only
+ * in its monotonic correlation-id counter; it owns no socket.
+ */
+interface SupervisorIpcClient {
+    /**
+     * Encode a request body into a complete, newline-terminated NDJSON envelope
+     * line ready to write to the transport.
+     *
+     * Stamps the frozen protocol version and a fresh correlation `id`, validates
+     * the result against {@link SupervisorIpcRequestEnvelopeSchema}, and returns
+     * the serialized line (including the trailing `\n`).
+     *
+     * @param request - The request body (validated by the envelope schema).
+     * @returns `{ id, line }` — the correlation id and the NDJSON line to send.
+     */
+    encodeRequest: (request: SupervisorIpcRequest) => {
+        id: string;
+        line: string;
+    };
+    /**
+     * Decode a single inbound NDJSON line into a typed response envelope.
+     *
+     * Parses the line as JSON, then validates it against
+     * {@link SupervisorIpcResponseEnvelopeSchema}. A malformed or
+     * schema-violating line throws {@link MalformedIpcFrameError} — it is never
+     * silently dropped.
+     *
+     * @param line - A single NDJSON line (without the trailing newline).
+     * @returns The decoded {@link SupervisorIpcResponseEnvelope}.
+     * @throws {MalformedIpcFrameError} When the line is not a valid response frame.
+     */
+    decodeResponseLine: (line: string) => SupervisorIpcResponseEnvelope;
+}
+/**
+ * Create a typed NDJSON codec for the FROZEN `supervisor-ipc` v1.0 contract.
+ *
+ * @returns A {@link SupervisorIpcClient}.
+ *
+ * @example
+ * ```ts
+ * const client = createSupervisorIpcClient();
+ * const { id, line } = client.encodeRequest({ kind: 'health' });
+ * socket.write(line);
+ * socket.on('line', (raw) => {
+ *   const env = client.decodeResponseLine(raw); // throws MalformedIpcFrameError on bad frame
+ *   if (env.response.kind === 'health') { /* ... *\/ }
+ * });
+ * ```
+ */
+declare function createSupervisorIpcClient(): SupervisorIpcClient;
+
+export { MalformedIpcFrameError, type SubsystemLogFields, type SubsystemLogger, SubsystemRegistry, type SupervisorIpcClient, createSubsystemLogger, createSupervisorIpcClient, defineSubsystem };

package/dist/daemon/index.js

@@ -0,0 +1,15 @@
+import {
+  MalformedIpcFrameError,
+  SubsystemRegistry,
+  createSubsystemLogger,
+  createSupervisorIpcClient,
+  defineSubsystem
+} from "../chunk-WSQQ5DQL.js";
+export {
+  MalformedIpcFrameError,
+  SubsystemRegistry,
+  createSubsystemLogger,
+  createSupervisorIpcClient,
+  defineSubsystem
+};
+//# sourceMappingURL=index.js.map

package/dist/daemon/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/gateway/http/index.d.ts

@@ -0,0 +1,10 @@
+export { H as HttpServerHandle, a as HttpServerOptions, b as HttpUnaryRequest, c as HttpUnaryResult, S as SSE_HEADERS, d as SseEmitter, e as SseFrame, f as SseSource, g as createSseStream, h as encodeSseFrame, i as encodeStreamEvent, p as parseHttpRoute, r as routeUnary, s as startHttpServer, j as statusForResponse } from '../rpc/index.js';
+import '@cleocode/contracts/gateway';
+import '@cleocode/core/store/background-jobs.js';
+import '@cleocode/contracts';
+import 'node:http';
+import '@cleocode/contracts/operations/orchestrate';
+import '@cleocode/core/internal';
+import '@cleocode/core';
+import '@cleocode/contracts/gateway/rpc';
+import 'node:net';

package/dist/gateway/http/index.js

@@ -0,0 +1,21 @@
+import {
+  SSE_HEADERS,
+  createSseStream,
+  encodeSseFrame,
+  encodeStreamEvent,
+  parseHttpRoute,
+  routeUnary,
+  startHttpServer,
+  statusForResponse
+} from "../../chunk-YZBIPGMH.js";
+export {
+  SSE_HEADERS,
+  createSseStream,
+  encodeSseFrame,
+  encodeStreamEvent,
+  parseHttpRoute,
+  routeUnary,
+  startHttpServer,
+  statusForResponse
+};
+//# sourceMappingURL=index.js.map

package/dist/gateway/http/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/gateway/index.d.ts

@@ -0,0 +1,10 @@
+import '@cleocode/contracts/gateway';
+export { B as BRAIN_DB_FILENAME, C as CLEO_DIR_NAME, DecodeResult, D as Dispatcher, z as DispatcherConfig, E as ErrorMeta, A as GatewayHandler, G as GatewayOperationKey, F as GatewayScope, I as GatewaySubsystemContext, J as GatewaySubsystemOptions, H as HttpServerHandle, a as HttpServerOptions, b as HttpUnaryRequest, c as HttpUnaryResult, LineBuffer, M as MCP_TOOL_PREFIX, k as McpContent, l as McpInputProperty, m as McpServerOptions, n as McpTool, o as McpToolResult, O as OPERATIONS, RpcServerHandle, RpcServerOptions, S as SSE_HEADERS, K as STRING_TO_EXIT, d as SseEmitter, e as SseFrame, f as SseSource, W as WORKFLOWS_SUBDIR, buildErrorFrame, L as buildNexusMetaExtensions, q as buildToolsList, t as callTool, N as cleoErrorToEngineError, P as compose, Q as createDispatchMeta, R as createGatewayHandler, g as createSseStream, decodeLine, T as defineGatewaySubsystem, U as deriveGatewayMatrix, encodeFrame, h as encodeSseFrame, i as encodeStreamEvent, V as engineError, u as exposedOperations, X as formatSuggestedNext, Y as gatewaySubsystemName, Z as generateTemplateConfig, _ as getActiveDomains, $ as getByDomain, a0 as getByGateway, a1 as getByTier, a2 as getCounts, a3 as getGatewayDomains, a4 as getJobManager, a5 as getTemplateForSubcommand, a6 as mapNumericExitCodeToString, v as operationToMcpTool, w as operationToToolName, p as parseHttpRoute, a7 as parseIssueTemplates, a8 as pickDecoratorMetaExtensions, a9 as resolve, routeFrame, r as routeUnary, aa as setJobManager, ab as stampNexusMeta, s as startHttpServer, x as startMcpServer, startRpcServer, j as statusForResponse, y as toolNameToOperationKey, ac as validateLabels, ad as validateRequiredParams, ae as validateSuggestedNext } from './rpc/index.js';
+export { BackgroundJob, BackgroundJobManager, BackgroundJobManagerConfig, BackgroundJobStatus, DurableJobStore } from '@cleocode/core/store/background-jobs.js';
+export { MinimalTaskRecord, OperationDef, Resolution, Session as SessionRecord, TaskRecord } from '@cleocode/contracts';
+export { OrchestratePlanResult } from '@cleocode/contracts/operations/orchestrate';
+export { ArchiveStatsResult as ArchiveStatsData, AuditResult as AuditData, BackupResult as BackupData, BackupEntry as BackupEntryData, CleanupResult as CleanupData, CompactTask, ComplianceData, ContextData, DashboardData, DecisionRecord, DiagnosticsResult as DiagnosticsData, FileRestoreResult, HealthResult as HealthData, HelpData, HookMatrixResult, InjectGenerateResult as InjectGenerateData, IssueTemplate, IvtrHistoryEntry, LabelsResult as LabelsData, LifecycleStageEntry, LogQueryData, SystemMetricsResult as MetricsData, MigrateResult as MigrateData, OrchestratePlanInput, PathsData, PlanWarning, PlanWave, PlanWorkerEntry, ProviderMatrixEntry, ManifestEntry as ResearchManifestEntry, RestoreResult as RestoreData, RuntimeDiagnostics as RuntimeData, SafestopResult as SafestopData, ScaffoldHubData, StatsData, SyncData, TemplateConfig, TemplateSection, UncancelResult as UncancelData, addTaskWithSessionScope, completeTaskStrict, configGet, configListPresets, configSet, configSetPreset, ensureInitialized, filterEntries as filterManifestEntries, getVersion, initProject, isAutoInitEnabled, lifecycleCheck, lifecycleGateFail, lifecycleGatePass, lifecycleGates, lifecycleHistory, lifecyclePrerequisites, lifecycleProgress, lifecycleReset, lifecycleSkip, lifecycleStatus, mapCodebase, memoryBrainStats, memoryContradictions, memoryDecisionFind, memoryDecisionStore, memoryFetch, memoryFind, memoryGraphAdd, memoryGraphContext, memoryGraphNeighbors, memoryGraphRelated, memoryGraphRemove, memoryGraphShow, memoryGraphStatsFull, memoryGraphTrace, memoryLearningFind, memoryLearningStats, memoryLearningStore, memoryLink, memoryObserve, memoryPatternFind, memoryPatternStats, memoryPatternStore, memoryQualityReport, memoryReasonSimilar, memoryReasonWhy, memorySearchHybrid, memoryShow, memorySuperseded, memoryTimeline, memoryUnlink, orchestrateAnalyze, orchestrateBootstrap, orchestrateCheck, orchestrateContext, orchestrateCriticalPath, orchestrateHandoff, orchestrateNext, orchestrateParallelEnd, orchestrateParallelStart, orchestratePlan, orchestrateReady, orchestrateReport, orchestrateSkillInject, orchestrateSpawn, orchestrateSpawnExecute, orchestrateStartup, orchestrateStatus, orchestrateUnblockOpportunities, orchestrateValidate, orchestrateWaves, phaseAdvance, phaseComplete, phaseDelete, phaseList, phaseRename, phaseSet, phaseShow, phaseStart, pipelineManifestAppend, pipelineManifestArchive, pipelineManifestFind, pipelineManifestList, pipelineManifestPending, pipelineManifestShow, pipelineManifestStats, queryCommonHooks, queryHookProviders, readManifestEntries, releaseCancel, releaseCommit, releaseGateCheck, releaseGatesRun, releaseIvtrAutoSuggest, releaseList, releaseOpen, releasePlan, releasePrStatus, releasePrepare, releasePush, releaseReconcileV2, releaseRollback, releaseRollbackFull, releaseShow, releaseTag, sessionAdopt, sessionArchive, sessionBriefing, sessionChainShow, sessionCleanup, sessionComputeDebrief, sessionComputeHandoff, sessionContextDrift, sessionContextInject, sessionDebriefShow, sessionDecisionLog, sessionEnd, sessionFind, sessionGc, sessionHandoff, sessionHistory, sessionList, sessionRecordAssumption, sessionRecordDecision, sessionResume, sessionShow, sessionStart, sessionStats, sessionStatus, sessionSuspend, sessionSwitch, systemHooksMatrix, taskAnalyze, taskArchive, taskBatchValidate, taskBlockers, taskCancel, taskClaim, taskComplete, taskComplexityEstimate, taskCurrentGet, taskDelete, taskDepends, taskDeps, taskDepsCycles, taskDepsOverview, taskDepsTree, taskDepsValidate, taskExists, taskExport, taskFind, taskHistory, taskImpact, taskImport, taskLabelList, taskLabelShow, taskLint, taskList, taskNext, taskPlan, taskPromote, taskRelates, taskRelatesAdd, taskRelatesAddBatch, taskRelatesFind, taskRelatesRemove, taskReopen, taskReorder, taskReparent, taskRestore, taskShow, taskShowIvtrHistory, taskShowOperation, taskShowWithHistory, taskSlice, taskStart, taskStats, taskStop, taskSyncLinks, taskSyncLinksRemove, taskSyncReconcile, taskTree, taskUnarchive, taskUnclaim, taskUpdate, taskWorkHistory, tasksAddBatchOp, coreBatchValidate as validateBatchValidate, validateChangelog, coreCoherenceCheck as validateCoherenceCheck, coreComplianceRecord as validateComplianceRecord, coreComplianceSummary as validateComplianceSummary, coreComplianceViolations as validateComplianceViolations, validateGateVerify, coreValidateManifest as validateManifestOp, coreValidateOutput as validateOutput, coreValidateProtocol as validateProtocol, validateProtocolArchitectureDecision, validateProtocolArtifactPublish, validateProtocolConsensus, validateProtocolContribution, validateProtocolDecomposition, validateProtocolImplementation, validateProtocolProvenance, validateProtocolRelease, validateProtocolResearch, validateProtocolSpecification, validateProtocolTesting, validateProtocolValidation, coreValidateSchema as validateSchemaOp, coreValidateTask as validateTaskOp, coreTestCoverage as validateTestCoverage, coreTestRun as validateTestRun, coreTestStatus as validateTestStatus } from '@cleocode/core/internal';
+export { EngineResult, engineSuccess } from '@cleocode/core';
+import 'node:http';
+import '@cleocode/contracts/gateway/rpc';
+import 'node:net';