@sema-agent/server 2.0.0 → 2.0.1

package/dist/boot/session-faces.js

@@ -0,0 +1,157 @@
+/**
+ * design/158 A10:composition root 分段 —— session 只读/删除面(审计、watch 注册表、E21 purge 协调器、
+ * degenerate 仪表、plan-cache 探针)。
+ *
+ * 纯搬运:函数体逐字来自 `main.ts`(原 2967-3092 行),缩进不变;新增的只有 import 与包壳。
+ *
+ * ⚠️ **位置即契约**:
+ *  1. `sessionWatchRegistry` 必须在 `purgeSession` **之前**构造 —— purge 尾部的 `dropSession` 是
+ *     同副本租户轮转围栏(delete 即终结旧 owner 的 SSE 订阅),两者是一对。
+ *  2. `setLeafAdvanceListener(...)` 是**进程级单点**装载(leaf-bus 只有一个监听位),必须与
+ *     registry 的构造同段发生,晚于它、早于任何会 append 的路由。
+ */
+import { buildSessionAudit, buildSessionAuditLocal, buildSessionAuditPg } from "../audit.js";
+import { makeDegenerateInstrument } from "../degenerate-instrument.js";
+import { PlanCacheProbe } from "../plan-cache-probe.js";
+import { purgeScratchpadDir } from "../env-facts.js";
+import { setLeafAdvanceListener } from "../session-leaf-bus.js";
+import { SessionWatchRegistry, posIntEnv } from "../session-watch.js";
+import { defaultTaskRegistry } from "@sema-agent/core";
+export function createSessionFaces(ctx) {
+    const { config, logger, metrics, localRoot, backend, sessionStore, runStore, checkpointStore, toolResultStore, resumeAnchorStore, approvalExemptionStore, sessionPolicyStore, taskAttachmentStore, fileSnapshotStore, workflowCompletionInbox, } = ctx;
+    // Audit回溯 + degenerate-output instrument are TiDB-specific raw-SQL consumers (outside the store
+    // abstraction); they run only on the TiDB backend (the mysql2 pool), and are a no-op on PG until ported.
+    const mysqlPool = backend?.mysqlPool();
+    const auditPgPool = backend?.pgPool(); // the audit face now has a PG twin — web session area lights up on DB_BACKEND=pg
+    const auditLocalRoot = backend?.kind === "local" ? (config.localDataRoot ?? localRoot) : undefined; // the File leg
+    const ownerAware = sessionStore;
+    const sessionAudit = mysqlPool || auditPgPool || auditLocalRoot
+        ? async (sessionId) => {
+            const audit = mysqlPool
+                ? await buildSessionAudit(mysqlPool, sessionId)
+                : auditPgPool
+                    ? await buildSessionAuditPg(auditPgPool, sessionId)
+                    : await buildSessionAuditLocal(auditLocalRoot, sessionId);
+            if (!audit)
+                return undefined;
+            return { ...audit, owner: (await ownerAware.ownerOf?.(sessionId)) ?? null };
+        }
+        : undefined;
+    // §0.5 E21 — DELETE /v1/sessions/:id purge coordinator. Deletes the session abstraction's CONVERSATION HISTORY
+    // (sessionStorage.deleteSession → session_meta/session_event) PLUS the service-owned operational rows for that
+    // session: the runs ledger (runStore.deleteBySession → task_run/task_active/task_event, owner-guarded), the
+    // durable checkpoints + resume-ctx (checkpointStore.deleteBySession, present only under DURABLE_APPROVAL), and
+    // offloaded tool results (toolResultStore.deleteBySession). Wired only when the session store can actually
+    // delete (a DB backend).
+    //
+    // 🔴 ORDERING (adversarial-review HIGH — privacy/right-to-delete + silent-success): the session HISTORY delete
+    // (session_meta) is the `ownerOf` gate the DELETE route consults to decide idempotency. It MUST be the LAST
+    // committed leg. If a privacy-relevant child leg (runs/checkpoint/tool-result) is deleted AFTER the meta row is
+    // gone and then FAILS, the idempotent retry sees `ownerOf===undefined` (history already gone) → the route
+    // short-circuits to 200 {deleted:false} and NEVER re-purges → those child rows are stranded while the API
+    // reports success. So we purge the child legs FIRST and PROPAGATE any error (do NOT swallow): on a child
+    // failure the history delete is SKIPPED, `session_meta` survives, the DELETE returns 500, and the idempotent
+    // retry's `ownerOf` still resolves → it re-runs the FULL purge to convergence. `deleted` is computed from the
+    // FINAL committed result (history-deleted || runsRemoved>0 — the privacy-relevant data that actually existed).
+    // [1196] session-watch registry(SSE 订阅共享探针面)。谓词与 /head 探针同门(getLeafId+ownerOf);
+    // env 旋钮经 posIntEnv 有界校验;getLeafId 箭头包一层=天然绑定宿主(SESSION_CACHE_TTL_SEC=0 裸类实例)。
+    const sessionWatchRegistry = ownerAware.getHead && ownerAware.ownerOf
+        ? new SessionWatchRegistry(async (sid) => (await ownerAware.getHead(sid)) ?? { owner: undefined, leafId: null }, {
+            hotMs: posIntEnv(process.env.SESSION_EVENTS_HOT_MS, 200),
+            warmMs: posIntEnv(process.env.SESSION_EVENTS_WARM_MS, 2000),
+            maxWatchedSessions: posIntEnv(process.env.SESSION_EVENTS_MAX_PROBES, 512, 100_000),
+        })
+        : undefined;
+    // S2 fast path([1208]③ 兑现):同副本 append 落点(tidb/pg persist post-commit)经 leaf-bus 直推
+    // notifyLocal——单副本部署零延迟;owner 不随 bus 传(写点无廉价 owner 读),探针围栏仍是租户权威
+    // (session-leaf-bus 契约注)。local lane 无写钩,探针道照旧。
+    setLeafAdvanceListener(sessionWatchRegistry ? (sid, leaf, owner, seq) => sessionWatchRegistry.notifyLocal(sid, leaf, owner, seq) : undefined);
+    const purgeSession = ownerAware.deleteSession
+        ? async (sessionId, owner) => {
+            // Runs-ledger FIRST: it transactionally re-asserts the no-active-run invariant (FOR UPDATE on task_active,
+            // serializing against a concurrent createRun). If a run claimed the session in the route's check→purge
+            // window it returns `{ active }` and deletes nothing → we bubble it up so the route 409s, BEFORE touching
+            // any other table (no partial purge of a live session). Each leg propagates its error so a child failure
+            // aborts the purge BEFORE the history-delete gate is removed (keeping the idempotent retry convergent).
+            const runs = runStore ? await runStore.deleteBySession(sessionId, owner) : { removed: 0 };
+            if ("active" in runs)
+                return { active: runs.active };
+            // checkpoint rows carry no owner column → owner-guarded via a session_meta.owner sub-select, so they MUST
+            // run while session_meta still exists (before the history delete below); tool_result is keyed only by
+            // `ref` so it stays route-guarded (see its deleteBySession doc).
+            if (checkpointStore)
+                await checkpointStore.deleteBySession(sessionId, owner);
+            if (toolResultStore)
+                await toolResultStore.deleteBySession?.(sessionId); // optional extra: SQL twins only (local file store has no per-session purge index; E21 purge is a durable-backend contract)
+            // E18 resume-at anchors are per-session privacy-relevant metadata → purge ALL of them with the session, scoped
+            // by session_id ALONE (the route already proved session ownership at the DELETE gate). A per-ROW owner guard
+            // here would LEAK: an anchor's owner is the per-run submitting principal, which diverges from the canonical
+            // session owner when an anonymous session is later attached by a principal (REQUIRE_PRINCIPAL=false) — those
+            // mixed-owner rows would survive the delete (a right-to-delete violation reported as success).
+            if (resumeAnchorStore)
+                await resumeAnchorStore.deleteBySession(sessionId);
+            // Approval exemptions are per-session operator decisions → purge with the session (same
+            // session_id-alone scoping rationale as the anchors above).
+            if (approvalExemptionStore)
+                await approvalExemptionStore.deleteBySession(sessionId);
+            // E6 session-policy rows are per-session operator rules → purge them too, scoped by session_id (the route
+            // owner-gated the session). Since core 1.423 the seam is on the INTERFACE (optional) and core's File/InMemory
+            // stores carry it too — so this fires on EVERY backend now. (The old note here claimed local rules were
+            // "process-ephemeral anyway" — false for the file-backed local store, whose policy rows survive restarts;
+            // that right-to-delete hole is what [1796]§三 → core 1.423 closed.)
+            if (sessionPolicyStore?.deleteBySession)
+                await sessionPolicyStore.deleteBySession(sessionId);
+            // D-1 附件随会话删(E21 级联;session_id 单键 scoping,与 anchors 同理由——路由已证会话所有权)。
+            if (taskAttachmentStore)
+                await taskAttachmentStore.deleteBySession(sessionId);
+            // E19 rewind-files snapshots are per-session working-tree state → purge them too (scoped by sessionId; the
+            // durable twins carry deleteBySession, local InMemory omits it → optional no-op on local).
+            if (fileSnapshotStore?.deleteBySession)
+                await fileSnapshotStore.deleteBySession(sessionId);
+            // P1 ①②: drop any pending async-workflow completions for this session (else they orphan when a later
+            // tenant reclaims the sessionId). Best-effort + non-fatal — a leftover entry is ALSO gated by the
+            // drain-time owner check, so a purge failure never leaks; it must not abort the session delete.
+            // `owner` scopes the purge fence (1.80): only the DELETED session's own late completions are fenced —
+            // a new tenant legitimately re-claiming this sessionId within the window keeps its push (review MED).
+            if (workflowCompletionInbox)
+                await workflowCompletionInbox.purge(sessionId, owner ?? null).catch((err) => logger.warn("workflow_completion_inbox_purge_failed", { sessionId, err: String(err) }));
+            // 修8(三路复审 absorb-2,接线 (a)):the session's scratchpad dir ([820]③, ensureScratchpadDir) rides
+            // the session lifecycle — purge it with the session. purgeScratchpadDir SELF-SWALLOWS (env-facts.ts
+            // contract: cleanup never faults the delete path; the periodic sweep below is the convergence backstop),
+            // so it cannot strand the E21 ordering invariant. Same root the ensure used (config.localDataRoot ?? localRoot).
+            await purgeScratchpadDir(config.localDataRoot ?? localRoot, sessionId);
+            // design/129 (core 1.239): reap this session's SESSION-scoped background children — they
+            // deliberately outlive turns (backgroundScope:"session"), so the session's DELETE is their lifecycle
+            // end (core's parent-teardown reap skips them by design; without this they run to their forced timeout).
+            // Sync + replica-local (the registry is in-process); best-effort — a reap of 0 on the wrong replica is
+            // covered by core's forced child-timeout cap.
+            // [1892]{core} 跨仓待办:scope 轴必传——core canAccess 对缺省 scope fail-closed(拒绝非通配,
+            // 1.441 复审①正过极性),不传 = 四类后台任务在会话删除时恒 0 回收(潜伏至今,core 复审顺手
+            // 核出)。铸值同源 runs.ts:25 契约:core 按 `spec.principal ?? "default"` 注册 ⇒ 此处
+            // owner(会话主)?? "default" 对齐;错 scope 不越租户由 canAccess 保证(session-reap-scope 钉)。
+            try {
+                const reaped = defaultTaskRegistry.reapSessionBackground(sessionId, owner ?? "default");
+                if (reaped > 0)
+                    logger.info("session_background_reaped", { sessionId, reaped });
+            }
+            catch (err) {
+                logger.warn("session_background_reap_failed", { sessionId, err: String(err) });
+            }
+            // History/meta LAST: once committed, the `ownerOf` gate is gone and the delete is durably complete. The
+            // owner is threaded into the SQL guard (session_meta.owner) for data-layer defense-in-depth.
+            const historyDeleted = await ownerAware.deleteSession(sessionId, owner);
+            // [1196] 三轮复审(租户轮转围栏,同副本半场):session 删除即终结其 SSE 订阅者+watch 条目——
+            // 旧 owner 的活流不得跨越 delete/reclaim 边界收新租户的 head;跨副本半场=路由心跳期 owner 复核。
+            sessionWatchRegistry?.dropSession(sessionId);
+            return { deleted: historyDeleted || runs.removed > 0 };
+        }
+        : undefined;
+    // Degenerate-output a/b instrument: needs the durable session log to inspect turn history (design/39
+    // ② gating data). Only on the TiDB backend (mysql2 pool); env-only / PG deploys get no-op.
+    const instrumentDegenerate = mysqlPool ? makeDegenerateInstrument(mysqlPool, metrics, logger) : undefined;
+    // Plan-cache recurrence probe (core design/42, INSTRUMENT-FIRST): pure in-memory, no backend needed —
+    // counts per-scope task-objective recurrence so core can decide whether to build plan caching.
+    const planCacheProbe = new PlanCacheProbe(metrics, logger);
+    return { ownerAware, sessionAudit, sessionWatchRegistry, purgeSession, instrumentDegenerate, planCacheProbe };
+}
+//# sourceMappingURL=session-faces.js.map

