@capybara-hq/kernel 0.1.0-rc.1 → 0.1.0-rc.10

package/dist/conversations/environment-status.d.ts

@@ -0,0 +1,24 @@
+import { EnvironmentsService, type EnvironmentView } from "../environments/environments.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { ConversationAccess } from "./access.js";
+import { ConversationsService } from "./conversations.service.js";
+/**
+ * The environment a conversation works in, for its page (environments spec §9: shown read only):
+ * a conversation the viewer may not see → `conversation.not_found`. A sub-agent shows its root
+ * conversation's environment. Null while the conversation is unbound, or when its environment is
+ * deleted or no longer its owner's (its sandbox tools then fail).
+ */
+export declare class ConversationEnvironmentStatus {
+    /** Who may see the conversation (the rule of its event stream). */
+    private readonly access;
+    /** The conversation whose environment it works in: a sub-agent's root, else itself. */
+    private readonly conversations;
+    private readonly environments;
+    private readonly db;
+    constructor(
+    /** Who may see the conversation (the rule of its event stream). */
+    access: Pick<ConversationAccess, "isAccessible">, 
+    /** The conversation whose environment it works in: a sub-agent's root, else itself. */
+    conversations: Pick<ConversationsService, "sandboxConversationOf">, environments: Pick<EnvironmentsService, "get">, db: KernelDb);
+    get(orgId: string, conversationId: string, viewerAccountId: string): Promise<EnvironmentView | null>;
+}

package/dist/conversations/environment-status.js

@@ -0,0 +1,71 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { EnvironmentsService } from "../environments/environments.service.js";
+import { ApiError } from "../errors.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { UUID_RE } from "../ui/registry.js";
+import { ConversationAccess } from "./access.js";
+import { ConversationsService } from "./conversations.service.js";
+/**
+ * The environment a conversation works in, for its page (environments spec §9: shown read only):
+ * a conversation the viewer may not see → `conversation.not_found`. A sub-agent shows its root
+ * conversation's environment. Null while the conversation is unbound, or when its environment is
+ * deleted or no longer its owner's (its sandbox tools then fail).
+ */
+let ConversationEnvironmentStatus = class ConversationEnvironmentStatus {
+    access;
+    conversations;
+    environments;
+    db;
+    constructor(
+    /** Who may see the conversation (the rule of its event stream). */
+    access, 
+    /** The conversation whose environment it works in: a sub-agent's root, else itself. */
+    conversations, environments, db) {
+        this.access = access;
+        this.conversations = conversations;
+        this.environments = environments;
+        this.db = db;
+    }
+    async get(orgId, conversationId, viewerAccountId) {
+        if (!UUID_RE.test(conversationId) ||
+            !(await this.access.isAccessible(orgId, conversationId, viewerAccountId))) {
+            throw new ApiError("conversation.not_found", "Conversation not found");
+        }
+        // a sub-agent works in its root conversation's environment (at every depth)
+        const root = await this.conversations.sandboxConversationOf(orgId, conversationId);
+        const conv = await this.db
+            .selectFrom("conversations")
+            .select(["account_id", "environment_id"])
+            .where("id", "=", root)
+            .where("org_id", "=", orgId)
+            .executeTakeFirst();
+        if (!conv?.environment_id)
+            return null;
+        try {
+            // the environment as its owner sees it (only the owner may use a personal environment)
+            return await this.environments.get(orgId, conv.account_id, conv.environment_id);
+        }
+        catch (e) {
+            if (e instanceof ApiError && e.code === "environment.not_found")
+                return null;
+            throw e;
+        }
+    }
+};
+ConversationEnvironmentStatus = __decorate([
+    Injectable(),
+    __param(0, Inject(ConversationAccess)),
+    __param(1, Inject(ConversationsService)),
+    __param(2, Inject(EnvironmentsService)),
+    __param(3, Inject(KernelDb))
+], ConversationEnvironmentStatus);
+export { ConversationEnvironmentStatus };

package/dist/conversations/event-log.d.ts

@@ -1,8 +1,8 @@
-import type { Logger } from "@capybara-hq/plugin-sdk";
-import { type Transaction } from "kysely";
-import type { KernelDatabase, KernelDb } from "../db/kernel-schema.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { KernelEvents } from "../infra/events/kernel-events.js";
+import type { KernelLogger } from "../log.js";
 import { type ConversationEvent, type ConversationEventType } from "./events.js";
