@hexis-ai/engram-server 0.7.0 → 0.9.0

package/dist/adapters/memory.d.ts

@@ -1,5 +1,5 @@
 import type { Session } from "@hexis-ai/engram-core";
-import type { AliasInfo, AliasUpsert, IdentityInfo, IdentityUpsert, PersonCreate, PersonInfo, PersonUpdate, SessionEvent, SessionInit } from "@hexis-ai/engram-sdk";
+import type { AliasInfo, AliasUpsert, IdentityInfo, IdentityUpsert, PersonCreate, PersonInfo, PersonUpdate, SessionEvent, SessionInit, SessionUpdate } from "@hexis-ai/engram-sdk";
 import { type StorageAdapter } from "../storage";
 export interface InMemoryAdapterOptions {
     /** Override for tests. Default: `p_${random}` with 8 chars. */
@@ -24,10 +24,12 @@ export declare class InMemoryAdapter implements StorageAdapter {
     }): Promise<void>;
     appendEvents(sessionId: string, events: SessionEvent[]): Promise<void>;
     getSession(sessionId: string): Promise<Session | null>;
+    updateSession(sessionId: string, patch: SessionUpdate): Promise<Session | null>;
     getSessionEvents(sessionId: string): Promise<SessionEvent[] | null>;
     listSessions(opts: {
         limit: number;
         channel?: string;
+        status?: "active" | "idle" | "completed";
     }): Promise<Session[]>;
     sessionsForPerson(personId: string, opts: {
         limit: number;

package/dist/adapters/memory.js

@@ -37,6 +37,17 @@ export class InMemoryAdapter {
                 participants,
                 viewable_by,
                 createdAt: init.createdAt,
+                updatedAt: init.createdAt,
+                // status defaults to 'active' to match the Postgres column default.
+                status: init.status ?? "active",
+                ...(init.summary != null ? { summary: init.summary } : {}),
+                ...(init.model != null ? { model: init.model } : {}),
+                ...(init.trigger_conversation_id != null
+                    ? { trigger_conversation_id: init.trigger_conversation_id }
+                    : {}),
+                ...(init.trigger_event_id != null
+                    ? { trigger_event_id: init.trigger_event_id }
+                    : {}),
             },
             events: new Map(),
         });
@@ -59,6 +70,13 @@ export class InMemoryAdapter {
                 };
             }
         }