package/dist/boot/shutdown.d.ts

@@ -0,0 +1,50 @@
+/**
+ * design/158 A10:composition root 分段 —— 进程收尾(hardShutdown / drain / 三个信号处理器)。
+ *
+ * 纯搬运:函数体逐字来自 `main.ts`(原 4385-4488 行),缩进不变;新增的只有 import 与
+ * `installShutdownHandlers(ctx)` 包壳。
+ *
+ * ⚠️ **位置即契约**(搬运不得改次序):
+ *  1. 本段必须在 `server.listen()` **之后**调用 —— `process.on("SIGTERM"|"SIGINT"|"SIGHUP")` 的注册
+ *     时点即"从此刻起信号可被优雅处理";提前注册会让一个尚未 listen 的进程走 drain 分支。
+ *  2. 三个 `process.on` 的**相对次序**保持 SIGTERM → SIGINT → SIGHUP(与原文件逐字一致);
+ *     它们互不覆盖,但 handler 之间共享 `closing`/`draining` 两个 latch,次序变化会改变
+ *     "第二个信号"的语义读数。
+ *  3. `clearInterval(reaper)` 必须是 hardShutdown 的第一件事(在 `server.close()` 之前),否则
+ *     收尾期还会有 reaper tick 打向正在关闭的池。
+ */
+import { Runner, type RunnerDeps } from "@sema-agent/core";
+import type { ServiceConfig } from "../config.js";
+import type { createHttpServer } from "../http/server.js";
+import type { Logger } from "../observability/logger.js";
+import type { startOtlpExporter } from "../observability/otel-exporter.js";
+import type { CostQuota } from "../observability/cost-quota.js";
+import type { RateLimiter } from "../observability/rate-limit.js";
+import type { startFleetClientFromEnv } from "../fleet-client.js";
+import type { BreakerStateStore, CostQuotaStore, RateLimiterStore, StoreBackend } from "../plugins/store-backend.js";
+import type { WorkflowNotifyJournalStore } from "../orchestration/workflow-notify-journal.js";
+export interface ShutdownCtx {
+    config: ServiceConfig;
+    logger: Logger;
+    server: ReturnType<typeof createHttpServer>;
+    reaper: NodeJS.Timeout;
+    otelExporter: ReturnType<typeof startOtlpExporter> | undefined;
+    breakerState: ReturnType<BreakerStateStore["startRefresh"]> | undefined;
+    costQuota: CostQuota | CostQuotaStore | undefined;
+    rateLimiter: RateLimiter | RateLimiterStore | undefined;
+    runner: Runner;
+    subRunner: Runner;
+    lspManager: RunnerDeps["lspManager"];
+    workflowNotifyJournal: WorkflowNotifyJournalStore | undefined;
+    fleetClient: ReturnType<typeof startFleetClientFromEnv>;
+    backend: StoreBackend | undefined;
+    drainState: {
+        draining: boolean;
+        since?: number;
+        inflight?: () => number;
+        lastActivityAt?: () => number;
+    };
+}
+/** 注册 SIGTERM/SIGINT/SIGHUP 收尾链。**必须在 listen 之后调用**(见文件头「位置即契约」)。 */
+export declare function installShutdownHandlers(ctx: ShutdownCtx): void;
+//# sourceMappingURL=shutdown.d.ts.map

