@deepseek-ai/dsh-message-feedback 0.1.2-alpha.5 → 0.1.3-alpha.2

package/lib/types/index.d.ts

@@ -1,14 +1,13 @@
 /**
- * Durable, lifecycle-bound feedback for finalized assistant messages.
+ * Canonical Session-log feedback for finalized assistant messages.
  * @module @deepseek-ai/dsh-message-feedback
  */
 import { Context, Service } from '@deepseek-ai/cordis';
 import s from '@deepseek-ai/schemastery';
+import type { SessionInspection } from '@deepseek-ai/dsh-session-persistence';
 import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import type { MessageFeedbackDeleteRequest, MessageFeedbackDeleteResult, MessageFeedbackListRequest, MessageFeedbackListResult, MessageFeedbackPutRequest, MessageFeedbackPutResult } from './types.ts';
 export type * from './types.ts';
-export { messageFeedbackDomainSpec, messageFeedbackItemSchema, messageFeedbackRatingSchema, messageFeedbackRowSchema, messageFeedbackSessionIdentitySchema, messageFeedbackVersionSchema, } from './spec.ts';
-export type { MessageFeedbackRow, MessageFeedbackSessionIdentity } from './spec.ts';
 /** Required deployment policy for optional notes. */
 export interface Config {
     /** Maximum UTF-8 byte length accepted for one note. */
@@ -18,71 +17,57 @@ declare module '@deepseek-ai/cordis' {
     interface Context {
         messageFeedback: MessageFeedbackService;
     }
+    interface Events {
+        /**
+         * Observe a durable cold feedback mutation without publishing a live Session.
+         * Observers run before write ownership is released and must not await
+         * another message-feedback operation for this Session. The payload is borrowed
+         * read-only; deep-clone it before transferring ownership (for example, to Session.fromRestore).
+         * @param inspection - committed canonical prefix, including the feedback as its last event.
+         * @mode parallel
+         */
+        'feedback/committed'(inspection: SessionInspection): void;
+    }
 }
-/**
- * Storage-domain sidecar service. It inspects persisted Session history and
- * never creates or resumes an Agent or Session.
- */
+/** Session-log service; cold operations never construct a Session or Agent. */
 export declare class MessageFeedbackService extends TypertRemoteService {
     static inject: string[];
     /** Loader validation for the required note-size policy. */
     static Config: s<Config>;
     private readonly maxNoteBytes;
-    private table?;
     private readonly operationTails;
     private mutationAdmissionOpen;
     /**
-     * @param ctx - Host context carrying persistence and the storage-domain form.
+     * @param ctx - Host context carrying Session persistence and live owners.
      * @param config - Required note-size policy.
      */
     constructor(ctx: Context, config: Config);
-    /** Open and own the one message-feedback sidecar domain. */
-    protected [Service.init](): Promise<void>;
+    protected [Service.init](): void;
     /**
-     * Read feedback belonging to the current persisted Session lifecycle.
-     * A stale row from a reused Session id is invisible.
-     * @param request - Session identity to inspect and list.
-     * @returns current immutable items or `session-not-found`.
+     * Read current feedback from the canonical log.
+     * @param request - Session to inspect.
+     * @returns immutable items or a definite persistence miss.
      */
     list(request: MessageFeedbackListRequest): Promise<MessageFeedbackListResult>;
     /**
-     * Create or replace feedback for one derived append-origin assistant
-     * message. Every request must match the addressed item's current version;
-     * a matching no-op returns the stored item without changing its revision.
-     * @param request - target, desired value, and observed item version.
-     * @returns the committed item or an explicit business failure.
+     * Create or replace feedback after checking its current version.
+     * Matching no-ops retain the version and append no event.
+     * @param request - Target, desired value, and observed item version.
+     * @returns the durable item or an explicit business failure.
      */
     put(request: MessageFeedbackPutRequest): Promise<MessageFeedbackPutResult>;
     /**
-     * Delete one feedback item. Absence is successful regardless of the
-     * supplied version; an existing item requires an exact version match.
+     * Delete one item after checking its version; absence succeeds without an event.
      * @param request - Session, message, and observed item version.
-     * @returns the stable absent postcondition, or an explicit failure.
+     * @returns the stable absent postcondition or an explicit failure.
      */
     delete(request: MessageFeedbackDeleteRequest): Promise<MessageFeedbackDeleteResult>;
-    /**
-     * Resolve a live owner directly; otherwise use the storage catalog as the
-     * existence authority before inspecting the log. Inspection failures for a
-     * catalogued Session remain infrastructure failures rather than being
-     * guessed into the business `session-not-found` branch.
-     */
-    private inspectSession;
-    /** Require the exact finalized append-origin assistant message projection. */
-    private hasFeedbackTarget;
-    /**
-     * Put the target log prefix behind a durability barrier before its sidecar.
-     * A live owner flushes through the SessionStore's canonical checkpoint; a
-     * cold owner is re-read from the physical durable prefix.
-     */
-    private ensureTargetDurable;
-    /** Validate optional-note semantics and the configured complete UTF-8 byte bound. */
+    /** Hold cold write ownership across read/compare/append; use live owners directly. */
+    private withSession;
     private resolveNote;
-    /** Return the authoritative item needed to reconcile one failed comparison. */
     private versionConflict;
-    /** Queue a complete read/compare/write mutation behind this Session's prior mutation. */
+    /** Serialize complete operations and drain their handles before disposal. */
     private enqueue;
-    /** Resolve the initialized durable table or fail a broken service lifecycle. */
-    private requireTable;
 }
 export default MessageFeedbackService;
 //# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -1,5 +1,5 @@
 /**
- * Durable, lifecycle-bound feedback for finalized assistant messages.
+ * Canonical Session-log feedback for finalized assistant messages.
  * @module @deepseek-ai/dsh-message-feedback
  */
 var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
@@ -38,77 +38,57 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
 };
 import { Buffer } from 'node:buffer';
 import { randomUUID } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
 import { Service } from '@deepseek-ai/cordis';
 import s from '@deepseek-ai/schemastery';