+        if (events.length > 0) {
+            const latestAt = events[events.length - 1].at;
+            // Bump updated_at to the latest event's `at` (monotonic).
+            if (latestAt > s.row.updatedAt) {
+                s.row = { ...s.row, updatedAt: latestAt };
+            }
+        }
     }
     async getSession(sessionId) {
         const s = this.sessions.get(sessionId);
@@ -66,6 +84,57 @@ export class InMemoryAdapter {
             return null;
         return foldEvents(s.row, [...s.events.values()], new Date());
     }
+    async updateSession(sessionId, patch) {
+        const s = this.sessions.get(sessionId);
+        if (!s)
+            return null;
+        // Patch semantics: undefined = leave alone; null = clear; value = set.
+        // SessionRow optional fields use `string | undefined`, so a "null"
+        // request collapses to `undefined` storage-side.
+        const next = { ...s.row };
+        if (patch.title !== undefined) {
+            if (patch.title === null)
+                delete next.title;
+            else
+                next.title = patch.title;
+        }
+        if (patch.channel !== undefined) {
+            if (patch.channel === null)
+                delete next.channel;
+            else
+                next.channel = patch.channel;
+        }
+        if (patch.status !== undefined) {
+            next.status = patch.status;
+        }
+        if (patch.summary !== undefined) {
+            if (patch.summary === null)
+                delete next.summary;
+            else
+                next.summary = patch.summary;
+        }
+        if (patch.model !== undefined) {
+            if (patch.model === null)
+                delete next.model;
+            else
+                next.model = patch.model;
+        }
+        if (patch.trigger_conversation_id !== undefined) {
+            if (patch.trigger_conversation_id === null)
+                delete next.trigger_conversation_id;
+            else
+                next.trigger_conversation_id = patch.trigger_conversation_id;
+        }
+        if (patch.trigger_event_id !== undefined) {
+            if (patch.trigger_event_id === null)
+                delete next.trigger_event_id;
+            else
+                next.trigger_event_id = patch.trigger_event_id;
+        }
+        next.updatedAt = new Date().toISOString();
+        s.row = next;
+        return foldEvents(s.row, [...s.events.values()], new Date());
+    }
     async getSessionEvents(sessionId) {
         const s = this.sessions.get(sessionId);
         if (!s)
@@ -78,12 +147,14 @@ export class InMemoryAdapter {
         for (const stored of this.sessions.values()) {
             if (opts.channel && stored.row.channel !== opts.channel)
                 continue;
+            if (opts.status && stored.row.status !== opts.status)
+                continue;
             all.push({
                 s: foldEvents(stored.row, [...stored.events.values()], now),
-                createdAt: stored.row.createdAt,
+                updatedAt: stored.row.updatedAt,
             });
         }
-        all.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        all.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
         return all.slice(0, opts.limit).map((x) => x.s);
     }
     async sessionsForPerson(personId, opts) {
@@ -112,15 +183,17 @@ export class InMemoryAdapter {
     async upsertPerson(id, input) {
         const now = new Date().toISOString();
         const existing = this.persons.get(id);
+        // `PersonCreate` has no notion of "clear" — that's `updatePerson`'s
+        // job. Missing / null in input means "keep what's there", matching
+        // the Postgres adapter's COALESCE-on-conflict.
         const next = {
             id,
-            // `PersonCreate` has no notion of "clear the name" — that is
-            // `updatePerson`'s job. A missing value (and, defensively, an
-            // explicit null that bypasses the schema) means "keep what's
-            // there", matching the Postgres adapter's `COALESCE(EXCLUDED.…)`.
             display_name: input.display_name != null
                 ? input.display_name
                 : existing?.display_name ?? null,
+            role: input.role != null ? input.role : existing?.role ?? null,
+            team: input.team != null ? input.team : existing?.team ?? null,
+            source: input.source ?? existing?.source ?? "auto",
             created_at: existing?.created_at ?? now,
             updated_at: now,
         };
@@ -132,9 +205,13 @@ export class InMemoryAdapter {
         if (!existing)
             return null;
         const now = new Date().toISOString();
+        // undefined = no-op, null = clear (per the SDK contract).
         const next = {
             ...existing,
             display_name: patch.display_name !== undefined ? patch.display_name : existing.display_name,
+            role: patch.role !== undefined ? patch.role : existing.role ?? null,
+            team: patch.team !== undefined ? patch.team : existing.team ?? null,
+            source: patch.source !== undefined ? patch.source : existing.source ?? "auto",
             updated_at: now,
         };
         this.persons.set(id, next);
@@ -155,9 +232,28 @@ export class InMemoryAdapter {
     async listPersons(opts) {
         const q = opts.q?.trim().toLowerCase() ?? "";
         const all = [...this.persons.values()];
+        // Search spans person fields + active identities (matching the
+        // Postgres impl). Slow O(n*m) here is fine — in-memory is for
+        // tests / dev / small single-node deploys.
         const matched = q
-            ? all.filter((p) => p.id.toLowerCase().includes(q) ||
-                (p.display_name?.toLowerCase().includes(q) ?? false))
+            ? all.filter((p) => {
+                if (p.id.toLowerCase().includes(q))
+                    return true;
+                if (p.display_name?.toLowerCase().includes(q))
+                    return true;
+                if (p.role?.toLowerCase().includes(q))
+                    return true;
+                if (p.team?.toLowerCase().includes(q))
+                    return true;
+                for (const i of this.identities.values()) {
+                    if (i.person_id === p.id &&
+                        i.unlinked_at == null &&
+                        i.display_name?.toLowerCase().includes(q)) {
+                        return true;
+                    }
+                }
+                return false;
+            })
             : all;
         matched.sort((a, b) => b.updated_at.localeCompare(a.updated_at));
         return matched.slice(0, opts.limit);
@@ -197,6 +293,10 @@ export class InMemoryAdapter {
             return null;
         const now = new Date().toISOString();
         const existing = this.identities.get(ref);
+        // COALESCE-on-conflict for the soft-overlap fields; ref-level
+        // mapping (person_id, service, external_id, linked_at) always
+        // takes the latest input. unlinked_at uses undefined=no-change
+        // semantics so callers can re-link without explicitly clearing.
         const next = {
             ref,
             person_id: input.person_id,
@@ -206,11 +306,12 @@ export class InMemoryAdapter {
                 ? input.display_name
                 : existing?.display_name ?? null,
             source: input.source !== undefined ? input.source : existing?.source ?? null,
-            is_primary: input.is_primary !== undefined
-                ? input.is_primary
-                : existing?.is_primary ?? null,
+            is_primary: input.is_primary ?? existing?.is_primary ?? false,
             picture: input.picture !== undefined ? input.picture : existing?.picture ?? null,
             linked_at: input.linked_at,
+            unlinked_at: input.unlinked_at !== undefined
+                ? input.unlinked_at
+                : existing?.unlinked_at ?? null,
             created_at: existing?.created_at ?? now,
             updated_at: now,
         };

package/dist/adapters/postgres.d.ts

@@ -1,5 +1,5 @@
 import type { Session } from "@hexis-ai/engram-core";
-import type { AliasInfo, AliasUpsert, IdentityInfo, IdentityUpsert, PersonCreate, PersonInfo, PersonUpdate, SessionEvent, SessionInit } from "@hexis-ai/engram-sdk";
+import type { AliasInfo, AliasUpsert, IdentityInfo, IdentityUpsert, PersonCreate, PersonInfo, PersonUpdate, SessionEvent, SessionInit, SessionUpdate } from "@hexis-ai/engram-sdk";
 import { type StorageAdapter } from "../storage";
 /**
  * Minimal subset of `postgres` driver's tagged-template surface that this
@@ -37,10 +37,12 @@ export declare class PostgresAdapter implements StorageAdapter {
     }): Promise<void>;
     appendEvents(sessionId: string, events: SessionEvent[]): Promise<void>;
     getSession(sessionId: string): Promise<Session | null>;
+    updateSession(sessionId: string, patch: SessionUpdate): Promise<Session | null>;
     getSessionEvents(sessionId: string): Promise<SessionEvent[] | null>;
     listSessions(opts: {
         limit: number;
         channel?: string;
+        status?: "active" | "idle" | "completed";
     }): Promise<Session[]>;
     sessionsForPerson(personId: string, opts: {
         limit: number;

package/dist/adapters/postgres.js

@@ -38,8 +38,14 @@ export class PostgresAdapter {
         const viewableBy = init.viewable_by
             ? Array.from(new Set([...init.viewable_by, ...participants]))
             : [...participants];
+        // status defaults to 'active' server-side via the column default;
+        // a null value here is treated as "use the default" by NULL-fallback.
         await this.sql `
-      INSERT INTO engram_sessions (workspace_id, id, title, channel, participants, viewable_by, created_at)
+      INSERT INTO engram_sessions (
+        workspace_id, id, title, channel, participants, viewable_by,
+        created_at, updated_at, status, summary, model,
+        trigger_conversation_id, trigger_event_id
+      )
       VALUES (
         ${this.workspaceId},
         ${init.id},
@@ -47,7 +53,13 @@ export class PostgresAdapter {
         ${init.channel ?? null},
         ${participants},
         ${viewableBy},
-        ${init.createdAt}
+        ${init.createdAt},
+        ${init.createdAt},
+        ${init.status ?? "active"},
+        ${init.summary ?? null},
+        ${init.model ?? null},
+        ${init.trigger_conversation_id ?? null},
+        ${init.trigger_event_id ?? null}
       )
       ON CONFLICT (workspace_id, id) DO NOTHING
     `;
@@ -84,31 +96,65 @@ export class PostgresAdapter {
         `;
             }
         }
+        // Bump updated_at once per batch so list-by-recent-activity stays
+        // accurate. Using the latest event's `at` (not now()) keeps the
+        // semantics deterministic for back-dated batches.
+        const latest = events[events.length - 1];
+        await this.sql `
+      UPDATE engram_sessions
+      SET updated_at = GREATEST(updated_at, ${latest.at}::timestamptz)
+      WHERE workspace_id = ${this.workspaceId} AND id = ${sessionId}
+    `;
     }
     async getSession(sessionId) {
         const rows = await this.sql `
-      SELECT id, title, channel, participants, viewable_by, created_at
+      SELECT id, title, channel, participants, viewable_by, created_at,
+             updated_at, status, summary, model,
+             trigger_conversation_id, trigger_event_id
       FROM engram_sessions
       WHERE workspace_id = ${this.workspaceId} AND id = ${sessionId}
       LIMIT 1
     `;
         if (rows.length === 0)
             return null;
-        const r = rows[0];
         const events = await this.sql `
       SELECT payload FROM engram_events
       WHERE workspace_id = ${this.workspaceId} AND session_id = ${sessionId}
       ORDER BY seq
     `;
-        const row = {
-            id: r.id,
-            ...(r.title ? { title: r.title } : {}),
-            ...(r.channel ? { channel: r.channel } : {}),
-            participants: r.participants,
-            viewable_by: r.viewable_by,
-            createdAt: typeof r.created_at === "string" ? r.created_at : r.created_at.toISOString(),
-        };
-        return foldEvents(row, events.map((e) => e.payload), new Date());
+        return foldEvents(toSessionRow(rows[0]), events.map((e) => e.payload), new Date());
+    }
+    async updateSession(sessionId, patch) {
+        // Translate JS undefined → "no change" via a per-column "provided"
+        // flag the SQL evaluates with CASE WHEN. null in patch becomes a
+        // real null in the DB (clear), value becomes a set.
+        const titleProvided = patch.title !== undefined;
+        const channelProvided = patch.channel !== undefined;
+        const statusProvided = patch.status !== undefined;
+        const summaryProvided = patch.summary !== undefined;
+        const modelProvided = patch.model !== undefined;
+        const tcIdProvided = patch.trigger_conversation_id !== undefined;
+        const teIdProvided = patch.trigger_event_id !== undefined;
+        const rows = await this.sql `
+      UPDATE engram_sessions SET
+        title    = CASE WHEN ${titleProvided}    THEN ${patch.title ?? null}    ELSE title    END,
+        channel  = CASE WHEN ${channelProvided}  THEN ${patch.channel ?? null}  ELSE channel  END,
+        status   = CASE WHEN ${statusProvided}   THEN ${patch.status ?? "active"} ELSE status END,
+        summary  = CASE WHEN ${summaryProvided}  THEN ${patch.summary ?? null}  ELSE summary  END,
+        model    = CASE WHEN ${modelProvided}    THEN ${patch.model ?? null}    ELSE model    END,
+        trigger_conversation_id = CASE WHEN ${tcIdProvided}
+          THEN ${patch.trigger_conversation_id ?? null}
+          ELSE trigger_conversation_id END,
+        trigger_event_id = CASE WHEN ${teIdProvided}
+          THEN ${patch.trigger_event_id ?? null}
+          ELSE trigger_event_id END,
+        updated_at = now()
+      WHERE workspace_id = ${this.workspaceId} AND id = ${sessionId}
+      RETURNING id
+    `;
+        if (rows.length === 0)
+            return null;
+        return this.getSession(sessionId);
     }
     async getSessionEvents(sessionId) {
         const rows = await this.sql `
@@ -127,11 +173,13 @@ export class PostgresAdapter {
     }
     async listSessions(opts) {
         const channelFilter = opts.channel ?? null;
+        const statusFilter = opts.status ?? null;
         const rows = await this.sql `
       SELECT id FROM engram_sessions
       WHERE workspace_id = ${this.workspaceId}
         AND (${channelFilter}::text IS NULL OR channel = ${channelFilter}::text)
-      ORDER BY created_at DESC
+        AND (${statusFilter}::text IS NULL OR status  = ${statusFilter}::text)
+      ORDER BY updated_at DESC
       LIMIT ${opts.limit}
     `;
         const sessions = await Promise.all(rows.map((r) => this.getSession(r.id)));
@@ -169,24 +217,41 @@ export class PostgresAdapter {
     }
     async upsertPerson(id, input) {
         const rows = await this.sql `
-      INSERT INTO engram_persons (workspace_id, id, display_name)
-      VALUES (${this.workspaceId}, ${id}, ${input.display_name ?? null})
+      INSERT INTO engram_persons (workspace_id, id, display_name, role, team, source)
+      VALUES (
+        ${this.workspaceId}, ${id},
+        ${input.display_name ?? null},
+        ${input.role ?? null},
+        ${input.team ?? null},
+        ${input.source ?? "auto"}
+      )
       ON CONFLICT (workspace_id, id) DO UPDATE SET
+        -- COALESCE-on-conflict so partial-info upserts don't clobber
+        -- richer profile data set earlier.
         display_name = COALESCE(EXCLUDED.display_name, engram_persons.display_name),
+        role         = COALESCE(EXCLUDED.role,         engram_persons.role),
+        team         = COALESCE(EXCLUDED.team,         engram_persons.team),
+        source       = COALESCE(EXCLUDED.source,       engram_persons.source),
         updated_at   = now()
-      RETURNING id, display_name, created_at, updated_at
+      RETURNING id, display_name, role, team, source, created_at, updated_at
     `;
         return toPersonInfo(rows[0]);
     }
     async updatePerson(id, patch) {
         // Treat `null` as an explicit clear; `undefined` as no-op.
         const nameProvided = patch.display_name !== undefined;
+        const roleProvided = patch.role !== undefined;
+        const teamProvided = patch.team !== undefined;
+        const sourceProvided = patch.source !== undefined;
         const rows = await this.sql `
-      UPDATE engram_persons
-      SET display_name = CASE WHEN ${nameProvided} THEN ${patch.display_name ?? null} ELSE display_name END,
-          updated_at   = now()
+      UPDATE engram_persons SET
+        display_name = CASE WHEN ${nameProvided}   THEN ${patch.display_name ?? null} ELSE display_name END,
+        role         = CASE WHEN ${roleProvided}   THEN ${patch.role ?? null}         ELSE role         END,
+        team         = CASE WHEN ${teamProvided}   THEN ${patch.team ?? null}         ELSE team         END,
+        source       = CASE WHEN ${sourceProvided} THEN ${patch.source ?? "auto"}     ELSE source       END,
+        updated_at   = now()
       WHERE workspace_id = ${this.workspaceId} AND id = ${id}
-      RETURNING id, display_name, created_at, updated_at
+      RETURNING id, display_name, role, team, source, created_at, updated_at
     `;
         if (rows.length === 0)
             return null;
@@ -194,7 +259,7 @@ export class PostgresAdapter {
     }
     async getPerson(id) {
         const rows = await this.sql `
-      SELECT id, display_name, created_at, updated_at
+      SELECT id, display_name, role, team, source, created_at, updated_at
       FROM engram_persons
       WHERE workspace_id = ${this.workspaceId} AND id = ${id}
       LIMIT 1
@@ -207,7 +272,7 @@ export class PostgresAdapter {
         if (ids.length === 0)
             return [];
         const rows = await this.sql `
-      SELECT id, display_name, created_at, updated_at
+      SELECT id, display_name, role, team, source, created_at, updated_at
       FROM engram_persons
       WHERE workspace_id = ${this.workspaceId}
         AND id = ANY(${ids}::text[])
@@ -218,18 +283,32 @@ export class PostgresAdapter {
         const q = opts.q?.trim() ?? "";
         if (q) {
             const pattern = `%${q.toLowerCase()}%`;
+            // Free-text search spans the person row + active identities so
+            // a query like "design" finds people by role *or* by external
+            // identity display_name (e.g. their Slack profile name).
             const rows = await this.sql `
-        SELECT id, display_name, created_at, updated_at
-        FROM engram_persons
-        WHERE workspace_id = ${this.workspaceId}
-          AND (lower(id) LIKE ${pattern} OR lower(coalesce(display_name, '')) LIKE ${pattern})
-        ORDER BY updated_at DESC
+        SELECT DISTINCT p.id, p.display_name, p.role, p.team, p.source,
+                        p.created_at, p.updated_at
+        FROM engram_persons p
+        LEFT JOIN engram_identities i
+          ON i.workspace_id = p.workspace_id
+         AND i.person_id    = p.id
+         AND i.unlinked_at  IS NULL
+        WHERE p.workspace_id = ${this.workspaceId}
+          AND (
+                lower(p.id)                          LIKE ${pattern}
+             OR lower(coalesce(p.display_name, '')) LIKE ${pattern}
+             OR lower(coalesce(p.role, ''))         LIKE ${pattern}
+             OR lower(coalesce(p.team, ''))         LIKE ${pattern}
+             OR lower(coalesce(i.display_name, '')) LIKE ${pattern}
+              )
+        ORDER BY p.updated_at DESC
         LIMIT ${opts.limit}
       `;
             return rows.map(toPersonInfo);
         }
         const rows = await this.sql `
-      SELECT id, display_name, created_at, updated_at
+      SELECT id, display_name, role, team, source, created_at, updated_at
       FROM engram_persons
       WHERE workspace_id = ${this.workspaceId}
       ORDER BY updated_at DESC
@@ -299,17 +378,21 @@ export class PostgresAdapter {
     `;
         if (personExists.length === 0)
             return null;
+        // unlinked_at semantics: undefined = leave alone, null = clear,
+        // value = set. matches the patch contract for the other fields.
+        const unlinkedProvided = input.unlinked_at !== undefined;
         const rows = await this.sql `
       INSERT INTO engram_identities (
         workspace_id, ref, person_id, service, external_id,
-        display_name, source, is_primary, picture, linked_at
+        display_name, source, is_primary, picture, linked_at, unlinked_at
       )
       VALUES (
         ${this.workspaceId}, ${ref}, ${input.person_id},
         ${input.service}, ${input.external_id},
         ${input.display_name ?? null}, ${input.source ?? null},
-        ${input.is_primary ?? null}, ${input.picture ?? null},
-        ${input.linked_at}
+        ${input.is_primary ?? false}, ${input.picture ?? null},
+        ${input.linked_at},
+        ${input.unlinked_at ?? null}
       )
       ON CONFLICT (workspace_id, ref) DO UPDATE SET
         person_id    = EXCLUDED.person_id,
@@ -317,19 +400,24 @@ export class PostgresAdapter {
         external_id  = EXCLUDED.external_id,
         display_name = COALESCE(EXCLUDED.display_name, engram_identities.display_name),
         source       = COALESCE(EXCLUDED.source,       engram_identities.source),
-        is_primary   = COALESCE(EXCLUDED.is_primary,   engram_identities.is_primary),
+        is_primary   = EXCLUDED.is_primary,
         picture      = COALESCE(EXCLUDED.picture,      engram_identities.picture),
         linked_at    = EXCLUDED.linked_at,
+        unlinked_at  = CASE WHEN ${unlinkedProvided}
+                       THEN ${input.unlinked_at ?? null}
+                       ELSE engram_identities.unlinked_at END,
         updated_at   = now()
       RETURNING ref, person_id, service, external_id, display_name, source,
-                is_primary, picture, linked_at, created_at, updated_at
+                is_primary, picture, linked_at, unlinked_at,
+                created_at, updated_at
     `;
         return toIdentityInfo(rows[0]);
     }
     async getIdentityByRef(ref) {
         const rows = await this.sql `
       SELECT ref, person_id, service, external_id, display_name, source,
-             is_primary, picture, linked_at, created_at, updated_at
+             is_primary, picture, linked_at, unlinked_at,
+             created_at, updated_at
       FROM engram_identities
       WHERE workspace_id = ${this.workspaceId} AND ref = ${ref}
       LIMIT 1
@@ -341,7 +429,8 @@ export class PostgresAdapter {
     async listIdentitiesByPerson(personId) {
         const rows = await this.sql `
       SELECT ref, person_id, service, external_id, display_name, source,
-             is_primary, picture, linked_at, created_at, updated_at
+             is_primary, picture, linked_at, unlinked_at,
+             created_at, updated_at
       FROM engram_identities
       WHERE workspace_id = ${this.workspaceId} AND person_id = ${personId}
       ORDER BY linked_at DESC
@@ -354,10 +443,36 @@ function toPersonInfo(r) {
     return {
         id: r.id,
         display_name: r.display_name,
+        role: r.role,
+        team: r.team,
+        source: r.source,
         created_at: toIso(r.created_at),
         updated_at: toIso(r.updated_at),
     };
 }
+function toSessionRow(r) {
+    const toIso = (v) => (typeof v === "string" ? v : v.toISOString());
+    return {
+        id: r.id,
+        ...(r.title ? { title: r.title } : {}),
+        ...(r.channel ? { channel: r.channel } : {}),
+        participants: r.participants,
+        viewable_by: r.viewable_by,
+        createdAt: toIso(r.created_at),
+        updatedAt: toIso(r.updated_at),
+        ...(r.status === "active" || r.status === "idle" || r.status === "completed"
+            ? { status: r.status }
+            : {}),
+        ...(r.summary !== null ? { summary: r.summary } : {}),
+        ...(r.model !== null ? { model: r.model } : {}),
+        ...(r.trigger_conversation_id !== null
+            ? { trigger_conversation_id: r.trigger_conversation_id }
+            : {}),
+        ...(r.trigger_event_id !== null
+            ? { trigger_event_id: r.trigger_event_id }
+            : {}),
+    };
+}
 function toAliasInfo(r) {
     const toIso = (v) => (typeof v === "string" ? v : v.toISOString());
     // last_used is a DATE column; postgres-js returns it as a Date at UTC
@@ -377,9 +492,7 @@ function toAliasInfo(r) {
 }
 function toIdentityInfo(r) {
     const toIso = (v) => (typeof v === "string" ? v : v.toISOString());
-    const linkedAt = typeof r.linked_at === "string"
-        ? r.linked_at.slice(0, 10)
-        : r.linked_at.toISOString().slice(0, 10);
+    // linked_at is now TIMESTAMPTZ (post-migration 0004). Emit full ISO.
     return {
         ref: r.ref,
         person_id: r.person_id,
@@ -389,7 +502,8 @@ function toIdentityInfo(r) {
         source: r.source,
         is_primary: r.is_primary,
         picture: r.picture,
-        linked_at: linkedAt,
+        linked_at: toIso(r.linked_at),
+        unlinked_at: r.unlinked_at === null ? null : toIso(r.unlinked_at),
         created_at: toIso(r.created_at),
         updated_at: toIso(r.updated_at),
     };

package/dist/migrations/0004-schema-completion.d.ts

@@ -0,0 +1,2 @@
+export declare const name = "0004-schema-completion";
+export declare const sql = "\n-- Wave 1 of the engram-as-sole-memory-source migration. Adds the\n-- richer columns monet needs to retire its in-tree memory tables, and\n-- tightens a few earlier schema choices before launch freezes the wire.\n\n-- Persons gain organizational fields. Previously engram was the\n-- retrieval primitive only, so role/team/source were intentionally\n-- absent (\"HR data belongs upstream\"). Now that engram is monet's\n-- canonical memory layer, those facts have to live here.\nALTER TABLE engram_persons ADD COLUMN IF NOT EXISTS role TEXT;\nALTER TABLE engram_persons ADD COLUMN IF NOT EXISTS team TEXT;\nALTER TABLE engram_persons ADD COLUMN IF NOT EXISTS source TEXT;\nUPDATE engram_persons SET source = 'auto' WHERE source IS NULL;\nALTER TABLE engram_persons ALTER COLUMN source SET DEFAULT 'auto';\nALTER TABLE engram_persons ALTER COLUMN source SET NOT NULL;\n\n-- Sessions gain monet-derived metadata so the host's conversation_*\n-- columns disappear.\nALTER TABLE engram_sessions ADD COLUMN IF NOT EXISTS status TEXT;\nUPDATE engram_sessions SET status = 'active' WHERE status IS NULL;\nALTER TABLE engram_sessions ALTER COLUMN status SET DEFAULT 'active';\nALTER TABLE engram_sessions ALTER COLUMN status SET NOT NULL;\nALTER TABLE engram_sessions ADD COLUMN IF NOT EXISTS summary TEXT;\nALTER TABLE engram_sessions ADD COLUMN IF NOT EXISTS model TEXT;\n-- A session can be triggered by another conversation (manual fan-out)\n-- or by an external event id (calendar event in monet, etc.). No FK on\n-- trigger_event_id \u2014 it crosses systems.\nALTER TABLE engram_sessions ADD COLUMN IF NOT EXISTS trigger_conversation_id TEXT;\nALTER TABLE engram_sessions ADD COLUMN IF NOT EXISTS trigger_event_id TEXT;\n\n-- Identities tightening \u2014 last chance to fix these before launch.\n--   is_primary: nullable BOOLEAN where null/false were ambiguous \u2192\n--     pin to NOT NULL DEFAULT false.\n--   unlinked_at: new \u2014 represents \"this external connection was\n--     revoked\", which the append-via-upsert model previously couldn't\n--     express. nullable; non-null means the identity is no longer\n--     authoritative.\n--   linked_at: was DATE (lossy). Widen to TIMESTAMPTZ to preserve\n--     full timing. The cast is a no-op when already TIMESTAMPTZ.\nUPDATE engram_identities SET is_primary = false WHERE is_primary IS NULL;\nALTER TABLE engram_identities ALTER COLUMN is_primary SET DEFAULT false;\nALTER TABLE engram_identities ALTER COLUMN is_primary SET NOT NULL;\nALTER TABLE engram_identities ADD COLUMN IF NOT EXISTS unlinked_at TIMESTAMPTZ;\nALTER TABLE engram_identities ALTER COLUMN linked_at TYPE TIMESTAMPTZ\n  USING linked_at::TIMESTAMPTZ;\n\n-- Index supporting \"active identities only\" queries \u2014 common after\n-- adding unlinked_at since most callers want non-revoked rows.\nCREATE INDEX IF NOT EXISTS idx_engram_identities_active_service_external\n  ON engram_identities (workspace_id, service, external_id)\n  WHERE unlinked_at IS NULL;\n";

package/dist/migrations/0004-schema-completion.js

@@ -0,0 +1,53 @@
+export const name = "0004-schema-completion";
+export const sql = `
+-- Wave 1 of the engram-as-sole-memory-source migration. Adds the
+-- richer columns monet needs to retire its in-tree memory tables, and
+-- tightens a few earlier schema choices before launch freezes the wire.
+
+-- Persons gain organizational fields. Previously engram was the
+-- retrieval primitive only, so role/team/source were intentionally
+-- absent ("HR data belongs upstream"). Now that engram is monet's
+-- canonical memory layer, those facts have to live here.
+ALTER TABLE engram_persons ADD COLUMN IF NOT EXISTS role TEXT;
+ALTER TABLE engram_persons ADD COLUMN IF NOT EXISTS team TEXT;
+ALTER TABLE engram_persons ADD COLUMN IF NOT EXISTS source TEXT;
+UPDATE engram_persons SET source = 'auto' WHERE source IS NULL;
+ALTER TABLE engram_persons ALTER COLUMN source SET DEFAULT 'auto';
+ALTER TABLE engram_persons ALTER COLUMN source SET NOT NULL;
+
+-- Sessions gain monet-derived metadata so the host's conversation_*
+-- columns disappear.
+ALTER TABLE engram_sessions ADD COLUMN IF NOT EXISTS status TEXT;
+UPDATE engram_sessions SET status = 'active' WHERE status IS NULL;
+ALTER TABLE engram_sessions ALTER COLUMN status SET DEFAULT 'active';
+ALTER TABLE engram_sessions ALTER COLUMN status SET NOT NULL;
+ALTER TABLE engram_sessions ADD COLUMN IF NOT EXISTS summary TEXT;
+ALTER TABLE engram_sessions ADD COLUMN IF NOT EXISTS model TEXT;
+-- A session can be triggered by another conversation (manual fan-out)
+-- or by an external event id (calendar event in monet, etc.). No FK on
+-- trigger_event_id — it crosses systems.
+ALTER TABLE engram_sessions ADD COLUMN IF NOT EXISTS trigger_conversation_id TEXT;
+ALTER TABLE engram_sessions ADD COLUMN IF NOT EXISTS trigger_event_id TEXT;
+
+-- Identities tightening — last chance to fix these before launch.
+--   is_primary: nullable BOOLEAN where null/false were ambiguous →
+--     pin to NOT NULL DEFAULT false.
+--   unlinked_at: new — represents "this external connection was
+--     revoked", which the append-via-upsert model previously couldn't
+--     express. nullable; non-null means the identity is no longer
+--     authoritative.
+--   linked_at: was DATE (lossy). Widen to TIMESTAMPTZ to preserve
+--     full timing. The cast is a no-op when already TIMESTAMPTZ.
+UPDATE engram_identities SET is_primary = false WHERE is_primary IS NULL;
+ALTER TABLE engram_identities ALTER COLUMN is_primary SET DEFAULT false;
+ALTER TABLE engram_identities ALTER COLUMN is_primary SET NOT NULL;
+ALTER TABLE engram_identities ADD COLUMN IF NOT EXISTS unlinked_at TIMESTAMPTZ;
+ALTER TABLE engram_identities ALTER COLUMN linked_at TYPE TIMESTAMPTZ
+  USING linked_at::TIMESTAMPTZ;
+
+-- Index supporting "active identities only" queries — common after
+-- adding unlinked_at since most callers want non-revoked rows.
+CREATE INDEX IF NOT EXISTS idx_engram_identities_active_service_external
+  ON engram_identities (workspace_id, service, external_id)
+  WHERE unlinked_at IS NULL;
+`;

package/dist/migrations/0005-session-updated-at.d.ts

@@ -0,0 +1,2 @@
+export declare const name = "0005-session-updated-at";
+export declare const sql = "\n-- Session-level updated_at, so listSessions can sort by \"most recent\n-- activity\" (matching monet's conversations.updated_at semantics) and\n-- callers can filter \"active in the last hour\" without re-folding the\n-- event log. Maintained by appendEvents + updateSession at write time.\nALTER TABLE engram_sessions ADD COLUMN IF NOT EXISTS updated_at TIMESTAMPTZ;\nUPDATE engram_sessions SET updated_at = created_at WHERE updated_at IS NULL;\nALTER TABLE engram_sessions ALTER COLUMN updated_at SET DEFAULT NOW();\nALTER TABLE engram_sessions ALTER COLUMN updated_at SET NOT NULL;\n\n-- Index supporting the most common list-by-recent-activity query and\n-- its status-filtered variant (status filter is cheap once the date\n-- range scan is narrow).\nCREATE INDEX IF NOT EXISTS idx_engram_sessions_workspace_updated\n  ON engram_sessions (workspace_id, updated_at DESC);\n";

package/dist/migrations/0005-session-updated-at.js

@@ -0,0 +1,17 @@
+export const name = "0005-session-updated-at";
+export const sql = `
+-- Session-level updated_at, so listSessions can sort by "most recent
+-- activity" (matching monet's conversations.updated_at semantics) and
+-- callers can filter "active in the last hour" without re-folding the
+-- event log. Maintained by appendEvents + updateSession at write time.
+ALTER TABLE engram_sessions ADD COLUMN IF NOT EXISTS updated_at TIMESTAMPTZ;
+UPDATE engram_sessions SET updated_at = created_at WHERE updated_at IS NULL;
+ALTER TABLE engram_sessions ALTER COLUMN updated_at SET DEFAULT NOW();
+ALTER TABLE engram_sessions ALTER COLUMN updated_at SET NOT NULL;
+
+-- Index supporting the most common list-by-recent-activity query and
+-- its status-filtered variant (status filter is cheap once the date
+-- range scan is narrow).
+CREATE INDEX IF NOT EXISTS idx_engram_sessions_workspace_updated
+  ON engram_sessions (workspace_id, updated_at DESC);
+`;

package/dist/migrations/index.js

@@ -1,6 +1,8 @@
 import * as m0001 from "./0001-baseline";
 import * as m0002 from "./0002-aliases";
 import * as m0003 from "./0003-identities";
+import * as m0004 from "./0004-schema-completion";
+import * as m0005 from "./0005-session-updated-at";
 /**
  * Schema migrations, applied in array order. Add a new file under
  * `migrations/NNNN-<slug>.ts` exporting `name` and `sql`, then append it
@@ -12,4 +14,6 @@ export const MIGRATIONS = [
     { name: m0001.name, sql: m0001.sql },
     { name: m0002.name, sql: m0002.sql },
     { name: m0003.name, sql: m0003.sql },
+    { name: m0004.name, sql: m0004.sql },
+    { name: m0005.name, sql: m0005.sql },
 ];

package/dist/openapi.js

@@ -128,6 +128,17 @@ function buildPaths() {
                     "401": res("認証エラー"),
                 },
             },
+            patch: {
+                summary: "セッションのメタデータ（title / channel / status / summary / model / trigger_*）を部分更新する。",
+                parameters: [pathParam("id", "セッション id。")],
+                requestBody: jsonBody("SessionUpdate"),
+                responses: {
+                    "200": res("更新後のセッションのエンベロープ"),
+                    "400": res("リクエストボディが不正"),
+                    "404": res("セッションが見つからない"),
+                    "401": res("認証エラー"),
+                },
+            },
         }),
         "/v1/sessions/{id}/events": tagged("Sessions", {
             post: {

package/dist/routes/sessions.d.ts

@@ -3,10 +3,11 @@ import type { Env } from "../context";
 import { type RouteConfig } from "./helpers";
 /**
  * Session routes. Mount under `/v1`:
- *   POST /v1/sessions             create a session
- *   POST /v1/sessions/:id/events  append events
- *   GET  /v1/sessions/:id         fetch one session + its persons map
- *   GET  /v1/sessions/:id/events  fetch the raw, ordered event log
- *   GET  /v1/sessions             list recent sessions + persons map
+ *   POST  /v1/sessions             create a session
+ *   PATCH /v1/sessions/:id         update session-level metadata
+ *   POST  /v1/sessions/:id/events  append events
+ *   GET   /v1/sessions/:id         fetch one session + its persons map
+ *   GET   /v1/sessions/:id/events  fetch the raw, ordered event log
+ *   GET   /v1/sessions             list recent sessions + persons map
  */
 export declare function sessionsRoutes(cfg: RouteConfig): Hono<Env>;

package/dist/routes/sessions.js

@@ -1,13 +1,14 @@
 import { Hono } from "hono";
-import { eventBatchSchema, parseJsonBody, sessionInitSchema } from "../schemas";
+import { eventBatchSchema, parseJsonBody, sessionInitSchema, sessionUpdateSchema, } from "../schemas";
 import { clampLimit, resolvePersonMap } from "./helpers";
 /**
  * Session routes. Mount under `/v1`:
- *   POST /v1/sessions             create a session
- *   POST /v1/sessions/:id/events  append events
- *   GET  /v1/sessions/:id         fetch one session + its persons map
- *   GET  /v1/sessions/:id/events  fetch the raw, ordered event log
- *   GET  /v1/sessions             list recent sessions + persons map
+ *   POST  /v1/sessions             create a session
+ *   PATCH /v1/sessions/:id         update session-level metadata
+ *   POST  /v1/sessions/:id/events  append events
+ *   GET   /v1/sessions/:id         fetch one session + its persons map
+ *   GET   /v1/sessions/:id/events  fetch the raw, ordered event log
+ *   GET   /v1/sessions             list recent sessions + persons map
  */
 export function sessionsRoutes(cfg) {
     const app = new Hono();
@@ -33,6 +34,17 @@ export function sessionsRoutes(cfg) {
         }
         return c.body(null, 204);
     });
+    app.patch("/sessions/:id", async (c) => {
+        const id = c.req.param("id");
+        const body = await parseJsonBody(c, sessionUpdateSchema);
+        if (body instanceof Response)
+            return body;
+        const session = await c.var.ctx.storage.updateSession(id, body);
+        if (!session)
+            return c.json({ error: "session_not_found" }, 404);
+        const persons = await resolvePersonMap(c.var.ctx.storage, [session]);
+        return c.json({ session, persons });
+    });
     app.get("/sessions/:id", async (c) => {
         const id = c.req.param("id");
         const s = await c.var.ctx.storage.getSession(id);
@@ -51,7 +63,15 @@ export function sessionsRoutes(cfg) {
     app.get("/sessions", async (c) => {
         const limit = clampLimit(c, cfg.defaultListLimit, cfg.maxListLimit);
         const channel = c.req.query("channel") || undefined;
-        const sessions = await c.var.ctx.storage.listSessions({ limit, channel });
+        const rawStatus = c.req.query("status");
+        const status = rawStatus === "active" || rawStatus === "idle" || rawStatus === "completed"
+            ? rawStatus
+            : undefined;
+        const sessions = await c.var.ctx.storage.listSessions({
+            limit,
+            channel,
+            status,
+        });
         const persons = await resolvePersonMap(c.var.ctx.storage, sessions);
         return c.json({ sessions, persons });
     });

package/dist/schemas.d.ts

@@ -15,6 +15,28 @@ export declare const sessionInitSchema: z.ZodObject<{
     channel: z.ZodOptional<z.ZodString>;
     participants: z.ZodOptional<z.ZodArray<z.ZodString>>;
     viewable_by: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        idle: "idle";
+        completed: "completed";
+    }>>;
+    summary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    trigger_conversation_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    trigger_event_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const sessionUpdateSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    channel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        idle: "idle";
+        completed: "completed";
+    }>>;
+    summary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    trigger_conversation_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    trigger_event_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 export declare const sessionEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"step">;

package/dist/schemas.js

@@ -15,6 +15,20 @@ export const sessionInitSchema = z.object({
     channel: z.string().optional(),
     participants: z.array(z.string()).optional(),
     viewable_by: z.array(z.string()).optional(),
+    status: z.enum(["active", "idle", "completed"]).optional(),
+    summary: z.string().nullable().optional(),
+    model: z.string().nullable().optional(),
+    trigger_conversation_id: z.string().nullable().optional(),
+    trigger_event_id: z.string().nullable().optional(),
+});
+export const sessionUpdateSchema = z.object({
+    title: z.string().nullable().optional(),
+    channel: z.string().nullable().optional(),
+    status: z.enum(["active", "idle", "completed"]).optional(),
+    summary: z.string().nullable().optional(),
+    model: z.string().nullable().optional(),
+    trigger_conversation_id: z.string().nullable().optional(),
+    trigger_event_id: z.string().nullable().optional(),
 });
 const stepEventSchema = z.object({
     type: z.literal("step"),

package/dist/server.js

@@ -52,7 +52,7 @@ export function createServer(opts) {
         ok: true,
         routes: {
             sessions: "POST/GET /v1/sessions",
-            sessionById: "GET /v1/sessions/:id",
+            sessionById: "GET/PATCH /v1/sessions/:id",
             events: "POST /v1/sessions/:id/events",
             sessionEvents: "GET /v1/sessions/:id/events",
             search: "POST /v1/search",

package/dist/storage.d.ts

@@ -1,5 +1,5 @@
 import type { Session } from "@hexis-ai/engram-core";
-import type { AliasInfo, AliasUpsert, IdentityInfo, IdentityUpsert, PersonCreate, PersonInfo, PersonUpdate, SessionEvent, SessionInit } from "@hexis-ai/engram-sdk";
+import type { AliasInfo, AliasUpsert, IdentityInfo, IdentityUpsert, PersonCreate, PersonInfo, PersonUpdate, SessionEvent, SessionInit, SessionUpdate } from "@hexis-ai/engram-sdk";
 /**
  * Storage adapter interface. Each implementation owns persistence for
  * a single workspace's sessions and persons. Multi-tenancy is the host's
@@ -18,6 +18,13 @@ export interface StorageAdapter {
     appendEvents(sessionId: string, events: SessionEvent[]): Promise<void>;
     /** Materialize a session (events folded into Session shape). */
     getSession(sessionId: string): Promise<Session | null>;
+    /**
+     * Patch session-level metadata (title / channel / status / summary /
+     * model / trigger_*). Each field updates only when present in `patch`
+     * — `undefined` leaves the column alone, `null` clears it. Returns
+     * the materialized session post-update, or `null` if unknown.
+     */
+    updateSession(sessionId: string, patch: SessionUpdate): Promise<Session | null>;
     /**
      * Raw event log for a session, ordered by `seq`. Unlike `getSession`,
      * this does not fold events — callers get per-event timestamps and the
@@ -26,10 +33,11 @@ export interface StorageAdapter {
      * events, which returns `[]`).
      */
     getSessionEvents(sessionId: string): Promise<SessionEvent[] | null>;
-    /** List recent sessions. */
+    /** List recent sessions, ordered by `updated_at` desc. */
     listSessions(opts: {
         limit: number;
         channel?: string;
+        status?: "active" | "idle" | "completed";
     }): Promise<Session[]>;
     /**
      * Create a person with a freshly allocated id. The host (e.g. monet)
@@ -46,7 +54,12 @@ export interface StorageAdapter {
     getPerson(id: string): Promise<PersonInfo | null>;
     /** Batch fetch — used by response envelopes to inline `persons` maps. */
     getPersons(ids: string[]): Promise<PersonInfo[]>;
-    /** List or search persons in this workspace. */
+    /**
+     * List or search persons in this workspace. The free-text query
+     * matches across id / display_name / role / team / linked identity
+     * display_names — so a search for "design" finds people with that
+     * role even if their display_name doesn't contain it.
+     */
     listPersons(opts: {
         limit: number;
         q?: string;
@@ -102,5 +115,11 @@ export interface SessionRow {
     participants: string[];
     viewable_by: string[];
     createdAt: string;
+    updatedAt: string;
+    status?: "active" | "idle" | "completed";
+    summary?: string;
+    model?: string;
+    trigger_conversation_id?: string;
+    trigger_event_id?: string;
 }
 export declare function foldEvents(row: SessionRow, events: SessionEvent[], now: Date): Session;

package/dist/storage.js

@@ -21,9 +21,20 @@ export function foldEvents(row, events, now) {
     return {
         id: row.id,
         ...(title ? { title } : {}),
+        ...(row.channel ? { channel: row.channel } : {}),
         steps,
         daysAgo,
         ...(participants.size > 0 ? { participants: [...participants] } : {}),
         ...(viewableSet.size > 0 ? { viewable_by: [...viewableSet] } : {}),
+        ...(row.status ? { status: row.status } : {}),
+        ...(row.summary !== undefined ? { summary: row.summary } : {}),
+        ...(row.model !== undefined ? { model: row.model } : {}),
+        ...(row.trigger_conversation_id !== undefined
+            ? { trigger_conversation_id: row.trigger_conversation_id }
+            : {}),
+        ...(row.trigger_event_id !== undefined
+            ? { trigger_event_id: row.trigger_event_id }
+            : {}),
+        updated_at: row.updatedAt,
     };
 }

package/openapi.json

@@ -85,6 +85,54 @@
             "items": {
               "type": "string"
             }
+          },
+          "status": {
+            "type": "string",
+            "enum": [
+              "active",
+              "idle",
+              "completed"
+            ]
+          },
+          "summary": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "model": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "trigger_conversation_id": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "trigger_event_id": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
           }
         },
         "additionalProperties": false
@@ -536,6 +584,47 @@
         "tags": [
           "Sessions"
         ]
+      },
+      "patch": {
+        "summary": "セッションのメタデータ（title / channel / status / summary / model / trigger_*）を部分更新する。",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "セッション id。"
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/SessionUpdate"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "更新後のセッションのエンベロープ"
+          },
+          "400": {
+            "description": "リクエストボディが不正"
+          },
+          "401": {
+            "description": "認証エラー"
+          },
+          "404": {
+            "description": "セッションが見つからない"
+          }
+        },
+        "tags": [
+          "Sessions"
+        ]
       }
     },
     "/v1/sessions/{id}/events": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hexis-ai/engram-server",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Engram server: ingest agent session events, persist via a pluggable adapter, expose search.",
   "keywords": [
     "engram",
@@ -50,7 +50,7 @@
   },
   "dependencies": {
     "@hexis-ai/engram-core": "^0.1.5",
-    "@hexis-ai/engram-sdk": "^0.6.0",
+    "@hexis-ai/engram-sdk": "^0.8.0",
     "hono": "^4.6.0",
     "zod": "^4.0.0"
   },