package/dist/boot/shutdown.js

@@ -0,0 +1,129 @@
+/**
+ * design/158 A10:composition root 分段 —— 进程收尾(hardShutdown / drain / 三个信号处理器)。
+ *
+ * 纯搬运:函数体逐字来自 `main.ts`(原 4385-4488 行),缩进不变;新增的只有 import 与
+ * `installShutdownHandlers(ctx)` 包壳。
+ *
+ * ⚠️ **位置即契约**(搬运不得改次序):
+ *  1. 本段必须在 `server.listen()` **之后**调用 —— `process.on("SIGTERM"|"SIGINT"|"SIGHUP")` 的注册
+ *     时点即"从此刻起信号可被优雅处理";提前注册会让一个尚未 listen 的进程走 drain 分支。
+ *  2. 三个 `process.on` 的**相对次序**保持 SIGTERM → SIGINT → SIGHUP(与原文件逐字一致);
+ *     它们互不覆盖,但 handler 之间共享 `closing`/`draining` 两个 latch,次序变化会改变
+ *     "第二个信号"的语义读数。
+ *  3. `clearInterval(reaper)` 必须是 hardShutdown 的第一件事(在 `server.close()` 之前),否则
+ *     收尾期还会有 reaper tick 打向正在关闭的池。
+ */
+import { Runner, defaultTaskRegistry } from "@sema-agent/core";
+import { createSighupIdleHandler } from "../sighup-idle.js";
+/** 注册 SIGTERM/SIGINT/SIGHUP 收尾链。**必须在 listen 之后调用**(见文件头「位置即契约」)。 */
+export function installShutdownHandlers(ctx) {
+    const { config, logger, server, reaper, otelExporter, breakerState, costQuota, rateLimiter, runner, subRunner, lspManager, workflowNotifyJournal, fleetClient, backend, drainState, } = ctx;
+    let closing = false;
+    const hardShutdown = () => {
+        if (closing)
+            return;
+        closing = true;
+        clearInterval(reaper);
+        otelExporter?.stop();
+        breakerState?.stop();
+        if (costQuota && "stop" in costQuota)
+            costQuota.stop(); // the DB-backed quota/limiter (TiDB|PG) have a refresh loop to stop; the in-memory ones don't
+        if (rateLimiter && "stop" in rateLimiter)
+            rateLimiter.stop();
+        runner.sessions.dispose();
+        subRunner.sessions.dispose();
+        // TOC local LSP: NodeLspManager holds LOCAL child-process language servers — kill them on shutdown so a
+        // restart doesn't orphan a fleet of stdio servers. dispose() isn't on the LspServerManager interface (only the
+        // concrete managers have it), so probe it; the e2b/k8s bridge manager is a harmless no-op if it lacks one.
+        void lspManager?.dispose?.();
+        // SVC-1: release the File journal's append handle; the SQL twins hold no fd (probe — close isn't on the seam).
+        void workflowNotifyJournal?.close?.();
+        // core 1.270.1:hardShutdown 终点(drain 已完,in-flight 不再被破坏)全量收割 session 驻留
+        // bg bash(detached 进程组,引擎死后 reparent PID 1 残留=实测;retain-declared 例外在原语内)。
+        // TOB 容器形态同样调=无害且显式;SIGKILL 路径无钩=已知不可救记档。
+        try {
+            const reaped = defaultTaskRegistry.reapAllSessionBackground();
+            if (reaped > 0)
+                logger.info("shutdown_background_reaped", { reaped });
+        }
+        catch (err) {
+            logger.warn("shutdown_background_reap_failed", { err: String(err) });
+        }
+        void fleetClient?.stop(); // stop heartbeat + flush final usage window + best-effort DELETE deregistration
+        server.close(() => {
+            void (backend ? backend.close() : Promise.resolve()).finally(() => process.exit(0));
+        });
+        // 对抗复查 B-4(HIGH):the exit above only fires after backend.close() SETTLES — a wedged pool teardown
+        // (dead DB, hung socket) kept the "force-terminated" process alive indefinitely (the 10s closeAllConnections
+        // below unblocks server.close(), but nothing bounded backend.close). FINAL deadline: whatever is still
+        // holding after 15s, exit anyway (durable state is already flushed by then — checkpoint/terminal writes
+        // happen before hardShutdown; the pool teardown is best-effort cleanup, not correctness).
+        const finalExit = setTimeout(() => { logger.warn("hard_shutdown_final_deadline", { afterMs: 15_000 }); process.exit(0); }, 15_000);
+        finalExit.unref?.();
+        // `server.close()` waits for every connection to end — an open SSE stream (/v1/tasks/stream, /events) would
+        // otherwise block it forever, so pool.end()/exit never run and the process hangs until SIGKILL. Drop idle
+        // keep-alives now, then force-terminate any lingering connections after a grace period so `close()` can
+        // resolve and shutdown completes. The timer is unref'd but still fires while the server holds connections.
+        server.closeIdleConnections?.();
+        const forceClose = setTimeout(() => server.closeAllConnections?.(), 10_000);
+        forceClose.unref?.();
+    };
+    // SIGTERM = graceful DRAIN — flip `draining` (new billable submits 503+Retry-After, /health carries
+    // draining:true for readiness摘流), then wait for this instance's in-flight legs (live streams + bg/resume) to
+    // finish before the hard shutdown. Bounded by DRAIN_GRACE_MS (default 10min — an interactive turn is minutes;
+    // the previous behavior was a 10s hard-cut that killed long turns). A SECOND SIGTERM or SIGINT (dev Ctrl-C)
+    // skips the wait — k8s sends SIGKILL after terminationGracePeriodSeconds regardless, so the escape hatch is free.
+    let draining = false;
+    const drainThenShutdown = () => {
+        if (closing)
+            return;
+        if (draining) {
+            logger.info("drain_second_signal_hard_stop", {});
+            hardShutdown();
+            return;
+        }
+        draining = true;
+        drainState.draining = true;
+        drainState.since = Date.now();
+        void fleetClient?.announceNow(); // draining 翻转即刻再 announce — 第一时间自摘流,比任何观测都快
+        const inflight = drainState.inflight?.() ?? 0;
+        logger.info("draining_started", { inflight, graceMs: config.drainGraceMs });
+        if (inflight === 0) {
+            hardShutdown();
+            return;
+        }
+        // 修3(三路复审 B3-2 时钟):drain elapsed/截止计算走 performance.now() 单调域(挂钟跳变不得吞掉/拉长
+        // drainGraceMs 窗);对外报告的 drainState.since(/health drainingSince)保留 epoch(Date.now)。
+        const t0 = performance.now();
+        // NOT unref'd on purpose — this timer IS the shutdown driver (the open connections keep the loop alive anyway).
+        const tick = setInterval(() => {
+            const n = drainState.inflight?.() ?? 0;
+            const elapsed = Math.round(performance.now() - t0);
+            if (n === 0 || elapsed >= config.drainGraceMs) {
+                clearInterval(tick);
+                logger.info("drain_complete", { inflight: n, elapsedMs: elapsed, timedOut: n > 0 });
+                hardShutdown();
+            }
+        }, 1_000);
+    };
+    process.on("SIGTERM", drainThenShutdown);
+    process.on("SIGINT", hardShutdown);
+    // SIGHUP(壳窗口关闭把信号打到整个进程组)≠「没人在用这只引擎」:共享引擎形态(同 config 多壳会话,
+    // 引擎按 T11 防孤儿拍骑在首壳进程组里)下 peer 会话还活着——无条件 drain 会把 peer mid-turn 斩掉(499)
+    // 且窗内新提交 503(B3,壳侧 [771]② 取证)。改 hup-pending 空闲窗:不翻 draining(peer 零感知),
+    // inflight()(bg/resume legs + live streams)连续 sighupIdleGraceMs 为 0 才 hardShutdown,任何在飞 leg
+    // 重置窗口。真孤儿(最后一窗关掉)有界自灭=T11 保留;第二个 SIGHUP 升级走既有 drain 路径(硬梯子)。
+    // session 驻留 bash 的全量收割仍挂 hardShutdown 终点(reapAllSessionBackground)。
+    process.on("SIGHUP", createSighupIdleHandler({
+        inflight: () => drainState.inflight?.() ?? 0,
+        // ⚠️ 时基契约(三路复审修3):lastActivityAt 由 server.ts 以 performance.now() 单调域打点,与
+        // sighup-idle.ts 内部的 `now` seam(缺省 performance.now)同域——不得混入 Date.now 值。
+        lastActivityAt: () => drainState.lastActivityAt?.() ?? 0,
+        isStopped: () => closing || draining,
+        escalate: drainThenShutdown,
+        shutdown: hardShutdown,
+        idleGraceMs: config.sighupIdleGraceMs,
+        log: (event, fields) => logger.info(event, fields),
+    }));
+}
+//# sourceMappingURL=shutdown.js.map