-type Trx = Transaction<KernelDatabase>;
 /** 事件日志依赖的总线：内核 bus（命名空间 `kernel`）。 */
 export interface EventBus {
     publish(topic: string, payload: unknown): Promise<void>;
@@ -28,13 +28,16 @@ export declare const conversationTopic: (conversationId: string) => string;
  * 会话频道上的总线消息：
  * - `events`：会话日志已推进到 `toSeq`（订阅方据此 `readAfter` 补读，消息本身不携带事件）；
  * - `delta`：运行的流式增量（文本 / 思考 / `step_reset`：丢弃该步此前推出的增量），只是草稿，
- *   最终内容以日志中的 assistant_message 为准。`offset`（仅 text）：本步本次尝试中此前已推出的文本字符数，
- *   中途才订阅的一方据此判断自己是否从头收到了该步的文本（渠道出站投递只在完整时发草稿）；
+ *   最终内容以日志中的 assistant_message 为准。`offset` (text and thinking): the characters of
+ *   that channel this attempt of the step streamed before the delta; a subscriber that joined midway
+ *   tells by it whether it has the step's text from the start (the channel outbound only drafts
+ *   complete text) and drops what a live draft already covers (spec 2026-11-07 §3.2);
  * - `ui`：插件经 `ctx.ui.invalidate` 告知这个会话的某个界面贡献变了（不进日志、不是模型可见内容），
  *   SSE 转发为 `event: ui`，网页据此重新取视图。
