@loicngr/kobo 2.1.6 → 2.1.9

package/dist/server/routes/mcp.js

@@ -3,9 +3,12 @@ import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { Hono } from 'hono';
 import { bodyLimit } from 'hono/body-limit';
+import { EXTERNAL_MEMORY_TOOL_DEFINITIONS, isMemoryToolName } from '../../shared/memory-tools.js';
 import { EXTERNAL_MCP_TOOLS } from '../../shared/workspace-dialogue-tools.js';
 import { createMcpClientContext } from '../services/mcp-client-context.js';
+import { executeMemoryMcpTool } from '../services/memory-mcp-service.js';
 import { executeWorkspaceDialogueTool } from '../services/workspace-dialogue-service.js';
+import { prepareMemoryToolEnvelope } from '../utils/memory-token-budget.js';
 const app = new Hono();
 app.use('*', bodyLimit({ maxSize: 1024 * 1024 }));
 app.all('/', async (c) => {
@@ -14,11 +17,27 @@ app.all('/', async (c) => {
         sessionIdGenerator: undefined,
         enableJsonResponse: true,
     });
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: EXTERNAL_MCP_TOOLS }));
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [...EXTERNAL_MCP_TOOLS, ...EXTERNAL_MEMORY_TOOL_DEFINITIONS],
+    }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const isMemory = isMemoryToolName(request.params.name);
         try {
             const source = createMcpClientContext(c.req.header('X-Kobo-Client-Name'), c.req.header('X-Kobo-Client-Transport') === 'stdio' ? 'stdio' : 'http', c.req.header('X-Kobo-Client-Name-Encoding'));
-            const data = await executeWorkspaceDialogueTool(request.params.name, request.params.arguments ?? {}, source);
+            const data = isMemory
+                ? executeMemoryMcpTool(request.params.name, request.params.arguments ?? {}, source)
+                : await executeWorkspaceDialogueTool(request.params.name, request.params.arguments ?? {}, source);
+            if (isMemory) {
+                const bounded = prepareMemoryToolEnvelope(data, { targetTokens: 1_000, transport: 'external' });
+                if (bounded.data.memoryOutputSuppressed === true)
+                    return { content: [], isError: true };
+                const { __mcpError, ...publicData } = bounded.data;
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(publicData) }],
+                    structuredContent: publicData,
+                    ...(__mcpError === true || publicData.budgetExhausted === true ? { isError: true } : {}),
+                };
+            }
             const structuredContent = data && typeof data === 'object' && !Array.isArray(data) ? data : undefined;
             return {
                 content: [{ type: 'text', text: JSON.stringify(data) }],
@@ -27,6 +46,16 @@ app.all('/', async (c) => {
             };
         }
         catch (error) {
+            if (isMemory) {
+                const bounded = prepareMemoryToolEnvelope({
+                    error: error instanceof Error ? error.message : String(error),
+                }, { targetTokens: 1_000, transport: 'external' });
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: JSON.stringify(bounded.data) }],
+                    structuredContent: bounded.data,
+                };
+            }
             return {
                 isError: true,
                 content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],

package/dist/server/routes/memory.js