package/dist/boot/stores.d.ts

@@ -0,0 +1,32 @@
+import { type MemoryBackend } from "@sema-agent/core";
+import type { ServiceConfig } from "../config.js";
+import { type MemorySyncRunner } from "../memory-sync-client.js";
+import type { Logger } from "../observability/logger.js";
+import type { Metrics } from "../observability/metrics.js";
+import { type MemorySyncStore } from "../plugins/memory-sync-store-pg.js";
+import { type TaskAttachmentStore } from "../plugins/task-attachment-store.js";
+import { type StoreBackend } from "../plugins/store-backend.js";
+export interface OpenStoresCtx {
+    config: ServiceConfig;
+    logger: Logger;
+    metrics: Metrics;
+    localRoot: string;
+}
+export declare function openStores(ctx: OpenStoresCtx): Promise<{
+    backend: StoreBackend | undefined;
+    storeBackendDegraded: boolean;
+    memoryEngine: {
+        backend: MemoryBackend;
+        root: string;
+    } | undefined;
+    memorySyncCursors: MemorySyncStore | undefined;
+    rosterStore: import("@sema-agent/core").RosterStore | undefined;
+    backgroundAgentStore: import("@sema-agent/core").BackgroundAgentStore | undefined;
+    taskAttachmentStore: TaskAttachmentStore | undefined;
+    mailboxStore: import("@sema-agent/core").MailboxStore | undefined;
+    memoryExportBackend: MemoryBackend | undefined;
+    memorySyncRunner: MemorySyncRunner | undefined;
+    sessionStore: import("@sema-agent/core").SessionStore;
+    breakerState: import("../plugins/breaker-state-sql.js").TiDBBreakerState | import("../plugins/breaker-state-sql.js").PgBreakerState | undefined;
+}>;
+//# sourceMappingURL=stores.d.ts.map