@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/web-ui/notifications/conversation-source.js

@@ -0,0 +1,26 @@
+import { isSparkSession } from "../../sessions/spark-session.js";
+import { toSnapshotMessage } from "../../sessions/record/projection.js";
+/** Navigation follows the stored session kind; titles never identify SPARK. */
+export function conversationNotificationSource(environmentId, sessionId, event, persisted) {
+    const parameters = new URLSearchParams({ environment: environmentId, session: sessionId });
+    if (!persisted || !isSparkSession(persisted))
+        return `/chat?${parameters}`;
+    parameters.delete("session");
+    parameters.set("spark", "1");
+    const proposal = event.event;
+    const message = [...(persisted.messages ?? [])].reverse().find((item) => {
+        if (item.role !== "assistant")
+            return false;
+        if (proposal?.type === "proposal_delivered")
+            return item.initiative?.proposalId === proposal.proposalId;
+        return typeof event.requestId === "string" && item.requestId === event.requestId;
+    });
+    if (message) {
+        const reference = toSnapshotMessage(sessionId, message, persisted.requests ?? []);
+        parameters.set("message", String(reference.id));
+        parameters.set("messageCreatedAt", String(reference.createdAt));
+        if (reference.requestId)
+            parameters.set("request", reference.requestId);
+    }
+    return `/home?${parameters}`;
+}

package/dist/src/web-ui/notifications/event-fields.d.ts

@@ -0,0 +1,3 @@
+export declare function eventText(value: unknown): string;
+export declare function hasNotificationIdentity(value: string): boolean;
+export declare function notificationBody(value: string): string;

package/dist/src/web-ui/notifications/event-fields.js

@@ -0,0 +1,12 @@
+export function eventText(value) {
+    return typeof value === "string" ? value : "";
+}
+export function hasNotificationIdentity(value) {
+    if (!value.trim() || value.length > 512)
+        return false;
+    return !/[\u0000-\u001f\u007f]/u.test(value);
+}
+export function notificationBody(value) {
+    const readable = value.replace(/[\u0000-\u001f\u007f]/gu, " ");
+    return [...readable.replace(/\s+/gu, " ").trim()].slice(0, 600).join("");
+}

package/dist/src/web-ui/notifications/event-projection.d.ts

@@ -1,3 +1,4 @@
 import type { WebNotification } from "./contracts.js";
+import { type NotificationSession } from "./conversation-source.js";
 /** Observe committed client output; replay and progress never create new records. */
-export declare function projectNotificationEvent(event: Record<string, unknown>, now: number): WebNotification | undefined;
+export declare function projectNotificationEvent(event: Record<string, unknown>, now: number, persistedSession?: NotificationSession | null): WebNotification | undefined;

package/dist/src/web-ui/notifications/event-projection.js

@@ -1,16 +1,9 @@
 import { createHash } from "node:crypto";