@@ -0,0 +1,525 @@
+import { Hono } from 'hono';
+import { bodyLimit } from 'hono/body-limit';
+import { MEMORY_BODY_MAX_CHARS, MEMORY_PAGE_SIZE_MAX, MEMORY_TITLE_MAX_CHARS } from '../../shared/memory.js';
+import { isMemoryToolName, validateMemoryToolArguments } from '../../shared/memory-tools.js';
+import { getMemoryCapability } from '../services/memory-agent-runtime.js';
+import { getInternalMemoryBudgetContext, reserveMemoryBudget, reserveMemoryBudgetDenial, wasMemoryFragmentDelivered, } from '../services/memory-budget-service.js';
+import { listMemoryContextRecords } from '../services/memory-context-service.js';
+import { approveMemoryProposal, clearMemoryScope, createMemory, deleteMemory, listMemories, listMemoryOperations, listMemoryProposals, listMemoryScopes, listWorkspaceMemoryOperations, MemoryConflictError, MemoryNotFoundError, previewMemoryClear, promoteMemory, readMemory, rejectMemoryProposal, remember, searchMemories, updateMemory, } from '../services/memory-service.js';
+import { prepareMemoryToolEnvelope, sliceMemoryBodyFragment } from '../utils/memory-token-budget.js';
+const app = new Hono();
+const human = { kind: 'human' };
+const MAX_BODY_BYTES = 16 * 1024;
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+async function readJson(c) {
+    let value;
+    try {
+        value = await c.req.json();
+    }
+    catch {
+        throw new TypeError('Request body must be valid JSON');
+    }
+    if (!isObject(value))
+        throw new TypeError('Request body must be a JSON object');
+    return value;
+}
+function requiredString(value, name, max = 512) {
+    if (typeof value !== 'string' || !value.trim() || value.length > max)
+        throw new TypeError(`Invalid ${name}`);
+    return value.trim();
+}
+function requiredRevision(value, name = 'revision', minimum = 1) {
+    if (!Number.isSafeInteger(value) || value < minimum)
+        throw new TypeError(`Invalid ${name}`);
+    return value;
+}
+function parseLimit(value) {
+    if (value === undefined)
+        return undefined;
+    if (!/^\d+$/.test(value))
+        throw new TypeError('Invalid page size');
+    const limit = Number(value);
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > MEMORY_PAGE_SIZE_MAX)
+        throw new TypeError('Invalid page size');
+    return limit;
+}
+function parseCursor(value) {
+    if (value === undefined)
+        return undefined;
+    if (!/^\d+$/.test(value) || !Number.isSafeInteger(Number(value)))
+        throw new TypeError('Invalid cursor');
+    return value;
+}
+function parseEntry(value, partial = false) {
+    const result = {};
+    if (!partial || value.key !== undefined)
+        result.key = requiredString(value.key, 'key', 80).toLowerCase();
+    if (!partial || value.title !== undefined)
+        result.title = requiredString(value.title, 'title', MEMORY_TITLE_MAX_CHARS);
+    if (!partial || value.body !== undefined) {
+        if (typeof value.body === 'string' && value.body.length > MEMORY_BODY_MAX_CHARS)
+            throw new PayloadTooLargeError('Memory body exceeds the character limit');
+        result.body = requiredString(value.body, 'body', MEMORY_BODY_MAX_CHARS);
+    }
+    if (partial && Object.keys(result).length === 0)
+        throw new TypeError('At least one memory field is required');
+    return result;
+}
+class PayloadTooLargeError extends Error {
+}
+function handleError(c, error) {
+    if (error instanceof MemoryNotFoundError)
+        return c.json({ error: error.message }, 404);
+    if (error instanceof MemoryConflictError)
+        return c.json({ error: error.message }, 409);
+    if (error instanceof PayloadTooLargeError)
+        return c.json({ error: error.message }, 413);
+    if (error instanceof TypeError)
+        return c.json({ error: error.message }, 400);
+    return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
+}
+function boundedAgentReply(c, capability, value, status = 200, deliveries = [], preReserved, pageOffset) {
+    let ledger;
+    try {
+        ledger = getInternalMemoryBudgetContext(capability.conversationKey);
+    }
+    catch (error) {
+        // Capabilities are normally created alongside their ledger. If stale or
+        // malformed runtime state breaks that invariant, preserve the validation
+        // status without turning a client error into a 500 or doing any write.
+        const bounded = prepareMemoryToolEnvelope(value, { targetTokens: 1_000, transport: 'internal' });
+        const statusCode = error instanceof TypeError ? status : 500;
+        return c.json(bounded.data, { status: statusCode });
+    }
+    const placeholder = {
+        ...value,
+        budget: { estimatedTokens: 1_000, remainingTokens: 6_000, exhausted: false },
+    };
+    const sized = prepareMemoryToolEnvelope(placeholder, { targetTokens: 1_000, transport: 'internal', pageOffset });
+    const emittedItems = Array.isArray(sized.data.items) ? sized.data.items : [];
+    const emittedIds = new Set(emittedItems
+        .filter((item) => !!item && typeof item === 'object' && !Array.isArray(item))
+        .map((item) => item.id));
+    const emittedDeliveries = deliveries.filter((delivery) => {
+        if (delivery.kind === 'metadata' || delivery.kind === 'excerpt')
+            return emittedIds.has(delivery.entryId);
+        const body = sized.data.entry?.body;
+        if (typeof body !== 'string')
+            return false;
+        delivery.end = delivery.start + [...body].length;
+        return true;
+    });
+    const reservation = preReserved ??
+        reserveMemoryBudget({
+            budgetContextId: ledger.id,
+            estimatedTokens: sized.estimatedTokens,
+            responseLimitTokens: 1_000,
+            deliveries: emittedDeliveries,
+        });
+    if (!reservation.accepted) {
+        return exhaustedAgentReply(c, capability);
+    }
+    const result = {
+        ...sized.data,
+        budget: {
+            estimatedTokens: reservation.estimatedTokens,
+            remainingTokens: reservation.remainingTokens,
+            exhausted: reservation.remainingTokens <= 0,
+        },
+    };
+    const bounded = prepareMemoryToolEnvelope(result, { targetTokens: 1_000, transport: 'internal' });
+    return c.json(bounded.data, { status });
+}
+function exhaustedAgentReply(c, capability, message = 'Budget mémoire épuisé; ne répète pas cette lecture dans la conversation courante.') {
+    const ledger = getInternalMemoryBudgetContext(capability.conversationKey);
+    const denial = prepareMemoryToolEnvelope({
+        budgetExhausted: true,
+        message,
+        remainingTokens: 0,
+        limitTokens: 6_000,
+    }, { targetTokens: 1_000, transport: 'internal' });
+    const reservation = reserveMemoryBudgetDenial(ledger.id, denial.estimatedTokens);
+    return c.json(reservation.responseAllowed ? denial.data : { budgetExhausted: true, memoryOutputSuppressed: true }, 200);
+}
+function reserveAgentWrite(capability) {
+    const ledger = getInternalMemoryBudgetContext(capability.conversationKey);
+    // Reserve the full output ceiling before mutating. Sizing a synthetic large
+    // receipt can collapse it to a small fallback and undercharge the real result.
+    return reserveMemoryBudget({
+        budgetContextId: ledger.id,
+        estimatedTokens: 1_000,
+        responseLimitTokens: 1_000,
+    });
+}
+app.use('*', bodyLimit({ maxSize: MAX_BODY_BYTES, onError: (c) => c.json({ error: 'Request body is too large' }, 413) }));
+app.get('/scopes', (c) => {
+    try {
+        const workspaceId = c.req.query('workspaceId');
+        return c.json(listMemoryScopes({
+            ...(workspaceId ? { workspaceId } : {}),
+            cursor: parseCursor(c.req.query('cursor')),
+            limit: parseLimit(c.req.query('limit')),
+        }));
+    }
+    catch (error) {
+        return handleError(c, error);
+    }
+});
+app.get('/entries', (c) => {
+    try {
+        const scopeId = c.req.query('scopeId');
+        const workspaceId = c.req.query('workspaceId');
+        if (Boolean(scopeId) === Boolean(workspaceId))
+            throw new TypeError('Specify exactly one scopeId or workspaceId');
+        const query = c.req.query('query');
+        if (query !== undefined && (!query.trim() || query.length > 200))
+            throw new TypeError('Invalid search query');
+        return c.json(listMemories({
+            ...(scopeId ? { scopeId } : { workspaceId }),
+            cursor: parseCursor(c.req.query('cursor')),
+            limit: parseLimit(c.req.query('limit')),
+            ...(query !== undefined ? { query } : {}),
+        }));
+    }
+    catch (error) {
+        return handleError(c, error);
+    }
+});
+app.post('/entries', async (c) => {
+    try {
+        const value = await readJson(c);
+        const scopeId = requiredString(value.scopeId, 'scopeId');
+        const input = parseEntry(value);
+        const created = createMemory({ scopeId, ...input, actor: human });
+        return c.json(created, 201);
+    }
+    catch (error) {
+        return handleError(c, error);
+    }
+});
+app.patch('/entries/:entryId', async (c) => {
+    try {
+        const value = await readJson(c);
+        const updated = updateMemory({
+            scopeId: requiredString(value.scopeId, 'scopeId'),
+            entryId: requiredString(c.req.param('entryId'), 'entryId'),
+            expectedRevision: requiredRevision(value.expectedRevision),
+            ...parseEntry(value, true),
+            actor: human,
+        });
+        return c.json(updated);
+    }
+    catch (error) {
+        return handleError(c, error);
+    }
+});
+app.delete('/entries/:entryId', async (c) => {
+    try {
+        const value = await readJson(c);
+        deleteMemory({
+            scopeId: requiredString(value.scopeId, 'scopeId'),
+            entryId: requiredString(c.req.param('entryId'), 'entryId'),
+            expectedRevision: requiredRevision(value.expectedRevision),
+            actor: human,
+        });
+        return c.body(null, 204);
+    }
+    catch (error) {
+        return handleError(c, error);
+    }
+});
+app.post('/entries/:entryId/promote', async (c) => {
+    try {
+        const value = await readJson(c);
+        const promoted = promoteMemory({
+            sourceScopeId: requiredString(value.sourceScopeId, 'sourceScopeId'),
+            entryId: requiredString(c.req.param('entryId'), 'entryId'),
+            targetScopeId: requiredString(value.targetScopeId, 'targetScopeId'),
+            actor: human,
+        });
+        return c.json(promoted, 201);
+    }
+    catch (error) {
+        return handleError(c, error);
+    }
+});
+app.get('/proposals', (c) => {
+    try {
+        const scopeId = requiredString(c.req.query('scopeId'), 'scopeId');
+        return c.json({ items: listMemoryProposals(scopeId) });
+    }
+    catch (error) {
+        return handleError(c, error);
+    }
+});
+app.post('/proposals/:proposalId/approve', (c) => {
+    try {
+        return c.json(approveMemoryProposal(requiredString(c.req.param('proposalId'), 'proposalId'), human));
+    }
+    catch (error) {
+        return handleError(c, error);
+    }
+});
+app.post('/proposals/:proposalId/reject', (c) => {
+    try {
+        rejectMemoryProposal(requiredString(c.req.param('proposalId'), 'proposalId'), human);
+        return c.body(null, 204);
+    }
+    catch (error) {
+        return handleError(c, error);
+    }
+});
+app.get('/scopes/:scopeId/clear-preview', (c) => {
+    try {
+        return c.json(previewMemoryClear(requiredString(c.req.param('scopeId'), 'scopeId'), human));
+    }
+    catch (error) {
+        return handleError(c, error);
+    }
+});
+app.post('/scopes/:scopeId/clear', async (c) => {
+    try {
+        const value = await readJson(c);
+        return c.json(clearMemoryScope({
+            scopeId: requiredString(c.req.param('scopeId'), 'scopeId'),
+            expectedRevision: requiredRevision(value.expectedRevision, 'preview revision', 0),
+            actor: human,
+        }));
+    }
+    catch (error) {
+        return handleError(c, error);
+    }
+});
+app.get('/operations', (c) => {
+    try {
+        const workspaceId = c.req.query('workspaceId');
+        const cursor = parseCursor(c.req.query('afterCursor'));
+        const limit = parseLimit(c.req.query('limit'));
+        if (workspaceId && !c.req.query('scopeId')) {
+            return c.json(listWorkspaceMemoryOperations(requiredString(workspaceId, 'workspaceId'), { cursor, limit }));
+        }
+        return c.json(listMemoryOperations({
+            scopeId: requiredString(c.req.query('scopeId'), 'scopeId'),
+            ...(workspaceId ? { workspaceId: requiredString(workspaceId, 'workspaceId') } : {}),
+            cursor,
+            limit,
+        }));
+    }
+    catch (error) {
+        return handleError(c, error);
+    }
+});
+app.get('/workspaces/:workspaceId/view', (c) => {
+    try {
+        const workspaceId = requiredString(c.req.param('workspaceId'), 'workspaceId');
+        const scopePage = listMemoryScopes({ workspaceId });
+        const scopes = scopePage.items;
+        const entries = listMemories({ workspaceId });
+        const proposals = scopes.flatMap((scope) => listMemoryProposals(scope.id));
+        // Context persistence is populated by the session-injection phase. Returning an
+        // honest empty collection is preferable to inventing delivery history here.
+        const sessionId = c.req.query('sessionId');
+        return c.json({
+            scopes,
+            entries: entries.items,
+            entriesNextCursor: entries.nextCursor,
+            entriesTotalCount: entries.totalCount,
+            proposals,
+            contexts: sessionId ? listMemoryContextRecords(workspaceId, sessionId) : [],
+            ...(sessionId ? { sessionId } : {}),
+        });
+    }
+    catch (error) {
+        return handleError(c, error);
+    }
+});
+/** Workspace MCP capability boundary. Provenance and scope are derived server-side. */
+app.post('/agent/:toolName', async (c) => {
+    const token = c.req.header('X-Kobo-Memory-Session');
+    const capability = getMemoryCapability(token);
+    if (!capability)
+        return c.json({ error: 'Invalid or expired memory capability' }, 401);
+    const toolName = c.req.param('toolName');
+    if (!isMemoryToolName(toolName))
+        return c.json({ error: 'Unknown memory tool' }, 404);
+    let writeReservation;
+    try {
+        const input = await readJson(c);
+        // Stop may revoke the launch while the request body is still arriving.
+        // No asynchronous work follows this check before service mutations.
+        if (getMemoryCapability(token) !== capability)
+            return c.json({ error: 'Invalid or expired memory capability' }, 401);
+        const args = validateMemoryToolArguments(toolName, input);
+        const actor = {
+            kind: 'internal-agent',
+            workspaceId: capability.workspaceId,
+            sessionId: capability.sessionId,
+            engine: capability.engine,
+        };
+        // Capability-only fields are never forwarded as memory arguments.
+        const scopeId = typeof args.scope_id === 'string' ? args.scope_id : undefined;
+        if (toolName === 'list_memory_scopes') {
+            const page = listMemoryScopes({
+                workspaceId: capability.workspaceId,
+                actor,
+                ...(typeof args.cursor === 'string' ? { cursor: args.cursor } : {}),
+                ...(typeof args.limit === 'number' ? { limit: args.limit } : {}),
+            });
+            return boundedAgentReply(c, capability, {
+                ...page,
+                items: page.items.map(({ id, level, generation, revision }) => ({ id, level, generation, revision })),
+            }, 200, [], undefined, Number(args.cursor ?? 0));
+        }
+        if (toolName === 'list_memories') {
+            const page = listMemories({
+                ...(scopeId ? { scopeId } : { workspaceId: capability.workspaceId }),
+                actor,
+                ...(typeof args.cursor === 'string' ? { cursor: args.cursor } : {}),
+                ...(typeof args.limit === 'number' ? { limit: args.limit } : {}),
+            });
+            const ledgerId = getInternalMemoryBudgetContext(capability.conversationKey).id;
+            const freshDeliveries = [];
+            const items = page.items.map((entry) => {
+                const delivery = { entryId: entry.id, revision: entry.revision, kind: 'metadata' };
+                if (wasMemoryFragmentDelivered(ledgerId, delivery))
+                    return { id: entry.id, revision: entry.revision, alreadyDelivered: true };
+                freshDeliveries.push(delivery);
+                return {
+                    id: entry.id,
+                    scopeId: entry.scopeId,
+                    key: entry.key,
+                    title: entry.title,
+                    revision: entry.revision,
+                    actor: entry.actor,
+                    createdAt: entry.createdAt,
+                    updatedAt: entry.updatedAt,
+                };
+            });
+            return boundedAgentReply(c, capability, { ...page, items }, 200, freshDeliveries, undefined, Number(args.cursor ?? 0));
+        }
+        if (toolName === 'read_memory') {
+            const entry = readMemory({ scopeId: scopeId, entryId: args.entry_id, actor });
+            const cursor = args.cursor;
+            const offset = cursor ? Number(cursor.split('.')[1]) : 0;
+            const delivery = {
+                entryId: entry.id,
+                revision: entry.revision,
+                kind: 'body-fragment',
+                start: offset,
+                end: offset + 40,
+            };
+            const fragment = sliceMemoryBodyFragment({
+                body: entry.body,
+                revision: entry.revision,
+                ...(cursor ? { cursor } : {}),
+                alreadyDelivered: wasMemoryFragmentDelivered(getInternalMemoryBudgetContext(capability.conversationKey).id, delivery),
+                repeat: args.repeat === true,
+            });
+            return boundedAgentReply(c, capability, {
+                entry: {
+                    id: entry.id,
+                    key: entry.key,
+                    title: entry.title,
+                    revision: entry.revision,
+                    ...(fragment.text !== undefined ? { body: fragment.text } : {}),
+                    offset: fragment.offset,
+                    totalCodePoints: fragment.totalCodePoints,
+                    truncated: fragment.truncated,
+                    ...(fragment.nextCursor ? { nextCursor: fragment.nextCursor } : {}),
+                    ...(fragment.alreadyDelivered ? { alreadyDelivered: true } : {}),
+                },
+            }, 200, fragment.text !== undefined ? [{ ...delivery, end: offset + [...fragment.text].length }] : []);
+        }
+        if (toolName === 'search_memories') {
+            const page = searchMemories({
+                scopeId: scopeId,
+                query: args.query,
+                actor,
+                ...(typeof args.cursor === 'string' ? { cursor: args.cursor } : {}),
+                ...(typeof args.limit === 'number' ? { limit: args.limit } : {}),
+            });
+            const ledgerId = getInternalMemoryBudgetContext(capability.conversationKey).id;
+            const freshDeliveries = [];
+            const items = page.items.map((entry) => {
+                const delivery = { entryId: entry.id, revision: entry.revision, kind: 'metadata' };
+                if (wasMemoryFragmentDelivered(ledgerId, delivery))
+                    return { id: entry.id, revision: entry.revision, alreadyDelivered: true };
+                freshDeliveries.push(delivery);
+                return {
+                    id: entry.id,
+                    scopeId: entry.scopeId,
+                    key: entry.key,
+                    title: entry.title,
+                    revision: entry.revision,
+                    actor: entry.actor,
+                    createdAt: entry.createdAt,
+                    updatedAt: entry.updatedAt,
+                };
+            });
+            return boundedAgentReply(c, capability, { ...page, items }, 200, freshDeliveries, undefined, Number(args.cursor ?? 0));
+        }
+        if (toolName === 'list_memory_operations') {
+            return boundedAgentReply(c, capability, listMemoryOperations({
+                scopeId: scopeId,
+                workspaceId: capability.workspaceId,
+                actor,
+                ...(typeof args.cursor === 'string' ? { cursor: args.cursor } : {}),
+                ...(typeof args.limit === 'number' ? { limit: args.limit } : {}),
+            }));
+        }
+        if (capability.readOnly)
+            return boundedAgentReply(c, capability, { error: 'This agent launch is read-only for memory' }, 403);
+        writeReservation = reserveAgentWrite(capability);
+        if (!writeReservation.accepted) {
+            return exhaustedAgentReply(c, capability, 'Budget mémoire épuisé; aucune écriture mémoire n’a été effectuée.');
+        }
+        const result = remember({
+            scopeId: scopeId,
+            expectedGeneration: args.expected_generation,
+            key: args.key,
+            title: args.title,
+            body: args.body,
+            ...(typeof args.entry_id === 'string' ? { targetEntryId: args.entry_id } : {}),
+            ...(typeof args.expected_revision === 'number' ? { expectedRevision: args.expected_revision } : {}),
+            actor,
+        });
+        const receipt = result.status === 'applied'
+            ? {
+                status: result.status,
+                entry: {
+                    id: result.entry.id,
+                    scopeId: result.entry.scopeId,
+                    key: result.entry.key,
+                    revision: result.entry.revision,
+                    updatedAt: result.entry.updatedAt,
+                },
+            }
+            : result.status === 'proposed'
+                ? {
+                    status: result.status,
+                    proposal: {
+                        id: result.proposal.id,
+                        scopeId: result.proposal.scopeId,
+                        generation: result.proposal.generation,
+                    },
+                }
+                : { status: result.status, reason: result.reason };
+        return boundedAgentReply(c, capability, receipt, 200, [], writeReservation);
+    }
+    catch (error) {
+        const status = error instanceof MemoryNotFoundError
+            ? 404
+            : error instanceof MemoryConflictError
+                ? 409
+                : error instanceof TypeError
+                    ? 400
+                    : 500;
+        const message = error instanceof Error ? error.message : String(error);
+        if (writeReservation?.accepted)
+            return boundedAgentReply(c, capability, { error: message }, status, [], writeReservation);
+        return boundedAgentReply(c, capability, { error: message }, status);
+    }
+});
+export default app;