- * - `subagent_progress`: after each step of a sub-agent run, on its **parent's** topic (sub-agents
- *   spec §14.2): the child's step and tool call count so far, and its last tool's key. Not in any
- *   log; the SSE forwards it as `event: subagent_progress` (data without `kind`).
+ * - `subagent_progress`: after each step of a sub-agent run, on the topic of **every ancestor**
+ *   (sub-agents spec §14.2, agent map spec §8), `subagentId` the progressing agent: its step and
+ *   tool call count so far, and its last tool's key. Not in any log; the SSE forwards it as
+ *   `event: subagent_progress` (data without `kind`).
  */
 export type ConversationBusMessage = {
     kind: "events";
@@ -64,34 +67,41 @@ export type ConversationBusMessage = {
  * What changed about a conversation outside its event log (UI refresh B): the SSE stream sends it as
  * `event: changed` with `{ what }`, and the web refetches that part. Never model-visible.
  */
-export declare const CONVERSATION_CHANGES: readonly ["title", "queue", "selection", "files"];
+export declare const CONVERSATION_CHANGES: readonly ["title", "queue", "selection", "files", "archived", "deleted", "background"];
 export type ConversationChange = (typeof CONVERSATION_CHANGES)[number];
 /**
  * 会话事件日志：只追加，是 agent 运行的唯一事实来源。
  * seq 由 `conversations.last_seq` 在会话行锁内连续分配（多副本并发写同一会话时串行化）；
  * 幂等键的「先查后写」也在同一把行锁内完成。
+ *
+ * Every published advance (`notify`) is also announced in-process as `conversation.event-appended`
+ * on {@link KernelEvents} (the channel outbound delivery enqueues from it), on this replica, right
+ * after the bus publish, in append order.
  */
 export declare class EventLog {
     private readonly db;
     private readonly bus;
-    private readonly log?;
+    private readonly log;
+    private readonly events;
+    readonly txHost: TransactionHost;
+    constructor(db: KernelDb, bus: EventBus, log: Pick<KernelLogger, "warn">, events: Pick<KernelEvents, "emit">, txHost: TransactionHost);
     /**
-     * 每次发布「日志已推进」之后调用（同步、不等待）：内核用它给有 IM 投递目标的会话排出站任务。
-     * 钩子自己负责吞掉错误。
+     * 追加事件，返回与输入一一对应的事件（幂等命中的为已有事件）。
+     * 自开一个独立事务（`requires_new`，与调用方的事务无关），提交后发布 `conv.<id>`。
+     * 要在调用方的事务里追加（与其他写入一起提交），用 {@link appendIn}。
      */
-    private readonly onNotify?;
-    constructor(db: KernelDb, bus: EventBus, log?: Pick<Logger, "warn"> | undefined, 
+    append(conversationId: string, events: AppendEvent[]): Promise<ConversationEvent[]>;
     /**
-     * 每次发布「日志已推进」之后调用（同步、不等待）：内核用它给有 IM 投递目标的会话排出站任务。
-     * 钩子自己负责吞掉错误。
+     * {@link append} inside the caller's transaction (it must hold one: `mandatory`): the events
+     * commit or roll back with the caller's writes, and the caller calls {@link notify} after the
+     * commit with the highest seq it wrote.
      */
-    onNotify?: ((conversationId: string, toSeq: number) => void) | undefined);
+    appendIn(conversationId: string, events: AppendEvent[]): Promise<ConversationEvent[]>;
+    private appendOwn;
     /**
-     * 追加事件，返回与输入一一对应的事件（幂等命中的为已有事件）。
-     * 不传 `trx` 时自开事务，提交后发布 `conv.<id>`；传入外部 `trx` 时由调用方在提交后调用 `notify`。
+     * 发布「日志已推进到 toSeq」；发布失败只记日志（事件已提交，订阅方可按 seq 补读）。Then announces
+     * it in-process (`conversation.event-appended`); a failing subscriber is logged by KernelEvents.
      */
-    append(conversationId: string, events: AppendEvent[], trx?: Trx): Promise<ConversationEvent[]>;
-    /** 发布「日志已推进到 toSeq」；发布失败只记日志（事件已提交，订阅方可按 seq 补读）。 */
     notify(conversationId: string, toSeq: number): Promise<void>;
     /**
      * Publishes a `changed` frame on the conversation topic (rename, generated title, selection, ...).
@@ -100,6 +110,18 @@ export declare class EventLog {
     publishChanged(conversationId: string, what: ConversationChange): Promise<void>;
     /** 读 `afterSeq` 之后的事件，按 seq 升序，最多 `limit` 条。 */
     readAfter(conversationId: string, afterSeq: number, limit?: number): Promise<ConversationEvent[]>;
+    /**
+     * The page of the log that ends right before `beforeSeq` (`null`: the log's end), in ascending
+     * seq: the last `limit` events before it, extended back so the first event is the log's first or
+     * the first one after a run's end (`run_finished` / `run_failed` / `run_aborted`), at most
+     * `extend` events further back (a longer run then starts mid-run). `turnsBefore`: how many runs
+     * started (distinct `run_id` of `run_started`) before the page's first event. History paging
+     * spec §2.
+     */
+    readTurnPageBefore(conversationId: string, beforeSeq: number | null, limit: number, extend: number): Promise<{
+        events: ConversationEvent[];
+        turnsBefore: number;
+    }>;
     /**
      * 读 `afterSeq` 之后、属于 `runIds` 中某次运行的事件，按 seq 升序，最多 `limit` 条（轨迹按运行分页用）。
      * `runIds` 为空时返回空数组。走部分索引 `conversation_events_run_idx (conversation_id, run_id, seq)`（0027）：
@@ -109,14 +131,29 @@ export declare class EventLog {
     /** 按幂等键取事件；没有 → undefined。 */
     findByIdem(conversationId: string, idemKey: string): Promise<ConversationEvent | undefined>;
     /**
-     * 会话里某类事件的最新一条（按 seq）；没有 → undefined。`skills_catalog` 有部分索引
-     * （0025，按会话直接取到最新一条）；其他类型按 (conversation_id, seq) 主键倒序扫本会话的事件并按 type 过滤，
-     * 没有该类事件时会扫完整个会话。
+     * The conversation's latest event of `type` (by seq); undefined without one. `skills_catalog`
+     * (0025) and `environment_paths` (0094) have partial indexes that answer it directly; other
+     * types scan the conversation's events backwards on the (conversation_id, seq) key, the whole
+     * conversation when it has none.
      */
     latestOfType<T extends ConversationEventType>(conversationId: string, type: T): Promise<Extract<ConversationEvent, {
         type: T;
     }> | undefined>;
+    /**
+     * The file state (`tool_result.view.file`) the latest `Read` / `Write` / `Edit` result of this
+     * conversation recorded for `path` (a normalized sandbox path); null when none did. One index
+     * probe per call: the partial index `conversation_events_file_state_idx` of migration 0063
+     * (conversation_id, view.file.path, seq DESC; tool_result rows only) answers it, also for a path
+     * never read (the query's predicate must keep matching that index's expression).
+     */
+    latestFileState(conversationId: string, path: string): Promise<{
+        size: number;
+        sha256: string;
+    } | null>;
     private validate;
-    private appendIn;
+    /** The append itself, in the context's transaction (both callers open or join one). */
+    private write;
+}
+/** The one {@link EventLog} (infra dependencies only, so every domain can import it). */
+export declare class EventLogModule {
 }
-export {};

package/dist/conversations/event-log.js

@@ -1,5 +1,20 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable, Module } from "@nestjs/common";
 import { sql } from "kysely";
 import { ApiError } from "../errors.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { Transactional } from "../infra/database/transactional.decorator.js";
+import { KernelEvents } from "../infra/events/kernel-events.js";
+import { KERNEL_BUS, KERNEL_LOGGER } from "../infra/tokens.js";
 import { ConversationEventSchema, } from "./events.js";
 /**
  * The JSON stored for an event payload, with every NUL (U+0000) in a string or an object key
@@ -26,7 +41,16 @@ export const conversationTopic = (conversationId) => `conv.${conversationId}`;
  * What changed about a conversation outside its event log (UI refresh B): the SSE stream sends it as
  * `event: changed` with `{ what }`, and the web refetches that part. Never model-visible.
  */
-export const CONVERSATION_CHANGES = ["title", "queue", "selection", "files"];
+export const CONVERSATION_CHANGES = [
+    "title",
+    "queue",
+    "selection",
+    "files",
+    "archived",
+    "deleted",
+    // the conversation's background tasks (or its sub-agents')
+    "background",
+];
 const notFound = () => new ApiError("conversation.not_found", "Conversation not found");
 function toEvent(r) {
     return {
@@ -50,53 +74,61 @@ const EVENT_COLUMNS = [
  * 会话事件日志：只追加，是 agent 运行的唯一事实来源。
  * seq 由 `conversations.last_seq` 在会话行锁内连续分配（多副本并发写同一会话时串行化）；
  * 幂等键的「先查后写」也在同一把行锁内完成。
+ *
+ * Every published advance (`notify`) is also announced in-process as `conversation.event-appended`
+ * on {@link KernelEvents} (the channel outbound delivery enqueues from it), on this replica, right
+ * after the bus publish, in append order.
  */
-export class EventLog {
+let EventLog = class EventLog {
     db;
     bus;
     log;
-    onNotify;
-    constructor(db, bus, log, 
-    /**
-     * 每次发布「日志已推进」之后调用（同步、不等待）：内核用它给有 IM 投递目标的会话排出站任务。
-     * 钩子自己负责吞掉错误。
-     */
-    onNotify) {
+    events;
+    txHost;
+    constructor(db, bus, log, events, txHost) {
         this.db = db;
         this.bus = bus;
         this.log = log;
-        this.onNotify = onNotify;
+        this.events = events;
+        this.txHost = txHost;
     }
     /**
      * 追加事件，返回与输入一一对应的事件（幂等命中的为已有事件）。
-     * 不传 `trx` 时自开事务，提交后发布 `conv.<id>`；传入外部 `trx` 时由调用方在提交后调用 `notify`。
+     * 自开一个独立事务（`requires_new`，与调用方的事务无关），提交后发布 `conv.<id>`。
+     * 要在调用方的事务里追加（与其他写入一起提交），用 {@link appendIn}。
      */
-    async append(conversationId, events, trx) {
+    async append(conversationId, events) {
         const bodies = events.map((e) => this.validate(e));
-        if (trx)
-            return (await this.appendIn(trx, conversationId, events, bodies)).events;
-        const { events: out, toSeq } = await this.db
-            .transaction()
-            .execute((t) => this.appendIn(t, conversationId, events, bodies));
+        const { events: out, toSeq } = await this.appendOwn(conversationId, events, bodies);
         if (toSeq !== null)
             await this.notify(conversationId, toSeq);
         return out;
     }
-    /** 发布「日志已推进到 toSeq」；发布失败只记日志（事件已提交，订阅方可按 seq 补读）。 */
+    /**
+     * {@link append} inside the caller's transaction (it must hold one: `mandatory`): the events
+     * commit or roll back with the caller's writes, and the caller calls {@link notify} after the
+     * commit with the highest seq it wrote.
+     */
+    async appendIn(conversationId, events) {
+        const bodies = events.map((e) => this.validate(e));
+        return (await this.write(conversationId, events, bodies)).events;
+    }
+    async appendOwn(conversationId, events, bodies) {
+        return this.write(conversationId, events, bodies);
+    }
+    /**
+     * 发布「日志已推进到 toSeq」；发布失败只记日志（事件已提交，订阅方可按 seq 补读）。Then announces
+     * it in-process (`conversation.event-appended`); a failing subscriber is logged by KernelEvents.
+     */
     async notify(conversationId, toSeq) {
         const msg = { kind: "events", toSeq };
         try {
             await this.bus.publish(conversationTopic(conversationId), msg);
         }
         catch (err) {
-            this.log?.warn("conversation event notify failed", { conversationId, toSeq, err });
-        }
-        try {
-            this.onNotify?.(conversationId, toSeq);
-        }
-        catch (err) {
-            this.log?.warn("conversation event notify hook failed", { conversationId, err });
+            this.log.warn("conversation event notify failed", { conversationId, toSeq, err });
         }
+        await this.events.emit("conversation.event-appended", { conversationId, toSeq });
     }
     /**
      * Publishes a `changed` frame on the conversation topic (rename, generated title, selection, ...).
@@ -108,7 +140,7 @@ export class EventLog {
             await this.bus.publish(conversationTopic(conversationId), msg);
         }
         catch (err) {
-            this.log?.warn("conversation change publish failed", { conversationId, what, err });
+            this.log.warn("conversation change publish failed", { conversationId, what, err });
         }
     }
     /** 读 `afterSeq` 之后的事件，按 seq 升序，最多 `limit` 条。 */
@@ -123,6 +155,66 @@ export class EventLog {
             .execute();
         return rows.map(toEvent);
     }
+    /**
+     * The page of the log that ends right before `beforeSeq` (`null`: the log's end), in ascending
+     * seq: the last `limit` events before it, extended back so the first event is the log's first or
+     * the first one after a run's end (`run_finished` / `run_failed` / `run_aborted`), at most
+     * `extend` events further back (a longer run then starts mid-run). `turnsBefore`: how many runs
+     * started (distinct `run_id` of `run_started`) before the page's first event. History paging
+     * spec §2.
+     */
+    async readTurnPageBefore(conversationId, beforeSeq, limit, extend) {
+        let q = this.db
+            .selectFrom("conversation_events")
+            .select(EVENT_COLUMNS)
+            .where("conversation_id", "=", conversationId);
+        if (beforeSeq !== null)
+            q = q.where("seq", "<", String(beforeSeq));
+        const rows = (await q.orderBy("seq", "desc").limit(limit).execute()).reverse();
+        const first = rows[0] === undefined ? null : Number(rows[0].seq);
+        if (first === null)
+            return { events: [], turnsBefore: 0 };
+        let start = first;
+        if (first > 1) {
+            // the latest run end at or before the event just above the page, within the extension
+            const end = await this.db
+                .selectFrom("conversation_events")
+                .select((eb) => eb.fn.max("seq").as("seq"))
+                .where("conversation_id", "=", conversationId)
+                .where("seq", "<", String(first))
+                .where("seq", ">=", String(Math.max(1, first - 1 - extend)))
+                .where("type", "in", ["run_finished", "run_failed", "run_aborted"])
+                .executeTakeFirst();
+            // none within reach: the page starts at the log's start when that is in reach, else mid-run
+            if (end?.seq != null)
+                start = Number(end.seq) + 1;
+            else if (first - 1 <= extend)
+                start = 1;
+        }
+        const head = start < first
+            ? await this.db
+                .selectFrom("conversation_events")
+                .select(EVENT_COLUMNS)
+                .where("conversation_id", "=", conversationId)
+                .where("seq", ">=", String(start))
+                .where("seq", "<", String(first))
+                .orderBy("seq")
+                .execute()
+            : [];
+        const turns = start > 1
+            ? await this.db
+                .selectFrom("conversation_events")
+                .select((eb) => eb.fn.count("run_id").distinct().as("n"))
+                .where("conversation_id", "=", conversationId)
+                .where("type", "=", "run_started")
+                .where("seq", "<", String(start))
+                .executeTakeFirst()
+            : undefined;
+        return {
+            events: [...head, ...rows].map(toEvent),
+            turnsBefore: Number(turns?.n ?? 0),
+        };
+    }
     /**
      * 读 `afterSeq` 之后、属于 `runIds` 中某次运行的事件，按 seq 升序，最多 `limit` 条（轨迹按运行分页用）。
      * `runIds` 为空时返回空数组。走部分索引 `conversation_events_run_idx (conversation_id, run_id, seq)`（0027）：
@@ -153,9 +245,10 @@ export class EventLog {
         return r && toEvent(r);
     }
     /**
-     * 会话里某类事件的最新一条（按 seq）；没有 → undefined。`skills_catalog` 有部分索引
-     * （0025，按会话直接取到最新一条）；其他类型按 (conversation_id, seq) 主键倒序扫本会话的事件并按 type 过滤，
-     * 没有该类事件时会扫完整个会话。
+     * The conversation's latest event of `type` (by seq); undefined without one. `skills_catalog`
+     * (0025) and `environment_paths` (0094) have partial indexes that answer it directly; other
+     * types scan the conversation's events backwards on the (conversation_id, seq) key, the whole
+     * conversation when it has none.
      */
     async latestOfType(conversationId, type) {
         const r = await this.db
@@ -168,6 +261,25 @@ export class EventLog {
             .executeTakeFirst();
         return r && toEvent(r);
     }
+    /**
+     * The file state (`tool_result.view.file`) the latest `Read` / `Write` / `Edit` result of this
+     * conversation recorded for `path` (a normalized sandbox path); null when none did. One index
+     * probe per call: the partial index `conversation_events_file_state_idx` of migration 0063
+     * (conversation_id, view.file.path, seq DESC; tool_result rows only) answers it, also for a path
+     * never read (the query's predicate must keep matching that index's expression).
+     */
+    async latestFileState(conversationId, path) {
+        const r = await this.db
+            .selectFrom("conversation_events")
+            .select(sql `payload->'view'->'file'`.as("file"))
+            .where("conversation_id", "=", conversationId)
+            .where("type", "=", "tool_result")
+            .where(sql `payload->'view'->'file'->>'path' = ${path}`)
+            .orderBy("seq", "desc")
+            .limit(1)
+            .executeTakeFirst();
+        return r ? { size: r.file.size, sha256: r.file.sha256 } : null;
+    }
     validate(e) {
         const r = ConversationEventSchema.safeParse({ type: e.type, payload: e.payload });
         if (!r.success) {
@@ -175,7 +287,9 @@ export class EventLog {
         }
         return r.data;
     }
-    async appendIn(t, conversationId, events, bodies) {
+    /** The append itself, in the context's transaction (both callers open or join one). */
+    async write(conversationId, events, bodies) {
+        const t = this.db;
         // 先锁会话行：之后的幂等查询与 seq 分配都在这把锁内，并发 append 依次执行。
         const conv = await t
             .selectFrom("conversations")
@@ -256,4 +370,26 @@ export class EventLog {
             toSeq,
         };
     }
-}
+};
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], EventLog.prototype, "appendIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], EventLog.prototype, "appendOwn", null);
+EventLog = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(KERNEL_BUS)),
+    __param(2, Inject(KERNEL_LOGGER)),
+    __param(3, Inject(KernelEvents)),
+    __param(4, Inject(TransactionHost))
+], EventLog);
+export { EventLog };
+/** The one {@link EventLog} (infra dependencies only, so every domain can import it). */
+let EventLogModule = class EventLogModule {
+};
+EventLogModule = __decorate([
+    Module({ providers: [EventLog], exports: [EventLog] })
+], EventLogModule);
+export { EventLogModule };