-import { SessionLogOffset } from '@deepseek-ai/dsh-session';
+import { z } from 'zod';
+import { SessionSeq } from '@deepseek-ai/dsh-session/types';
 import { deriveEventMessage, isAppendSurfaceEvent } from '@deepseek-ai/dsh-session/surface';
 import { TypertRemoteService, Remote } from '@deepseek-ai/dsh-typert-protocol';
-import { messageFeedbackDomainSpec } from "./spec.js";
-export { messageFeedbackDomainSpec, messageFeedbackItemSchema, messageFeedbackRatingSchema, messageFeedbackRowSchema, messageFeedbackSessionIdentitySchema, messageFeedbackVersionSchema, } from "./spec.js";
-/** Immutable empty list reused only as an input to caller-owned copying. */
-const EMPTY_ITEMS = Object.freeze([]);
-/** Validate the one deployment-varying limit at the configuration boundary. */
-function resolveMaxNoteBytes(value) {
-    if (!Number.isSafeInteger(value) || value < 1) {
-        throw new TypeError(`message-feedback: maxNoteBytes must be a positive safe integer, got ${String(value)}`);
-    }
-    return value;
-}
-/** Copy and freeze one item before it crosses the service boundary. */
+const timestamp = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const itemSchema = z.object({
+    messageId: z.string().min(1),
+    rating: z.enum(['positive', 'negative']),
+    note: z.string().refine(note => note.trim().length > 0).optional(),
+    version: z.uuid(),
+    createdAt: timestamp,
+    updatedAt: timestamp,
+}).refine(item => item.updatedAt >= item.createdAt);
+const putSchema = z.object({ sessionId: z.string().min(1), item: itemSchema });
+const deleteSchema = z.object({ sessionId: z.string().min(1), messageId: z.string().min(1) });
+/** Return a caller-owned immutable value, detached from the log. */
 function snapshotItem(item) {
-    return Object.freeze({
-        messageId: item.messageId,
-        rating: item.rating,
-        ...(item.note === undefined ? {} : { note: item.note }),
-        version: item.version,
-        createdAt: item.createdAt,
-        updatedAt: item.updatedAt,
-    });
-}
-/** Copy and freeze a list response. */
-function snapshotList(items) {
-    return Object.freeze({ items: Object.freeze(items.map(snapshotItem)) });
+    return Object.freeze({ ...item });
 }
-/** Build a frozen success branch. */
 function success(value) {
     return Object.freeze({ ok: true, value });
 }
-/** Build a frozen business-failure branch. */
 function rejected(error) {
     return Object.freeze({ ok: false, error: Object.freeze(error) });
 }