-function eventText(value) {
-    return typeof value === "string" ? value : "";
-}
-function hasNotificationIdentity(value) {
-    if (!value.trim() || value.length > 512)
-        return false;
-    return !/[\u0000-\u001f\u007f]/u.test(value);
-}
-function notificationBody(value) {
-    const readable = value.replace(/[\u0000-\u001f\u007f]/gu, " ");
-    return [...readable.replace(/\s+/gu, " ").trim()].slice(0, 600).join("");
-}
+import { isSparkSession } from "../../sessions/spark-session.js";
+import { hasAutomationSessionOrigin } from "../../sessions/automation-session-origin.js";
+import { projectAutomationRunNotificationEvent } from "./automation-event-projection.js";
+import { eventText, hasNotificationIdentity, notificationBody } from "./event-fields.js";
+import { conversationNotificationSource } from "./conversation-source.js";
 function stoppedResponse(event) {
     const details = event.details;
     if (!details || typeof details !== "object" || Array.isArray(details))
@@ -22,6 +15,13 @@ function isCancelledRequestEvent(event) {
         return true;
     return event.error === "request_cancelled";
 }
+function isAutomationChildReply(event, persistedSession) {
+    if (event.type !== "completed")
+        return false;
+    if (!persistedSession)
+        return false;
+    return hasAutomationSessionOrigin(persistedSession);
+}
 function failedNotification(event) {
     const sessionId = eventText(event.sessionId);
     const key = eventText(event.requestId);
@@ -84,14 +84,19 @@ function readNotificationEvent(event) {
         kind: "proposal",
         key: eventText(proposal.proposalId),
         sessionId: eventText(proposal.sessionId),
-        title: "New Co-worker suggestion",
-        body: "Co-worker has a new suggestion for you. Open the conversation to review it.",
+        title: "New SPARK suggestion",
+        body: "SPARK has a new suggestion for you. Open the conversation to review it.",
     };
 }
 /** Observe committed client output; replay and progress never create new records. */
-export function projectNotificationEvent(event, now) {
+export function projectNotificationEvent(event, now, persistedSession) {
     if (event.sessionDeleted === true)
         return;
+    if (isAutomationChildReply(event, persistedSession))
+        return;
+    const automation = projectAutomationRunNotificationEvent(event, now);
+    if (automation)
+        return automation;
     const environmentId = eventText(event.environment) || eventText(event.environmentId);
     if (!hasNotificationIdentity(environmentId))
         return;
@@ -105,10 +110,6 @@ export function projectNotificationEvent(event, now) {
     const id = createHash("sha256")
         .update(JSON.stringify([environmentId, projected.kind, projected.key]))
         .digest("hex");
-    const parameters = new URLSearchParams({
-        environment: environmentId,
-        session: projected.sessionId,
-    });
     const requestId = eventText(event.requestId);
     return {
         id,
@@ -119,8 +120,9 @@ export function projectNotificationEvent(event, now) {
         readAt: null,
         environmentId,
         sessionId: projected.sessionId,
+        ...(persistedSession && isSparkSession(persistedSession) ? { sessionKind: "spark" } : {}),
         ...(hasNotificationIdentity(requestId) ? { requestId } : {}),
-        sourceUrl: `/chat?${parameters}`,
+        sourceUrl: conversationNotificationSource(environmentId, projected.sessionId, event, persistedSession),
         delivery: { status: "pending" },
     };
 }

package/dist/src/web-ui/notifications/service.js

@@ -1,3 +1,5 @@
+import { assertValidSessionId } from "../../sessions/record/rules.js";
+import { loadSessionFile } from "../../sessions/session-store.js";
 import { NotificationDeliveryQueue } from "./delivery-queue.js";
 import { projectNotificationEvent } from "./event-projection.js";
 import { WebNotificationStore, notificationStorePath } from "./store.js";
@@ -6,6 +8,20 @@ function isSuppressedReply(item, options) {
         return false;
     return options.isViewing(item.environmentId, item.sessionId);
 }
+function hasValidPersistedSessionReference(sessionId) {
+    try {
+        assertValidSessionId(sessionId);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isCompletedConversationNotification(event, item) {
+    if (event.type !== "completed")
+        return false;
+    return item.kind !== "automation";
+}
 function permitsDesktopNotification(preferences, item) {
     if (!preferences.desktopEnabled)
         return false;
@@ -51,13 +67,28 @@ export class WebNotificationService {
     observe(event) {
         if (this.abort.signal.aborted)
             return;
-        const item = projectNotificationEvent(event, this.now());
+        const observedAt = this.now();
+        const item = projectNotificationEvent(event, observedAt);
         if (!item || isSuppressedReply(item, this.options))
             return;
         if (!this.hasEnvironment(item.environmentId))
             return;
+        if (item.kind !== "automation" &&
+            !hasValidPersistedSessionReference(item.sessionId))
+            return;
         this.queue = this.queue
-            .then(() => this.record(item))
+            .then(async () => {
+            if (item.kind === "automation")
+                return this.record(item);
+            const { sessionsDir } = this.options.environment(item.environmentId).services.config.paths;
+            const persisted = await loadSessionFile(sessionsDir, item.sessionId);
+            const hasPersistedConversation = persisted !== null;
+            if (!hasPersistedConversation && isCompletedConversationNotification(event, item))
+                return;
+            const projected = projectNotificationEvent(event, observedAt, persisted);
+            if (projected)
+                await this.record(projected);
+        })
             .catch((error) => this.reportFailure(item.environmentId, error));
     }
     async record(item) {

package/dist/src/web-ui/notifications/storage-schema.js

@@ -1,3 +1,4 @@
+import { SPARK_SESSION_ID } from "../../sessions/spark-session.js";
 export function isNotificationRecord(value) {
     if (value === null)
         return false;
@@ -40,12 +41,40 @@ export function isNotificationPreferences(value) {
         return false;
     if (!isNotificationRecord(value.kinds))
         return false;
-    const kinds = ["reply", "failure", "approval", "proposal"];
+    const kinds = ["reply", "failure", "approval", "proposal", "automation"];
     const preferences = value.kinds;
     if (!hasOnlyNotificationFields(preferences, kinds))
         return false;
     return kinds.every((kind) => typeof preferences[kind] === "boolean");
 }
+function normalizeStoredNotificationPreferences(value) {
+    if (isNotificationPreferences(value))
+        return value;
+    if (!isNotificationRecord(value))
+        return null;
+    if (!hasOnlyNotificationFields(value, ["desktopEnabled", "kinds"]))
+        return null;
+    if (typeof value.desktopEnabled !== "boolean")
+        return null;
+    if (!isNotificationRecord(value.kinds))
+        return null;
+    const kinds = value.kinds;
+    const legacyKinds = ["reply", "failure", "approval", "proposal"];
+    if (!hasOnlyNotificationFields(kinds, legacyKinds))
+        return null;
+    if (!legacyKinds.every((kind) => typeof kinds[kind] === "boolean"))
+        return null;
+    return {
+        desktopEnabled: value.desktopEnabled,
+        kinds: {
+            reply: kinds.reply,
+            failure: kinds.failure,
+            approval: kinds.approval,
+            proposal: kinds.proposal,
+            automation: true,
+        },
+    };
+}
 export function isNotificationDelivery(value) {
     if (!isNotificationRecord(value))
         return false;
@@ -67,28 +96,97 @@ export function isNotificationDelivery(value) {
         return true;
     return isNotificationText(value.error, 4096);
 }
+function sparkNotificationSourceTarget(value, source) {
+    if (value.sessionKind !== "spark")
+        return null;
+    if (value.sessionId !== SPARK_SESSION_ID)
+        return null;
+    const parameters = {
+        environment: value.environmentId,
+        spark: "1",
+    };
+    const message = source.get("message");
+    const createdAt = source.get("messageCreatedAt");
+    const request = source.get("request");
+    if (message === null && createdAt === null && request === null)
+        return { path: "/home", parameters };
+    if (!isNotificationIdentifier(message))
+        return null;
+    if (createdAt === null || !isNotificationTimestamp(Number(createdAt)))
+        return null;
+    if (String(Number(createdAt)) !== createdAt)
+        return null;
+    parameters.message = message;
+    parameters.messageCreatedAt = createdAt;
+    if (request !== (value.requestId ?? null))
+        return null;
+    if (request !== null)
+        parameters.request = request;
+    return { path: "/home", parameters };
+}
+function notificationSourceTarget(value, source) {
+    if (value.kind === "automation") {
+        if (!isNotificationIdentifier(value.automationId))
+            return null;
+        if (!isNotificationIdentifier(value.runId))
+            return null;
+        if (value.sessionId !== undefined)
+            return null;
+        if (value.sessionKind !== undefined)
+            return null;
+        if (value.requestId !== undefined)
+            return null;
+        return {
+            path: "/automations",
+            parameters: {
+                environment: value.environmentId,
+                automation: value.automationId,
+                run: value.runId,
+            },
+        };
+    }
+    if (!isNotificationIdentifier(value.sessionId))
+        return null;
+    if (value.automationId !== undefined)
+        return null;
+    if (value.runId !== undefined)
+        return null;
+    if (value.requestId !== undefined && !isNotificationIdentifier(value.requestId))
+        return null;
+    if (value.sessionKind !== undefined)
+        return sparkNotificationSourceTarget(value, source);
+    return {
+        path: "/chat",
+        parameters: {
+            environment: value.environmentId,
+            session: value.sessionId,
+        },
+    };
+}
 function hasBoundNotificationSource(value) {
     if (typeof value.sourceUrl !== "string")
         return false;
-    if (!value.sourceUrl.startsWith("/chat?"))
-        return false;
     try {
         const url = new URL(value.sourceUrl, "http://notification.local");
-        if (url.origin !== "http://notification.local")
-            return false;
-        if (url.pathname !== "/chat")
+        const target = notificationSourceTarget(value, url.searchParams);
+        if (!target)
             return false;
-        if (url.hash)
+        if (!value.sourceUrl.startsWith(`${target.path}?`))
             return false;
-        if (url.searchParams.get("environment") !== value.environmentId)
-            return false;
-        if (url.searchParams.get("session") !== value.sessionId)
+        if (url.origin !== "http://notification.local")
             return false;
-        if (url.searchParams.getAll("environment").length !== 1)
+        if (url.pathname !== target.path)
             return false;
-        if (url.searchParams.getAll("session").length !== 1)
+        if (url.hash)
             return false;
-        return [...url.searchParams.keys()].every((key) => ["environment", "session"].includes(key));
+        const expectedKeys = Object.keys(target.parameters);
+        for (const key of expectedKeys) {
+            if (url.searchParams.getAll(key).length !== 1)
+                return false;
+            if (url.searchParams.get(key) !== target.parameters[key])
+                return false;
+        }
+        return [...url.searchParams.keys()].every((key) => expectedKeys.includes(key));
     }
     catch {
         return false;
@@ -106,7 +204,10 @@ export function isWebNotification(value, environmentId) {
         "readAt",
         "environmentId",
         "sessionId",
+        "sessionKind",
         "requestId",
+        "automationId",
+        "runId",
         "sourceUrl",
         "delivery",
     ];
@@ -116,7 +217,7 @@ export function isWebNotification(value, environmentId) {
         return false;
     if (typeof value.kind !== "string")
         return false;
-    if (!["reply", "failure", "approval", "proposal"].includes(value.kind))
+    if (!["reply", "failure", "approval", "proposal", "automation"].includes(value.kind))
         return false;
     if (!isNotificationText(value.title, 1024))
         return false;
@@ -130,11 +231,6 @@ export function isWebNotification(value, environmentId) {
         return false;
     if (value.environmentId !== environmentId)
         return false;
-    if (!isNotificationIdentifier(value.sessionId))
-        return false;
-    if (value.requestId !== undefined &&
-        !isNotificationIdentifier(value.requestId))
-        return false;
     if (!hasBoundNotificationSource(value))
         return false;
     return isNotificationDelivery(value.delivery);
@@ -154,7 +250,8 @@ export function decodeNotificationState(raw, environmentId) {
         "preferences",
     ]))
         throw new Error("Unexpected notification storage fields.");
-    if (!isNotificationPreferences(value.preferences))
+    const preferences = normalizeStoredNotificationPreferences(value.preferences);
+    if (!preferences)
         throw new Error("Invalid notification preferences.");
     if (!Array.isArray(value.items))
         throw new Error("Invalid notification history.");
@@ -166,5 +263,5 @@ export function decodeNotificationState(raw, environmentId) {
             throw new Error("Duplicate stored notification.");
         seen.add(item.id);
     }
-    return value;
+    return { ...value, preferences };
 }

package/dist/src/web-ui/server.js

@@ -203,7 +203,7 @@ export function startWebUiServer(overrides = {}) {
     }
     const handleLinkPreview = createLinkPreviewRouteHandler();
     const systemHost = localRuntimeBackend
-        ? new WebSystemHostService(rootDir, () => localRuntimeBackend.notifyHostConnectionChanged())
+        ? new WebSystemHostService(rootDir, () => localRuntimeBackend.notifyHostConnectionChanged(), (environmentId) => localRuntimeBackend.nativePermissions(environmentId))
         : null;
     const allowPublishedLoopback = allowsPublishedLoopbackAuthority(options.host);
     const server = createServer((req, res) => {

package/dist/src/web-ui/session-read-state/service.d.ts

@@ -19,6 +19,18 @@ export declare class WebSessionReadStates {
     forget(environmentId: string, sessionId: string): Promise<void>;
     reset(environmentId: string, sessionId: string): Promise<void>;
     project(environmentId: string, snapshot: SessionSnapshot): Promise<{
+        sessionId: string;
+        readStateStatus: "available";
+        unreadMessageIds: (string | number)[];
+        unreadCount: number;
+        hasUnread: boolean;
+        readRevision: number;
+        readGeneration: string;
+        lastReadAt: number;
+        lastReadMessageId: string | number | null;
+        latestMessageId: string | number | null;
+        latestAssistantMessageId: string | number | null;
+    } | {
         sessionId: string;
         readStateStatus: "unavailable";
         unreadCount: null;
@@ -36,6 +48,18 @@ export declare class WebSessionReadStates {
         latestAssistantMessageId: string | number | null;
     }>;
     mark(environmentId: string, sessionId: string, boundary: ReadBoundary): Promise<{
+        sessionId: string;
+        readStateStatus: "available";
+        unreadMessageIds: (string | number)[];
+        unreadCount: number;
+        hasUnread: boolean;
+        readRevision: number;
+        readGeneration: string;
+        lastReadAt: number;
+        lastReadMessageId: string | number | null;
+        latestMessageId: string | number | null;
+        latestAssistantMessageId: string | number | null;
+    } | {
         sessionId: string;
         readStateStatus: "available";
         unreadCount: number;
@@ -45,6 +69,19 @@ export declare class WebSessionReadStates {
         latestMessageId: string | number | null;
         latestAssistantMessageId: string | number | null;
     } | null>;
+    markVisible(environmentId: string, sessionId: string, input: unknown, generation: unknown, visibleMessages: unknown): Promise<{
+        sessionId: string;
+        readStateStatus: "available";
+        unreadMessageIds: (string | number)[];
+        unreadCount: number;
+        hasUnread: boolean;
+        readRevision: number;
+        readGeneration: string;
+        lastReadAt: number;
+        lastReadMessageId: string | number | null;
+        latestMessageId: string | number | null;
+        latestAssistantMessageId: string | number | null;
+    } | null>;
     list(environmentId: string): Promise<{
         sessions: {
             sessionId: string;
@@ -65,6 +102,7 @@ export declare class WebSessionReadStates {
                 name: string;
                 directory: string;
             }> | undefined;
+            kind?: "spark" | undefined;
             id: string;
         }[];
         nextCursor: null;
@@ -88,6 +126,7 @@ export declare class WebSessionReadStates {
                 name: string;
                 directory: string;
             }> | undefined;
+            kind?: "spark" | undefined;
             id: string;
         }[];
         nextCursor: null;

package/dist/src/web-ui/session-read-state/service.js

@@ -1,6 +1,8 @@
 import { createHash } from "node:crypto";
 import { join, resolve } from "node:path";
 import { SessionService } from "../../sessions/session-service.js";
+import { isSparkSession } from "../../sessions/spark-session.js";
+import { markVisibleAssistantMessages, projectVisibleSessionReadState, visibleReadMessageIds, visibleReadObservations } from "./visible-messages.js";
 import { clientVisibleMessages, toSessionListItem, toSnapshotMessage, } from "../../sessions/record/projection.js";
 import { WebReadStateStore } from "./store.js";
 import { captureReadStateAvailability, unavailableSessionReadState, } from "./availability.js";
@@ -39,7 +41,9 @@ export class WebSessionReadStates {
         await captureReadStateAvailability(() => this.store(environmentId).reset(sessionId, this.now()));
     }
     async project(environmentId, snapshot) {
-        const result = await captureReadStateAvailability(() => this.store(environmentId).transaction((state) => projectSessionReadState(state, snapshot.sessionId, snapshot.messages)));
+        const result = await captureReadStateAvailability(() => this.store(environmentId).transaction((state) => isSparkSession(snapshot)
+            ? projectVisibleSessionReadState(state, snapshot.sessionId, snapshot.messages)
+            : projectSessionReadState(state, snapshot.sessionId, snapshot.messages)));
         if (result.readStateStatus === "unavailable")
             return unavailableSessionReadState(snapshot.sessionId);
         return result.value;
@@ -54,16 +58,30 @@ export class WebSessionReadStates {
             });
             if (!snapshot)
                 return null;
+            if (isSparkSession(snapshot))
+                return projectVisibleSessionReadState(state, sessionId, snapshot.messages);
             advanceReadCursor(state, sessionId, snapshot.messages, boundary, this.now());
             return projectSessionReadState(state, sessionId, snapshot.messages);
         });
     }
+    async markVisible(environmentId, sessionId, input, generation, visibleMessages) {
+        const ids = visibleReadMessageIds(input);
+        const observations = visibleReadObservations(ids, visibleMessages);
+        const sessions = this.getEnvironment(environmentId).services.sessions;
+        return this.store(environmentId).transaction(async (state) => {
+            const snapshot = await sessions.getSessionSnapshot(sessionId, { includeRequests: false });
+            if (!snapshot || !isSparkSession(snapshot))
+                return null;
+            markVisibleAssistantMessages(state, sessionId, snapshot.messages, observations, generation, this.now());
+            return projectVisibleSessionReadState(state, sessionId, snapshot.messages);
+        });
+    }
     async list(environmentId) {
         const { sessionsDir } = this.getEnvironment(environmentId).services.config.paths;
         // One canonical disk enumeration avoids mutable offset pages and sending
         // every request event across the managed Runtime's bounded RPC transport.
         const records = await new SessionService({ sessionsDir }).getAllSessions();
-        const projectedSessions = records.map((record) => ({
+        const projectedSessions = records.filter((record) => !isSparkSession(record)).map((record) => ({
             summary: toSessionListItem(record),
             messages: clientVisibleMessages(record.messages).map((message) => toSnapshotMessage(record.id, message, record.requests ?? [])),
         }));

package/dist/src/web-ui/session-read-state/store.d.ts

@@ -1,3 +1,4 @@
+import { type VisibleMessageReadState } from "./visible-messages.js";
 export type WebReadCursor = {
     messageId: string;
     createdAt: number;
@@ -7,6 +8,7 @@ export type WebReadState = {
     version: 1;
     initializedAt: number;
     cursors: Array<[string, WebReadCursor]>;
+    visibleMessages?: Array<[string, VisibleMessageReadState]>;
 };
 /** UI-owned state; never writes Runtime session records or model context. */
 export declare class WebReadStateStore {

package/dist/src/web-ui/session-read-state/store.js

@@ -1,6 +1,7 @@
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
+import { readVisibleMessageReceipts } from "./visible-messages.js";
 const pendingWrites = new Map();
 function hasFileErrorCode(error, code) {
     return error instanceof Error && "code" in error && error.code === code;
@@ -29,6 +30,7 @@ function decodeReadState(raw) {
         if (typeof entry[0] !== "string" || !isReadCursor(entry[1]))
             throw new Error("Invalid Web UI read cursor entry.");
     }
+    state.visibleMessages = readVisibleMessageReceipts(state.visibleMessages);
     return state;
 }
 /** UI-owned state; never writes Runtime session records or model context. */
@@ -100,11 +102,16 @@ export class WebReadStateStore {
                 lastReadAt: Math.max(now, (previous?.lastReadAt ?? state.initializedAt) + 1),
             });
             state.cursors = [...cursors];
+            const visible = new Map(state.visibleMessages ?? []);
+            const prior = visible.get(sessionId);
+            visible.set(sessionId, { generation: randomUUID(), revision: Math.max(now, (prior?.revision ?? 0) + 1), messages: [] });
+            state.visibleMessages = [...visible];
         });
     }
     forget(sessionId) {
         return this.transaction((state) => {
             state.cursors = state.cursors.filter(([id]) => id !== sessionId);
+            state.visibleMessages = state.visibleMessages?.filter(([id]) => id !== sessionId);
         });
     }
 }

package/dist/src/web-ui/session-read-state/visible-messages.d.ts

@@ -0,0 +1,30 @@
+import type { SessionSnapshotMessage } from "../../sessions/types.js";
+import type { WebReadState } from "./store.js";
+export type VisibleMessageReceipt = {
+    messageId: string;
+    createdAt: number;
+    requestId: string | null;
+};
+export type VisibleMessageReadState = {
+    generation: string;
+    revision: number;
+    messages: VisibleMessageReceipt[];
+};
+export declare function isVisibleMessageReadState(value: unknown): value is VisibleMessageReadState;
+export declare function readVisibleMessageReceipts(value: unknown): WebReadState["visibleMessages"];
+export declare function visibleReadMessageIds(input: unknown): string[];
+export declare function visibleReadObservations(ids: readonly string[], input: unknown): VisibleMessageReceipt[];
+export declare function markVisibleAssistantMessages(state: WebReadState, sessionId: string, messages: SessionSnapshotMessage[], observations: readonly VisibleMessageReceipt[], generation: unknown, now: number): void;
+export declare function projectVisibleSessionReadState(state: WebReadState, sessionId: string, messages: SessionSnapshotMessage[]): {
+    sessionId: string;
+    readStateStatus: "available";
+    unreadMessageIds: (string | number)[];
+    unreadCount: number;
+    hasUnread: boolean;
+    readRevision: number;
+    readGeneration: string;
+    lastReadAt: number;
+    lastReadMessageId: string | number | null;
+    latestMessageId: string | number | null;
+    latestAssistantMessageId: string | number | null;
+};