package/dist/server/routes/settings.js

@@ -1,4 +1,5 @@
 import { Hono } from 'hono';
+import { isMemoryMode } from '../../shared/memory.js';
 import { isValidSkillSuite } from '../../shared/skill-suite-prompts.js';
 import { isWorkflowPolicy } from '../../shared/workflow-policy.js';
 import { getDb } from '../db/index.js';
@@ -164,6 +165,8 @@ app.put('/global', async (c) => {
             return c.json({ error: 'Invalid JSON body' }, 400);
         if (body.workflowPolicy !== undefined && !isWorkflowPolicy(body.workflowPolicy))
             return c.json({ error: 'Invalid workflowPolicy' }, 400);
+        if (body.memoryMode !== undefined && !isMemoryMode(body.memoryMode))
+            return c.json({ error: 'Invalid memoryMode' }, 400);
         const updated = settingsService.updateGlobalSettings(body);
         // The client assigns this response straight into its store, so echoing the
         // real credentials back would undo the masking on GET the first time

package/dist/server/routes/workspaces.js

@@ -492,6 +492,9 @@ app.post('/', migrationGuard, creationBodyLimit, async (c) => {
         if (body.comparisonId !== undefined && typeof body.comparisonId !== 'string') {
             return c.json({ error: 'comparisonId must be a string' }, 400);
         }
+        if (body.tags !== undefined && (!Array.isArray(body.tags) || body.tags.some((tag) => typeof tag !== 'string'))) {
+            return c.json({ error: 'tags must be an array of strings' }, 400);
+        }
         creationId = typeof body.creationId === 'string' && body.creationId.length > 0 ? body.creationId : undefined;
         currentStep = 'validate';
         emitCreateProgress(creationId, currentStep);
@@ -841,7 +844,7 @@ app.post('/', migrationGuard, creationBodyLimit, async (c) => {
             // Skip any tag the user has removed from the catalogue so we respect
             // their choice (they may have pruned "notion"/"sentry" on purpose).
             const catalogTags = new Set(globalSettings.tags ?? []);
-            const autoTags = [];
+            const autoTags = [...(body.tags ?? [])];
             if (body.notionUrl && catalogTags.has('notion'))
                 autoTags.push('notion');
             if (body.sentryUrl && catalogTags.has('sentry'))

package/dist/server/services/agent/engines/claude-code/event-mapper.js

@@ -179,6 +179,10 @@ export function mapSdkMessage(msg, state) {
         return event;
     });
 }
+function sdkCompactionId(msg) {
+    const uuid = msg.uuid;
+    return typeof uuid === 'string' && uuid.length > 0 ? uuid : undefined;
+}
 function mapSdkMessagePayload(msg, state) {
     // Treat as a generic record — the SDK discriminated union is too broad to
     // narrow per branch here.
@@ -230,7 +234,10 @@ function mapSdkMessagePayload(msg, state) {
     }
     if (type === 'system') {
         if (subtype === 'compact' || subtype === 'compact_boundary') {
-            events.push({ kind: 'session:compacted' });
+            events.push({
+                kind: 'session:compacted',
+                ...(sdkCompactionId(msg) ? { compactionId: sdkCompactionId(msg) } : {}),
+            });
             return events;
         }
         // Live status message: the SDK announces it is compacting context before the
@@ -238,7 +245,11 @@ function mapSdkMessagePayload(msg, state) {
         // UI can tell the user "compacting…" instead of looking frozen.
         if (subtype === 'status') {
             const sdkStatus = typeof parsed.status === 'string' ? parsed.status : null;
-            events.push({ kind: 'session:compacting', active: sdkStatus === 'compacting' });
+            events.push({
+                kind: 'session:compacting',
+                active: sdkStatus === 'compacting',
+                ...(sdkCompactionId(msg) ? { compactionId: sdkCompactionId(msg) } : {}),
+            });
             return events;
         }
         if (subtype === 'task_started' ||

package/dist/server/services/agent/engines/codex/event-mapper.js

@@ -182,7 +182,7 @@ export function handleItemStarted(item, state) {
         return events;
     }
     if (item.type === 'contextCompaction') {
-        events.push({ kind: 'session:compacting', active: true });
+        events.push({ kind: 'session:compacting', active: true, compactionId: item.id });
         return events;
     }
     return events;
@@ -193,7 +193,7 @@ export function handleItemStarted(item, state) {
 export function handleItemCompleted(item, state) {
     const events = [];
     if (item.type === 'contextCompaction')
-        return [{ kind: 'session:compacted' }];
+        return [{ kind: 'session:compacted', compactionId: item.id }];
     if (item.type === 'agentMessage') {
         const text = item.text ?? '';
         const messageId = scopedId(state, item.id);