-/** Project the Session fields that distinguish one persisted log lifecycle. */
-function identityOf(header) {
-    return Object.freeze({
-        createdAt: header.createdAt,
-        ...(header.cwd === undefined ? {} : { cwd: header.cwd }),
-    });
-}
-/** Whether a stored row belongs to the inspected Session lifecycle. */
-function sameIdentity(row, header) {
-    return row.session.createdAt === header.createdAt && row.session.cwd === header.cwd;
-}
-/** Whether two observations name the same persisted Session lifecycle. */
-function sameHeaderIdentity(left, right) {
-    return left.id === right.id && left.createdAt === right.createdAt && left.cwd === right.cwd;
-}
-/** Freeze the replacement row so storage-domain never exposes mutable aliases. */
-function rowSnapshot(session, items) {
-    const copiedItems = items.map(snapshotItem);
-    Object.freeze(copiedItems);
-    return Object.freeze({
-        session,
-        items: copiedItems,
-    });
-}
-/** Generate an opaque equality token for one material mutation. */
-function nextVersion() {
-    return randomUUID();
+/** Validate persisted payloads before deriving current, Session-owned feedback. */
+function currentItems(sessionId, events) {
+    const items = new Map();
+    for (const event of events) {
+        switch (event.type) {
+            case 'feedback/message-put':
+                putSchema.parse(event.data);
+                if (event.data.sessionId === sessionId)
+                    items.set(event.data.item.messageId, event.data.item);
+                break;
+            case 'feedback/message-delete':
+                deleteSchema.parse(event.data);
+                if (event.data.sessionId === sessionId)
+                    items.delete(event.data.messageId);
+                break;
+            default:
+                // Other plugins' events do not change message feedback.
+                break;
+        }
+    }
+    return [...items.values()];
 }
-/**
- * Storage-domain sidecar service. It inspects persisted Session history and
- * never creates or resumes an Agent or Session.
- */
+/** Session-log service; cold operations never construct a Session or Agent. */
 let MessageFeedbackService = (() => {
     let _classSuper = TypertRemoteService;
     let _instanceExtraInitializers = [];
@@ -126,177 +106,154 @@ let MessageFeedbackService = (() => {
             __esDecorate(this, null, _delete_decorators, { kind: "method", name: "delete", static: false, private: false, access: { has: obj => "delete" in obj, get: obj => obj.delete }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        static inject = ['storageDomain', 'sessionPersistence', 'sessions'];
+        static inject = ['sessionPersistence', 'sessions'];
         /** Loader validation for the required note-size policy. */
         static Config = s.object({
             maxNoteBytes: s.number().step(1).min(1).required(),
         });
         maxNoteBytes = __runInitializers(this, _instanceExtraInitializers);
-        table;
         operationTails = new Map();
         mutationAdmissionOpen = true;
         /**
-         * @param ctx - Host context carrying persistence and the storage-domain form.
+         * @param ctx - Host context carrying Session persistence and live owners.
          * @param config - Required note-size policy.
          */
         constructor(ctx, config) {
             super(ctx, 'messageFeedback');
-            this.maxNoteBytes = resolveMaxNoteBytes(config.maxNoteBytes);
+            if (!Number.isSafeInteger(config.maxNoteBytes) || config.maxNoteBytes < 1) {
+                throw new TypeError('message-feedback: maxNoteBytes must be a positive safe integer');
+            }
+            this.maxNoteBytes = config.maxNoteBytes;
         }
-        /** Open and own the one message-feedback sidecar domain. */
-        async [Service.init]() {
-            const domain = await this.ctx.storageDomain.open(messageFeedbackDomainSpec);
+        [Service.init]() {
             this.ctx.effect(() => async () => {
                 this.mutationAdmissionOpen = false;
                 await Promise.all(this.operationTails.values());
-                await domain.close();
-            }, 'message-feedback.domainClose');
-            this.table = domain.table('sessions');
+            }, 'message-feedback.drain');
         }
         /**
-         * Read feedback belonging to the current persisted Session lifecycle.
-         * A stale row from a reused Session id is invisible.
-         * @param request - Session identity to inspect and list.
-         * @returns current immutable items or `session-not-found`.
+         * Read current feedback from the canonical log.
+         * @param request - Session to inspect.
+         * @returns immutable items or a definite persistence miss.
          */
-        async list(request) {
-            const known = await this.inspectSession(request.sessionId);
-            if (!known.ok)
-                return known;
-            const row = this.requireTable().get(request.sessionId);
-            const items = row !== undefined && sameIdentity(row, known.value.meta) ? row.items : EMPTY_ITEMS;
-            return success(snapshotList(items));
+        list(request) {
+            return this.enqueue(request.sessionId, () => this.withSession(request.sessionId, false, events => success(Object.freeze({ items: Object.freeze(currentItems(request.sessionId, events).map(snapshotItem)) }))));
         }
         /**
-         * Create or replace feedback for one derived append-origin assistant
-         * message. Every request must match the addressed item's current version;
-         * a matching no-op returns the stored item without changing its revision.
-         * @param request - target, desired value, and observed item version.
-         * @returns the committed item or an explicit business failure.
+         * Create or replace feedback after checking its current version.
+         * Matching no-ops retain the version and append no event.
+         * @param request - Target, desired value, and observed item version.
+         * @returns the durable item or an explicit business failure.
          */
         put(request) {
             const note = this.resolveNote(request.note);
             if (!note.ok)
                 return Promise.resolve(note);
-            return this.enqueue(request.sessionId, async () => {
-                const known = await this.inspectSession(request.sessionId);
-                if (!known.ok)
-                    return known;
-                if (!this.hasFeedbackTarget(known.value, request.messageId)) {
-                    return rejected({
-                        code: 'target-not-found',
-                        sessionId: request.sessionId,
-                        messageId: request.messageId,
-                    });
-                }
-                const durable = await this.ensureTargetDurable(known.value);
-                if (!sameHeaderIdentity(durable.meta, known.value.meta)
-                    || !this.hasFeedbackTarget(durable, request.messageId)) {
-                    return rejected({
-                        code: 'target-not-found',
-                        sessionId: request.sessionId,
-                        messageId: request.messageId,
-                    });
+            return this.enqueue(request.sessionId, () => this.withSession(request.sessionId, true, async (events, append) => {
+                const items = currentItems(request.sessionId, events);
+                if (!events.some(event => event.type === 'assistant/message'
+                    && isAppendSurfaceEvent(event)
+                    && deriveEventMessage(event)?.id === request.messageId)) {
+                    return rejected({ code: 'target-not-found', sessionId: request.sessionId, messageId: request.messageId });
                 }
-                const table = this.requireTable();
-                const stored = table.get(request.sessionId);
-                const current = stored !== undefined && sameIdentity(stored, durable.meta) ? stored : undefined;
-                const items = current?.items ?? EMPTY_ITEMS;
-                const index = items.findIndex(item => item.messageId === request.messageId);
-                const existing = items[index];
+                const existing = items.find(item => item.messageId === request.messageId);
                 if (request.ifVersion !== (existing?.version ?? null)) {
                     return rejected(this.versionConflict(existing ?? null));
                 }
-                if (existing !== undefined
-                    && existing.rating === request.rating
-                    && existing.note === note.value) {
+                if (existing !== undefined && existing.rating === request.rating && existing.note === note.value) {
+                    await append();
                     return success(snapshotItem(existing));
                 }
                 const now = Date.now();
-                const item = snapshotItem({
+                const item = {
                     messageId: request.messageId,
                     rating: request.rating,
                     ...(note.value === undefined ? {} : { note: note.value }),
-                    version: nextVersion(),
+                    version: randomUUID(),
                     createdAt: existing?.createdAt ?? now,
                     updatedAt: existing === undefined ? now : Math.max(now, existing.updatedAt),
-                });
-                const nextItems = [...items];
-                if (index === -1)
-                    nextItems.push(item);
-                else
-                    nextItems[index] = item;
-                await table.put(request.sessionId, rowSnapshot(identityOf(durable.meta), nextItems));
+                };
+                await append({ type: 'feedback/message-put', data: { sessionId: request.sessionId, item } });
                 return success(snapshotItem(item));
-            });
+            }));
         }
         /**
-         * Delete one feedback item. Absence is successful regardless of the
-         * supplied version; an existing item requires an exact version match.
+         * Delete one item after checking its version; absence succeeds without an event.
          * @param request - Session, message, and observed item version.
-         * @returns the stable absent postcondition, or an explicit failure.
+         * @returns the stable absent postcondition or an explicit failure.
          */
         delete(request) {
-            return this.enqueue(request.sessionId, async () => {
-                const known = await this.inspectSession(request.sessionId);
-                if (!known.ok)
-                    return known;
-                const table = this.requireTable();
-                const stored = table.get(request.sessionId);
-                const current = stored !== undefined && sameIdentity(stored, known.value.meta) ? stored : undefined;
-                const items = current?.items ?? EMPTY_ITEMS;
-                const existing = items.find(item => item.messageId === request.messageId);
-                if (existing === undefined) {
-                    return success(Object.freeze({ absent: true }));
+            return this.enqueue(request.sessionId, () => this.withSession(request.sessionId, true, async (events, append) => {
+                const existing = currentItems(request.sessionId, events).find(item => item.messageId === request.messageId);
+                if (existing !== undefined) {
+                    if (request.ifVersion !== existing.version)
+                        return rejected(this.versionConflict(existing));
+                    await append({ type: 'feedback/message-delete', data: { sessionId: request.sessionId, messageId: request.messageId } });
                 }
-                if (request.ifVersion !== existing.version) {
-                    return rejected(this.versionConflict(existing));
+                else {
+                    await append();
                 }
-                await table.put(request.sessionId, rowSnapshot(identityOf(known.value.meta), items.filter(item => item !== existing)));
                 return success(Object.freeze({ absent: true }));
-            });
+            }));
         }
-        /**
-         * Resolve a live owner directly; otherwise use the storage catalog as the
-         * existence authority before inspecting the log. Inspection failures for a
-         * catalogued Session remain infrastructure failures rather than being
-         * guessed into the business `session-not-found` branch.
-         */
-        async inspectSession(sessionId) {
-            if (this.ctx.sessions.get(sessionId) === undefined) {
-                const snapshots = await this.ctx.sessionPersistence.listSnapshots();
-                if (!snapshots.some(snapshot => snapshot.header.id === sessionId)
-                    && this.ctx.sessions.get(sessionId) === undefined) {
-                    return rejected({ code: 'session-not-found', sessionId });
-                }
+        /** Hold cold write ownership across read/compare/append; use live owners directly. */
+        async withSession(sessionId, write, operation) {
+            if (this.ctx.sessions.get(sessionId) === undefined
+                && await this.ctx.sessionPersistence.stat(sessionId) === undefined
+                && this.ctx.sessions.get(sessionId) === undefined) {
+                return rejected({ code: 'session-not-found', sessionId });
             }
-            return success(await this.ctx.sessionPersistence.inspect(sessionId));
-        }
-        /** Require the exact finalized append-origin assistant message projection. */
-        hasFeedbackTarget(inspection, messageId) {
-            return inspection.events.some((event) => {
-                if (event.type !== 'assistant/message' || !isAppendSurfaceEvent(event))
-                    return false;
-                const message = deriveEventMessage(event);
-                return message?.role === 'assistant' && message.id === messageId;
-            });
-        }
-        /**
-         * Put the target log prefix behind a durability barrier before its sidecar.
-         * A live owner flushes through the SessionStore's canonical checkpoint; a
-         * cold owner is re-read from the physical durable prefix.
-         */
-        async ensureTargetDurable(inspection) {
-            const live = this.ctx.sessions.get(inspection.meta.id);
-            if (live !== undefined && sameHeaderIdentity(live.header, inspection.meta)) {
-                if (!(await this.ctx.sessions.flush(live))) {
-                    throw new Error(`message-feedback: no durability listener participated for live session '${inspection.meta.id}'`);
-                }
-                return await this.ctx.sessionPersistence.readFrom(inspection.meta.id, SessionLogOffset(0));
+            const live = this.ctx.sessions.get(sessionId);
+            if (live !== undefined) {
+                return operation(live.snapshotEvents(), async (event) => {
+                    if (event !== undefined) {
+                        live.append(event.type, event.data);
+                    }
+                    const last = live.snapshotEvents().at(-1);
+                    if (!(await this.ctx.sessions.flush(live))) {
+                        throw new Error(`message-feedback: no durability listener participated for live session '${sessionId}'`);
+                    }
+                    // Listener participation alone does not prove this Session has a persistence writer.
+                    const handle = await this.ctx.sessionPersistence.open(sessionId, 'read');
+                    try {
+                        const { events: stored } = await handle.read(last?.seq ?? 0, 1);
+                        if (!isDeepStrictEqual([handle.header.id, handle.header.createdAt, handle.header.cwd], [live.header.id, live.header.createdAt, live.header.cwd])
+                            || (last !== undefined && !isDeepStrictEqual(stored[0], last))) {
+                            throw new Error(`message-feedback: feedback prefix is not durable for live session '${sessionId}'`);
+                        }
+                    }
+                    finally {
+                        await handle.close();
+                    }
+                });
+            }
+            const handle = await this.ctx.sessionPersistence.open(sessionId, write ? 'write' : 'read');
+            try {
+                const { events } = await handle.read();
+                return await operation(events, async (event) => {
+                    const entry = event === undefined ? undefined
+                        : { ...event, seq: SessionSeq(events.length), time: Date.now() };
+                    if (entry !== undefined)
+                        await handle.append([entry]);
+                    await handle.flush();
+                    if (entry !== undefined) {
+                        try {
+                            await this.ctx.parallel('feedback/committed', {
+                                meta: handle.header,
+                                inheritedEventCount: handle.inheritedEventCount,
+                                events: [...events, entry],
+                            });
+                        }
+                        catch (error) {
+                            this.ctx.logger.warn('message-feedback: committed feedback observer failed', error);
+                        }
+                    }
+                });
+            }
+            finally {
+                await handle.close();
             }
-            return await this.ctx.sessionPersistence.readFrom(inspection.meta.id, SessionLogOffset(0));
         }
-        /** Validate optional-note semantics and the configured complete UTF-8 byte bound. */
         resolveNote(note) {
             if (note === undefined)
                 return success(undefined);
@@ -308,18 +265,13 @@ let MessageFeedbackService = (() => {
             }
             return success(note);
         }
-        /** Return the authoritative item needed to reconcile one failed comparison. */
         versionConflict(current) {
-            return {
-                code: 'version-conflict',
-                current: current === null ? null : snapshotItem(current),
-            };
+            return { code: 'version-conflict', current: current === null ? null : snapshotItem(current) };
         }
-        /** Queue a complete read/compare/write mutation behind this Session's prior mutation. */
+        /** Serialize complete operations and drain their handles before disposal. */
         enqueue(sessionId, operation) {
-            if (!this.mutationAdmissionOpen) {
+            if (!this.mutationAdmissionOpen)
                 return Promise.reject(new Error('message-feedback: service is disposing'));
-            }
             const previous = this.operationTails.get(sessionId) ?? Promise.resolve();
             const result = previous.then(operation);
             const tail = result.then(() => undefined, () => undefined);
@@ -329,13 +281,6 @@ let MessageFeedbackService = (() => {
                     this.operationTails.delete(sessionId);
             });
         }
-        /** Resolve the initialized durable table or fail a broken service lifecycle. */
-        requireTable() {
-            if (this.table === undefined) {
-                throw new Error('message-feedback: durable domain is not initialized');
-            }
-            return this.table;
-        }
     };
 })();
 export { MessageFeedbackService };

package/lib/types/types.d.ts

@@ -26,9 +26,31 @@ export interface MessageFeedbackItem {
     /** Host-assigned time of the most recent material update. */
     readonly updatedAt: number;
 }
+/** A material creation or edit, retaining its complete current value. */
+export interface MessageFeedbackPut {
+    /** Owning Session; inherited feedback in a fork belongs to its parent. */
+    readonly sessionId: SessionId;
+    /** Value after this mutation, including the original creation time. */
+    readonly item: MessageFeedbackItem;
+}
+/** A material deletion of one current feedback item. */
+export interface MessageFeedbackDelete {
+    /** Session that owns the deleted feedback. */
+    readonly sessionId: SessionId;
+    /** Message whose feedback was removed. */
+    readonly messageId: MessageId;
+}
+declare module '@deepseek-ai/dsh-session/types' {
+    interface SessionEventMap {
+        /** Log-only human feedback; never enters model history. */
+        'feedback/message-put': MessageFeedbackPut;
+        /** Log-only deletion; earlier ratings and notes remain in the log. */
+        'feedback/message-delete': MessageFeedbackDelete;
+    }
+}
 /** Read all message feedback belonging to one persisted Session lifecycle. */
 export interface MessageFeedbackListRequest {
-    /** Persisted Session whose sidecar should be read. */
+    /** Session whose feedback events should be read. */
     readonly sessionId: SessionId;
 }
 /** Current feedback values for one Session, in first-creation order. */
@@ -51,7 +73,7 @@ export interface MessageFeedbackPutRequest {
 }
 /** Delete feedback for one message after observing its current version. */
 export interface MessageFeedbackDeleteRequest {
-    /** Persisted Session that owns the sidecar. */
+    /** Session that owns the feedback. */
     readonly sessionId: SessionId;
     /** Message whose feedback should be absent after this operation. */
     readonly messageId: MessageId;